/* vec_cmpeq */
-static vector /*bool*/ char __ATTRS_o_ai
+static vector bool char __ATTRS_o_ai
vec_cmpeq(vector signed char a, vector signed char b)
{
- return __builtin_altivec_vcmpequb((vector char)a, (vector char)b);
+ return (vector bool char)
+ __builtin_altivec_vcmpequb((vector char)a, (vector char)b);
}
-static vector /*bool*/ char __ATTRS_o_ai
+static vector bool char __ATTRS_o_ai
vec_cmpeq(vector unsigned char a, vector unsigned char b)
{
- return __builtin_altivec_vcmpequb((vector char)a, (vector char)b);
+ return (vector bool char)
+ __builtin_altivec_vcmpequb((vector char)a, (vector char)b);
}
-static vector /*bool*/ short __ATTRS_o_ai
+static vector bool short __ATTRS_o_ai
vec_cmpeq(vector short a, vector short b)
{
- return __builtin_altivec_vcmpequh(a, b);
+ return (vector bool short)__builtin_altivec_vcmpequh(a, b);
}
-static vector /*bool*/ short __ATTRS_o_ai
+static vector bool short __ATTRS_o_ai
vec_cmpeq(vector unsigned short a, vector unsigned short b)
{
- return __builtin_altivec_vcmpequh((vector short)a, (vector short)b);
+ return (vector bool short)
+ __builtin_altivec_vcmpequh((vector short)a, (vector short)b);
}
-static vector /*bool*/ int __ATTRS_o_ai
+static vector bool int __ATTRS_o_ai
vec_cmpeq(vector int a, vector int b)
{
- return __builtin_altivec_vcmpequw(a, b);
+ return (vector bool int)__builtin_altivec_vcmpequw(a, b);
}
-static vector /*bool*/ int __ATTRS_o_ai
+static vector bool int __ATTRS_o_ai
vec_cmpeq(vector unsigned int a, vector unsigned int b)
{
- return __builtin_altivec_vcmpequw((vector int)a, (vector int)b);
+ return (vector bool int)
+ __builtin_altivec_vcmpequw((vector int)a, (vector int)b);
}
-static vector /*bool*/ int __ATTRS_o_ai
+static vector bool int __ATTRS_o_ai
vec_cmpeq(vector float a, vector float b)
{
- return __builtin_altivec_vcmpeqfp(a, b);
+ return (vector bool int)__builtin_altivec_vcmpeqfp(a, b);
}
/* vec_cmpge */
-static vector /*bool*/ int __attribute__((__always_inline__))
+static vector bool int __attribute__((__always_inline__))
vec_cmpge(vector float a, vector float b)
{
- return __builtin_altivec_vcmpgefp(a, b);
+ return (vector bool int)__builtin_altivec_vcmpgefp(a, b);
}
/* vec_vcmpgefp */
-static vector /*bool*/ int __attribute__((__always_inline__))
+static vector bool int __attribute__((__always_inline__))
vec_vcmpgefp(vector float a, vector float b)
{
- return __builtin_altivec_vcmpgefp(a, b);
+ return (vector bool int)__builtin_altivec_vcmpgefp(a, b);
}
/* vec_cmpgt */
-static vector /*bool*/ char __ATTRS_o_ai
+static vector bool char __ATTRS_o_ai
vec_cmpgt(vector signed char a, vector signed char b)
{
- return __builtin_altivec_vcmpgtsb(a, b);
+ return (vector bool char)__builtin_altivec_vcmpgtsb(a, b);
}
-static vector /*bool*/ char __ATTRS_o_ai
+static vector bool char __ATTRS_o_ai
vec_cmpgt(vector unsigned char a, vector unsigned char b)
{
- return __builtin_altivec_vcmpgtub(a, b);
+ return (vector bool char)__builtin_altivec_vcmpgtub(a, b);
}
-static vector /*bool*/ short __ATTRS_o_ai
+static vector bool short __ATTRS_o_ai
vec_cmpgt(vector short a, vector short b)
{
- return __builtin_altivec_vcmpgtsh(a, b);
+ return (vector bool short)__builtin_altivec_vcmpgtsh(a, b);
}
-static vector /*bool*/ short __ATTRS_o_ai
+static vector bool short __ATTRS_o_ai
vec_cmpgt(vector unsigned short a, vector unsigned short b)
{
- return __builtin_altivec_vcmpgtuh(a, b);
+ return (vector bool short)__builtin_altivec_vcmpgtuh(a, b);
}
-static vector /*bool*/ int __ATTRS_o_ai
+static vector bool int __ATTRS_o_ai
vec_cmpgt(vector int a, vector int b)
{
- return __builtin_altivec_vcmpgtsw(a, b);
+ return (vector bool int)__builtin_altivec_vcmpgtsw(a, b);
}
-static vector /*bool*/ int __ATTRS_o_ai
+static vector bool int __ATTRS_o_ai
vec_cmpgt(vector unsigned int a, vector unsigned int b)
{
- return __builtin_altivec_vcmpgtuw(a, b);
+ return (vector bool int)__builtin_altivec_vcmpgtuw(a, b);
}
-static vector /*bool*/ int __ATTRS_o_ai
+static vector bool int __ATTRS_o_ai
vec_cmpgt(vector float a, vector float b)
{
- return __builtin_altivec_vcmpgtfp(a, b);
+ return (vector bool int)__builtin_altivec_vcmpgtfp(a, b);
}
/* vec_vcmpgtsb */
-static vector /*bool*/ char __attribute__((__always_inline__))
+static vector bool char __attribute__((__always_inline__))
vec_vcmpgtsb(vector signed char a, vector signed char b)
{
- return __builtin_altivec_vcmpgtsb(a, b);
+ return (vector bool char)__builtin_altivec_vcmpgtsb(a, b);
}
/* vec_vcmpgtub */
-static vector /*bool*/ char __attribute__((__always_inline__))
+static vector bool char __attribute__((__always_inline__))
vec_vcmpgtub(vector unsigned char a, vector unsigned char b)
{
- return __builtin_altivec_vcmpgtub(a, b);
+ return (vector bool char)__builtin_altivec_vcmpgtub(a, b);
}
/* vec_vcmpgtsh */
-static vector /*bool*/ short __attribute__((__always_inline__))
+static vector bool short __attribute__((__always_inline__))
vec_vcmpgtsh(vector short a, vector short b)
{
- return __builtin_altivec_vcmpgtsh(a, b);
+ return (vector bool short)__builtin_altivec_vcmpgtsh(a, b);
}
/* vec_vcmpgtuh */
-static vector /*bool*/ short __attribute__((__always_inline__))
+static vector bool short __attribute__((__always_inline__))
vec_vcmpgtuh(vector unsigned short a, vector unsigned short b)
{
- return __builtin_altivec_vcmpgtuh(a, b);
+ return (vector bool short)__builtin_altivec_vcmpgtuh(a, b);
}
/* vec_vcmpgtsw */
-static vector /*bool*/ int __attribute__((__always_inline__))
+static vector bool int __attribute__((__always_inline__))
vec_vcmpgtsw(vector int a, vector int b)
{
- return __builtin_altivec_vcmpgtsw(a, b);
+ return (vector bool int)__builtin_altivec_vcmpgtsw(a, b);
}
/* vec_vcmpgtuw */
-static vector /*bool*/ int __attribute__((__always_inline__))
+static vector bool int __attribute__((__always_inline__))
vec_vcmpgtuw(vector unsigned int a, vector unsigned int b)
{
- return __builtin_altivec_vcmpgtuw(a, b);
+ return (vector bool int)__builtin_altivec_vcmpgtuw(a, b);
}
/* vec_vcmpgtfp */
-static vector /*bool*/ int __attribute__((__always_inline__))
+static vector bool int __attribute__((__always_inline__))
vec_vcmpgtfp(vector float a, vector float b)
{
- return __builtin_altivec_vcmpgtfp(a, b);
+ return (vector bool int)__builtin_altivec_vcmpgtfp(a, b);
}
/* vec_cmple */
-static vector /*bool*/ int __attribute__((__always_inline__))
+static vector bool int __attribute__((__always_inline__))
vec_cmple(vector float a, vector float b)
{
- return __builtin_altivec_vcmpgefp(b, a);
+ return (vector bool int)__builtin_altivec_vcmpgefp(b, a);
}
/* vec_cmplt */
-static vector /*bool*/ char __ATTRS_o_ai
+static vector bool char __ATTRS_o_ai
vec_cmplt(vector signed char a, vector signed char b)
{
- return __builtin_altivec_vcmpgtsb(b, a);
+ return (vector bool char)__builtin_altivec_vcmpgtsb(b, a);
}
-static vector /*bool*/ char __ATTRS_o_ai
+static vector bool char __ATTRS_o_ai
vec_cmplt(vector unsigned char a, vector unsigned char b)
{
- return __builtin_altivec_vcmpgtub(b, a);
+ return (vector bool char)__builtin_altivec_vcmpgtub(b, a);
}
-static vector /*bool*/ short __ATTRS_o_ai
+static vector bool short __ATTRS_o_ai
vec_cmplt(vector short a, vector short b)
{
- return __builtin_altivec_vcmpgtsh(b, a);
+ return (vector bool short)__builtin_altivec_vcmpgtsh(b, a);
}
-static vector /*bool*/ short __ATTRS_o_ai
+static vector bool short __ATTRS_o_ai
vec_cmplt(vector unsigned short a, vector unsigned short b)
{
- return __builtin_altivec_vcmpgtuh(b, a);
+ return (vector bool short)__builtin_altivec_vcmpgtuh(b, a);
}
-static vector /*bool*/ int __ATTRS_o_ai
+static vector bool int __ATTRS_o_ai
vec_cmplt(vector int a, vector int b)
{
- return __builtin_altivec_vcmpgtsw(b, a);
+ return (vector bool int)__builtin_altivec_vcmpgtsw(b, a);
}
-static vector /*bool*/ int __ATTRS_o_ai
+static vector bool int __ATTRS_o_ai
vec_cmplt(vector unsigned int a, vector unsigned int b)
{
- return __builtin_altivec_vcmpgtuw(b, a);
+ return (vector bool int)__builtin_altivec_vcmpgtuw(b, a);
}
-static vector /*bool*/ int __ATTRS_o_ai
+static vector bool int __ATTRS_o_ai
vec_cmplt(vector float a, vector float b)
{
- return __builtin_altivec_vcmpgtfp(b, a);
+ return (vector bool int)__builtin_altivec_vcmpgtfp(b, a);
}
/* vec_ctf */
return (vector unsigned char)__builtin_altivec_lvx(a, b);
}
+static vector bool char __ATTRS_o_ai
+vec_ld(int a, vector bool char *b)
+{
+ return (vector bool char)__builtin_altivec_lvx(a, b);
+}
+
static vector short __ATTRS_o_ai
vec_ld(int a, vector short *b)
{
return (vector unsigned short)__builtin_altivec_lvx(a, b);
}
+static vector bool short __ATTRS_o_ai
+vec_ld(int a, vector bool short *b)
+{
+ return (vector bool short)__builtin_altivec_lvx(a, b);
+}
+
+static vector pixel __ATTRS_o_ai
+vec_ld(int a, vector pixel *b)
+{
+ return (vector pixel)__builtin_altivec_lvx(a, b);
+}
+
static vector int __ATTRS_o_ai
vec_ld(int a, vector int *b)
{
return (vector unsigned int)__builtin_altivec_lvx(a, b);
}
+static vector bool int __ATTRS_o_ai
+vec_ld(int a, vector bool int *b)
+{
+ return (vector bool int)__builtin_altivec_lvx(a, b);
+}
+
static vector float __ATTRS_o_ai
vec_ld(int a, vector float *b)
{
return (vector unsigned char)__builtin_altivec_lvx(a, b);
}
+static vector bool char __ATTRS_o_ai
+vec_lvx(int a, vector bool char *b)
+{
+ return (vector bool char)__builtin_altivec_lvx(a, b);
+}
+
static vector short __ATTRS_o_ai
vec_lvx(int a, vector short *b)
{
return (vector unsigned short)__builtin_altivec_lvx(a, b);
}
+static vector bool short __ATTRS_o_ai
+vec_lvx(int a, vector bool short *b)
+{
+ return (vector bool short)__builtin_altivec_lvx(a, b);
+}
+
+static vector pixel __ATTRS_o_ai
+vec_lvx(int a, vector pixel *b)
+{
+ return (vector pixel)__builtin_altivec_lvx(a, b);
+}
+
static vector int __ATTRS_o_ai
vec_lvx(int a, vector int *b)
{
return (vector unsigned int)__builtin_altivec_lvx(a, b);
}
+static vector bool int __ATTRS_o_ai
+vec_lvx(int a, vector bool int *b)
+{
+ return (vector bool int)__builtin_altivec_lvx(a, b);
+}
+
static vector float __ATTRS_o_ai
vec_lvx(int a, vector float *b)
{
return (vector unsigned char)__builtin_altivec_lvxl(a, b);
}
+static vector bool char __ATTRS_o_ai
+vec_ldl(int a, vector bool char *b)
+{
+ return (vector bool char)__builtin_altivec_lvxl(a, b);
+}
+
static vector short __ATTRS_o_ai
vec_ldl(int a, vector short *b)
{
return (vector unsigned short)__builtin_altivec_lvxl(a, b);
}
+static vector bool short __ATTRS_o_ai
+vec_ldl(int a, vector bool short *b)
+{
+ return (vector bool short)__builtin_altivec_lvxl(a, b);
+}
+
+static vector pixel __ATTRS_o_ai
+vec_ldl(int a, vector pixel *b)
+{
+ return (vector pixel short)__builtin_altivec_lvxl(a, b);
+}
+
static vector int __ATTRS_o_ai
vec_ldl(int a, vector int *b)
{
return (vector unsigned int)__builtin_altivec_lvxl(a, b);
}
+static vector bool int __ATTRS_o_ai
+vec_ldl(int a, vector bool int *b)
+{
+ return (vector bool int)__builtin_altivec_lvxl(a, b);
+}
+
static vector float __ATTRS_o_ai
vec_ldl(int a, vector float *b)
{
return (vector unsigned char)__builtin_altivec_lvxl(a, b);
}
+static vector bool char __ATTRS_o_ai
+vec_lvxl(int a, vector bool char *b)
+{
+ return (vector bool char)__builtin_altivec_lvxl(a, b);
+}
+
static vector short __ATTRS_o_ai
vec_lvxl(int a, vector short *b)
{
return (vector unsigned short)__builtin_altivec_lvxl(a, b);
}
+static vector bool short __ATTRS_o_ai
+vec_lvxl(int a, vector bool short *b)
+{
+ return (vector bool short)__builtin_altivec_lvxl(a, b);
+}
+
+static vector pixel __ATTRS_o_ai
+vec_lvxl(int a, vector pixel *b)
+{
+ return (vector pixel)__builtin_altivec_lvxl(a, b);
+}
+
static vector int __ATTRS_o_ai
vec_lvxl(int a, vector int *b)
{
return (vector unsigned int)__builtin_altivec_lvxl(a, b);
}
+static vector bool int __ATTRS_o_ai
+vec_lvxl(int a, vector bool int *b)
+{
+ return (vector bool int)__builtin_altivec_lvxl(a, b);
+}
+
static vector float __ATTRS_o_ai
vec_lvxl(int a, vector float *b)
{
return __builtin_altivec_vmaxsb(a, b);
}
+static vector signed char __ATTRS_o_ai
+vec_max(vector bool char a, vector signed char b)
+{
+ return __builtin_altivec_vmaxsb((vector signed char)a, b);
+}
+
+static vector signed char __ATTRS_o_ai
+vec_max(vector signed char a, vector bool char b)
+{
+ return __builtin_altivec_vmaxsb(a, (vector signed char)b);
+}
+
static vector unsigned char __ATTRS_o_ai
vec_max(vector unsigned char a, vector unsigned char b)
{
return __builtin_altivec_vmaxub(a, b);
}
+static vector unsigned char __ATTRS_o_ai
+vec_max(vector bool char a, vector unsigned char b)
+{
+ return __builtin_altivec_vmaxub((vector unsigned char)a, b);
+}
+
+static vector unsigned char __ATTRS_o_ai
+vec_max(vector unsigned char a, vector bool char b)
+{
+ return __builtin_altivec_vmaxub(a, (vector unsigned char)b);
+}
+
static vector short __ATTRS_o_ai
vec_max(vector short a, vector short b)
{
return __builtin_altivec_vmaxsh(a, b);
}
+static vector short __ATTRS_o_ai
+vec_max(vector bool short a, vector short b)
+{
+ return __builtin_altivec_vmaxsh((vector short)a, b);
+}
+
+static vector short __ATTRS_o_ai
+vec_max(vector short a, vector bool short b)
+{
+ return __builtin_altivec_vmaxsh(a, (vector short)b);
+}
+
static vector unsigned short __ATTRS_o_ai
vec_max(vector unsigned short a, vector unsigned short b)
{
return __builtin_altivec_vmaxuh(a, b);
}
+static vector unsigned short __ATTRS_o_ai
+vec_max(vector bool short a, vector unsigned short b)
+{
+ return __builtin_altivec_vmaxuh((vector unsigned short)a, b);
+}
+
+static vector unsigned short __ATTRS_o_ai
+vec_max(vector unsigned short a, vector bool short b)
+{
+ return __builtin_altivec_vmaxuh(a, (vector unsigned short)b);
+}
+
static vector int __ATTRS_o_ai
vec_max(vector int a, vector int b)
{
return __builtin_altivec_vmaxsw(a, b);
}
+static vector int __ATTRS_o_ai
+vec_max(vector bool int a, vector int b)
+{
+ return __builtin_altivec_vmaxsw((vector int)a, b);
+}
+
+static vector int __ATTRS_o_ai
+vec_max(vector int a, vector bool int b)
+{
+ return __builtin_altivec_vmaxsw(a, (vector int)b);
+}
+
static vector unsigned int __ATTRS_o_ai
vec_max(vector unsigned int a, vector unsigned int b)
{
return __builtin_altivec_vmaxuw(a, b);
}
+static vector unsigned int __ATTRS_o_ai
+vec_max(vector bool int a, vector unsigned int b)
+{
+ return __builtin_altivec_vmaxuw((vector unsigned int)a, b);
+}
+
+static vector unsigned int __ATTRS_o_ai
+vec_max(vector unsigned int a, vector bool int b)
+{
+ return __builtin_altivec_vmaxuw(a, (vector unsigned int)b);
+}
+
static vector float __ATTRS_o_ai
vec_max(vector float a, vector float b)
{
/* vec_vmaxsb */
-static vector signed char __attribute__((__always_inline__))
+static vector signed char __ATTRS_o_ai
vec_vmaxsb(vector signed char a, vector signed char b)
{
return __builtin_altivec_vmaxsb(a, b);
}
+static vector signed char __ATTRS_o_ai
+vec_vmaxsb(vector bool char a, vector signed char b)
+{
+ return __builtin_altivec_vmaxsb((vector signed char)a, b);
+}
+
+static vector signed char __ATTRS_o_ai
+vec_vmaxsb(vector signed char a, vector bool char b)
+{
+ return __builtin_altivec_vmaxsb(a, (vector signed char)b);
+}
+
/* vec_vmaxub */
-static vector unsigned char __attribute__((__always_inline__))
+static vector unsigned char __ATTRS_o_ai
vec_vmaxub(vector unsigned char a, vector unsigned char b)
{
return __builtin_altivec_vmaxub(a, b);
}
+static vector unsigned char __ATTRS_o_ai
+vec_vmaxub(vector bool char a, vector unsigned char b)
+{
+ return __builtin_altivec_vmaxub((vector unsigned char)a, b);
+}
+
+static vector unsigned char __ATTRS_o_ai
+vec_vmaxub(vector unsigned char a, vector bool char b)
+{
+ return __builtin_altivec_vmaxub(a, (vector unsigned char)b);
+}
+
/* vec_vmaxsh */
-static vector short __attribute__((__always_inline__))
+static vector short __ATTRS_o_ai
vec_vmaxsh(vector short a, vector short b)
{
return __builtin_altivec_vmaxsh(a, b);
}
+static vector short __ATTRS_o_ai
+vec_vmaxsh(vector bool short a, vector short b)
+{
+ return __builtin_altivec_vmaxsh((vector short)a, b);
+}
+
+static vector short __ATTRS_o_ai
+vec_vmaxsh(vector short a, vector bool short b)
+{
+ return __builtin_altivec_vmaxsh(a, (vector short)b);
+}
+
/* vec_vmaxuh */
-static vector unsigned short __attribute__((__always_inline__))
+static vector unsigned short __ATTRS_o_ai
vec_vmaxuh(vector unsigned short a, vector unsigned short b)
{
return __builtin_altivec_vmaxuh(a, b);
}
+static vector unsigned short __ATTRS_o_ai
+vec_vmaxuh(vector bool short a, vector unsigned short b)
+{
+ return __builtin_altivec_vmaxuh((vector unsigned short)a, b);
+}
+
+static vector unsigned short __ATTRS_o_ai
+vec_vmaxuh(vector unsigned short a, vector bool short b)
+{
+ return __builtin_altivec_vmaxuh(a, (vector unsigned short)b);
+}
+
/* vec_vmaxsw */
-static vector int __attribute__((__always_inline__))
+static vector int __ATTRS_o_ai
vec_vmaxsw(vector int a, vector int b)
{
return __builtin_altivec_vmaxsw(a, b);
}
+static vector int __ATTRS_o_ai
+vec_vmaxsw(vector bool int a, vector int b)
+{
+ return __builtin_altivec_vmaxsw((vector int)a, b);
+}
+
+static vector int __ATTRS_o_ai
+vec_vmaxsw(vector int a, vector bool int b)
+{
+ return __builtin_altivec_vmaxsw(a, (vector int)b);
+}
+
/* vec_vmaxuw */
-static vector unsigned int __attribute__((__always_inline__))
+static vector unsigned int __ATTRS_o_ai
vec_vmaxuw(vector unsigned int a, vector unsigned int b)
{
return __builtin_altivec_vmaxuw(a, b);
}
+static vector unsigned int __ATTRS_o_ai
+vec_vmaxuw(vector bool int a, vector unsigned int b)
+{
+ return __builtin_altivec_vmaxuw((vector unsigned int)a, b);
+}
+
+static vector unsigned int __ATTRS_o_ai
+vec_vmaxuw(vector unsigned int a, vector bool int b)
+{
+ return __builtin_altivec_vmaxuw(a, (vector unsigned int)b);
+}
+
/* vec_vmaxfp */
static vector float __attribute__((__always_inline__))
return __builtin_altivec_vminsb(a, b);
}
+static vector signed char __ATTRS_o_ai
+vec_min(vector bool char a, vector signed char b)
+{
+ return __builtin_altivec_vminsb((vector signed char)a, b);
+}
+
+static vector signed char __ATTRS_o_ai
+vec_min(vector signed char a, vector bool char b)
+{
+ return __builtin_altivec_vminsb(a, (vector signed char)b);
+}
+
static vector unsigned char __ATTRS_o_ai
vec_min(vector unsigned char a, vector unsigned char b)
{
return __builtin_altivec_vminub(a, b);
}
+static vector unsigned char __ATTRS_o_ai
+vec_min(vector bool char a, vector unsigned char b)
+{
+ return __builtin_altivec_vminub((vector unsigned char)a, b);
+}
+
+static vector unsigned char __ATTRS_o_ai
+vec_min(vector unsigned char a, vector bool char b)
+{
+ return __builtin_altivec_vminub(a, (vector unsigned char)b);
+}
+
static vector short __ATTRS_o_ai
vec_min(vector short a, vector short b)
{
return __builtin_altivec_vminsh(a, b);
}
+static vector short __ATTRS_o_ai
+vec_min(vector bool short a, vector short b)
+{
+ return __builtin_altivec_vminsh((vector short)a, b);
+}
+
+static vector short __ATTRS_o_ai
+vec_min(vector short a, vector bool short b)
+{
+ return __builtin_altivec_vminsh(a, (vector short)b);
+}
+
static vector unsigned short __ATTRS_o_ai
vec_min(vector unsigned short a, vector unsigned short b)
{
return __builtin_altivec_vminuh(a, b);
}
+static vector unsigned short __ATTRS_o_ai
+vec_min(vector bool short a, vector unsigned short b)
+{
+ return __builtin_altivec_vminuh((vector unsigned short)a, b);
+}
+
+static vector unsigned short __ATTRS_o_ai
+vec_min(vector unsigned short a, vector bool short b)
+{
+ return __builtin_altivec_vminuh(a, (vector unsigned short)b);
+}
+
static vector int __ATTRS_o_ai
vec_min(vector int a, vector int b)
{
return __builtin_altivec_vminsw(a, b);
}
+static vector int __ATTRS_o_ai
+vec_min(vector bool int a, vector int b)
+{
+ return __builtin_altivec_vminsw((vector int)a, b);
+}
+
+static vector int __ATTRS_o_ai
+vec_min(vector int a, vector bool int b)
+{
+ return __builtin_altivec_vminsw(a, (vector int)b);
+}
+
static vector unsigned int __ATTRS_o_ai
vec_min(vector unsigned int a, vector unsigned int b)
{
return __builtin_altivec_vminuw(a, b);
}
+static vector unsigned int __ATTRS_o_ai
+vec_min(vector bool int a, vector unsigned int b)
+{
+ return __builtin_altivec_vminuw((vector unsigned int)a, b);
+}
+
+static vector unsigned int __ATTRS_o_ai
+vec_min(vector unsigned int a, vector bool int b)
+{
+ return __builtin_altivec_vminuw(a, (vector unsigned int)b);
+}
+
static vector float __ATTRS_o_ai
vec_min(vector float a, vector float b)
{
/* vec_vminsb */
-static vector signed char __attribute__((__always_inline__))
+static vector signed char __ATTRS_o_ai
vec_vminsb(vector signed char a, vector signed char b)
{
return __builtin_altivec_vminsb(a, b);
}
+static vector signed char __ATTRS_o_ai
+vec_vminsb(vector bool char a, vector signed char b)
+{
+ return __builtin_altivec_vminsb((vector signed char)a, b);
+}
+
+static vector signed char __ATTRS_o_ai
+vec_vminsb(vector signed char a, vector bool char b)
+{
+ return __builtin_altivec_vminsb(a, (vector signed char)b);
+}
+
/* vec_vminub */
-static vector unsigned char __attribute__((__always_inline__))
+static vector unsigned char __ATTRS_o_ai
vec_vminub(vector unsigned char a, vector unsigned char b)
{
return __builtin_altivec_vminub(a, b);
}
-/* vec_vminsh */
-
-static vector short __attribute__((__always_inline__))
+static vector unsigned char __ATTRS_o_ai
+vec_vminub(vector bool char a, vector unsigned char b)
+{
+ return __builtin_altivec_vminub((vector unsigned char)a, b);
+}
+
+static vector unsigned char __ATTRS_o_ai
+vec_vminub(vector unsigned char a, vector bool char b)
+{
+ return __builtin_altivec_vminub(a, (vector unsigned char)b);
+}
+
+/* vec_vminsh */
+
+static vector short __ATTRS_o_ai
vec_vminsh(vector short a, vector short b)
{
return __builtin_altivec_vminsh(a, b);
}
+static vector short __ATTRS_o_ai
+vec_vminsh(vector bool short a, vector short b)
+{
+ return __builtin_altivec_vminsh((vector short)a, b);
+}
+
+static vector short __ATTRS_o_ai
+vec_vminsh(vector short a, vector bool short b)
+{
+ return __builtin_altivec_vminsh(a, (vector short)b);
+}
+
/* vec_vminuh */
-static vector unsigned short __attribute__((__always_inline__))
+static vector unsigned short __ATTRS_o_ai
vec_vminuh(vector unsigned short a, vector unsigned short b)
{
return __builtin_altivec_vminuh(a, b);
}
+static vector unsigned short __ATTRS_o_ai
+vec_vminuh(vector bool short a, vector unsigned short b)
+{
+ return __builtin_altivec_vminuh((vector unsigned short)a, b);
+}
+
+static vector unsigned short __ATTRS_o_ai
+vec_vminuh(vector unsigned short a, vector bool short b)
+{
+ return __builtin_altivec_vminuh(a, (vector unsigned short)b);
+}
+
/* vec_vminsw */
-static vector int __attribute__((__always_inline__))
+static vector int __ATTRS_o_ai
vec_vminsw(vector int a, vector int b)
{
return __builtin_altivec_vminsw(a, b);
}
+static vector int __ATTRS_o_ai
+vec_vminsw(vector bool int a, vector int b)
+{
+ return __builtin_altivec_vminsw((vector int)a, b);
+}
+
+static vector int __ATTRS_o_ai
+vec_vminsw(vector int a, vector bool int b)
+{
+ return __builtin_altivec_vminsw(a, (vector int)b);
+}
+
/* vec_vminuw */
-static vector unsigned int __attribute__((__always_inline__))
+static vector unsigned int __ATTRS_o_ai
vec_vminuw(vector unsigned int a, vector unsigned int b)
{
return __builtin_altivec_vminuw(a, b);
}
+static vector unsigned int __ATTRS_o_ai
+vec_vminuw(vector bool int a, vector unsigned int b)
+{
+ return __builtin_altivec_vminuw((vector unsigned int)a, b);
+}
+
+static vector unsigned int __ATTRS_o_ai
+vec_vminuw(vector unsigned int a, vector bool int b)
+{
+ return __builtin_altivec_vminuw(a, (vector unsigned int)b);
+}
+
/* vec_vminfp */
static vector float __attribute__((__always_inline__))
__builtin_altivec_mtvscr((vector int)a);
}
+static void __ATTRS_o_ai
+vec_mtvscr(vector bool char a)
+{
+ __builtin_altivec_mtvscr((vector int)a);
+}
+
static void __ATTRS_o_ai
vec_mtvscr(vector short a)
{
__builtin_altivec_mtvscr((vector int)a);
}
+static void __ATTRS_o_ai
+vec_mtvscr(vector bool short a)
+{
+ __builtin_altivec_mtvscr((vector int)a);
+}
+
+static void __ATTRS_o_ai
+vec_mtvscr(vector pixel a)
+{
+ __builtin_altivec_mtvscr((vector int)a);
+}
+
static void __ATTRS_o_ai
vec_mtvscr(vector int a)
{
__builtin_altivec_mtvscr((vector int)a);
}
+static void __ATTRS_o_ai
+vec_mtvscr(vector bool int a)
+{
+ __builtin_altivec_mtvscr((vector int)a);
+}
+
static void __ATTRS_o_ai
vec_mtvscr(vector float a)
{
return ~(a | b);
}
+static vector bool char __ATTRS_o_ai
+vec_nor(vector bool char a, vector bool char b)
+{
+ return ~(a | b);
+}
+
static vector short __ATTRS_o_ai
vec_nor(vector short a, vector short b)
{
return ~(a | b);
}
+static vector bool short __ATTRS_o_ai
+vec_nor(vector bool short a, vector bool short b)
+{
+ return ~(a | b);
+}
+
static vector int __ATTRS_o_ai
vec_nor(vector int a, vector int b)
{
return ~(a | b);
}
+static vector bool int __ATTRS_o_ai
+vec_nor(vector bool int a, vector bool int b)
+{
+ return ~(a | b);
+}
+
static vector float __ATTRS_o_ai
vec_nor(vector float a, vector float b)
{
return ~(a | b);
}
+static vector bool char __ATTRS_o_ai
+vec_vnor(vector bool char a, vector bool char b)
+{
+ return ~(a | b);
+}
+
static vector short __ATTRS_o_ai
vec_vnor(vector short a, vector short b)
{
return ~(a | b);
}
+static vector bool short __ATTRS_o_ai
+vec_vnor(vector bool short a, vector bool short b)
+{
+ return ~(a | b);
+}
+
static vector int __ATTRS_o_ai
vec_vnor(vector int a, vector int b)
{
return ~(a | b);
}
+static vector bool int __ATTRS_o_ai
+vec_vnor(vector bool int a, vector bool int b)
+{
+ return ~(a | b);
+}
+
static vector float __ATTRS_o_ai
vec_vnor(vector float a, vector float b)
{
return a | b;
}
+static vector signed char __ATTRS_o_ai
+vec_or(vector bool char a, vector signed char b)
+{
+ return (vector signed char)a | b;
+}
+
+static vector signed char __ATTRS_o_ai
+vec_or(vector signed char a, vector bool char b)
+{
+ return a | (vector signed char)b;
+}
+
static vector unsigned char __ATTRS_o_ai
vec_or(vector unsigned char a, vector unsigned char b)
{
return a | b;
}
+static vector unsigned char __ATTRS_o_ai
+vec_or(vector bool char a, vector unsigned char b)
+{
+ return (vector unsigned char)a | b;
+}
+
+static vector unsigned char __ATTRS_o_ai
+vec_or(vector unsigned char a, vector bool char b)
+{
+ return a | (vector unsigned char)b;
+}
+
+static vector bool char __ATTRS_o_ai
+vec_or(vector bool char a, vector bool char b)
+{
+ return a | b;
+}
+
static vector short __ATTRS_o_ai
vec_or(vector short a, vector short b)
{
return a | b;
}
+static vector short __ATTRS_o_ai
+vec_or(vector bool short a, vector short b)
+{
+ return (vector short)a | b;
+}
+
+static vector short __ATTRS_o_ai
+vec_or(vector short a, vector bool short b)
+{
+ return a | (vector short)b;
+}
+
static vector unsigned short __ATTRS_o_ai
vec_or(vector unsigned short a, vector unsigned short b)
{
return a | b;
}
+static vector unsigned short __ATTRS_o_ai
+vec_or(vector bool short a, vector unsigned short b)
+{
+ return (vector unsigned short)a | b;
+}
+
+static vector unsigned short __ATTRS_o_ai
+vec_or(vector unsigned short a, vector bool short b)
+{
+ return a | (vector unsigned short)b;
+}
+
+static vector bool short __ATTRS_o_ai
+vec_or(vector bool short a, vector bool short b)
+{
+ return a | b;
+}
+
static vector int __ATTRS_o_ai
vec_or(vector int a, vector int b)
{
return a | b;
}
+static vector int __ATTRS_o_ai
+vec_or(vector bool int a, vector int b)
+{
+ return (vector int)a | b;
+}
+
+static vector int __ATTRS_o_ai
+vec_or(vector int a, vector bool int b)
+{
+ return a | (vector int)b;
+}
+
static vector unsigned int __ATTRS_o_ai
vec_or(vector unsigned int a, vector unsigned int b)
{
return a | b;
}
+static vector unsigned int __ATTRS_o_ai
+vec_or(vector bool int a, vector unsigned int b)
+{
+ return (vector unsigned int)a | b;
+}
+
+static vector unsigned int __ATTRS_o_ai
+vec_or(vector unsigned int a, vector bool int b)
+{
+ return a | (vector unsigned int)b;
+}
+
+static vector bool int __ATTRS_o_ai
+vec_or(vector bool int a, vector bool int b)
+{
+ return a | b;
+}
+
static vector float __ATTRS_o_ai
vec_or(vector float a, vector float b)
{
return (vector float)res;
}
+static vector float __ATTRS_o_ai
+vec_or(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_or(vector float a, vector bool int b)
+{
+ vector unsigned int res = (vector unsigned int)a | (vector unsigned int)b;
+ return (vector float)res;
+}
+
/* vec_vor */
static vector signed char __ATTRS_o_ai
return a | b;
}
+static vector signed char __ATTRS_o_ai
+vec_vor(vector bool char a, vector signed char b)
+{
+ return (vector signed char)a | b;
+}
+
+static vector signed char __ATTRS_o_ai
+vec_vor(vector signed char a, vector bool char b)
+{
+ return a | (vector signed char)b;
+}
+
static vector unsigned char __ATTRS_o_ai
vec_vor(vector unsigned char a, vector unsigned char b)
{
return a | b;
}
+static vector unsigned char __ATTRS_o_ai
+vec_vor(vector bool char a, vector unsigned char b)
+{
+ return (vector unsigned char)a | b;
+}
+
+static vector unsigned char __ATTRS_o_ai
+vec_vor(vector unsigned char a, vector bool char b)
+{
+ return a | (vector unsigned char)b;
+}
+
+static vector bool char __ATTRS_o_ai
+vec_vor(vector bool char a, vector bool char b)
+{
+ return a | b;
+}
+
static vector short __ATTRS_o_ai
vec_vor(vector short a, vector short b)
{
return a | b;
}
+static vector short __ATTRS_o_ai
+vec_vor(vector bool short a, vector short b)
+{
+ return (vector short)a | b;
+}
+
+static vector short __ATTRS_o_ai
+vec_vor(vector short a, vector bool short b)
+{
+ return a | (vector short)b;
+}
+
static vector unsigned short __ATTRS_o_ai
vec_vor(vector unsigned short a, vector unsigned short b)
{
return a | b;
}
+static vector unsigned short __ATTRS_o_ai
+vec_vor(vector bool short a, vector unsigned short b)
+{
+ return (vector unsigned short)a | b;
+}
+
+static vector unsigned short __ATTRS_o_ai
+vec_vor(vector unsigned short a, vector bool short b)
+{
+ return a | (vector unsigned short)b;
+}
+
+static vector bool short __ATTRS_o_ai
+vec_vor(vector bool short a, vector bool short b)
+{
+ return a | b;
+}
+
static vector int __ATTRS_o_ai
vec_vor(vector int a, vector int b)
{
return a | b;
}
+static vector int __ATTRS_o_ai
+vec_vor(vector bool int a, vector int b)
+{
+ return (vector int)a | b;
+}
+
+static vector int __ATTRS_o_ai
+vec_vor(vector int a, vector bool int b)
+{
+ return a | (vector int)b;
+}
+
static vector unsigned int __ATTRS_o_ai
vec_vor(vector unsigned int a, vector unsigned int b)
{
return a | b;
}
+static vector unsigned int __ATTRS_o_ai
+vec_vor(vector bool int a, vector unsigned int b)
+{
+ return (vector unsigned int)a | b;
+}
+
+static vector unsigned int __ATTRS_o_ai
+vec_vor(vector unsigned int a, vector bool int b)
+{
+ return a | (vector unsigned int)b;
+}
+
+static vector bool int __ATTRS_o_ai
+vec_vor(vector bool int a, vector bool int b)
+{
+ return a | b;
+}
+
static vector float __ATTRS_o_ai
vec_vor(vector float a, vector float b)
{
return (vector float)res;
}
+static vector float __ATTRS_o_ai
+vec_vor(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_vor(vector float a, vector bool int b)
+{
+ vector unsigned int res = (vector unsigned int)a | (vector unsigned int)b;
+ return (vector float)res;
+}
+
/* vec_pack */
static vector signed char __ATTRS_o_ai
return (a & ~(vector signed char)c) | (b & (vector signed char)c);
}
+static vector signed char __ATTRS_o_ai
+vec_sel(vector signed char a, vector signed char b, vector bool char c)
+{
+ return (a & ~(vector signed char)c) | (b & (vector signed char)c);
+}
+
static vector unsigned char __ATTRS_o_ai
vec_sel(vector unsigned char a, vector unsigned char b, vector unsigned char c)
{
return (a & ~c) | (b & c);
}
-static vector short __ATTRS_o_ai
-vec_sel(vector short a, vector short b, vector unsigned short c)
+static vector unsigned char __ATTRS_o_ai
+vec_sel(vector unsigned char a, vector unsigned char b, vector bool char c)
+{
+ return (a & ~(vector unsigned char)c) | (b & (vector unsigned char)c);
+}
+
+static vector bool char __ATTRS_o_ai
+vec_sel(vector bool char a, vector bool char b, vector unsigned char c)
+{
+ return (a & ~(vector bool char)c) | (b & (vector bool char)c);
+}
+
+static vector bool char __ATTRS_o_ai
+vec_sel(vector bool char a, vector bool char b, vector bool char c)
+{
+ return (a & ~c) | (b & c);
+}
+
+static vector short __ATTRS_o_ai
+vec_sel(vector short a, vector short b, vector unsigned short c)
+{
+ return (a & ~(vector short)c) | (b & (vector short)c);
+}
+
+static vector short __ATTRS_o_ai
+vec_sel(vector short a, vector short b, vector bool short c)
{
return (a & ~(vector short)c) | (b & (vector short)c);
}
return (a & ~c) | (b & c);
}
+static vector unsigned short __ATTRS_o_ai
+vec_sel(vector unsigned short a, vector unsigned short b, vector bool short c)
+{
+ return (a & ~(vector unsigned short)c) | (b & (vector unsigned short)c);
+}
+
+static vector bool short __ATTRS_o_ai
+vec_sel(vector bool short a, vector bool short b, vector unsigned short c)
+{
+ return (a & ~(vector bool short)c) | (b & (vector bool short)c);
+}
+
+static vector bool short __ATTRS_o_ai
+vec_sel(vector bool short a, vector bool short b, vector bool short c)
+{
+ return (a & ~c) | (b & c);
+}
+
static vector int __ATTRS_o_ai
vec_sel(vector int a, vector int b, vector unsigned int c)
{
return (a & ~(vector int)c) | (b & (vector int)c);
}
+static vector int __ATTRS_o_ai
+vec_sel(vector int a, vector int b, vector bool int c)
+{
+ return (a & ~(vector int)c) | (b & (vector int)c);
+}
+
static vector unsigned int __ATTRS_o_ai
vec_sel(vector unsigned int a, vector unsigned int b, vector unsigned int c)
{
return (a & ~c) | (b & c);
}
+static vector unsigned int __ATTRS_o_ai
+vec_sel(vector unsigned int a, vector unsigned int b, vector bool int c)
+{
+ return (a & ~(vector unsigned int)c) | (b & (vector unsigned int)c);
+}
+
+static vector bool int __ATTRS_o_ai
+vec_sel(vector bool int a, vector bool int b, vector unsigned int c)
+{
+ return (a & ~(vector bool int)c) | (b & (vector bool int)c);
+}
+
+static vector bool int __ATTRS_o_ai
+vec_sel(vector bool int a, vector bool int b, vector bool int c)
+{
+ return (a & ~c) | (b & c);
+}
+
static vector float __ATTRS_o_ai
vec_sel(vector float a, vector float b, vector unsigned int c)
{
return (vector float)res;
}
+static vector float __ATTRS_o_ai
+vec_sel(vector float a, vector float b, vector bool int c)
+{
+ vector int res = ((vector int)a & ~(vector int)c) | ((vector int)b & (vector int)c);
+ return (vector float)res;
+}
+
/* vec_vsel */
static vector signed char __ATTRS_o_ai
return (a & ~(vector signed char)c) | (b & (vector signed char)c);
}
+static vector signed char __ATTRS_o_ai
+vec_vsel(vector signed char a, vector signed char b, vector bool char c)
+{
+ return (a & ~(vector signed char)c) | (b & (vector signed char)c);
+}
+
static vector unsigned char __ATTRS_o_ai
vec_vsel(vector unsigned char a, vector unsigned char b, vector unsigned char c)
{
return (a & ~c) | (b & c);
}
+static vector unsigned char __ATTRS_o_ai
+vec_vsel(vector unsigned char a, vector unsigned char b, vector bool char c)
+{
+ return (a & ~(vector unsigned char)c) | (b & (vector unsigned char)c);
+}
+
+static vector bool char __ATTRS_o_ai
+vec_vsel(vector bool char a, vector bool char b, vector unsigned char c)
+{
+ return (a & ~(vector bool char)c) | (b & (vector bool char)c);
+}
+
+static vector bool char __ATTRS_o_ai
+vec_vsel(vector bool char a, vector bool char b, vector bool char c)
+{
+ return (a & ~c) | (b & c);
+}
+
static vector short __ATTRS_o_ai
vec_vsel(vector short a, vector short b, vector unsigned short c)
{
return (a & ~(vector short)c) | (b & (vector short)c);
}
+static vector short __ATTRS_o_ai
+vec_vsel(vector short a, vector short b, vector bool short c)
+{
+ return (a & ~(vector short)c) | (b & (vector short)c);
+}
+
static vector unsigned short __ATTRS_o_ai
vec_vsel(vector unsigned short a, vector unsigned short b, vector unsigned short c)
{
return (a & ~c) | (b & c);
}
+static vector unsigned short __ATTRS_o_ai
+vec_vsel(vector unsigned short a, vector unsigned short b, vector bool short c)
+{
+ return (a & ~(vector unsigned short)c) | (b & (vector unsigned short)c);
+}
+
+static vector bool short __ATTRS_o_ai
+vec_vsel(vector bool short a, vector bool short b, vector unsigned short c)
+{
+ return (a & ~(vector bool short)c) | (b & (vector bool short)c);
+}
+
+static vector bool short __ATTRS_o_ai
+vec_vsel(vector bool short a, vector bool short b, vector bool short c)
+{
+ return (a & ~c) | (b & c);
+}
+
static vector int __ATTRS_o_ai
vec_vsel(vector int a, vector int b, vector unsigned int c)
{
return (a & ~(vector int)c) | (b & (vector int)c);
}
+static vector int __ATTRS_o_ai
+vec_vsel(vector int a, vector int b, vector bool int c)
+{
+ return (a & ~(vector int)c) | (b & (vector int)c);
+}
+
static vector unsigned int __ATTRS_o_ai
vec_vsel(vector unsigned int a, vector unsigned int b, vector unsigned int c)
{
return (a & ~c) | (b & c);
}
+static vector unsigned int __ATTRS_o_ai
+vec_vsel(vector unsigned int a, vector unsigned int b, vector bool int c)
+{
+ return (a & ~(vector unsigned int)c) | (b & (vector unsigned int)c);
+}
+
+static vector bool int __ATTRS_o_ai
+vec_vsel(vector bool int a, vector bool int b, vector unsigned int c)
+{
+ return (a & ~(vector bool int)c) | (b & (vector bool int)c);
+}
+
+static vector bool int __ATTRS_o_ai
+vec_vsel(vector bool int a, vector bool int b, vector bool int c)
+{
+ return (a & ~c) | (b & c);
+}
+
static vector float __ATTRS_o_ai
vec_vsel(vector float a, vector float b, vector unsigned int c)
{
return (vector float)res;
}
+static vector float __ATTRS_o_ai
+vec_vsel(vector float a, vector float b, vector bool int c)
+{
+ vector int res = ((vector int)a & ~(vector int)c) | ((vector int)b & (vector int)c);
+ return (vector float)res;
+}
+
/* vec_sl */
static vector signed char __ATTRS_o_ai
return (vector unsigned char)__builtin_altivec_vsl((vector int)a, (vector int)b);
}
+static vector bool char __ATTRS_o_ai
+vec_sll(vector bool char a, vector unsigned char b)
+{
+ return (vector bool char)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
+static vector bool char __ATTRS_o_ai
+vec_sll(vector bool char a, vector unsigned short b)
+{
+ return (vector bool char)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
+static vector bool char __ATTRS_o_ai
+vec_sll(vector bool char a, vector unsigned int b)
+{
+ return (vector bool char)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
static vector short __ATTRS_o_ai
vec_sll(vector short a, vector unsigned char b)
{
return (vector unsigned short)__builtin_altivec_vsl((vector int)a, (vector int)b);
}
+static vector bool short __ATTRS_o_ai
+vec_sll(vector bool short a, vector unsigned char b)
+{
+ return (vector bool short)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
+static vector bool short __ATTRS_o_ai
+vec_sll(vector bool short a, vector unsigned short b)
+{
+ return (vector bool short)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
+static vector bool short __ATTRS_o_ai
+vec_sll(vector bool short a, vector unsigned int b)
+{
+ return (vector bool short)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
+static vector pixel __ATTRS_o_ai
+vec_sll(vector pixel a, vector unsigned char b)
+{
+ return (vector pixel)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
+static vector pixel __ATTRS_o_ai
+vec_sll(vector pixel a, vector unsigned short b)
+{
+ return (vector pixel)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
+static vector pixel __ATTRS_o_ai
+vec_sll(vector pixel a, vector unsigned int b)
+{
+ return (vector pixel)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
static vector int __ATTRS_o_ai
vec_sll(vector int a, vector unsigned char b)
{
return (vector unsigned int)__builtin_altivec_vsl((vector int)a, (vector int)b);
}
+static vector bool int __ATTRS_o_ai
+vec_sll(vector bool int a, vector unsigned char b)
+{
+ return (vector bool int)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
+static vector bool int __ATTRS_o_ai
+vec_sll(vector bool int a, vector unsigned short b)
+{
+ return (vector bool int)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
+static vector bool int __ATTRS_o_ai
+vec_sll(vector bool int a, vector unsigned int b)
+{
+ return (vector bool int)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
/* vec_vsl */
static vector signed char __ATTRS_o_ai
return (vector unsigned char)__builtin_altivec_vsl((vector int)a, (vector int)b);
}
+static vector bool char __ATTRS_o_ai
+vec_vsl(vector bool char a, vector unsigned char b)
+{
+ return (vector bool char)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
+static vector bool char __ATTRS_o_ai
+vec_vsl(vector bool char a, vector unsigned short b)
+{
+ return (vector bool char)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
+static vector bool char __ATTRS_o_ai
+vec_vsl(vector bool char a, vector unsigned int b)
+{
+ return (vector bool char)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
static vector short __ATTRS_o_ai
vec_vsl(vector short a, vector unsigned char b)
{
return (vector unsigned short)__builtin_altivec_vsl((vector int)a, (vector int)b);
}
+static vector bool short __ATTRS_o_ai
+vec_vsl(vector bool short a, vector unsigned char b)
+{
+ return (vector bool short)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
+static vector bool short __ATTRS_o_ai
+vec_vsl(vector bool short a, vector unsigned short b)
+{
+ return (vector bool short)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
+static vector bool short __ATTRS_o_ai
+vec_vsl(vector bool short a, vector unsigned int b)
+{
+ return (vector bool short)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
+static vector pixel __ATTRS_o_ai
+vec_vsl(vector pixel a, vector unsigned char b)
+{
+ return (vector pixel)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
+static vector pixel __ATTRS_o_ai
+vec_vsl(vector pixel a, vector unsigned short b)
+{
+ return (vector pixel)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
+static vector pixel __ATTRS_o_ai
+vec_vsl(vector pixel a, vector unsigned int b)
+{
+ return (vector pixel)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
static vector int __ATTRS_o_ai
vec_vsl(vector int a, vector unsigned char b)
{
return (vector unsigned int)__builtin_altivec_vsl((vector int)a, (vector int)b);
}
+static vector bool int __ATTRS_o_ai
+vec_vsl(vector bool int a, vector unsigned char b)
+{
+ return (vector bool int)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
+static vector bool int __ATTRS_o_ai
+vec_vsl(vector bool int a, vector unsigned short b)
+{
+ return (vector bool int)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
+static vector bool int __ATTRS_o_ai
+vec_vsl(vector bool int a, vector unsigned int b)
+{
+ return (vector bool int)__builtin_altivec_vsl((vector int)a, (vector int)b);
+}
+
/* vec_slo */
static vector signed char __ATTRS_o_ai
return (vector unsigned short)__builtin_altivec_vslo((vector int)a, (vector int)b);
}
+static vector pixel __ATTRS_o_ai
+vec_slo(vector pixel a, vector signed char b)
+{
+ return (vector pixel)__builtin_altivec_vslo((vector int)a, (vector int)b);
+}
+
+static vector pixel __ATTRS_o_ai
+vec_slo(vector pixel a, vector unsigned char b)
+{
+ return (vector pixel)__builtin_altivec_vslo((vector int)a, (vector int)b);
+}
+
static vector int __ATTRS_o_ai
vec_slo(vector int a, vector signed char b)
{
return (vector unsigned short)__builtin_altivec_vslo((vector int)a, (vector int)b);
}
+static vector pixel __ATTRS_o_ai
+vec_vslo(vector pixel a, vector signed char b)
+{
+ return (vector pixel)__builtin_altivec_vslo((vector int)a, (vector int)b);
+}
+
+static vector pixel __ATTRS_o_ai
+vec_vslo(vector pixel a, vector unsigned char b)
+{
+ return (vector pixel)__builtin_altivec_vslo((vector int)a, (vector int)b);
+}
+
static vector int __ATTRS_o_ai
vec_vslo(vector int a, vector signed char b)
{
return (vector unsigned char)__builtin_altivec_vsr((vector int)a, (vector int)b);
}
+static vector bool char __ATTRS_o_ai
+vec_srl(vector bool char a, vector unsigned char b)
+{
+ return (vector bool char)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
+static vector bool char __ATTRS_o_ai
+vec_srl(vector bool char a, vector unsigned short b)
+{
+ return (vector bool char)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
+static vector bool char __ATTRS_o_ai
+vec_srl(vector bool char a, vector unsigned int b)
+{
+ return (vector bool char)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
static vector short __ATTRS_o_ai
vec_srl(vector short a, vector unsigned char b)
{
return (vector unsigned short)__builtin_altivec_vsr((vector int)a, (vector int)b);
}
-static vector int __ATTRS_o_ai
-vec_srl(vector int a, vector unsigned char b)
+static vector bool short __ATTRS_o_ai
+vec_srl(vector bool short a, vector unsigned char b)
{
- return (vector int)__builtin_altivec_vsr(a, (vector int)b);
+ return (vector bool short)__builtin_altivec_vsr((vector int)a, (vector int)b);
}
-static vector int __ATTRS_o_ai
-vec_srl(vector int a, vector unsigned short b)
+static vector bool short __ATTRS_o_ai
+vec_srl(vector bool short a, vector unsigned short b)
{
- return (vector int)__builtin_altivec_vsr(a, (vector int)b);
+ return (vector bool short)__builtin_altivec_vsr((vector int)a, (vector int)b);
}
-static vector int __ATTRS_o_ai
-vec_srl(vector int a, vector unsigned int b)
+static vector bool short __ATTRS_o_ai
+vec_srl(vector bool short a, vector unsigned int b)
{
- return (vector int)__builtin_altivec_vsr(a, (vector int)b);
+ return (vector bool short)__builtin_altivec_vsr((vector int)a, (vector int)b);
}
-static vector unsigned int __ATTRS_o_ai
-vec_srl(vector unsigned int a, vector unsigned char b)
+static vector pixel __ATTRS_o_ai
+vec_srl(vector pixel a, vector unsigned char b)
+{
+ return (vector pixel)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
+static vector pixel __ATTRS_o_ai
+vec_srl(vector pixel a, vector unsigned short b)
+{
+ return (vector pixel)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
+static vector pixel __ATTRS_o_ai
+vec_srl(vector pixel a, vector unsigned int b)
+{
+ return (vector pixel)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
+static vector int __ATTRS_o_ai
+vec_srl(vector int a, vector unsigned char b)
+{
+ return (vector int)__builtin_altivec_vsr(a, (vector int)b);
+}
+
+static vector int __ATTRS_o_ai
+vec_srl(vector int a, vector unsigned short b)
+{
+ return (vector int)__builtin_altivec_vsr(a, (vector int)b);
+}
+
+static vector int __ATTRS_o_ai
+vec_srl(vector int a, vector unsigned int b)
+{
+ return (vector int)__builtin_altivec_vsr(a, (vector int)b);
+}
+
+static vector unsigned int __ATTRS_o_ai
+vec_srl(vector unsigned int a, vector unsigned char b)
{
return (vector unsigned int)__builtin_altivec_vsr((vector int)a, (vector int)b);
}
return (vector unsigned int)__builtin_altivec_vsr((vector int)a, (vector int)b);
}
+static vector bool int __ATTRS_o_ai
+vec_srl(vector bool int a, vector unsigned char b)
+{
+ return (vector bool int)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
+static vector bool int __ATTRS_o_ai
+vec_srl(vector bool int a, vector unsigned short b)
+{
+ return (vector bool int)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
+static vector bool int __ATTRS_o_ai
+vec_srl(vector bool int a, vector unsigned int b)
+{
+ return (vector bool int)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
/* vec_vsr */
static vector signed char __ATTRS_o_ai
return (vector unsigned char)__builtin_altivec_vsr((vector int)a, (vector int)b);
}
+static vector bool char __ATTRS_o_ai
+vec_vsr(vector bool char a, vector unsigned char b)
+{
+ return (vector bool char)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
+static vector bool char __ATTRS_o_ai
+vec_vsr(vector bool char a, vector unsigned short b)
+{
+ return (vector bool char)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
+static vector bool char __ATTRS_o_ai
+vec_vsr(vector bool char a, vector unsigned int b)
+{
+ return (vector bool char)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
static vector short __ATTRS_o_ai
vec_vsr(vector short a, vector unsigned char b)
{
return (vector unsigned short)__builtin_altivec_vsr((vector int)a, (vector int)b);
}
+static vector bool short __ATTRS_o_ai
+vec_vsr(vector bool short a, vector unsigned char b)
+{
+ return (vector bool short)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
+static vector bool short __ATTRS_o_ai
+vec_vsr(vector bool short a, vector unsigned short b)
+{
+ return (vector bool short)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
+static vector bool short __ATTRS_o_ai
+vec_vsr(vector bool short a, vector unsigned int b)
+{
+ return (vector bool short)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
+static vector pixel __ATTRS_o_ai
+vec_vsr(vector pixel a, vector unsigned char b)
+{
+ return (vector pixel)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
+static vector pixel __ATTRS_o_ai
+vec_vsr(vector pixel a, vector unsigned short b)
+{
+ return (vector pixel)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
+static vector pixel __ATTRS_o_ai
+vec_vsr(vector pixel a, vector unsigned int b)
+{
+ return (vector pixel)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
static vector int __ATTRS_o_ai
vec_vsr(vector int a, vector unsigned char b)
{
return (vector unsigned int)__builtin_altivec_vsr((vector int)a, (vector int)b);
}
+static vector bool int __ATTRS_o_ai
+vec_vsr(vector bool int a, vector unsigned char b)
+{
+ return (vector bool int)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
+static vector bool int __ATTRS_o_ai
+vec_vsr(vector bool int a, vector unsigned short b)
+{
+ return (vector bool int)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
+static vector bool int __ATTRS_o_ai
+vec_vsr(vector bool int a, vector unsigned int b)
+{
+ return (vector bool int)__builtin_altivec_vsr((vector int)a, (vector int)b);
+}
+
/* vec_sro */
static vector signed char __ATTRS_o_ai
return (vector unsigned short)__builtin_altivec_vsro((vector int)a, (vector int)b);
}
+static vector pixel __ATTRS_o_ai
+vec_sro(vector pixel a, vector signed char b)
+{
+ return (vector pixel)__builtin_altivec_vsro((vector int)a, (vector int)b);
+}
+
+static vector pixel __ATTRS_o_ai
+vec_sro(vector pixel a, vector unsigned char b)
+{
+ return (vector pixel)__builtin_altivec_vsro((vector int)a, (vector int)b);
+}
+
static vector int __ATTRS_o_ai
vec_sro(vector int a, vector signed char b)
{
return (vector unsigned short)__builtin_altivec_vsro((vector int)a, (vector int)b);
}
+static vector pixel __ATTRS_o_ai
+vec_vsro(vector pixel a, vector signed char b)
+{
+ return (vector pixel)__builtin_altivec_vsro((vector int)a, (vector int)b);
+}
+
+static vector pixel __ATTRS_o_ai
+vec_vsro(vector pixel a, vector unsigned char b)
+{
+ return (vector pixel)__builtin_altivec_vsro((vector int)a, (vector int)b);
+}
+
static vector int __ATTRS_o_ai
vec_vsro(vector int a, vector signed char b)
{
}
static void __ATTRS_o_ai
-vec_st(vector short a, int b, vector short *c)
+vec_st(vector bool char a, int b, signed char *c)
{
__builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_st(vector short a, int b, short *c)
+vec_st(vector bool char a, int b, unsigned char *c)
{
__builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_st(vector unsigned short a, int b, vector unsigned short *c)
+vec_st(vector bool char a, int b, vector bool char *c)
{
__builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_st(vector unsigned short a, int b, unsigned short *c)
+vec_st(vector short a, int b, vector short *c)
{
__builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_st(vector int a, int b, vector int *c)
+vec_st(vector short a, int b, short *c)
{
- __builtin_altivec_stvx(a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_st(vector int a, int b, int *c)
+vec_st(vector unsigned short a, int b, vector unsigned short *c)
{
- __builtin_altivec_stvx(a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_st(vector unsigned int a, int b, vector unsigned int *c)
+vec_st(vector unsigned short a, int b, unsigned short *c)
{
__builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_st(vector unsigned int a, int b, unsigned int *c)
+vec_st(vector bool short a, int b, short *c)
{
__builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_st(vector float a, int b, vector float *c)
+vec_st(vector bool short a, int b, unsigned short *c)
{
__builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_st(vector float a, int b, float *c)
+vec_st(vector bool short a, int b, vector bool short *c)
{
__builtin_altivec_stvx((vector int)a, b, c);
}
-/* vec_stvx */
-
static void __ATTRS_o_ai
-vec_stvx(vector signed char a, int b, vector signed char *c)
+vec_st(vector pixel a, int b, short *c)
{
__builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stvx(vector signed char a, int b, signed char *c)
+vec_st(vector pixel a, int b, unsigned short *c)
{
__builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stvx(vector unsigned char a, int b, vector unsigned char *c)
+vec_st(vector pixel a, int b, vector pixel *c)
{
__builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stvx(vector unsigned char a, int b, unsigned char *c)
+vec_st(vector int a, int b, vector int *c)
{
- __builtin_altivec_stvx((vector int)a, b, c);
+ __builtin_altivec_stvx(a, b, c);
}
static void __ATTRS_o_ai
-vec_stvx(vector short a, int b, vector short *c)
+vec_st(vector int a, int b, int *c)
{
- __builtin_altivec_stvx((vector int)a, b, c);
+ __builtin_altivec_stvx(a, b, c);
}
static void __ATTRS_o_ai
-vec_stvx(vector short a, int b, short *c)
+vec_st(vector unsigned int a, int b, vector unsigned int *c)
{
__builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stvx(vector unsigned short a, int b, vector unsigned short *c)
+vec_st(vector unsigned int a, int b, unsigned int *c)
{
__builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stvx(vector unsigned short a, int b, unsigned short *c)
+vec_st(vector bool int a, int b, int *c)
{
__builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stvx(vector int a, int b, vector int *c)
+vec_st(vector bool int a, int b, unsigned int *c)
{
- __builtin_altivec_stvx(a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stvx(vector int a, int b, int *c)
+vec_st(vector bool int a, int b, vector bool int *c)
{
- __builtin_altivec_stvx(a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stvx(vector unsigned int a, int b, vector unsigned int *c)
+vec_st(vector float a, int b, vector float *c)
{
__builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stvx(vector unsigned int a, int b, unsigned int *c)
+vec_st(vector float a, int b, float *c)
{
__builtin_altivec_stvx((vector int)a, b, c);
}
+/* vec_stvx */
+
static void __ATTRS_o_ai
-vec_stvx(vector float a, int b, vector float *c)
+vec_stvx(vector signed char a, int b, vector signed char *c)
{
__builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stvx(vector float a, int b, float *c)
+vec_stvx(vector signed char a, int b, signed char *c)
{
__builtin_altivec_stvx((vector int)a, b, c);
}
-/* vec_ste */
-
static void __ATTRS_o_ai
-vec_ste(vector signed char a, int b, signed char *c)
+vec_stvx(vector unsigned char a, int b, vector unsigned char *c)
{
- __builtin_altivec_stvebx((vector char)a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_ste(vector unsigned char a, int b, unsigned char *c)
+vec_stvx(vector unsigned char a, int b, unsigned char *c)
{
- __builtin_altivec_stvebx((vector char)a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_ste(vector short a, int b, short *c)
+vec_stvx(vector bool char a, int b, signed char *c)
{
- __builtin_altivec_stvehx(a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_ste(vector unsigned short a, int b, unsigned short *c)
+vec_stvx(vector bool char a, int b, unsigned char *c)
{
- __builtin_altivec_stvehx((vector short)a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_ste(vector int a, int b, int *c)
+vec_stvx(vector bool char a, int b, vector bool char *c)
{
- __builtin_altivec_stvewx(a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_ste(vector unsigned int a, int b, unsigned int *c)
+vec_stvx(vector short a, int b, vector short *c)
{
- __builtin_altivec_stvewx((vector int)a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_ste(vector float a, int b, float *c)
+vec_stvx(vector short a, int b, short *c)
{
- __builtin_altivec_stvewx((vector int)a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
-/* vec_stvebx */
-
static void __ATTRS_o_ai
-vec_stvebx(vector signed char a, int b, signed char *c)
+vec_stvx(vector unsigned short a, int b, vector unsigned short *c)
{
- __builtin_altivec_stvebx((vector char)a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stvebx(vector unsigned char a, int b, unsigned char *c)
+vec_stvx(vector unsigned short a, int b, unsigned short *c)
{
- __builtin_altivec_stvebx((vector char)a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
-/* vec_stvehx */
-
static void __ATTRS_o_ai
-vec_stvehx(vector short a, int b, short *c)
+vec_stvx(vector bool short a, int b, short *c)
{
- __builtin_altivec_stvehx(a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stvehx(vector unsigned short a, int b, unsigned short *c)
+vec_stvx(vector bool short a, int b, unsigned short *c)
{
- __builtin_altivec_stvehx((vector short)a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
-/* vec_stvewx */
-
static void __ATTRS_o_ai
-vec_stvewx(vector int a, int b, int *c)
+vec_stvx(vector bool short a, int b, vector bool short *c)
{
- __builtin_altivec_stvewx(a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stvewx(vector unsigned int a, int b, unsigned int *c)
+vec_stvx(vector pixel a, int b, short *c)
{
- __builtin_altivec_stvewx((vector int)a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stvewx(vector float a, int b, float *c)
+vec_stvx(vector pixel a, int b, unsigned short *c)
{
- __builtin_altivec_stvewx((vector int)a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
-/* vec_stl */
-
static void __ATTRS_o_ai
-vec_stl(vector signed char a, int b, vector signed char *c)
+vec_stvx(vector pixel a, int b, vector pixel *c)
{
- __builtin_altivec_stvxl((vector int)a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stl(vector signed char a, int b, signed char *c)
+vec_stvx(vector int a, int b, vector int *c)
{
- __builtin_altivec_stvxl((vector int)a, b, c);
+ __builtin_altivec_stvx(a, b, c);
}
static void __ATTRS_o_ai
-vec_stl(vector unsigned char a, int b, vector unsigned char *c)
+vec_stvx(vector int a, int b, int *c)
{
- __builtin_altivec_stvxl((vector int)a, b, c);
+ __builtin_altivec_stvx(a, b, c);
}
static void __ATTRS_o_ai
-vec_stl(vector unsigned char a, int b, unsigned char *c)
+vec_stvx(vector unsigned int a, int b, vector unsigned int *c)
{
- __builtin_altivec_stvxl((vector int)a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stl(vector short a, int b, vector short *c)
+vec_stvx(vector unsigned int a, int b, unsigned int *c)
{
- __builtin_altivec_stvxl((vector int)a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stl(vector short a, int b, short *c)
+vec_stvx(vector bool int a, int b, int *c)
{
- __builtin_altivec_stvxl((vector int)a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stl(vector unsigned short a, int b, vector unsigned short *c)
+vec_stvx(vector bool int a, int b, unsigned int *c)
{
- __builtin_altivec_stvxl((vector int)a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stl(vector unsigned short a, int b, unsigned short *c)
+vec_stvx(vector bool int a, int b, vector bool int *c)
{
- __builtin_altivec_stvxl((vector int)a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stl(vector int a, int b, vector int *c)
+vec_stvx(vector float a, int b, vector float *c)
{
- __builtin_altivec_stvxl(a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
static void __ATTRS_o_ai
-vec_stl(vector int a, int b, int *c)
+vec_stvx(vector float a, int b, float *c)
{
- __builtin_altivec_stvxl(a, b, c);
+ __builtin_altivec_stvx((vector int)a, b, c);
}
+/* vec_ste */
+
static void __ATTRS_o_ai
-vec_stl(vector unsigned int a, int b, vector unsigned int *c)
+vec_ste(vector signed char a, int b, signed char *c)
+{
+ __builtin_altivec_stvebx((vector char)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_ste(vector unsigned char a, int b, unsigned char *c)
+{
+ __builtin_altivec_stvebx((vector char)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_ste(vector bool char a, int b, signed char *c)
+{
+ __builtin_altivec_stvebx((vector char)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_ste(vector bool char a, int b, unsigned char *c)
+{
+ __builtin_altivec_stvebx((vector char)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_ste(vector short a, int b, short *c)
+{
+ __builtin_altivec_stvehx(a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_ste(vector unsigned short a, int b, unsigned short *c)
+{
+ __builtin_altivec_stvehx((vector short)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_ste(vector bool short a, int b, short *c)
+{
+ __builtin_altivec_stvehx((vector short)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_ste(vector bool short a, int b, unsigned short *c)
+{
+ __builtin_altivec_stvehx((vector short)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_ste(vector pixel a, int b, short *c)
+{
+ __builtin_altivec_stvehx((vector short)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_ste(vector pixel a, int b, unsigned short *c)
+{
+ __builtin_altivec_stvehx((vector short)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_ste(vector int a, int b, int *c)
+{
+ __builtin_altivec_stvewx(a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_ste(vector unsigned int a, int b, unsigned int *c)
+{
+ __builtin_altivec_stvewx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_ste(vector bool int a, int b, int *c)
+{
+ __builtin_altivec_stvewx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_ste(vector bool int a, int b, unsigned int *c)
+{
+ __builtin_altivec_stvewx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_ste(vector float a, int b, float *c)
+{
+ __builtin_altivec_stvewx((vector int)a, b, c);
+}
+
+/* vec_stvebx */
+
+static void __ATTRS_o_ai
+vec_stvebx(vector signed char a, int b, signed char *c)
+{
+ __builtin_altivec_stvebx((vector char)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvebx(vector unsigned char a, int b, unsigned char *c)
+{
+ __builtin_altivec_stvebx((vector char)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvebx(vector bool char a, int b, signed char *c)
+{
+ __builtin_altivec_stvebx((vector char)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvebx(vector bool char a, int b, unsigned char *c)
+{
+ __builtin_altivec_stvebx((vector char)a, b, c);
+}
+
+/* vec_stvehx */
+
+static void __ATTRS_o_ai
+vec_stvehx(vector short a, int b, short *c)
+{
+ __builtin_altivec_stvehx(a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvehx(vector unsigned short a, int b, unsigned short *c)
+{
+ __builtin_altivec_stvehx((vector short)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvehx(vector bool short a, int b, short *c)
+{
+ __builtin_altivec_stvehx((vector short)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvehx(vector bool short a, int b, unsigned short *c)
+{
+ __builtin_altivec_stvehx((vector short)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvehx(vector pixel a, int b, short *c)
+{
+ __builtin_altivec_stvehx((vector short)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvehx(vector pixel a, int b, unsigned short *c)
+{
+ __builtin_altivec_stvehx((vector short)a, b, c);
+}
+
+/* vec_stvewx */
+
+static void __ATTRS_o_ai
+vec_stvewx(vector int a, int b, int *c)
+{
+ __builtin_altivec_stvewx(a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvewx(vector unsigned int a, int b, unsigned int *c)
+{
+ __builtin_altivec_stvewx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvewx(vector bool int a, int b, int *c)
+{
+ __builtin_altivec_stvewx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvewx(vector bool int a, int b, unsigned int *c)
+{
+ __builtin_altivec_stvewx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvewx(vector float a, int b, float *c)
+{
+ __builtin_altivec_stvewx((vector int)a, b, c);
+}
+
+/* vec_stl */
+
+static void __ATTRS_o_ai
+vec_stl(vector signed char a, int b, vector signed char *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector signed char a, int b, signed char *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector unsigned char a, int b, vector unsigned char *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector unsigned char a, int b, unsigned char *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector bool char a, int b, signed char *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector bool char a, int b, unsigned char *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector bool char a, int b, vector bool char *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector short a, int b, vector short *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector short a, int b, short *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector unsigned short a, int b, vector unsigned short *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector unsigned short a, int b, unsigned short *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector bool short a, int b, short *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector bool short a, int b, unsigned short *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector bool short a, int b, vector bool short *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector pixel a, int b, short *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector pixel a, int b, unsigned short *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector pixel a, int b, vector pixel *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector int a, int b, vector int *c)
+{
+ __builtin_altivec_stvxl(a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector int a, int b, int *c)
+{
+ __builtin_altivec_stvxl(a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector unsigned int a, int b, vector unsigned int *c)
{
__builtin_altivec_stvxl((vector int)a, b, c);
}
__builtin_altivec_stvxl((vector int)a, b, c);
}
+static void __ATTRS_o_ai
+vec_stl(vector bool int a, int b, int *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector bool int a, int b, unsigned int *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stl(vector bool int a, int b, vector bool int *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
static void __ATTRS_o_ai
vec_stl(vector float a, int b, vector float *c)
{
__builtin_altivec_stvxl((vector int)a, b, c);
}
+static void __ATTRS_o_ai
+vec_stvxl(vector bool char a, int b, signed char *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvxl(vector bool char a, int b, unsigned char *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvxl(vector bool char a, int b, vector bool char *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
static void __ATTRS_o_ai
vec_stvxl(vector short a, int b, vector short *c)
{
__builtin_altivec_stvxl((vector int)a, b, c);
}
+static void __ATTRS_o_ai
+vec_stvxl(vector bool short a, int b, short *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvxl(vector bool short a, int b, unsigned short *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvxl(vector bool short a, int b, vector bool short *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvxl(vector pixel a, int b, short *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvxl(vector pixel a, int b, unsigned short *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvxl(vector pixel a, int b, vector pixel *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
static void __ATTRS_o_ai
vec_stvxl(vector int a, int b, vector int *c)
{
__builtin_altivec_stvxl((vector int)a, b, c);
}
+static void __ATTRS_o_ai
+vec_stvxl(vector bool int a, int b, int *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvxl(vector bool int a, int b, unsigned int *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvxl(vector bool int a, int b, vector bool int *c)
+{
+ __builtin_altivec_stvxl((vector int)a, b, c);
+}
+
static void __ATTRS_o_ai
vec_stvxl(vector float a, int b, vector float *c)
{
return a - b;
}
+static vector signed char __ATTRS_o_ai
+vec_sub(vector bool char a, vector signed char b)
+{
+ return (vector signed char)a - b;
+}
+
+static vector signed char __ATTRS_o_ai
+vec_sub(vector signed char a, vector bool char b)
+{
+ return a - (vector signed char)b;
+}
+
static vector unsigned char __ATTRS_o_ai
vec_sub(vector unsigned char a, vector unsigned char b)
{
return a - b;
}
+static vector unsigned char __ATTRS_o_ai
+vec_sub(vector bool char a, vector unsigned char b)
+{
+ return (vector unsigned char)a - b;
+}
+
+static vector unsigned char __ATTRS_o_ai
+vec_sub(vector unsigned char a, vector bool char b)
+{
+ return a - (vector unsigned char)b;
+}
+
static vector short __ATTRS_o_ai
vec_sub(vector short a, vector short b)
{
return a - b;
}
+static vector short __ATTRS_o_ai
+vec_sub(vector bool short a, vector short b)
+{
+ return (vector short)a - b;
+}
+
+static vector short __ATTRS_o_ai
+vec_sub(vector short a, vector bool short b)
+{
+ return a - (vector short)b;
+}
+
static vector unsigned short __ATTRS_o_ai
vec_sub(vector unsigned short a, vector unsigned short b)
{
return a - b;
}
+static vector unsigned short __ATTRS_o_ai
+vec_sub(vector bool short a, vector unsigned short b)
+{
+ return (vector unsigned short)a - b;
+}
+
+static vector unsigned short __ATTRS_o_ai
+vec_sub(vector unsigned short a, vector bool short b)
+{
+ return a - (vector unsigned short)b;
+}
+
static vector int __ATTRS_o_ai
vec_sub(vector int a, vector int b)
{
return a - b;
}
+static vector int __ATTRS_o_ai
+vec_sub(vector bool int a, vector int b)
+{
+ return (vector int)a - b;
+}
+
+static vector int __ATTRS_o_ai
+vec_sub(vector int a, vector bool int b)
+{
+ return a - (vector int)b;
+}
+
static vector unsigned int __ATTRS_o_ai
vec_sub(vector unsigned int a, vector unsigned int b)
{
return a - b;
}
+static vector unsigned int __ATTRS_o_ai
+vec_sub(vector bool int a, vector unsigned int b)
+{
+ return (vector unsigned int)a - b;
+}
+
+static vector unsigned int __ATTRS_o_ai
+vec_sub(vector unsigned int a, vector bool int b)
+{
+ return a - (vector unsigned int)b;
+}
+
static vector float __ATTRS_o_ai
vec_sub(vector float a, vector float b)
{
return a - b;
}
+static vector signed char __ATTRS_o_ai
+vec_vsububm(vector bool char a, vector signed char b)
+{
+ return (vector signed char)a - b;
+}
+
+static vector signed char __ATTRS_o_ai
+vec_vsububm(vector signed char a, vector bool char b)
+{
+ return a - (vector signed char)b;
+}
+
static vector unsigned char __ATTRS_o_ai
vec_vsububm(vector unsigned char a, vector unsigned char b)
{
return a - b;
}
+static vector unsigned char __ATTRS_o_ai
+vec_vsububm(vector bool char a, vector unsigned char b)
+{
+ return (vector unsigned char)a - b;
+}
+
+static vector unsigned char __ATTRS_o_ai
+vec_vsububm(vector unsigned char a, vector bool char b)
+{
+ return a - (vector unsigned char)b;
+}
+
/* vec_vsubuhm */
#define __builtin_altivec_vsubuhm vec_vsubuhm
return a - b;
}
+static vector short __ATTRS_o_ai
+vec_vsubuhm(vector bool short a, vector short b)
+{
+ return (vector short)a - b;
+}
+
+static vector short __ATTRS_o_ai
+vec_vsubuhm(vector short a, vector bool short b)
+{
+ return a - (vector short)b;
+}
+
static vector unsigned short __ATTRS_o_ai
vec_vsubuhm(vector unsigned short a, vector unsigned short b)
{
return a - b;
}
+static vector unsigned short __ATTRS_o_ai
+vec_vsubuhm(vector bool short a, vector unsigned short b)
+{
+ return (vector unsigned short)a - b;
+}
+
+static vector unsigned short __ATTRS_o_ai
+vec_vsubuhm(vector unsigned short a, vector bool short b)
+{
+ return a - (vector unsigned short)b;
+}
+
/* vec_vsubuwm */
#define __builtin_altivec_vsubuwm vec_vsubuwm
return a - b;
}
+static vector int __ATTRS_o_ai
+vec_vsubuwm(vector bool int a, vector int b)
+{
+ return (vector int)a - b;
+}
+
+static vector int __ATTRS_o_ai
+vec_vsubuwm(vector int a, vector bool int b)
+{
+ return a - (vector int)b;
+}
+
static vector unsigned int __ATTRS_o_ai
vec_vsubuwm(vector unsigned int a, vector unsigned int b)
{
return a - b;
}
+static vector unsigned int __ATTRS_o_ai
+vec_vsubuwm(vector bool int a, vector unsigned int b)
+{
+ return (vector unsigned int)a - b;
+}
+
+static vector unsigned int __ATTRS_o_ai
+vec_vsubuwm(vector unsigned int a, vector bool int b)
+{
+ return a - (vector unsigned int)b;
+}
+
/* vec_vsubfp */
#define __builtin_altivec_vsubfp vec_vsubfp
return __builtin_altivec_vsubsbs(a, b);
}
+static vector signed char __ATTRS_o_ai
+vec_subs(vector bool char a, vector signed char b)
+{
+ return __builtin_altivec_vsubsbs((vector signed char)a, b);
+}
+
+static vector signed char __ATTRS_o_ai
+vec_subs(vector signed char a, vector bool char b)
+{
+ return __builtin_altivec_vsubsbs(a, (vector signed char)b);
+}
+
static vector unsigned char __ATTRS_o_ai
vec_subs(vector unsigned char a, vector unsigned char b)
{
return __builtin_altivec_vsububs(a, b);
}
+static vector unsigned char __ATTRS_o_ai
+vec_subs(vector bool char a, vector unsigned char b)
+{
+ return __builtin_altivec_vsububs((vector unsigned char)a, b);
+}
+
+static vector unsigned char __ATTRS_o_ai
+vec_subs(vector unsigned char a, vector bool char b)
+{
+ return __builtin_altivec_vsububs(a, (vector unsigned char)b);
+}
+
static vector short __ATTRS_o_ai
vec_subs(vector short a, vector short b)
{
return __builtin_altivec_vsubshs(a, b);
}
+static vector short __ATTRS_o_ai
+vec_subs(vector bool short a, vector short b)
+{
+ return __builtin_altivec_vsubshs((vector short)a, b);
+}
+
+static vector short __ATTRS_o_ai
+vec_subs(vector short a, vector bool short b)
+{
+ return __builtin_altivec_vsubshs(a, (vector short)b);
+}
+
static vector unsigned short __ATTRS_o_ai
vec_subs(vector unsigned short a, vector unsigned short b)
{
return __builtin_altivec_vsubuhs(a, b);
}
+static vector unsigned short __ATTRS_o_ai
+vec_subs(vector bool short a, vector unsigned short b)
+{
+ return __builtin_altivec_vsubuhs((vector unsigned short)a, b);
+}
+
+static vector unsigned short __ATTRS_o_ai
+vec_subs(vector unsigned short a, vector bool short b)
+{
+ return __builtin_altivec_vsubuhs(a, (vector unsigned short)b);
+}
+
static vector int __ATTRS_o_ai
vec_subs(vector int a, vector int b)
{
return __builtin_altivec_vsubsws(a, b);
}
+static vector int __ATTRS_o_ai
+vec_subs(vector bool int a, vector int b)
+{
+ return __builtin_altivec_vsubsws((vector int)a, b);
+}
+
+static vector int __ATTRS_o_ai
+vec_subs(vector int a, vector bool int b)
+{
+ return __builtin_altivec_vsubsws(a, (vector int)b);
+}
+
static vector unsigned int __ATTRS_o_ai
vec_subs(vector unsigned int a, vector unsigned int b)
{
return __builtin_altivec_vsubuws(a, b);
}
+static vector unsigned int __ATTRS_o_ai
+vec_subs(vector bool int a, vector unsigned int b)
+{
+ return __builtin_altivec_vsubuws((vector unsigned int)a, b);
+}
+
+static vector unsigned int __ATTRS_o_ai
+vec_subs(vector unsigned int a, vector bool int b)
+{
+ return __builtin_altivec_vsubuws(a, (vector unsigned int)b);
+}
+
/* vec_vsubsbs */
-static vector signed char __attribute__((__always_inline__))
+static vector signed char __ATTRS_o_ai
vec_vsubsbs(vector signed char a, vector signed char b)
{
return __builtin_altivec_vsubsbs(a, b);
}
+static vector signed char __ATTRS_o_ai
+vec_vsubsbs(vector bool char a, vector signed char b)
+{
+ return __builtin_altivec_vsubsbs((vector signed char)a, b);
+}
+
+static vector signed char __ATTRS_o_ai
+vec_vsubsbs(vector signed char a, vector bool char b)
+{
+ return __builtin_altivec_vsubsbs(a, (vector signed char)b);
+}
+
/* vec_vsububs */
-static vector unsigned char __attribute__((__always_inline__))
+static vector unsigned char __ATTRS_o_ai
vec_vsububs(vector unsigned char a, vector unsigned char b)
{
return __builtin_altivec_vsububs(a, b);
}
+static vector unsigned char __ATTRS_o_ai
+vec_vsububs(vector bool char a, vector unsigned char b)
+{
+ return __builtin_altivec_vsububs((vector unsigned char)a, b);
+}
+
+static vector unsigned char __ATTRS_o_ai
+vec_vsububs(vector unsigned char a, vector bool char b)
+{
+ return __builtin_altivec_vsububs(a, (vector unsigned char)b);
+}
+
/* vec_vsubshs */
-static vector short __attribute__((__always_inline__))
+static vector short __ATTRS_o_ai
vec_vsubshs(vector short a, vector short b)
{
return __builtin_altivec_vsubshs(a, b);
}
+static vector short __ATTRS_o_ai
+vec_vsubshs(vector bool short a, vector short b)
+{
+ return __builtin_altivec_vsubshs((vector short)a, b);
+}
+
+static vector short __ATTRS_o_ai
+vec_vsubshs(vector short a, vector bool short b)
+{
+ return __builtin_altivec_vsubshs(a, (vector short)b);
+}
+
/* vec_vsubuhs */
-static vector unsigned short __attribute__((__always_inline__))
+static vector unsigned short __ATTRS_o_ai
vec_vsubuhs(vector unsigned short a, vector unsigned short b)
{
return __builtin_altivec_vsubuhs(a, b);
}
+static vector unsigned short __ATTRS_o_ai
+vec_vsubuhs(vector bool short a, vector unsigned short b)
+{
+ return __builtin_altivec_vsubuhs((vector unsigned short)a, b);
+}
+
+static vector unsigned short __ATTRS_o_ai
+vec_vsubuhs(vector unsigned short a, vector bool short b)
+{
+ return __builtin_altivec_vsubuhs(a, (vector unsigned short)b);
+}
+
/* vec_vsubsws */
-static vector int __attribute__((__always_inline__))
+static vector int __ATTRS_o_ai
vec_vsubsws(vector int a, vector int b)
{
return __builtin_altivec_vsubsws(a, b);
}
+static vector int __ATTRS_o_ai
+vec_vsubsws(vector bool int a, vector int b)
+{
+ return __builtin_altivec_vsubsws((vector int)a, b);
+}
+
+static vector int __ATTRS_o_ai
+vec_vsubsws(vector int a, vector bool int b)
+{
+ return __builtin_altivec_vsubsws(a, (vector int)b);
+}
+
/* vec_vsubuws */
-static vector unsigned int __attribute__((__always_inline__))
+static vector unsigned int __ATTRS_o_ai
vec_vsubuws(vector unsigned int a, vector unsigned int b)
{
return __builtin_altivec_vsubuws(a, b);
}
+static vector unsigned int __ATTRS_o_ai
+vec_vsubuws(vector bool int a, vector unsigned int b)
+{
+ return __builtin_altivec_vsubuws((vector unsigned int)a, b);
+}
+
+static vector unsigned int __ATTRS_o_ai
+vec_vsubuws(vector unsigned int a, vector bool int b)
+{
+ return __builtin_altivec_vsubuws(a, (vector unsigned int)b);
+}
+
/* vec_sum4s */
static vector int __ATTRS_o_ai
return __builtin_altivec_vupkhsb((vector char)a);
}
+static vector bool short __ATTRS_o_ai
+vec_unpackh(vector bool char a)
+{
+ return (vector bool short)__builtin_altivec_vupkhsb((vector char)a);
+}
+
static vector int __ATTRS_o_ai
vec_unpackh(vector short a)
{
return __builtin_altivec_vupkhsh(a);
}
+static vector bool int __ATTRS_o_ai
+vec_unpackh(vector bool short a)
+{
+ return (vector bool int)__builtin_altivec_vupkhsh((vector short)a);
+}
+
+static vector unsigned int __ATTRS_o_ai
+vec_unpackh(vector pixel a)
+{
+ return (vector unsigned int)__builtin_altivec_vupkhsh((vector short)a);
+}
+
/* vec_vupkhsb */
-static vector short __attribute__((__always_inline__))
+static vector short __ATTRS_o_ai
vec_vupkhsb(vector signed char a)
{
return __builtin_altivec_vupkhsb((vector char)a);
}
+static vector bool short __ATTRS_o_ai
+vec_vupkhsb(vector bool char a)
+{
+ return (vector bool short)__builtin_altivec_vupkhsb((vector char)a);
+}
+
/* vec_vupkhsh */
-static vector int __attribute__((__always_inline__))
+static vector int __ATTRS_o_ai
vec_vupkhsh(vector short a)
{
return __builtin_altivec_vupkhsh(a);
}
+static vector bool int __ATTRS_o_ai
+vec_vupkhsh(vector bool short a)
+{
+ return (vector bool int)__builtin_altivec_vupkhsh((vector short)a);
+}
+
+static vector unsigned int __ATTRS_o_ai
+vec_vupkhsh(vector pixel a)
+{
+ return (vector unsigned int)__builtin_altivec_vupkhsh((vector short)a);
+}
+
/* vec_unpackl */
static vector short __ATTRS_o_ai
return __builtin_altivec_vupklsb((vector char)a);
}
+static vector bool short __ATTRS_o_ai
+vec_unpackl(vector bool char a)
+{
+ return (vector bool short)__builtin_altivec_vupklsb((vector char)a);
+}
+
static vector int __ATTRS_o_ai
vec_unpackl(vector short a)
{
return __builtin_altivec_vupklsh(a);
}
+static vector bool int __ATTRS_o_ai
+vec_unpackl(vector bool short a)
+{
+ return (vector bool int)__builtin_altivec_vupklsh((vector short)a);
+}
+
+static vector unsigned int __ATTRS_o_ai
+vec_unpackl(vector pixel a)
+{
+ return (vector unsigned int)__builtin_altivec_vupklsh((vector short)a);
+}
+
/* vec_vupklsb */
-static vector short __attribute__((__always_inline__))
+static vector short __ATTRS_o_ai
vec_vupklsb(vector signed char a)
{
return __builtin_altivec_vupklsb((vector char)a);
}
+static vector bool short __ATTRS_o_ai
+vec_vupklsb(vector bool char a)
+{
+ return (vector bool short)__builtin_altivec_vupklsb((vector char)a);
+}
+
/* vec_vupklsh */
-static vector int __attribute__((__always_inline__))
+static vector int __ATTRS_o_ai
vec_vupklsh(vector short a)
{
return __builtin_altivec_vupklsh(a);
}
+static vector bool int __ATTRS_o_ai
+vec_vupklsh(vector bool short a)
+{
+ return (vector bool int)__builtin_altivec_vupklsh((vector short)a);
+}
+
+static vector unsigned int __ATTRS_o_ai
+vec_vupklsh(vector pixel a)
+{
+ return (vector unsigned int)__builtin_altivec_vupklsh((vector short)a);
+}
+
/* vec_xor */
#define __builtin_altivec_vxor vec_xor
return a ^ b;
}
+static vector signed char __ATTRS_o_ai
+vec_xor(vector bool char a, vector signed char b)
+{
+ return (vector signed char)a ^ b;
+}
+
+static vector signed char __ATTRS_o_ai
+vec_xor(vector signed char a, vector bool char b)
+{
+ return a ^ (vector signed char)b;
+}
+
static vector unsigned char __ATTRS_o_ai
vec_xor(vector unsigned char a, vector unsigned char b)
{
return a ^ b;
}
+static vector unsigned char __ATTRS_o_ai
+vec_xor(vector bool char a, vector unsigned char b)
+{
+ return (vector unsigned char)a ^ b;
+}
+
+static vector unsigned char __ATTRS_o_ai
+vec_xor(vector unsigned char a, vector bool char b)
+{
+ return a ^ (vector unsigned char)b;
+}
+
+static vector bool char __ATTRS_o_ai
+vec_xor(vector bool char a, vector bool char b)
+{
+ return a ^ b;
+}
+
static vector short __ATTRS_o_ai
vec_xor(vector short a, vector short b)
{
return a ^ b;
}
+static vector short __ATTRS_o_ai
+vec_xor(vector bool short a, vector short b)
+{
+ return (vector short)a ^ b;
+}
+
+static vector short __ATTRS_o_ai
+vec_xor(vector short a, vector bool short b)
+{
+ return a ^ (vector short)b;
+}
+
static vector unsigned short __ATTRS_o_ai
vec_xor(vector unsigned short a, vector unsigned short b)
{
return a ^ b;
}
+static vector unsigned short __ATTRS_o_ai
+vec_xor(vector bool short a, vector unsigned short b)
+{
+ return (vector unsigned short)a ^ b;
+}
+
+static vector unsigned short __ATTRS_o_ai
+vec_xor(vector unsigned short a, vector bool short b)
+{
+ return a ^ (vector unsigned short)b;
+}
+
+static vector bool short __ATTRS_o_ai
+vec_xor(vector bool short a, vector bool short b)
+{
+ return a ^ b;
+}
+
static vector int __ATTRS_o_ai
vec_xor(vector int a, vector int b)
{
return a ^ b;
}
+static vector int __ATTRS_o_ai
+vec_xor(vector bool int a, vector int b)
+{
+ return (vector int)a ^ b;
+}
+
+static vector int __ATTRS_o_ai
+vec_xor(vector int a, vector bool int b)
+{
+ return a ^ (vector int)b;
+}
+
static vector unsigned int __ATTRS_o_ai
vec_xor(vector unsigned int a, vector unsigned int b)
{
return a ^ b;
}
+static vector unsigned int __ATTRS_o_ai
+vec_xor(vector bool int a, vector unsigned int b)
+{
+ return (vector unsigned int)a ^ b;
+}
+
+static vector unsigned int __ATTRS_o_ai
+vec_xor(vector unsigned int a, vector bool int b)
+{
+ return a ^ (vector unsigned int)b;
+}
+
+static vector bool int __ATTRS_o_ai
+vec_xor(vector bool int a, vector bool int b)
+{
+ return a ^ b;
+}
+
static vector float __ATTRS_o_ai
vec_xor(vector float a, vector float b)
{
return (vector float)res;
}
+static vector float __ATTRS_o_ai
+vec_xor(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_xor(vector float a, vector bool int b)
+{
+ vector unsigned int res = (vector unsigned int)a ^ (vector unsigned int)b;
+ return (vector float)res;
+}
+
/* vec_vxor */
static vector signed char __ATTRS_o_ai
return a ^ b;
}
+static vector signed char __ATTRS_o_ai
+vec_vxor(vector bool char a, vector signed char b)
+{
+ return (vector signed char)a ^ b;
+}
+
+static vector signed char __ATTRS_o_ai
+vec_vxor(vector signed char a, vector bool char b)
+{
+ return a ^ (vector signed char)b;
+}
+
static vector unsigned char __ATTRS_o_ai
vec_vxor(vector unsigned char a, vector unsigned char b)
{
return a ^ b;
}
+static vector unsigned char __ATTRS_o_ai
+vec_vxor(vector bool char a, vector unsigned char b)
+{
+ return (vector unsigned char)a ^ b;
+}
+
+static vector unsigned char __ATTRS_o_ai
+vec_vxor(vector unsigned char a, vector bool char b)
+{
+ return a ^ (vector unsigned char)b;
+}
+
+static vector bool char __ATTRS_o_ai
+vec_vxor(vector bool char a, vector bool char b)
+{
+ return a ^ b;
+}
+
static vector short __ATTRS_o_ai
vec_vxor(vector short a, vector short b)
{
return a ^ b;
}
+static vector short __ATTRS_o_ai
+vec_vxor(vector bool short a, vector short b)
+{
+ return (vector short)a ^ b;
+}
+
+static vector short __ATTRS_o_ai
+vec_vxor(vector short a, vector bool short b)
+{
+ return a ^ (vector short)b;
+}
+
static vector unsigned short __ATTRS_o_ai
vec_vxor(vector unsigned short a, vector unsigned short b)
{
return a ^ b;
}
+static vector unsigned short __ATTRS_o_ai
+vec_vxor(vector bool short a, vector unsigned short b)
+{
+ return (vector unsigned short)a ^ b;
+}
+
+static vector unsigned short __ATTRS_o_ai
+vec_vxor(vector unsigned short a, vector bool short b)
+{
+ return a ^ (vector unsigned short)b;
+}
+
+static vector bool short __ATTRS_o_ai
+vec_vxor(vector bool short a, vector bool short b)
+{
+ return a ^ b;
+}
+
static vector int __ATTRS_o_ai
vec_vxor(vector int a, vector int b)
{
return a ^ b;
}
+static vector int __ATTRS_o_ai
+vec_vxor(vector bool int a, vector int b)
+{
+ return (vector int)a ^ b;
+}
+
+static vector int __ATTRS_o_ai
+vec_vxor(vector int a, vector bool int b)
+{
+ return a ^ (vector int)b;
+}
+
static vector unsigned int __ATTRS_o_ai
vec_vxor(vector unsigned int a, vector unsigned int b)
{
return a ^ b;
}
+static vector unsigned int __ATTRS_o_ai
+vec_vxor(vector bool int a, vector unsigned int b)
+{
+ return (vector unsigned int)a ^ b;
+}
+
+static vector unsigned int __ATTRS_o_ai
+vec_vxor(vector unsigned int a, vector bool int b)
+{
+ return a ^ (vector unsigned int)b;
+}
+
+static vector bool int __ATTRS_o_ai
+vec_vxor(vector bool int a, vector bool int b)
+{
+ return a ^ b;
+}
+
static vector float __ATTRS_o_ai
vec_vxor(vector float a, vector float b)
{
return (vector float)res;
}
+static vector float __ATTRS_o_ai
+vec_vxor(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_vxor(vector float a, vector bool int b)
+{
+ vector unsigned int res = (vector unsigned int)a ^ (vector unsigned int)b;
+ return (vector float)res;
+}
+
/* ------------------------------ predicates ------------------------------------ */
/* vec_all_eq */
res_vf = vec_vandc(vf, vbi); // CHECK: xor <4 x i32>
// CHECK: and <4 x i32>
+
}
-// CHECK: i32 @test2
-int test2() {
+// CHECK: define void @test2
+void test2() {
/* vec_avg */
- res_vsc = vec_avg(vsc, vsc); // CHECK: call {{.*}}@llvm.ppc.altivec.vavgsb
+ res_vsc = vec_avg(vsc, vsc); // CHECK: @llvm.ppc.altivec.vavgsb
res_vuc = vec_avg(vuc, vuc); // CHECK: @llvm.ppc.altivec.vavgub
res_vs = vec_avg(vs, vs); // CHECK: @llvm.ppc.altivec.vavgsh
res_vus = vec_avg(vus, vus); // CHECK: @llvm.ppc.altivec.vavguh
res_vi = vec_vcmpbfp(vf, vf); // CHECK: @llvm.ppc.altivec.vcmpbfp
/* vec_cmpeq */
- vsc = vec_cmpeq(vsc, vsc); // CHCK: call {{.*}}@llvm.ppc.altivec.vcmpequb
- vuc = vec_cmpeq(vuc, vuc); // CHCK: @llvm.ppc.altivec.vcmpequb
- vs = vec_cmpeq(vs, vs); // CHCK: @llvm.ppc.altivec.vcmpequh
- vs = vec_cmpeq(vus, vus); // CHCK: @llvm.ppc.altivec.vcmpequh
- vi = vec_cmpeq(vi, vi); // CHCK: @llvm.ppc.altivec.vcmpequw
- vui = vec_cmpeq(vui, vui); // CHCK: @llvm.ppc.altivec.vcmpequw
- vf = vec_cmpeq(vf, vf); // CHCK: @llvm.ppc.altivec.vcmpeqfp
+ res_vbc = vec_cmpeq(vsc, vsc); // CHECK: @llvm.ppc.altivec.vcmpequb
+ res_vbc = vec_cmpeq(vuc, vuc); // CHECK: @llvm.ppc.altivec.vcmpequb
+ res_vbs = vec_cmpeq(vs, vs); // CHECK: @llvm.ppc.altivec.vcmpequh
+ res_vbs = vec_cmpeq(vus, vus); // CHECK: @llvm.ppc.altivec.vcmpequh
+ res_vbi = vec_cmpeq(vi, vi); // CHECK: @llvm.ppc.altivec.vcmpequw
+ res_vbi = vec_cmpeq(vui, vui); // CHECK: @llvm.ppc.altivec.vcmpequw
+ res_vbi = vec_cmpeq(vf, vf); // CHECK: @llvm.ppc.altivec.vcmpeqfp
/* vec_cmpge */
- vf = vec_cmpge(vf, vf); // CHCK: @llvm.ppc.altivec.vcmpgefp
- vf = vec_vcmpgefp(vf, vf); // CHCK: call {{.*}}@llvm.ppc.altivec.vcmpgefp
-
+ res_vbi = vec_cmpge(vf, vf); // CHECK: @llvm.ppc.altivec.vcmpgefp
+ res_vbi = vec_vcmpgefp(vf, vf); // CHECK: @llvm.ppc.altivec.vcmpgefp
}
-// CHECK: define i32 @test5
-int test5() {
+// CHECK: define void @test5
+void test5() {
/* vec_cmpgt */
- vsc = vec_cmpgt(vsc, vsc); // CHECK: call {{.*}}@llvm.ppc.altivec.vcmpgtsb
- vuc = vec_cmpgt(vuc, vuc); // CHECK: call {{.*}}@llvm.ppc.altivec.vcmpgtub
- vs = vec_cmpgt(vs, vs); // CHECK: call {{.*}}@llvm.ppc.altivec.vcmpgtsh
- vus = vec_cmpgt(vus, vus); // CHECK: @llvm.ppc.altivec.vcmpgtuh
- vi = vec_cmpgt(vi, vi); // CHECK: @llvm.ppc.altivec.vcmpgtsw
- vui = vec_cmpgt(vui, vui); // CHECK: @llvm.ppc.altivec.vcmpgtuw
- vf = vec_cmpgt(vf, vf); // CHECK: @llvm.ppc.altivec.vcmpgtfp
- vsc = vec_vcmpgtsb(vsc, vsc); // CHECK: @llvm.ppc.altivec.vcmpgtsb
- vuc = vec_vcmpgtub(vuc, vuc); // CHECK: @llvm.ppc.altivec.vcmpgtub
- vs = vec_vcmpgtsh(vs, vs); // CHECK: @llvm.ppc.altivec.vcmpgtsh
- vus = vec_vcmpgtuh(vus, vus); // CHECK: @llvm.ppc.altivec.vcmpgtuh
- vi = vec_vcmpgtsw(vi, vi); // CHECK: @llvm.ppc.altivec.vcmpgtsw
- vui = vec_vcmpgtuw(vui, vui); // CHECK: @llvm.ppc.altivec.vcmpgtuw
- vf = vec_vcmpgtfp(vf, vf); // CHECK: @llvm.ppc.altivec.vcmpgtfp
+ res_vbc = vec_cmpgt(vsc, vsc); // CHECK: @llvm.ppc.altivec.vcmpgtsb
+ res_vbc = vec_cmpgt(vuc, vuc); // CHECK: @llvm.ppc.altivec.vcmpgtub
+ res_vbs = vec_cmpgt(vs, vs); // CHECK: @llvm.ppc.altivec.vcmpgtsh
+ res_vbs = vec_cmpgt(vus, vus); // CHECK: @llvm.ppc.altivec.vcmpgtuh
+ res_vbi = vec_cmpgt(vi, vi); // CHECK: @llvm.ppc.altivec.vcmpgtsw
+ res_vbi = vec_cmpgt(vui, vui); // CHECK: @llvm.ppc.altivec.vcmpgtuw
+ res_vbi = vec_cmpgt(vf, vf); // CHECK: @llvm.ppc.altivec.vcmpgtfp
+ res_vbc = vec_vcmpgtsb(vsc, vsc); // CHECK: @llvm.ppc.altivec.vcmpgtsb
+ res_vbc = vec_vcmpgtub(vuc, vuc); // CHECK: @llvm.ppc.altivec.vcmpgtub
+ res_vbs = vec_vcmpgtsh(vs, vs); // CHECK: @llvm.ppc.altivec.vcmpgtsh
+ res_vbs = vec_vcmpgtuh(vus, vus); // CHECK: @llvm.ppc.altivec.vcmpgtuh
+ res_vbi = vec_vcmpgtsw(vi, vi); // CHECK: @llvm.ppc.altivec.vcmpgtsw
+ res_vbi = vec_vcmpgtuw(vui, vui); // CHECK: @llvm.ppc.altivec.vcmpgtuw
+ res_vbi = vec_vcmpgtfp(vf, vf); // CHECK: @llvm.ppc.altivec.vcmpgtfp
/* vec_cmple */
- vf = vec_cmple(vf, vf); // CHECK: call {{.*}}@llvm.ppc.altivec.vcmpgefp
+ res_vbi = vec_cmple(vf, vf); // CHECK: @llvm.ppc.altivec.vcmpgefp
}
-// CHECK: define i32 @test6
-int test6() {
+// CHECK: define void @test6
+void test6() {
/* vec_cmplt */
- vsc =vec_cmplt(vsc, vsc); // CHECK: call {{.*}}@llvm.ppc.altivec.vcmpgtsb
- vsc =vec_cmplt(vuc, vuc); // CHECK: call {{.*}}@llvm.ppc.altivec.vcmpgtub
- vs = vec_cmplt(vs, vs); // CHECK: call {{.*}}@llvm.ppc.altivec.vcmpgtsh
- vs = vec_cmplt(vus, vus); // CHECK: @llvm.ppc.altivec.vcmpgtuh
- vi = vec_cmplt(vi, vi); // CHECK: @llvm.ppc.altivec.vcmpgtsw
- vui = vec_cmplt(vui, vui); // CHECK: @llvm.ppc.altivec.vcmpgtuw
- vf = vec_cmplt(vf, vf); // CHECK: @llvm.ppc.altivec.vcmpgtfp
+ res_vbc = vec_cmplt(vsc, vsc); // CHECK: @llvm.ppc.altivec.vcmpgtsb
+ res_vbc = vec_cmplt(vuc, vuc); // CHECK: @llvm.ppc.altivec.vcmpgtub
+ res_vbs = vec_cmplt(vs, vs); // CHECK: @llvm.ppc.altivec.vcmpgtsh
+ res_vbs = vec_cmplt(vus, vus); // CHECK: @llvm.ppc.altivec.vcmpgtuh
+ res_vbi = vec_cmplt(vi, vi); // CHECK: @llvm.ppc.altivec.vcmpgtsw
+ res_vbi = vec_cmplt(vui, vui); // CHECK: @llvm.ppc.altivec.vcmpgtuw
+ res_vbi = vec_cmplt(vf, vf); // CHECK: @llvm.ppc.altivec.vcmpgtfp
/* vec_ctf */
res_vf = vec_ctf(vi, param_i); // CHECK: @llvm.ppc.altivec.vcfsx
res_vsc = vec_ld(0, ¶m_sc); // CHECK: @llvm.ppc.altivec.lvx
res_vuc = vec_ld(0, &vuc); // CHECK: @llvm.ppc.altivec.lvx
res_vuc = vec_ld(0, ¶m_uc); // CHECK: @llvm.ppc.altivec.lvx
+ res_vbc = vec_ld(0, &vbc); // CHECK: @llvm.ppc.altivec.lvx
res_vs = vec_ld(0, &vs); // CHECK: @llvm.ppc.altivec.lvx
res_vs = vec_ld(0, ¶m_s); // CHECK: @llvm.ppc.altivec.lvx
res_vus = vec_ld(0, &vus); // CHECK: @llvm.ppc.altivec.lvx
res_vus = vec_ld(0, ¶m_us); // CHECK: @llvm.ppc.altivec.lvx
+ res_vbs = vec_ld(0, &vbs); // CHECK: @llvm.ppc.altivec.lvx
+ res_vp = vec_ld(0, &vp); // CHECK: @llvm.ppc.altivec.lvx
res_vi = vec_ld(0, &vi); // CHECK: @llvm.ppc.altivec.lvx
res_vi = vec_ld(0, ¶m_i); // CHECK: @llvm.ppc.altivec.lvx
res_vui = vec_ld(0, &vui); // CHECK: @llvm.ppc.altivec.lvx
res_vui = vec_ld(0, ¶m_ui); // CHECK: @llvm.ppc.altivec.lvx
+ res_vbi = vec_ld(0, &vbi); // CHECK: @llvm.ppc.altivec.lvx
res_vf = vec_ld(0, &vf); // CHECK: @llvm.ppc.altivec.lvx
res_vf = vec_ld(0, ¶m_f); // CHECK: @llvm.ppc.altivec.lvx
res_vsc = vec_lvx(0, &vsc); // CHECK: @llvm.ppc.altivec.lvx
res_vsc = vec_lvx(0, ¶m_sc); // CHECK: @llvm.ppc.altivec.lvx
res_vuc = vec_lvx(0, &vuc); // CHECK: @llvm.ppc.altivec.lvx
res_vuc = vec_lvx(0, ¶m_uc); // CHECK: @llvm.ppc.altivec.lvx
+ res_vbc = vec_lvx(0, &vbc); // CHECK: @llvm.ppc.altivec.lvx
res_vs = vec_lvx(0, &vs); // CHECK: @llvm.ppc.altivec.lvx
res_vs = vec_lvx(0, ¶m_s); // CHECK: @llvm.ppc.altivec.lvx
res_vus = vec_lvx(0, &vus); // CHECK: @llvm.ppc.altivec.lvx
res_vus = vec_lvx(0, ¶m_us); // CHECK: @llvm.ppc.altivec.lvx
+ res_vbs = vec_lvx(0, &vbs); // CHECK: @llvm.ppc.altivec.lvx
+ res_vp = vec_lvx(0, &vp); // CHECK: @llvm.ppc.altivec.lvx
res_vi = vec_lvx(0, &vi); // CHECK: @llvm.ppc.altivec.lvx
res_vi = vec_lvx(0, ¶m_i); // CHECK: @llvm.ppc.altivec.lvx
res_vui = vec_lvx(0, &vui); // CHECK: @llvm.ppc.altivec.lvx
res_vui = vec_lvx(0, ¶m_ui); // CHECK: @llvm.ppc.altivec.lvx
+ res_vbi = vec_lvx(0, &vbi); // CHECK: @llvm.ppc.altivec.lvx
res_vf = vec_lvx(0, &vf); // CHECK: @llvm.ppc.altivec.lvx
res_vf = vec_lvx(0, ¶m_f); // CHECK: @llvm.ppc.altivec.lvx
res_vsc = vec_ldl(0, ¶m_sc); // CHECK: @llvm.ppc.altivec.lvxl
res_vuc = vec_ldl(0, &vuc); // CHECK: @llvm.ppc.altivec.lvxl
res_vuc = vec_ldl(0, ¶m_uc); // CHECK: @llvm.ppc.altivec.lvxl
+ res_vbc = vec_ldl(0, &vbc); // CHECK: @llvm.ppc.altivec.lvxl
res_vs = vec_ldl(0, &vs); // CHECK: @llvm.ppc.altivec.lvxl
res_vs = vec_ldl(0, ¶m_s); // CHECK: @llvm.ppc.altivec.lvxl
res_vus = vec_ldl(0, &vus); // CHECK: @llvm.ppc.altivec.lvxl
res_vus = vec_ldl(0, ¶m_us); // CHECK: @llvm.ppc.altivec.lvxl
+ res_vbs = vec_ldl(0, &vbs); // CHECK: @llvm.ppc.altivec.lvxl
+ res_vp = vec_ldl(0, &vp); // CHECK: @llvm.ppc.altivec.lvxl
res_vi = vec_ldl(0, &vi); // CHECK: @llvm.ppc.altivec.lvxl
res_vi = vec_ldl(0, ¶m_i); // CHECK: @llvm.ppc.altivec.lvxl
res_vui = vec_ldl(0, &vui); // CHECK: @llvm.ppc.altivec.lvxl
res_vui = vec_ldl(0, ¶m_ui); // CHECK: @llvm.ppc.altivec.lvxl
+ res_vbi = vec_ldl(0, &vbi); // CHECK: @llvm.ppc.altivec.lvxl
res_vf = vec_ldl(0, &vf); // CHECK: @llvm.ppc.altivec.lvxl
res_vf = vec_ldl(0, ¶m_f); // CHECK: @llvm.ppc.altivec.lvxl
res_vsc = vec_lvxl(0, &vsc); // CHECK: @llvm.ppc.altivec.lvxl
res_vsc = vec_lvxl(0, ¶m_sc); // CHECK: @llvm.ppc.altivec.lvxl
res_vuc = vec_lvxl(0, &vuc); // CHECK: @llvm.ppc.altivec.lvxl
+ res_vbc = vec_lvxl(0, &vbc); // CHECK: @llvm.ppc.altivec.lvxl
res_vuc = vec_lvxl(0, ¶m_uc); // CHECK: @llvm.ppc.altivec.lvxl
res_vs = vec_lvxl(0, &vs); // CHECK: @llvm.ppc.altivec.lvxl
res_vs = vec_lvxl(0, ¶m_s); // CHECK: @llvm.ppc.altivec.lvxl
res_vus = vec_lvxl(0, &vus); // CHECK: @llvm.ppc.altivec.lvxl
res_vus = vec_lvxl(0, ¶m_us); // CHECK: @llvm.ppc.altivec.lvxl
+ res_vbs = vec_lvxl(0, &vbs); // CHECK: @llvm.ppc.altivec.lvxl
+ res_vp = vec_lvxl(0, &vp); // CHECK: @llvm.ppc.altivec.lvxl
res_vi = vec_lvxl(0, &vi); // CHECK: @llvm.ppc.altivec.lvxl
res_vi = vec_lvxl(0, ¶m_i); // CHECK: @llvm.ppc.altivec.lvxl
res_vui = vec_lvxl(0, &vui); // CHECK: @llvm.ppc.altivec.lvxl
res_vui = vec_lvxl(0, ¶m_ui); // CHECK: @llvm.ppc.altivec.lvxl
+ res_vbi = vec_lvxl(0, &vbi); // CHECK: @llvm.ppc.altivec.lvxl
res_vf = vec_lvxl(0, &vf); // CHECK: @llvm.ppc.altivec.lvxl
res_vf = vec_lvxl(0, ¶m_f); // CHECK: @llvm.ppc.altivec.lvxl
/* vec_max */
res_vsc = vec_max(vsc, vsc); // CHECK: @llvm.ppc.altivec.vmaxsb
+ res_vsc = vec_max(vbc, vsc); // CHECK: @llvm.ppc.altivec.vmaxsb
+ res_vsc = vec_max(vsc, vbc); // CHECK: @llvm.ppc.altivec.vmaxsb
res_vuc = vec_max(vuc, vuc); // CHECK: @llvm.ppc.altivec.vmaxub
+ res_vuc = vec_max(vbc, vuc); // CHECK: @llvm.ppc.altivec.vmaxub
+ res_vuc = vec_max(vuc, vbc); // CHECK: @llvm.ppc.altivec.vmaxub
res_vs = vec_max(vs, vs); // CHECK: @llvm.ppc.altivec.vmaxsh
+ res_vs = vec_max(vbs, vs); // CHECK: @llvm.ppc.altivec.vmaxsh
+ res_vs = vec_max(vs, vbs); // CHECK: @llvm.ppc.altivec.vmaxsh
res_vus = vec_max(vus, vus); // CHECK: @llvm.ppc.altivec.vmaxuh
+ res_vus = vec_max(vbs, vus); // CHECK: @llvm.ppc.altivec.vmaxuh
+ res_vus = vec_max(vus, vbs); // CHECK: @llvm.ppc.altivec.vmaxuh
res_vi = vec_max(vi, vi); // CHECK: @llvm.ppc.altivec.vmaxsw
+ res_vi = vec_max(vbi, vi); // CHECK: @llvm.ppc.altivec.vmaxsw
+ res_vi = vec_max(vi, vbi); // CHECK: @llvm.ppc.altivec.vmaxsw
res_vui = vec_max(vui, vui); // CHECK: @llvm.ppc.altivec.vmaxuw
+ res_vui = vec_max(vbi, vui); // CHECK: @llvm.ppc.altivec.vmaxuw
+ res_vui = vec_max(vui, vbi); // CHECK: @llvm.ppc.altivec.vmaxuw
res_vf = vec_max(vf, vf); // CHECK: @llvm.ppc.altivec.vmaxfp
res_vsc = vec_vmaxsb(vsc, vsc); // CHECK: @llvm.ppc.altivec.vmaxsb
+ res_vsc = vec_vmaxsb(vbc, vsc); // CHECK: @llvm.ppc.altivec.vmaxsb
+ res_vsc = vec_vmaxsb(vsc, vbc); // CHECK: @llvm.ppc.altivec.vmaxsb
res_vuc = vec_vmaxub(vuc, vuc); // CHECK: @llvm.ppc.altivec.vmaxub
+ res_vuc = vec_vmaxub(vbc, vuc); // CHECK: @llvm.ppc.altivec.vmaxub
+ res_vuc = vec_vmaxub(vuc, vbc); // CHECK: @llvm.ppc.altivec.vmaxub
res_vs = vec_vmaxsh(vs, vs); // CHECK: @llvm.ppc.altivec.vmaxsh
+ res_vs = vec_vmaxsh(vbs, vs); // CHECK: @llvm.ppc.altivec.vmaxsh
+ res_vs = vec_vmaxsh(vs, vbs); // CHECK: @llvm.ppc.altivec.vmaxsh
res_vus = vec_vmaxuh(vus, vus); // CHECK: @llvm.ppc.altivec.vmaxuh
+ res_vus = vec_vmaxuh(vbs, vus); // CHECK: @llvm.ppc.altivec.vmaxuh
+ res_vus = vec_vmaxuh(vus, vbs); // CHECK: @llvm.ppc.altivec.vmaxuh
res_vi = vec_vmaxsw(vi, vi); // CHECK: @llvm.ppc.altivec.vmaxsw
+ res_vi = vec_vmaxsw(vbi, vi); // CHECK: @llvm.ppc.altivec.vmaxsw
+ res_vi = vec_vmaxsw(vi, vbi); // CHECK: @llvm.ppc.altivec.vmaxsw
res_vui = vec_vmaxuw(vui, vui); // CHECK: @llvm.ppc.altivec.vmaxuw
+ res_vui = vec_vmaxuw(vbi, vui); // CHECK: @llvm.ppc.altivec.vmaxuw
+ res_vui = vec_vmaxuw(vui, vbi); // CHECK: @llvm.ppc.altivec.vmaxuw
res_vf = vec_vmaxfp(vf, vf); // CHECK: @llvm.ppc.altivec.vmaxfp
/* vec_mergeh */
/* vec_min */
res_vsc = vec_min(vsc, vsc); // CHECK: @llvm.ppc.altivec.vminsb
+ res_vsc = vec_min(vbc, vsc); // CHECK: @llvm.ppc.altivec.vminsb
+ res_vsc = vec_min(vsc, vbc); // CHECK: @llvm.ppc.altivec.vminsb
res_vuc = vec_min(vuc, vuc); // CHECK: @llvm.ppc.altivec.vminub
+ res_vuc = vec_min(vbc, vuc); // CHECK: @llvm.ppc.altivec.vminub
+ res_vuc = vec_min(vuc, vbc); // CHECK: @llvm.ppc.altivec.vminub
res_vs = vec_min(vs, vs); // CHECK: @llvm.ppc.altivec.vminsh
+ res_vs = vec_min(vbs, vs); // CHECK: @llvm.ppc.altivec.vminsh
+ res_vs = vec_min(vs, vbs); // CHECK: @llvm.ppc.altivec.vminsh
res_vus = vec_min(vus, vus); // CHECK: @llvm.ppc.altivec.vminuh
+ res_vus = vec_min(vbs, vus); // CHECK: @llvm.ppc.altivec.vminuh
+ res_vus = vec_min(vus, vbs); // CHECK: @llvm.ppc.altivec.vminuh
res_vi = vec_min(vi, vi); // CHECK: @llvm.ppc.altivec.vminsw
+ res_vi = vec_min(vbi, vi); // CHECK: @llvm.ppc.altivec.vminsw
+ res_vi = vec_min(vi, vbi); // CHECK: @llvm.ppc.altivec.vminsw
res_vui = vec_min(vui, vui); // CHECK: @llvm.ppc.altivec.vminuw
+ res_vui = vec_min(vbi, vui); // CHECK: @llvm.ppc.altivec.vminuw
+ res_vui = vec_min(vui, vbi); // CHECK: @llvm.ppc.altivec.vminuw
res_vf = vec_min(vf, vf); // CHECK: @llvm.ppc.altivec.vminfp
res_vsc = vec_vminsb(vsc, vsc); // CHECK: @llvm.ppc.altivec.vminsb
+ res_vsc = vec_vminsb(vbc, vsc); // CHECK: @llvm.ppc.altivec.vminsb
+ res_vsc = vec_vminsb(vsc, vbc); // CHECK: @llvm.ppc.altivec.vminsb
res_vuc = vec_vminub(vuc, vuc); // CHECK: @llvm.ppc.altivec.vminub
+ res_vuc = vec_vminub(vbc, vuc); // CHECK: @llvm.ppc.altivec.vminub
+ res_vuc = vec_vminub(vuc, vbc); // CHECK: @llvm.ppc.altivec.vminub
res_vs = vec_vminsh(vs, vs); // CHECK: @llvm.ppc.altivec.vminsh
+ res_vs = vec_vminsh(vbs, vs); // CHECK: @llvm.ppc.altivec.vminsh
+ res_vs = vec_vminsh(vs, vbs); // CHECK: @llvm.ppc.altivec.vminsh
res_vus = vec_vminuh(vus, vus); // CHECK: @llvm.ppc.altivec.vminuh
+ res_vus = vec_vminuh(vbs, vus); // CHECK: @llvm.ppc.altivec.vminuh
+ res_vus = vec_vminuh(vus, vbs); // CHECK: @llvm.ppc.altivec.vminuh
res_vi = vec_vminsw(vi, vi); // CHECK: @llvm.ppc.altivec.vminsw
+ res_vi = vec_vminsw(vbi, vi); // CHECK: @llvm.ppc.altivec.vminsw
+ res_vi = vec_vminsw(vi, vbi); // CHECK: @llvm.ppc.altivec.vminsw
res_vui = vec_vminuw(vui, vui); // CHECK: @llvm.ppc.altivec.vminuw
+ res_vui = vec_vminuw(vbi, vui); // CHECK: @llvm.ppc.altivec.vminuw
+ res_vui = vec_vminuw(vui, vbi); // CHECK: @llvm.ppc.altivec.vminuw
res_vf = vec_vminfp(vf, vf); // CHECK: @llvm.ppc.altivec.vminfp
/* vec_mladd */
/* vec_mtvscr */
vec_mtvscr(vsc); // CHECK: @llvm.ppc.altivec.mtvscr
+ vec_mtvscr(vuc); // CHECK: @llvm.ppc.altivec.mtvscr
+ vec_mtvscr(vbc); // CHECK: @llvm.ppc.altivec.mtvscr
+ vec_mtvscr(vs); // CHECK: @llvm.ppc.altivec.mtvscr
+ vec_mtvscr(vus); // CHECK: @llvm.ppc.altivec.mtvscr
+ vec_mtvscr(vbs); // CHECK: @llvm.ppc.altivec.mtvscr
+ vec_mtvscr(vp); // CHECK: @llvm.ppc.altivec.mtvscr
+ vec_mtvscr(vi); // CHECK: @llvm.ppc.altivec.mtvscr
+ vec_mtvscr(vui); // CHECK: @llvm.ppc.altivec.mtvscr
+ vec_mtvscr(vbi); // CHECK: @llvm.ppc.altivec.mtvscr
/* vec_mule */
res_vs = vec_mule(vsc, vsc); // CHECK: @llvm.ppc.altivec.vmulesb
res_vuc = vec_nor(vuc, vuc); // CHECK: or <16 x i8>
// CHECK: xor <16 x i8>
+ res_vuc = vec_nor(vbc, vbc); // CHECK: or <16 x i8>
+ // CHECK: xor <16 x i8>
+
res_vs = vec_nor(vs, vs); // CHECK: or <8 x i16>
// CHECK: xor <8 x i16>
res_vus = vec_nor(vus, vus); // CHECK: or <8 x i16>
// CHECK: xor <8 x i16>
+ res_vus = vec_nor(vbs, vbs); // CHECK: or <8 x i16>
+ // CHECK: xor <8 x i16>
+
res_vi = vec_nor(vi, vi); // CHECK: or <4 x i32>
// CHECK: xor <4 x i32>
res_vui = vec_nor(vui, vui); // CHECK: or <4 x i32>
// CHECK: xor <4 x i32>
+ res_vui = vec_nor(vbi, vbi); // CHECK: or <4 x i32>
+ // CHECK: xor <4 x i32>
+
res_vf = vec_nor(vf, vf); // CHECK: or <4 x i32>
// CHECK: xor <4 x i32>
res_vuc = vec_vnor(vuc, vuc); // CHECK: or <16 x i8>
// CHECK: xor <16 x i8>
+ res_vuc = vec_vnor(vbc, vbc); // CHECK: or <16 x i8>
+ // CHECK: xor <16 x i8>
+
res_vs = vec_vnor(vs, vs); // CHECK: or <8 x i16>
// CHECK: xor <8 x i16>
res_vus = vec_vnor(vus, vus); // CHECK: or <8 x i16>
// CHECK: xor <8 x i16>
+ res_vus = vec_vnor(vbs, vbs); // CHECK: or <8 x i16>
+ // CHECK: xor <8 x i16>
+
res_vi = vec_vnor(vi, vi); // CHECK: or <4 x i32>
// CHECK: xor <4 x i32>
res_vui = vec_vnor(vui, vui); // CHECK: or <4 x i32>
// CHECK: xor <4 x i32>
+ res_vui = vec_vnor(vbi, vbi); // CHECK: or <4 x i32>
+ // CHECK: xor <4 x i32>
+
res_vf = vec_vnor(vf, vf); // CHECK: or <4 x i32>
// CHECK: xor <4 x i32>
/* vec_or */
res_vsc = vec_or(vsc, vsc); // CHECK: or <16 x i8>
+ res_vsc = vec_or(vbc, vsc); // CHECK: or <16 x i8>
+ res_vsc = vec_or(vsc, vbc); // CHECK: or <16 x i8>
res_vuc = vec_or(vuc, vuc); // CHECK: or <16 x i8>
+ res_vuc = vec_or(vbc, vuc); // CHECK: or <16 x i8>
+ res_vuc = vec_or(vuc, vbc); // CHECK: or <16 x i8>
+ res_vbc = vec_or(vbc, vbc); // CHECK: or <16 x i8>
res_vs = vec_or(vs, vs); // CHECK: or <8 x i16>
+ res_vs = vec_or(vbs, vs); // CHECK: or <8 x i16>
+ res_vs = vec_or(vs, vbs); // CHECK: or <8 x i16>
res_vus = vec_or(vus, vus); // CHECK: or <8 x i16>
+ res_vus = vec_or(vbs, vus); // CHECK: or <8 x i16>
+ res_vus = vec_or(vus, vbs); // CHECK: or <8 x i16>
+ res_vbs = vec_or(vbs, vbs); // CHECK: or <8 x i16>
res_vi = vec_or(vi, vi); // CHECK: or <4 x i32>
+ res_vi = vec_or(vbi, vi); // CHECK: or <4 x i32>
+ res_vi = vec_or(vi, vbi); // CHECK: or <4 x i32>
res_vui = vec_or(vui, vui); // CHECK: or <4 x i32>
+ res_vui = vec_or(vbi, vui); // CHECK: or <4 x i32>
+ res_vui = vec_or(vui, vbi); // CHECK: or <4 x i32>
+ res_vbi = vec_or(vbi, vbi); // CHECK: or <4 x i32>
res_vf = vec_or(vf, vf); // CHECK: or <4 x i32>
+ res_vf = vec_or(vbi, vf); // CHECK: or <4 x i32>
+ res_vf = vec_or(vf, vbi); // CHECK: or <4 x i32>
res_vsc = vec_vor(vsc, vsc); // CHECK: or <16 x i8>
+ res_vsc = vec_vor(vbc, vsc); // CHECK: or <16 x i8>
+ res_vsc = vec_vor(vsc, vbc); // CHECK: or <16 x i8>
res_vuc = vec_vor(vuc, vuc); // CHECK: or <16 x i8>
+ res_vuc = vec_vor(vbc, vuc); // CHECK: or <16 x i8>
+ res_vuc = vec_vor(vuc, vbc); // CHECK: or <16 x i8>
+ res_vbc = vec_vor(vbc, vbc); // CHECK: or <16 x i8>
res_vs = vec_vor(vs, vs); // CHECK: or <8 x i16>
+ res_vs = vec_vor(vbs, vs); // CHECK: or <8 x i16>
+ res_vs = vec_vor(vs, vbs); // CHECK: or <8 x i16>
res_vus = vec_vor(vus, vus); // CHECK: or <8 x i16>
+ res_vus = vec_vor(vbs, vus); // CHECK: or <8 x i16>
+ res_vus = vec_vor(vus, vbs); // CHECK: or <8 x i16>
+ res_vbs = vec_vor(vbs, vbs); // CHECK: or <8 x i16>
res_vi = vec_vor(vi, vi); // CHECK: or <4 x i32>
+ res_vi = vec_vor(vbi, vi); // CHECK: or <4 x i32>
+ res_vi = vec_vor(vi, vbi); // CHECK: or <4 x i32>
res_vui = vec_vor(vui, vui); // CHECK: or <4 x i32>
+ res_vui = vec_vor(vbi, vui); // CHECK: or <4 x i32>
+ res_vui = vec_vor(vui, vbi); // CHECK: or <4 x i32>
+ res_vbi = vec_vor(vbi, vbi); // CHECK: or <4 x i32>
res_vf = vec_vor(vf, vf); // CHECK: or <4 x i32>
+ res_vf = vec_vor(vbi, vf); // CHECK: or <4 x i32>
+ res_vf = vec_vor(vf, vbi); // CHECK: or <4 x i32>
/* vec_pack */
res_vsc = vec_pack(vs, vs); // CHECK: @llvm.ppc.altivec.vperm
// CHECK: and <16 x i8>
// CHECK: or <16 x i8>
+ res_vsc = vec_sel(vsc, vsc, vbc); // CHECK: xor <16 x i8>
+ // CHECK: and <16 x i8>
+ // CHECK: and <16 x i8>
+ // CHECK: or <16 x i8>
+
res_vuc = vec_sel(vuc, vuc, vuc); // CHECK: xor <16 x i8>
// CHECK: and <16 x i8>
// CHECK: and <16 x i8>
// CHECK: or <16 x i8>
+ res_vuc = vec_sel(vuc, vuc, vbc); // CHECK: xor <16 x i8>
+ // CHECK: and <16 x i8>
+ // CHECK: and <16 x i8>
+ // CHECK: or <16 x i8>
+
+ res_vbc = vec_sel(vbc, vbc, vuc); // CHECK: xor <16 x i8>
+ // CHECK: and <16 x i8>
+ // CHECK: and <16 x i8>
+ // CHECK: or <16 x i8>
+
+ res_vbc = vec_sel(vbc, vbc, vbc); // CHECK: xor <16 x i8>
+ // CHECK: and <16 x i8>
+ // CHECK: and <16 x i8>
+ // CHECK: or <16 x i8>
+
res_vs = vec_sel(vs, vs, vus); // CHECK: xor <8 x i16>
// CHECK: and <8 x i16>
// CHECK: and <8 x i16>
// CHECK: or <8 x i16>
+ res_vs = vec_sel(vs, vs, vbs); // CHECK: xor <8 x i16>
+ // CHECK: and <8 x i16>
+ // CHECK: and <8 x i16>
+ // CHECK: or <8 x i16>
res_vus = vec_sel(vus, vus, vus); // CHECK: xor <8 x i16>
// CHECK: and <8 x i16>
// CHECK: and <8 x i16>
// CHECK: or <8 x i16>
+ res_vus = vec_sel(vus, vus, vbs); // CHECK: xor <8 x i16>
+ // CHECK: and <8 x i16>
+ // CHECK: and <8 x i16>
+ // CHECK: or <8 x i16>
+
+ res_vbs = vec_sel(vbs, vbs, vus); // CHECK: xor <8 x i16>
+ // CHECK: and <8 x i16>
+ // CHECK: and <8 x i16>
+ // CHECK: or <8 x i16>
+
+ res_vbs = vec_sel(vbs, vbs, vbs); // CHECK: xor <8 x i16>
+ // CHECK: and <8 x i16>
+ // CHECK: and <8 x i16>
+ // CHECK: or <8 x i16>
+
res_vi = vec_sel(vi, vi, vui); // CHECK: xor <4 x i32>
// CHECK: and <4 x i32>
// CHECK: and <4 x i32>
// CHECK: or <4 x i32>
+ res_vi = vec_sel(vi, vi, vbi); // CHECK: xor <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: or <4 x i32>
res_vui = vec_sel(vui, vui, vui); // CHECK: xor <4 x i32>
// CHECK: and <4 x i32>
// CHECK: and <4 x i32>
// CHECK: or <4 x i32>
+ res_vui = vec_sel(vui, vui, vbi); // CHECK: xor <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: or <4 x i32>
+
+ res_vbi = vec_sel(vbi, vbi, vui); // CHECK: xor <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: or <4 x i32>
+
+ res_vbi = vec_sel(vbi, vbi, vbi); // CHECK: xor <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: or <4 x i32>
res_vf = vec_sel(vf, vf, vui); // CHECK: xor <4 x i32>
// CHECK: and <4 x i32>
// CHECK: and <4 x i32>
// CHECK: or <4 x i32>
+ res_vf = vec_sel(vf, vf, vbi); // CHECK: xor <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: or <4 x i32>
+
res_vsc = vec_vsel(vsc, vsc, vuc); // CHECK: xor <16 x i8>
// CHECK: and <16 x i8>
// CHECK: and <16 x i8>
// CHECK: or <16 x i8>
+ res_vsc = vec_vsel(vsc, vsc, vbc); // CHECK: xor <16 x i8>
+ // CHECK: and <16 x i8>
+ // CHECK: and <16 x i8>
+ // CHECK: or <16 x i8>
+
res_vuc = vec_vsel(vuc, vuc, vuc); // CHECK: xor <16 x i8>
// CHECK: and <16 x i8>
// CHECK: and <16 x i8>
// CHECK: or <16 x i8>
+ res_vuc = vec_vsel(vuc, vuc, vbc); // CHECK: xor <16 x i8>
+ // CHECK: and <16 x i8>
+ // CHECK: and <16 x i8>
+ // CHECK: or <16 x i8>
+
+ res_vbc = vec_vsel(vbc, vbc, vuc); // CHECK: xor <16 x i8>
+ // CHECK: and <16 x i8>
+ // CHECK: and <16 x i8>
+ // CHECK: or <16 x i8>
+
+ res_vbc = vec_vsel(vbc, vbc, vbc); // CHECK: xor <16 x i8>
+ // CHECK: and <16 x i8>
+ // CHECK: and <16 x i8>
+ // CHECK: or <16 x i8>
+
res_vs = vec_vsel(vs, vs, vus); // CHECK: xor <8 x i16>
// CHECK: and <8 x i16>
// CHECK: and <8 x i16>
// CHECK: or <8 x i16>
+ res_vs = vec_vsel(vs, vs, vbs); // CHECK: xor <8 x i16>
+ // CHECK: and <8 x i16>
+ // CHECK: and <8 x i16>
+ // CHECK: or <8 x i16>
res_vus = vec_vsel(vus, vus, vus); // CHECK: xor <8 x i16>
// CHECK: and <8 x i16>
// CHECK: and <8 x i16>
// CHECK: or <8 x i16>
+ res_vus = vec_vsel(vus, vus, vbs); // CHECK: xor <8 x i16>
+ // CHECK: and <8 x i16>
+ // CHECK: and <8 x i16>
+ // CHECK: or <8 x i16>
+
+ res_vbs = vec_vsel(vbs, vbs, vus); // CHECK: xor <8 x i16>
+ // CHECK: and <8 x i16>
+ // CHECK: and <8 x i16>
+ // CHECK: or <8 x i16>
+
+ res_vbs = vec_vsel(vbs, vbs, vbs); // CHECK: xor <8 x i16>
+ // CHECK: and <8 x i16>
+ // CHECK: and <8 x i16>
+ // CHECK: or <8 x i16>
+
res_vi = vec_vsel(vi, vi, vui); // CHECK: xor <4 x i32>
// CHECK: and <4 x i32>
// CHECK: and <4 x i32>
// CHECK: or <4 x i32>
+ res_vi = vec_vsel(vi, vi, vbi); // CHECK: xor <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: or <4 x i32>
res_vui = vec_vsel(vui, vui, vui); // CHECK: xor <4 x i32>
// CHECK: and <4 x i32>
// CHECK: and <4 x i32>
// CHECK: or <4 x i32>
+ res_vui = vec_vsel(vui, vui, vbi); // CHECK: xor <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: or <4 x i32>
+
+ res_vbi = vec_vsel(vbi, vbi, vui); // CHECK: xor <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: or <4 x i32>
+
+ res_vbi = vec_vsel(vbi, vbi, vbi); // CHECK: xor <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: or <4 x i32>
res_vf = vec_vsel(vf, vf, vui); // CHECK: xor <4 x i32>
// CHECK: and <4 x i32>
// CHECK: and <4 x i32>
// CHECK: or <4 x i32>
+ res_vf = vec_vsel(vf, vf, vbi); // CHECK: xor <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: and <4 x i32>
+ // CHECK: or <4 x i32>
/* vec_sl */
res_vsc = vec_sl(vsc, vuc); // CHECK: shl <16 x i8>
res_vuc = vec_sll(vuc, vuc); // CHECK: @llvm.ppc.altivec.vsl
res_vuc = vec_sll(vuc, vus); // CHECK: @llvm.ppc.altivec.vsl
res_vuc = vec_sll(vuc, vui); // CHECK: @llvm.ppc.altivec.vsl
+ res_vbc = vec_sll(vbc, vuc); // CHECK: @llvm.ppc.altivec.vsl
+ res_vbc = vec_sll(vbc, vus); // CHECK: @llvm.ppc.altivec.vsl
+ res_vbc = vec_sll(vbc, vui); // CHECK: @llvm.ppc.altivec.vsl
res_vs = vec_sll(vs, vuc); // CHECK: @llvm.ppc.altivec.vsl
res_vs = vec_sll(vs, vus); // CHECK: @llvm.ppc.altivec.vsl
res_vs = vec_sll(vs, vui); // CHECK: @llvm.ppc.altivec.vsl
res_vus = vec_sll(vus, vuc); // CHECK: @llvm.ppc.altivec.vsl
res_vus = vec_sll(vus, vus); // CHECK: @llvm.ppc.altivec.vsl
res_vus = vec_sll(vus, vui); // CHECK: @llvm.ppc.altivec.vsl
+ res_vbs = vec_sll(vbs, vuc); // CHECK: @llvm.ppc.altivec.vsl
+ res_vbs = vec_sll(vbs, vus); // CHECK: @llvm.ppc.altivec.vsl
+ res_vbs = vec_sll(vbs, vui); // CHECK: @llvm.ppc.altivec.vsl
+ res_vp = vec_sll(vp, vuc); // CHECK: @llvm.ppc.altivec.vsl
+ res_vp = vec_sll(vp, vus); // CHECK: @llvm.ppc.altivec.vsl
+ res_vp = vec_sll(vp, vui); // CHECK: @llvm.ppc.altivec.vsl
res_vi = vec_sll(vi, vuc); // CHECK: @llvm.ppc.altivec.vsl
res_vi = vec_sll(vi, vus); // CHECK: @llvm.ppc.altivec.vsl
res_vi = vec_sll(vi, vui); // CHECK: @llvm.ppc.altivec.vsl
res_vui = vec_sll(vui, vuc); // CHECK: @llvm.ppc.altivec.vsl
res_vui = vec_sll(vui, vus); // CHECK: @llvm.ppc.altivec.vsl
res_vui = vec_sll(vui, vui); // CHECK: @llvm.ppc.altivec.vsl
+ res_vbi = vec_sll(vbi, vuc); // CHECK: @llvm.ppc.altivec.vsl
+ res_vbi = vec_sll(vbi, vus); // CHECK: @llvm.ppc.altivec.vsl
+ res_vbi = vec_sll(vbi, vui); // CHECK: @llvm.ppc.altivec.vsl
res_vsc = vec_vsl(vsc, vuc); // CHECK: @llvm.ppc.altivec.vsl
res_vsc = vec_vsl(vsc, vus); // CHECK: @llvm.ppc.altivec.vsl
res_vsc = vec_vsl(vsc, vui); // CHECK: @llvm.ppc.altivec.vsl
res_vuc = vec_vsl(vuc, vuc); // CHECK: @llvm.ppc.altivec.vsl
res_vuc = vec_vsl(vuc, vus); // CHECK: @llvm.ppc.altivec.vsl
res_vuc = vec_vsl(vuc, vui); // CHECK: @llvm.ppc.altivec.vsl
+ res_vbc = vec_vsl(vbc, vuc); // CHECK: @llvm.ppc.altivec.vsl
+ res_vbc = vec_vsl(vbc, vus); // CHECK: @llvm.ppc.altivec.vsl
+ res_vbc = vec_vsl(vbc, vui); // CHECK: @llvm.ppc.altivec.vsl
res_vs = vec_vsl(vs, vuc); // CHECK: @llvm.ppc.altivec.vsl
res_vs = vec_vsl(vs, vus); // CHECK: @llvm.ppc.altivec.vsl
res_vs = vec_vsl(vs, vui); // CHECK: @llvm.ppc.altivec.vsl
res_vus = vec_vsl(vus, vuc); // CHECK: @llvm.ppc.altivec.vsl
res_vus = vec_vsl(vus, vus); // CHECK: @llvm.ppc.altivec.vsl
res_vus = vec_vsl(vus, vui); // CHECK: @llvm.ppc.altivec.vsl
+ res_vbs = vec_vsl(vbs, vuc); // CHECK: @llvm.ppc.altivec.vsl
+ res_vbs = vec_vsl(vbs, vus); // CHECK: @llvm.ppc.altivec.vsl
+ res_vbs = vec_vsl(vbs, vui); // CHECK: @llvm.ppc.altivec.vsl
+ res_vp = vec_vsl(vp, vuc); // CHECK: @llvm.ppc.altivec.vsl
+ res_vp = vec_vsl(vp, vus); // CHECK: @llvm.ppc.altivec.vsl
+ res_vp = vec_vsl(vp, vui); // CHECK: @llvm.ppc.altivec.vsl
res_vi = vec_vsl(vi, vuc); // CHECK: @llvm.ppc.altivec.vsl
res_vi = vec_vsl(vi, vus); // CHECK: @llvm.ppc.altivec.vsl
res_vi = vec_vsl(vi, vui); // CHECK: @llvm.ppc.altivec.vsl
res_vui = vec_vsl(vui, vuc); // CHECK: @llvm.ppc.altivec.vsl
res_vui = vec_vsl(vui, vus); // CHECK: @llvm.ppc.altivec.vsl
res_vui = vec_vsl(vui, vui); // CHECK: @llvm.ppc.altivec.vsl
+ res_vbi = vec_vsl(vbi, vuc); // CHECK: @llvm.ppc.altivec.vsl
+ res_vbi = vec_vsl(vbi, vus); // CHECK: @llvm.ppc.altivec.vsl
+ res_vbi = vec_vsl(vbi, vui); // CHECK: @llvm.ppc.altivec.vsl
/* vec_slo */
res_vsc = vec_slo(vsc, vsc); // CHECK: @llvm.ppc.altivec.vslo
res_vs = vec_slo(vs, vuc); // CHECK: @llvm.ppc.altivec.vslo
res_vus = vec_slo(vus, vsc); // CHECK: @llvm.ppc.altivec.vslo
res_vus = vec_slo(vus, vuc); // CHECK: @llvm.ppc.altivec.vslo
+ res_vp = vec_slo(vp, vsc); // CHECK: @llvm.ppc.altivec.vslo
+ res_vp = vec_slo(vp, vuc); // CHECK: @llvm.ppc.altivec.vslo
res_vi = vec_slo(vi, vsc); // CHECK: @llvm.ppc.altivec.vslo
res_vi = vec_slo(vi, vuc); // CHECK: @llvm.ppc.altivec.vslo
res_vui = vec_slo(vui, vsc); // CHECK: @llvm.ppc.altivec.vslo
res_vs = vec_vslo(vs, vuc); // CHECK: @llvm.ppc.altivec.vslo
res_vus = vec_vslo(vus, vsc); // CHECK: @llvm.ppc.altivec.vslo
res_vus = vec_vslo(vus, vuc); // CHECK: @llvm.ppc.altivec.vslo
+ res_vp = vec_vslo(vp, vsc); // CHECK: @llvm.ppc.altivec.vslo
+ res_vp = vec_vslo(vp, vuc); // CHECK: @llvm.ppc.altivec.vslo
res_vi = vec_vslo(vi, vsc); // CHECK: @llvm.ppc.altivec.vslo
res_vi = vec_vslo(vi, vuc); // CHECK: @llvm.ppc.altivec.vslo
res_vui = vec_vslo(vui, vsc); // CHECK: @llvm.ppc.altivec.vslo
res_vuc = vec_srl(vuc, vuc); // CHECK: @llvm.ppc.altivec.vsr
res_vuc = vec_srl(vuc, vus); // CHECK: @llvm.ppc.altivec.vsr
res_vuc = vec_srl(vuc, vui); // CHECK: @llvm.ppc.altivec.vsr
+ res_vbc = vec_srl(vbc, vuc); // CHECK: @llvm.ppc.altivec.vsr
+ res_vbc = vec_srl(vbc, vus); // CHECK: @llvm.ppc.altivec.vsr
+ res_vbc = vec_srl(vbc, vui); // CHECK: @llvm.ppc.altivec.vsr
res_vs = vec_srl(vs, vuc); // CHECK: @llvm.ppc.altivec.vsr
res_vs = vec_srl(vs, vus); // CHECK: @llvm.ppc.altivec.vsr
res_vs = vec_srl(vs, vui); // CHECK: @llvm.ppc.altivec.vsr
res_vus = vec_srl(vus, vuc); // CHECK: @llvm.ppc.altivec.vsr
res_vus = vec_srl(vus, vus); // CHECK: @llvm.ppc.altivec.vsr
res_vus = vec_srl(vus, vui); // CHECK: @llvm.ppc.altivec.vsr
+ res_vbs = vec_srl(vbs, vuc); // CHECK: @llvm.ppc.altivec.vsr
+ res_vbs = vec_srl(vbs, vus); // CHECK: @llvm.ppc.altivec.vsr
+ res_vbs = vec_srl(vbs, vui); // CHECK: @llvm.ppc.altivec.vsr
+ res_vp = vec_srl(vp, vuc); // CHECK: @llvm.ppc.altivec.vsr
+ res_vp = vec_srl(vp, vus); // CHECK: @llvm.ppc.altivec.vsr
+ res_vp = vec_srl(vp, vui); // CHECK: @llvm.ppc.altivec.vsr
res_vi = vec_srl(vi, vuc); // CHECK: @llvm.ppc.altivec.vsr
res_vi = vec_srl(vi, vus); // CHECK: @llvm.ppc.altivec.vsr
res_vi = vec_srl(vi, vui); // CHECK: @llvm.ppc.altivec.vsr
res_vui = vec_srl(vui, vuc); // CHECK: @llvm.ppc.altivec.vsr
res_vui = vec_srl(vui, vus); // CHECK: @llvm.ppc.altivec.vsr
res_vui = vec_srl(vui, vui); // CHECK: @llvm.ppc.altivec.vsr
+ res_vbi = vec_srl(vbi, vuc); // CHECK: @llvm.ppc.altivec.vsr
+ res_vbi = vec_srl(vbi, vus); // CHECK: @llvm.ppc.altivec.vsr
+ res_vbi = vec_srl(vbi, vui); // CHECK: @llvm.ppc.altivec.vsr
res_vsc = vec_vsr(vsc, vuc); // CHECK: @llvm.ppc.altivec.vsr
res_vsc = vec_vsr(vsc, vus); // CHECK: @llvm.ppc.altivec.vsr
res_vsc = vec_vsr(vsc, vui); // CHECK: @llvm.ppc.altivec.vsr
res_vuc = vec_vsr(vuc, vuc); // CHECK: @llvm.ppc.altivec.vsr
res_vuc = vec_vsr(vuc, vus); // CHECK: @llvm.ppc.altivec.vsr
res_vuc = vec_vsr(vuc, vui); // CHECK: @llvm.ppc.altivec.vsr
+ res_vbc = vec_vsr(vbc, vuc); // CHECK: @llvm.ppc.altivec.vsr
+ res_vbc = vec_vsr(vbc, vus); // CHECK: @llvm.ppc.altivec.vsr
+ res_vbc = vec_vsr(vbc, vui); // CHECK: @llvm.ppc.altivec.vsr
res_vs = vec_vsr(vs, vuc); // CHECK: @llvm.ppc.altivec.vsr
res_vs = vec_vsr(vs, vus); // CHECK: @llvm.ppc.altivec.vsr
res_vs = vec_vsr(vs, vui); // CHECK: @llvm.ppc.altivec.vsr
res_vus = vec_vsr(vus, vuc); // CHECK: @llvm.ppc.altivec.vsr
res_vus = vec_vsr(vus, vus); // CHECK: @llvm.ppc.altivec.vsr
res_vus = vec_vsr(vus, vui); // CHECK: @llvm.ppc.altivec.vsr
+ res_vbs = vec_vsr(vbs, vuc); // CHECK: @llvm.ppc.altivec.vsr
+ res_vbs = vec_vsr(vbs, vus); // CHECK: @llvm.ppc.altivec.vsr
+ res_vbs = vec_vsr(vbs, vui); // CHECK: @llvm.ppc.altivec.vsr
+ res_vp = vec_vsr(vp, vuc); // CHECK: @llvm.ppc.altivec.vsr
+ res_vp = vec_vsr(vp, vus); // CHECK: @llvm.ppc.altivec.vsr
+ res_vp = vec_vsr(vp, vui); // CHECK: @llvm.ppc.altivec.vsr
res_vi = vec_vsr(vi, vuc); // CHECK: @llvm.ppc.altivec.vsr
res_vi = vec_vsr(vi, vus); // CHECK: @llvm.ppc.altivec.vsr
res_vi = vec_vsr(vi, vui); // CHECK: @llvm.ppc.altivec.vsr
res_vui = vec_vsr(vui, vuc); // CHECK: @llvm.ppc.altivec.vsr
res_vui = vec_vsr(vui, vus); // CHECK: @llvm.ppc.altivec.vsr
res_vui = vec_vsr(vui, vui); // CHECK: @llvm.ppc.altivec.vsr
+ res_vbi = vec_vsr(vbi, vuc); // CHECK: @llvm.ppc.altivec.vsr
+ res_vbi = vec_vsr(vbi, vus); // CHECK: @llvm.ppc.altivec.vsr
+ res_vbi = vec_vsr(vbi, vui); // CHECK: @llvm.ppc.altivec.vsr
/* vec_sro */
res_vsc = vec_sro(vsc, vsc); // CHECK: @llvm.ppc.altivec.vsro
res_vs = vec_sro(vs, vuc); // CHECK: @llvm.ppc.altivec.vsro
res_vus = vec_sro(vus, vsc); // CHECK: @llvm.ppc.altivec.vsro
res_vus = vec_sro(vus, vuc); // CHECK: @llvm.ppc.altivec.vsro
+ res_vp = vec_sro(vp, vsc); // CHECK: @llvm.ppc.altivec.vsro
+ res_vp = vec_sro(vp, vuc); // CHECK: @llvm.ppc.altivec.vsro
res_vi = vec_sro(vi, vsc); // CHECK: @llvm.ppc.altivec.vsro
res_vi = vec_sro(vi, vuc); // CHECK: @llvm.ppc.altivec.vsro
res_vui = vec_sro(vui, vsc); // CHECK: @llvm.ppc.altivec.vsro
res_vs = vec_vsro(vs, vuc); // CHECK: @llvm.ppc.altivec.vsro
res_vus = vec_vsro(vus, vsc); // CHECK: @llvm.ppc.altivec.vsro
res_vus = vec_vsro(vus, vuc); // CHECK: @llvm.ppc.altivec.vsro
+ res_vp = vec_vsro(vp, vsc); // CHECK: @llvm.ppc.altivec.vsro
+ res_vp = vec_vsro(vp, vuc); // CHECK: @llvm.ppc.altivec.vsro
res_vi = vec_vsro(vi, vsc); // CHECK: @llvm.ppc.altivec.vsro
res_vi = vec_vsro(vi, vuc); // CHECK: @llvm.ppc.altivec.vsro
res_vui = vec_vsro(vui, vsc); // CHECK: @llvm.ppc.altivec.vsro
vec_st(vsc, 0, ¶m_sc); // CHECK: @llvm.ppc.altivec.stvx
vec_st(vuc, 0, &vuc); // CHECK: @llvm.ppc.altivec.stvx
vec_st(vuc, 0, ¶m_uc); // CHECK: @llvm.ppc.altivec.stvx
+ vec_st(vbc, 0, ¶m_uc); // CHECK: @llvm.ppc.altivec.stvx
+ vec_st(vbc, 0, ¶m_uc); // CHECK: @llvm.ppc.altivec.stvx
+ vec_st(vbc, 0, &vbc); // CHECK: @llvm.ppc.altivec.stvx
vec_st(vs, 0, &vs); // CHECK: @llvm.ppc.altivec.stvx
vec_st(vs, 0, ¶m_s); // CHECK: @llvm.ppc.altivec.stvx
vec_st(vus, 0, &vus); // CHECK: @llvm.ppc.altivec.stvx
vec_st(vus, 0, ¶m_us); // CHECK: @llvm.ppc.altivec.stvx
+ vec_st(vbs, 0, ¶m_s); // CHECK: @llvm.ppc.altivec.stvx
+ vec_st(vbs, 0, ¶m_us); // CHECK: @llvm.ppc.altivec.stvx
+ vec_st(vbs, 0, &vbs); // CHECK: @llvm.ppc.altivec.stvx
+ vec_st(vp, 0, ¶m_s); // CHECK: @llvm.ppc.altivec.stvx
+ vec_st(vp, 0, ¶m_us); // CHECK: @llvm.ppc.altivec.stvx
+ vec_st(vp, 0, &vp); // CHECK: @llvm.ppc.altivec.stvx
vec_st(vi, 0, &vi); // CHECK: @llvm.ppc.altivec.stvx
vec_st(vi, 0, ¶m_i); // CHECK: @llvm.ppc.altivec.stvx
vec_st(vui, 0, &vui); // CHECK: @llvm.ppc.altivec.stvx
vec_st(vui, 0, ¶m_ui); // CHECK: @llvm.ppc.altivec.stvx
+ vec_st(vbi, 0, ¶m_i); // CHECK: @llvm.ppc.altivec.stvx
+ vec_st(vbi, 0, ¶m_ui); // CHECK: @llvm.ppc.altivec.stvx
+ vec_st(vbi, 0, &vbi); // CHECK: @llvm.ppc.altivec.stvx
vec_st(vf, 0, &vf); // CHECK: @llvm.ppc.altivec.stvx
vec_st(vf, 0, ¶m_f); // CHECK: @llvm.ppc.altivec.stvx
vec_stvx(vsc, 0, &vsc); // CHECK: @llvm.ppc.altivec.stvx
vec_stvx(vsc, 0, ¶m_sc); // CHECK: @llvm.ppc.altivec.stvx
vec_stvx(vuc, 0, &vuc); // CHECK: @llvm.ppc.altivec.stvx
vec_stvx(vuc, 0, ¶m_uc); // CHECK: @llvm.ppc.altivec.stvx
+ vec_stvx(vbc, 0, ¶m_uc); // CHECK: @llvm.ppc.altivec.stvx
+ vec_stvx(vbc, 0, ¶m_uc); // CHECK: @llvm.ppc.altivec.stvx
+ vec_stvx(vbc, 0, &vbc); // CHECK: @llvm.ppc.altivec.stvx
vec_stvx(vs, 0, &vs); // CHECK: @llvm.ppc.altivec.stvx
vec_stvx(vs, 0, ¶m_s); // CHECK: @llvm.ppc.altivec.stvx
vec_stvx(vus, 0, &vus); // CHECK: @llvm.ppc.altivec.stvx
vec_stvx(vus, 0, ¶m_us); // CHECK: @llvm.ppc.altivec.stvx
+ vec_stvx(vbs, 0, ¶m_s); // CHECK: @llvm.ppc.altivec.stvx
+ vec_stvx(vbs, 0, ¶m_us); // CHECK: @llvm.ppc.altivec.stvx
+ vec_stvx(vbs, 0, &vbs); // CHECK: @llvm.ppc.altivec.stvx
+ vec_stvx(vp, 0, ¶m_s); // CHECK: @llvm.ppc.altivec.stvx
+ vec_stvx(vp, 0, ¶m_us); // CHECK: @llvm.ppc.altivec.stvx
+ vec_stvx(vp, 0, &vp); // CHECK: @llvm.ppc.altivec.stvx
vec_stvx(vi, 0, &vi); // CHECK: @llvm.ppc.altivec.stvx
vec_stvx(vi, 0, ¶m_i); // CHECK: @llvm.ppc.altivec.stvx
vec_stvx(vui, 0, &vui); // CHECK: @llvm.ppc.altivec.stvx
vec_stvx(vui, 0, ¶m_ui); // CHECK: @llvm.ppc.altivec.stvx
+ vec_stvx(vbi, 0, ¶m_i); // CHECK: @llvm.ppc.altivec.stvx
+ vec_stvx(vbi, 0, ¶m_ui); // CHECK: @llvm.ppc.altivec.stvx
+ vec_stvx(vbi, 0, &vbi); // CHECK: @llvm.ppc.altivec.stvx
vec_stvx(vf, 0, &vf); // CHECK: @llvm.ppc.altivec.stvx
vec_stvx(vf, 0, ¶m_f); // CHECK: @llvm.ppc.altivec.stvx
/* vec_ste */
vec_ste(vsc, 0, ¶m_sc); // CHECK: @llvm.ppc.altivec.stvebx
vec_ste(vuc, 0, ¶m_uc); // CHECK: @llvm.ppc.altivec.stvebx
+ vec_ste(vbc, 0, ¶m_sc); // CHECK: @llvm.ppc.altivec.stvebx
+ vec_ste(vbc, 0, ¶m_uc); // CHECK: @llvm.ppc.altivec.stvebx
vec_ste(vs, 0, ¶m_s); // CHECK: @llvm.ppc.altivec.stvehx
vec_ste(vus, 0, ¶m_us); // CHECK: @llvm.ppc.altivec.stvehx
+ vec_ste(vbs, 0, ¶m_s); // CHECK: @llvm.ppc.altivec.stvehx
+ vec_ste(vbs, 0, ¶m_us); // CHECK: @llvm.ppc.altivec.stvehx
+ vec_ste(vp, 0, ¶m_s); // CHECK: @llvm.ppc.altivec.stvehx
+ vec_ste(vp, 0, ¶m_us); // CHECK: @llvm.ppc.altivec.stvehx
vec_ste(vi, 0, ¶m_i); // CHECK: @llvm.ppc.altivec.stvewx
vec_ste(vui, 0, ¶m_ui); // CHECK: @llvm.ppc.altivec.stvewx
+ vec_ste(vbi, 0, ¶m_i); // CHECK: @llvm.ppc.altivec.stvewx
+ vec_ste(vbi, 0, ¶m_ui); // CHECK: @llvm.ppc.altivec.stvewx
vec_ste(vf, 0, ¶m_f); // CHECK: @llvm.ppc.altivec.stvewx
vec_stvebx(vsc, 0, ¶m_sc); // CHECK: @llvm.ppc.altivec.stvebx
vec_stvebx(vuc, 0, ¶m_uc); // CHECK: @llvm.ppc.altivec.stvebx
+ vec_stvebx(vbc, 0, ¶m_sc); // CHECK: @llvm.ppc.altivec.stvebx
+ vec_stvebx(vbc, 0, ¶m_uc); // CHECK: @llvm.ppc.altivec.stvebx
vec_stvehx(vs, 0, ¶m_s); // CHECK: @llvm.ppc.altivec.stvehx
vec_stvehx(vus, 0, ¶m_us); // CHECK: @llvm.ppc.altivec.stvehx
+ vec_stvehx(vbs, 0, ¶m_s); // CHECK: @llvm.ppc.altivec.stvehx
+ vec_stvehx(vbs, 0, ¶m_us); // CHECK: @llvm.ppc.altivec.stvehx
+ vec_stvehx(vp, 0, ¶m_s); // CHECK: @llvm.ppc.altivec.stvehx
+ vec_stvehx(vp, 0, ¶m_us); // CHECK: @llvm.ppc.altivec.stvehx
vec_stvewx(vi, 0, ¶m_i); // CHECK: @llvm.ppc.altivec.stvewx
vec_stvewx(vui, 0, ¶m_ui); // CHECK: @llvm.ppc.altivec.stvewx
+ vec_stvewx(vbi, 0, ¶m_i); // CHECK: @llvm.ppc.altivec.stvewx
+ vec_stvewx(vbi, 0, ¶m_ui); // CHECK: @llvm.ppc.altivec.stvewx
vec_stvewx(vf, 0, ¶m_f); // CHECK: @llvm.ppc.altivec.stvewx
/* vec_stl */
vec_stl(vsc, 0, ¶m_sc); // CHECK: @llvm.ppc.altivec.stvxl
vec_stl(vuc, 0, &vuc); // CHECK: @llvm.ppc.altivec.stvxl
vec_stl(vuc, 0, ¶m_uc); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stl(vbc, 0, ¶m_sc); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stl(vbc, 0, ¶m_uc); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stl(vbc, 0, &vbc); // CHECK: @llvm.ppc.altivec.stvxl
vec_stl(vs, 0, &vs); // CHECK: @llvm.ppc.altivec.stvxl
vec_stl(vs, 0, ¶m_s); // CHECK: @llvm.ppc.altivec.stvxl
vec_stl(vus, 0, &vus); // CHECK: @llvm.ppc.altivec.stvxl
vec_stl(vus, 0, ¶m_us); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stl(vbs, 0, ¶m_s); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stl(vbs, 0, ¶m_us); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stl(vbs, 0, &vbs); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stl(vp, 0, ¶m_s); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stl(vp, 0, ¶m_us); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stl(vp, 0, &vp); // CHECK: @llvm.ppc.altivec.stvxl
vec_stl(vi, 0, &vi); // CHECK: @llvm.ppc.altivec.stvxl
vec_stl(vi, 0, ¶m_i); // CHECK: @llvm.ppc.altivec.stvxl
vec_stl(vui, 0, &vui); // CHECK: @llvm.ppc.altivec.stvxl
vec_stl(vui, 0, ¶m_ui); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stl(vbi, 0, ¶m_i); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stl(vbi, 0, ¶m_ui); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stl(vbi, 0, &vbi); // CHECK: @llvm.ppc.altivec.stvxl
vec_stl(vf, 0, &vf); // CHECK: @llvm.ppc.altivec.stvxl
vec_stl(vf, 0, ¶m_f); // CHECK: @llvm.ppc.altivec.stvxl
vec_stvxl(vsc, 0, &vsc); // CHECK: @llvm.ppc.altivec.stvxl
vec_stvxl(vsc, 0, ¶m_sc); // CHECK: @llvm.ppc.altivec.stvxl
vec_stvxl(vuc, 0, &vuc); // CHECK: @llvm.ppc.altivec.stvxl
vec_stvxl(vuc, 0, ¶m_uc); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stvxl(vbc, 0, ¶m_sc); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stvxl(vbc, 0, ¶m_uc); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stvxl(vbc, 0, &vbc); // CHECK: @llvm.ppc.altivec.stvxl
vec_stvxl(vs, 0, &vs); // CHECK: @llvm.ppc.altivec.stvxl
vec_stvxl(vs, 0, ¶m_s); // CHECK: @llvm.ppc.altivec.stvxl
vec_stvxl(vus, 0, &vus); // CHECK: @llvm.ppc.altivec.stvxl
vec_stvxl(vus, 0, ¶m_us); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stvxl(vbs, 0, ¶m_s); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stvxl(vbs, 0, ¶m_us); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stvxl(vbs, 0, &vbs); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stvxl(vp, 0, ¶m_s); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stvxl(vp, 0, ¶m_us); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stvxl(vp, 0, &vp); // CHECK: @llvm.ppc.altivec.stvxl
vec_stvxl(vi, 0, &vi); // CHECK: @llvm.ppc.altivec.stvxl
vec_stvxl(vi, 0, ¶m_i); // CHECK: @llvm.ppc.altivec.stvxl
vec_stvxl(vui, 0, &vui); // CHECK: @llvm.ppc.altivec.stvxl
vec_stvxl(vui, 0, ¶m_ui); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stvxl(vbi, 0, ¶m_i); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stvxl(vbi, 0, ¶m_ui); // CHECK: @llvm.ppc.altivec.stvxl
+ vec_stvxl(vbi, 0, &vbi); // CHECK: @llvm.ppc.altivec.stvxl
vec_stvxl(vf, 0, &vf); // CHECK: @llvm.ppc.altivec.stvxl
vec_stvxl(vf, 0, ¶m_f); // CHECK: @llvm.ppc.altivec.stvxl
/* vec_sub */
res_vsc = vec_sub(vsc, vsc); // CHECK: sub nsw <16 x i8>
+ res_vsc = vec_sub(vbc, vsc); // CHECK: sub nsw <16 x i8>
+ res_vsc = vec_sub(vsc, vbc); // CHECK: sub nsw <16 x i8>
res_vuc = vec_sub(vuc, vuc); // CHECK: sub <16 x i8>
+ res_vuc = vec_sub(vbc, vuc); // CHECK: sub <16 x i8>
+ res_vuc = vec_sub(vuc, vbc); // CHECK: sub <16 x i8>
res_vs = vec_sub(vs, vs); // CHECK: sub nsw <8 x i16>
+ res_vs = vec_sub(vbs, vs); // CHECK: sub nsw <8 x i16>
+ res_vs = vec_sub(vs, vbs); // CHECK: sub nsw <8 x i16>
res_vus = vec_sub(vus, vus); // CHECK: sub <8 x i16>
+ res_vus = vec_sub(vbs, vus); // CHECK: sub <8 x i16>
+ res_vus = vec_sub(vus, vbs); // CHECK: sub <8 x i16>
res_vi = vec_sub(vi, vi); // CHECK: sub nsw <4 x i32>
+ res_vi = vec_sub(vbi, vi); // CHECK: sub nsw <4 x i32>
+ res_vi = vec_sub(vi, vbi); // CHECK: sub nsw <4 x i32>
res_vui = vec_sub(vui, vui); // CHECK: sub <4 x i32>
+ res_vui = vec_sub(vbi, vui); // CHECK: sub <4 x i32>
+ res_vui = vec_sub(vui, vbi); // CHECK: sub <4 x i32>
res_vf = vec_sub(vf, vf); // CHECK: fsub <4 x float>
res_vsc = vec_vsububm(vsc, vsc); // CHECK: sub nsw <16 x i8>
+ res_vsc = vec_vsububm(vbc, vsc); // CHECK: sub nsw <16 x i8>
+ res_vsc = vec_vsububm(vsc, vbc); // CHECK: sub nsw <16 x i8>
res_vuc = vec_vsububm(vuc, vuc); // CHECK: sub <16 x i8>
+ res_vuc = vec_vsububm(vbc, vuc); // CHECK: sub <16 x i8>
+ res_vuc = vec_vsububm(vuc, vbc); // CHECK: sub <16 x i8>
res_vs = vec_vsubuhm(vs, vs); // CHECK: sub nsw <8 x i16>
+ res_vs = vec_vsubuhm(vbs, vus); // CHECK: sub <8 x i16>
+ res_vs = vec_vsubuhm(vus, vbs); // CHECK: sub <8 x i16>
res_vus = vec_vsubuhm(vus, vus); // CHECK: sub <8 x i16>
+ res_vus = vec_vsubuhm(vbs, vus); // CHECK: sub <8 x i16>
+ res_vus = vec_vsubuhm(vus, vbs); // CHECK: sub <8 x i16>
res_vi = vec_vsubuwm(vi, vi); // CHECK: sub nsw <4 x i32>
+ res_vi = vec_vsubuwm(vbi, vi); // CHECK: sub nsw <4 x i32>
+ res_vi = vec_vsubuwm(vi, vbi); // CHECK: sub nsw <4 x i32>
res_vui = vec_vsubuwm(vui, vui); // CHECK: sub <4 x i32>
+ res_vui = vec_vsubuwm(vbi, vui); // CHECK: sub <4 x i32>
+ res_vui = vec_vsubuwm(vui, vbi); // CHECK: sub <4 x i32>
res_vf = vec_vsubfp(vf, vf); // CHECK: fsub <4 x float>
/* vec_subc */
/* vec_subs */
res_vsc = vec_subs(vsc, vsc); // CHECK: @llvm.ppc.altivec.vsubsbs
+ res_vsc = vec_subs(vbc, vsc); // CHECK: @llvm.ppc.altivec.vsubsbs
+ res_vsc = vec_subs(vsc, vbc); // CHECK: @llvm.ppc.altivec.vsubsbs
res_vuc = vec_subs(vuc, vuc); // CHECK: @llvm.ppc.altivec.vsububs
+ res_vuc = vec_subs(vbc, vuc); // CHECK: @llvm.ppc.altivec.vsububs
+ res_vuc = vec_subs(vuc, vbc); // CHECK: @llvm.ppc.altivec.vsububs
res_vs = vec_subs(vs, vs); // CHECK: @llvm.ppc.altivec.vsubshs
+ res_vs = vec_subs(vbs, vs); // CHECK: @llvm.ppc.altivec.vsubshs
+ res_vs = vec_subs(vs, vbs); // CHECK: @llvm.ppc.altivec.vsubshs
res_vus = vec_subs(vus, vus); // CHECK: @llvm.ppc.altivec.vsubuhs
+ res_vus = vec_subs(vbs, vus); // CHECK: @llvm.ppc.altivec.vsubuhs
+ res_vus = vec_subs(vus, vbs); // CHECK: @llvm.ppc.altivec.vsubuhs
res_vi = vec_subs(vi, vi); // CHECK: @llvm.ppc.altivec.vsubsws
+ res_vi = vec_subs(vbi, vi); // CHECK: @llvm.ppc.altivec.vsubsws
+ res_vi = vec_subs(vi, vbi); // CHECK: @llvm.ppc.altivec.vsubsws
res_vui = vec_subs(vui, vui); // CHECK: @llvm.ppc.altivec.vsubuws
+ res_vui = vec_subs(vbi, vui); // CHECK: @llvm.ppc.altivec.vsubuws
+ res_vui = vec_subs(vui, vbi); // CHECK: @llvm.ppc.altivec.vsubuws
res_vsc = vec_vsubsbs(vsc, vsc); // CHECK: @llvm.ppc.altivec.vsubsbs
+ res_vsc = vec_vsubsbs(vbc, vsc); // CHECK: @llvm.ppc.altivec.vsubsbs
+ res_vsc = vec_vsubsbs(vsc, vbc); // CHECK: @llvm.ppc.altivec.vsubsbs
res_vuc = vec_vsububs(vuc, vuc); // CHECK: @llvm.ppc.altivec.vsububs
+ res_vuc = vec_vsububs(vbc, vuc); // CHECK: @llvm.ppc.altivec.vsububs
+ res_vuc = vec_vsububs(vuc, vbc); // CHECK: @llvm.ppc.altivec.vsububs
res_vs = vec_vsubshs(vs, vs); // CHECK: @llvm.ppc.altivec.vsubshs
+ res_vs = vec_vsubshs(vbs, vs); // CHECK: @llvm.ppc.altivec.vsubshs
+ res_vs = vec_vsubshs(vs, vbs); // CHECK: @llvm.ppc.altivec.vsubshs
res_vus = vec_vsubuhs(vus, vus); // CHECK: @llvm.ppc.altivec.vsubuhs
+ res_vus = vec_vsubuhs(vbs, vus); // CHECK: @llvm.ppc.altivec.vsubuhs
+ res_vus = vec_vsubuhs(vus, vbs); // CHECK: @llvm.ppc.altivec.vsubuhs
res_vi = vec_vsubsws(vi, vi); // CHECK: @llvm.ppc.altivec.vsubsws
+ res_vi = vec_vsubsws(vbi, vi); // CHECK: @llvm.ppc.altivec.vsubsws
+ res_vi = vec_vsubsws(vi, vbi); // CHECK: @llvm.ppc.altivec.vsubsws
res_vui = vec_vsubuws(vui, vui); // CHECK: @llvm.ppc.altivec.vsubuws
+ res_vui = vec_vsubuws(vbi, vui); // CHECK: @llvm.ppc.altivec.vsubuws
+ res_vui = vec_vsubuws(vui, vbi); // CHECK: @llvm.ppc.altivec.vsubuws
/* vec_sum4s */
res_vi = vec_sum4s(vsc, vi); // CHECK: @llvm.ppc.altivec.vsum4sbs
res_vf = vec_vrfiz(vf); // CHECK: @llvm.ppc.altivec.vrfiz
/* vec_unpackh */
- res_vs = vec_unpackh(vsc); // CHECK: @llvm.ppc.altivec.vupkhsb
- res_vi = vec_unpackh(vs); // CHECK: @llvm.ppc.altivec.vupkhsh
- res_vs = vec_vupkhsb(vsc); // CHECK: @llvm.ppc.altivec.vupkhsb
- res_vi = vec_vupkhsh(vs); // CHECK: @llvm.ppc.altivec.vupkhsh
+ res_vs = vec_unpackh(vsc); // CHECK: @llvm.ppc.altivec.vupkhsb
+ res_vbs = vec_unpackh(vbc); // CHECK: @llvm.ppc.altivec.vupkhsb
+ res_vi = vec_unpackh(vs); // CHECK: @llvm.ppc.altivec.vupkhsh
+ res_vbi = vec_unpackh(vbs); // CHECK: @llvm.ppc.altivec.vupkhsh
+ res_vui = vec_unpackh(vp); // CHECK: @llvm.ppc.altivec.vupkhsh
+ res_vs = vec_vupkhsb(vsc); // CHECK: @llvm.ppc.altivec.vupkhsb
+ res_vbs = vec_vupkhsb(vbc); // CHECK: @llvm.ppc.altivec.vupkhsb
+ res_vi = vec_vupkhsh(vs); // CHECK: @llvm.ppc.altivec.vupkhsh
+ res_vbi = vec_vupkhsh(vbs); // CHECK: @llvm.ppc.altivec.vupkhsh
+ res_vui = vec_vupkhsh(vp); // CHECK: @llvm.ppc.altivec.vupkhsh
/* vec_unpackl */
- res_vs = vec_unpackl(vsc); // CHECK: @llvm.ppc.altivec.vupklsb
- res_vi = vec_vupklsh(vs); // CHECK: @llvm.ppc.altivec.vupklsh
- res_vs = vec_vupklsb(vsc); // CHECK: @llvm.ppc.altivec.vupklsb
- res_vi = vec_vupklsh(vs); // CHECK: @llvm.ppc.altivec.vupklsh
+ res_vs = vec_unpackl(vsc); // CHECK: @llvm.ppc.altivec.vupklsb
+ res_vbs = vec_unpackl(vbc); // CHECK: @llvm.ppc.altivec.vupklsb
+ res_vi = vec_unpackl(vs); // CHECK: @llvm.ppc.altivec.vupklsh
+ res_vbi = vec_unpackl(vbs); // CHECK: @llvm.ppc.altivec.vupklsh
+ res_vui = vec_unpackl(vp); // CHECK: @llvm.ppc.altivec.vupklsh
+ res_vs = vec_vupklsb(vsc); // CHECK: @llvm.ppc.altivec.vupklsb
+ res_vbs = vec_vupklsb(vbc); // CHECK: @llvm.ppc.altivec.vupklsb
+ res_vi = vec_vupklsh(vs); // CHECK: @llvm.ppc.altivec.vupklsh
+ res_vbi = vec_vupklsh(vbs); // CHECK: @llvm.ppc.altivec.vupklsh
+ res_vui = vec_vupklsh(vp); // CHECK: @llvm.ppc.altivec.vupklsh
/* vec_xor */
res_vsc = vec_xor(vsc, vsc); // CHECK: xor <16 x i8>
+ res_vsc = vec_xor(vbc, vsc); // CHECK: xor <16 x i8>
+ res_vsc = vec_xor(vsc, vbc); // CHECK: xor <16 x i8>
res_vuc = vec_xor(vuc, vuc); // CHECK: xor <16 x i8>
+ res_vuc = vec_xor(vbc, vuc); // CHECK: xor <16 x i8>
+ res_vuc = vec_xor(vuc, vbc); // CHECK: xor <16 x i8>
+ res_vbc = vec_xor(vbc, vbc); // CHECK: xor <16 x i8>
res_vs = vec_xor(vs, vs); // CHECK: xor <8 x i16>
+ res_vs = vec_xor(vbs, vs); // CHECK: xor <8 x i16>
+ res_vs = vec_xor(vs, vbs); // CHECK: xor <8 x i16>
res_vus = vec_xor(vus, vus); // CHECK: xor <8 x i16>
+ res_vus = vec_xor(vbs, vus); // CHECK: xor <8 x i16>
+ res_vus = vec_xor(vus, vbs); // CHECK: xor <8 x i16>
+ res_vbs = vec_xor(vbs, vbs); // CHECK: xor <8 x i16>
res_vi = vec_xor(vi, vi); // CHECK: xor <4 x i32>
+ res_vi = vec_xor(vbi, vi); // CHECK: xor <4 x i32>
+ res_vi = vec_xor(vi, vbi); // CHECK: xor <4 x i32>
res_vui = vec_xor(vui, vui); // CHECK: xor <4 x i32>
+ res_vui = vec_xor(vbi, vui); // CHECK: xor <4 x i32>
+ res_vui = vec_xor(vui, vbi); // CHECK: xor <4 x i32>
+ res_vbi = vec_xor(vbi, vbi); // CHECK: xor <4 x i32>
res_vf = vec_xor(vf, vf); // CHECK: xor <4 x i32>
+ res_vf = vec_xor(vbi, vf); // CHECK: xor <4 x i32>
+ res_vf = vec_xor(vf, vbi); // CHECK: xor <4 x i32>
res_vsc = vec_vxor(vsc, vsc); // CHECK: xor <16 x i8>
+ res_vsc = vec_vxor(vbc, vsc); // CHECK: xor <16 x i8>
+ res_vsc = vec_vxor(vsc, vbc); // CHECK: xor <16 x i8>
res_vuc = vec_vxor(vuc, vuc); // CHECK: xor <16 x i8>
+ res_vuc = vec_vxor(vbc, vuc); // CHECK: xor <16 x i8>
+ res_vuc = vec_vxor(vuc, vbc); // CHECK: xor <16 x i8>
+ res_vbc = vec_vxor(vbc, vbc); // CHECK: xor <16 x i8>
res_vs = vec_vxor(vs, vs); // CHECK: xor <8 x i16>
+ res_vs = vec_vxor(vbs, vs); // CHECK: xor <8 x i16>
+ res_vs = vec_vxor(vs, vbs); // CHECK: xor <8 x i16>
res_vus = vec_vxor(vus, vus); // CHECK: xor <8 x i16>
+ res_vus = vec_vxor(vbs, vus); // CHECK: xor <8 x i16>
+ res_vus = vec_vxor(vus, vbs); // CHECK: xor <8 x i16>
+ res_vbs = vec_vxor(vbs, vbs); // CHECK: xor <8 x i16>
res_vi = vec_vxor(vi, vi); // CHECK: xor <4 x i32>
+ res_vi = vec_vxor(vbi, vi); // CHECK: xor <4 x i32>
+ res_vi = vec_vxor(vi, vbi); // CHECK: xor <4 x i32>
res_vui = vec_vxor(vui, vui); // CHECK: xor <4 x i32>
+ res_vui = vec_vxor(vbi, vui); // CHECK: xor <4 x i32>
+ res_vui = vec_vxor(vui, vbi); // CHECK: xor <4 x i32>
+ res_vbi = vec_vxor(vbi, vbi); // CHECK: xor <4 x i32>
res_vf = vec_vxor(vf, vf); // CHECK: xor <4 x i32>
+ res_vf = vec_vxor(vbi, vf); // CHECK: xor <4 x i32>
+ res_vf = vec_vxor(vf, vbi); // CHECK: xor <4 x i32>
/* ------------------------------ predicates -------------------------------------- */
/* vec_any_out */
res_i = vec_any_out(vf, vf); // CHECK: @llvm.ppc.altivec.vcmpbfp.p
-
- return 0;
}