support for the rest of AltiVec functions with bool/pixel arguments and return values (except predicates)

llvm-svn: 111511

2 files changed, 2695 insertions, 133 deletions

diff --git a/clang/lib/Headers/altivec.h b/clang/lib/Headers/altivec.h
index 1350eb5bd1f..5d251de2839 100644
--- a/clang/lib/Headers/altivec.h
+++ b/clang/lib/Headers/altivec.h
@@ -1339,214 +1339,218 @@ vec_vcmpbfp(vector float a, vector float b)
 
 /* 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 */
@@ -1717,6 +1721,12 @@ vec_ld(int a, unsigned char *b)
   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)
 {
@@ -1741,6 +1751,18 @@ vec_ld(int a, unsigned 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)
 {
@@ -1765,6 +1787,12 @@ vec_ld(int a, unsigned 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)
 {
@@ -1803,6 +1831,12 @@ vec_lvx(int a, unsigned char *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)
 {
@@ -1827,6 +1861,18 @@ vec_lvx(int a, unsigned 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)
 {
@@ -1851,6 +1897,12 @@ vec_lvx(int a, unsigned 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)
 {
@@ -1981,6 +2033,12 @@ vec_ldl(int a, unsigned char *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)
 {
@@ -2005,6 +2063,18 @@ vec_ldl(int a, unsigned 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)
 {
@@ -2029,6 +2099,12 @@ vec_ldl(int a, unsigned 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)
 {
@@ -2067,6 +2143,12 @@ vec_lvxl(int a, unsigned char *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)
 {
@@ -2091,6 +2173,18 @@ vec_lvxl(int a, unsigned 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)
 {
@@ -2115,6 +2209,12 @@ vec_lvxl(int a, unsigned 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)
 {
@@ -2270,36 +2370,108 @@ vec_max(vector signed char a, vector signed char 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)
 {
@@ -2308,52 +2480,124 @@ 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__))
@@ -2758,36 +3002,108 @@ vec_min(vector signed char a, vector signed char b)
   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)
 {
@@ -2796,52 +3112,124 @@ 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);
 }
 
+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 __attribute__((__always_inline__))
+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__))
@@ -3023,6 +3411,12 @@ vec_mtvscr(vector unsigned char 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);
@@ -3035,6 +3429,18 @@ vec_mtvscr(vector unsigned short 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);
@@ -3047,6 +3453,12 @@ vec_mtvscr(vector unsigned 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)
 {
   __builtin_altivec_mtvscr((vector int)a);
@@ -3200,6 +3612,12 @@ vec_nor(vector unsigned char a, vector unsigned char b)
   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)
 {
@@ -3212,6 +3630,12 @@ vec_nor(vector unsigned short a, vector unsigned 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)
 {
@@ -3224,6 +3648,12 @@ vec_nor(vector unsigned int a, vector unsigned 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)
 {
@@ -3245,6 +3675,12 @@ vec_vnor(vector unsigned char a, vector unsigned char 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)
 {
@@ -3257,6 +3693,12 @@ vec_vnor(vector unsigned short a, vector unsigned 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)
 {
@@ -3269,6 +3711,12 @@ vec_vnor(vector unsigned int a, vector unsigned 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)
 {
@@ -3286,36 +3734,126 @@ vec_or(vector signed char a, vector signed char 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)
 {
@@ -3323,6 +3861,20 @@ 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
@@ -3331,36 +3883,126 @@ vec_vor(vector signed char a, vector signed char b)
   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)
 {
@@ -3368,6 +4010,20 @@ 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
@@ -3876,36 +4532,108 @@ vec_sel(vector signed char a, vector signed char b, vector unsigned char c)
   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 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);
+}
+
 static vector unsigned short __ATTRS_o_ai
 vec_sel(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_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)
 {
@@ -3913,6 +4641,13 @@ 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
@@ -3921,36 +4656,108 @@ vec_vsel(vector signed char a, vector signed char b, vector unsigned char c)
   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)
 {
@@ -3958,6 +4765,13 @@ 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
@@ -4216,6 +5030,24 @@ vec_sll(vector unsigned char a, vector unsigned int b)
   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)
 {
@@ -4252,6 +5084,42 @@ vec_sll(vector unsigned short a, vector unsigned int 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)
 {
@@ -4288,6 +5156,24 @@ vec_sll(vector unsigned int a, vector unsigned int 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
@@ -4326,6 +5212,24 @@ vec_vsl(vector unsigned char a, vector unsigned int b)
   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)
 {
@@ -4362,6 +5266,42 @@ vec_vsl(vector unsigned short a, vector unsigned int 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)
 {
@@ -4398,6 +5338,24 @@ vec_vsl(vector unsigned int a, vector unsigned int 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
@@ -4448,6 +5406,18 @@ vec_slo(vector unsigned short a, vector unsigned char b)
   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)
 {
@@ -4534,6 +5504,18 @@ vec_vslo(vector unsigned short a, vector unsigned 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)
 {
@@ -5039,6 +6021,24 @@ vec_srl(vector unsigned char a, vector unsigned int 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)
 {
@@ -5075,6 +6075,42 @@ vec_srl(vector unsigned short a, vector unsigned int b)
   return (vector unsigned short)__builtin_altivec_vsr((vector int)a, (vector int)b);
 }
 
+static vector bool short __ATTRS_o_ai
+vec_srl(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_srl(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_srl(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_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)
 {
@@ -5111,6 +6147,24 @@ vec_srl(vector unsigned int a, vector unsigned 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
@@ -5149,6 +6203,24 @@ vec_vsr(vector unsigned char a, vector unsigned int b)
   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)
 {
@@ -5185,6 +6257,42 @@ vec_vsr(vector unsigned short a, vector unsigned int 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)
 {
@@ -5221,6 +6329,24 @@ vec_vsr(vector unsigned int a, vector unsigned int 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
@@ -5271,6 +6397,18 @@ vec_sro(vector unsigned short a, vector unsigned char b)
   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)
 {
@@ -5357,6 +6495,18 @@ vec_vsro(vector unsigned short a, vector unsigned 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)
 {
@@ -5420,6 +6570,24 @@ vec_st(vector unsigned char a, int b, unsigned char *c)
 }
 
 static void __ATTRS_o_ai
+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 bool char a, int b, unsigned char *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+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 short a, int b, vector short *c)
 {
   __builtin_altivec_stvx((vector int)a, b, c);
@@ -5444,6 +6612,42 @@ vec_st(vector unsigned short a, int b, unsigned short *c)
 }
 
 static void __ATTRS_o_ai
+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 bool short a, int b, unsigned short *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_st(vector bool short a, int b, vector bool short *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_st(vector pixel a, int b, short *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_st(vector pixel a, int b, unsigned short *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_st(vector pixel a, int b, vector pixel *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
 vec_st(vector int a, int b, vector int *c)
 {
   __builtin_altivec_stvx(a, b, c);
@@ -5468,6 +6672,24 @@ vec_st(vector unsigned int a, int b, unsigned int *c)
 }
 
 static void __ATTRS_o_ai
+vec_st(vector bool int a, int b, int *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_st(vector bool int a, int b, unsigned int *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_st(vector bool int a, int b, vector bool int *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
 vec_st(vector float a, int b, vector float *c)
 {
   __builtin_altivec_stvx((vector int)a, b, c);
@@ -5506,6 +6728,24 @@ vec_stvx(vector unsigned char a, int b, unsigned char *c)
 }
 
 static void __ATTRS_o_ai
+vec_stvx(vector bool char a, int b, signed char *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvx(vector bool char a, int b, unsigned char *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvx(vector bool char a, int b, vector bool char *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
 vec_stvx(vector short a, int b, vector short *c)
 {
   __builtin_altivec_stvx((vector int)a, b, c);
@@ -5530,6 +6770,42 @@ vec_stvx(vector unsigned short a, int b, unsigned short *c)
 }
 
 static void __ATTRS_o_ai
+vec_stvx(vector bool short a, int b, short *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvx(vector bool short a, int b, unsigned short *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvx(vector bool short a, int b, vector bool short *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvx(vector pixel a, int b, short *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvx(vector pixel a, int b, unsigned short *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvx(vector pixel a, int b, vector pixel *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
 vec_stvx(vector int a, int b, vector int *c)
 {
   __builtin_altivec_stvx(a, b, c);
@@ -5554,6 +6830,24 @@ vec_stvx(vector unsigned int a, int b, unsigned int *c)
 }
 
 static void __ATTRS_o_ai
+vec_stvx(vector bool int a, int b, int *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvx(vector bool int a, int b, unsigned int *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
+vec_stvx(vector bool int a, int b, vector bool int *c)
+{
+  __builtin_altivec_stvx((vector int)a, b, c);
+}
+
+static void __ATTRS_o_ai
 vec_stvx(vector float a, int b, vector float *c)
 {
   __builtin_altivec_stvx((vector int)a, b, c);
@@ -5580,6 +6874,18 @@ vec_ste(vector unsigned char a, int b, unsigned char *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);
@@ -5592,6 +6898,30 @@ vec_ste(vector unsigned short a, int b, unsigned short *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);
@@ -5604,6 +6934,18 @@ vec_ste(vector unsigned int a, int b, unsigned int *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);
@@ -5623,6 +6965,18 @@ 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
@@ -5637,6 +6991,30 @@ 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
@@ -5652,6 +7030,18 @@ vec_stvewx(vector unsigned int a, int b, unsigned int *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);
@@ -5684,6 +7074,24 @@ vec_stl(vector unsigned char a, int b, unsigned char *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);
@@ -5708,6 +7116,42 @@ vec_stl(vector unsigned short a, int b, unsigned short *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);
@@ -5732,6 +7176,24 @@ vec_stl(vector unsigned int a, int b, unsigned int *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);
@@ -5770,6 +7232,24 @@ vec_stvxl(vector unsigned char a, int b, unsigned char *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);
@@ -5794,6 +7274,42 @@ vec_stvxl(vector unsigned short a, int b, unsigned short *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(a, b, c);
@@ -5818,6 +7334,24 @@ vec_stvxl(vector unsigned int a, int b, unsigned int *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)
 {
   __builtin_altivec_stvxl((vector int)a, b, c);
@@ -5837,36 +7371,108 @@ vec_sub(vector signed char a, vector signed char b)
   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)
 {
@@ -5883,12 +7489,36 @@ vec_vsububm(vector signed char a, vector signed char 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
@@ -5899,12 +7529,36 @@ vec_vsubuhm(vector short a, vector short b)
   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
@@ -5915,12 +7569,36 @@ vec_vsubuwm(vector int a, vector int b)
   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
@@ -5955,84 +7633,228 @@ vec_subs(vector signed char a, vector signed char b)
   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
@@ -6133,28 +7955,64 @@ vec_unpackh(vector signed char a)
   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
@@ -6163,28 +8021,64 @@ vec_unpackl(vector signed char a)
   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
@@ -6195,36 +8089,126 @@ vec_xor(vector signed char a, vector signed char b)
   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)
 {
@@ -6232,6 +8216,20 @@ 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
@@ -6240,36 +8238,126 @@ vec_vxor(vector signed char a, vector signed char b)
   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)
 {
@@ -6277,6 +8365,20 @@ 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 */
diff --git a/clang/test/CodeGen/builtins-ppc-altivec.c b/clang/test/CodeGen/builtins-ppc-altivec.c
index 587e2b405e1..6bf3c83981b 100644
--- a/clang/test/CodeGen/builtins-ppc-altivec.c
+++ b/clang/test/CodeGen/builtins-ppc-altivec.c
@@ -323,12 +323,13 @@ void test1() {
 
   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
@@ -350,53 +351,52 @@ int test2() {
   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
@@ -443,28 +443,36 @@ int test6() {
   res_vsc = vec_ld(0, &param_sc);               // CHECK: @llvm.ppc.altivec.lvx
   res_vuc = vec_ld(0, &vuc);                    // CHECK: @llvm.ppc.altivec.lvx
   res_vuc = vec_ld(0, &param_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, &param_s);                // CHECK: @llvm.ppc.altivec.lvx
   res_vus = vec_ld(0, &vus);                    // CHECK: @llvm.ppc.altivec.lvx
   res_vus = vec_ld(0, &param_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, &param_i);                // CHECK: @llvm.ppc.altivec.lvx
   res_vui = vec_ld(0, &vui);                    // CHECK: @llvm.ppc.altivec.lvx
   res_vui = vec_ld(0, &param_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, &param_f);                // CHECK: @llvm.ppc.altivec.lvx
   res_vsc = vec_lvx(0, &vsc);                   // CHECK: @llvm.ppc.altivec.lvx
   res_vsc = vec_lvx(0, &param_sc);              // CHECK: @llvm.ppc.altivec.lvx
   res_vuc = vec_lvx(0, &vuc);                   // CHECK: @llvm.ppc.altivec.lvx
   res_vuc = vec_lvx(0, &param_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, &param_s);               // CHECK: @llvm.ppc.altivec.lvx
   res_vus = vec_lvx(0, &vus);                   // CHECK: @llvm.ppc.altivec.lvx
   res_vus = vec_lvx(0, &param_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, &param_i);               // CHECK: @llvm.ppc.altivec.lvx
   res_vui = vec_lvx(0, &vui);                   // CHECK: @llvm.ppc.altivec.lvx
   res_vui = vec_lvx(0, &param_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, &param_f);               // CHECK: @llvm.ppc.altivec.lvx
 
@@ -489,28 +497,36 @@ int test6() {
   res_vsc = vec_ldl(0, &param_sc);              // CHECK: @llvm.ppc.altivec.lvxl
   res_vuc = vec_ldl(0, &vuc);                   // CHECK: @llvm.ppc.altivec.lvxl
   res_vuc = vec_ldl(0, &param_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, &param_s);               // CHECK: @llvm.ppc.altivec.lvxl
   res_vus = vec_ldl(0, &vus);                   // CHECK: @llvm.ppc.altivec.lvxl
   res_vus = vec_ldl(0, &param_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, &param_i);               // CHECK: @llvm.ppc.altivec.lvxl
   res_vui = vec_ldl(0, &vui);                   // CHECK: @llvm.ppc.altivec.lvxl
   res_vui = vec_ldl(0, &param_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, &param_f);               // CHECK: @llvm.ppc.altivec.lvxl
   res_vsc = vec_lvxl(0, &vsc);                  // CHECK: @llvm.ppc.altivec.lvxl
   res_vsc = vec_lvxl(0, &param_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, &param_uc);             // CHECK: @llvm.ppc.altivec.lvxl
   res_vs  = vec_lvxl(0, &vs);                   // CHECK: @llvm.ppc.altivec.lvxl
   res_vs  = vec_lvxl(0, &param_s);              // CHECK: @llvm.ppc.altivec.lvxl
   res_vus = vec_lvxl(0, &vus);                  // CHECK: @llvm.ppc.altivec.lvxl
   res_vus = vec_lvxl(0, &param_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, &param_i);              // CHECK: @llvm.ppc.altivec.lvxl
   res_vui = vec_lvxl(0, &vui);                  // CHECK: @llvm.ppc.altivec.lvxl
   res_vui = vec_lvxl(0, &param_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, &param_f);              // CHECK: @llvm.ppc.altivec.lvxl
 
@@ -534,18 +550,42 @@ int test6() {
 
   /* 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 */
@@ -601,18 +641,42 @@ int test6() {
 
   /* 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 */
@@ -650,6 +714,15 @@ int test6() {
 
   /* 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
@@ -682,18 +755,27 @@ int test6() {
   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>
 
@@ -703,36 +785,79 @@ int test6() {
   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
@@ -828,77 +953,200 @@ int test6() {
                                                 // 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>
@@ -939,36 +1187,60 @@ int test6() {
   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
@@ -979,6 +1251,8 @@ int test6() {
   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
@@ -993,6 +1267,8 @@ int test6() {
   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
@@ -1080,36 +1356,60 @@ int test6() {
   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
@@ -1120,6 +1420,8 @@ int test6() {
   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
@@ -1134,6 +1436,8 @@ int test6() {
   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
@@ -1146,45 +1450,85 @@ int test6() {
   vec_st(vsc, 0, &param_sc);                   // CHECK: @llvm.ppc.altivec.stvx
   vec_st(vuc, 0, &vuc);                        // CHECK: @llvm.ppc.altivec.stvx
   vec_st(vuc, 0, &param_uc);                   // CHECK: @llvm.ppc.altivec.stvx
+  vec_st(vbc, 0, &param_uc);                   // CHECK: @llvm.ppc.altivec.stvx
+  vec_st(vbc, 0, &param_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, &param_s);                     // CHECK: @llvm.ppc.altivec.stvx
   vec_st(vus, 0, &vus);                        // CHECK: @llvm.ppc.altivec.stvx
   vec_st(vus, 0, &param_us);                   // CHECK: @llvm.ppc.altivec.stvx
+  vec_st(vbs, 0, &param_s);                    // CHECK: @llvm.ppc.altivec.stvx
+  vec_st(vbs, 0, &param_us);                   // CHECK: @llvm.ppc.altivec.stvx
+  vec_st(vbs, 0, &vbs);                        // CHECK: @llvm.ppc.altivec.stvx
+  vec_st(vp, 0, &param_s);                     // CHECK: @llvm.ppc.altivec.stvx
+  vec_st(vp, 0, &param_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, &param_i);                     // CHECK: @llvm.ppc.altivec.stvx
   vec_st(vui, 0, &vui);                        // CHECK: @llvm.ppc.altivec.stvx
   vec_st(vui, 0, &param_ui);                   // CHECK: @llvm.ppc.altivec.stvx
+  vec_st(vbi, 0, &param_i);                    // CHECK: @llvm.ppc.altivec.stvx
+  vec_st(vbi, 0, &param_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, &param_f);                     // CHECK: @llvm.ppc.altivec.stvx
   vec_stvx(vsc, 0, &vsc);                      // CHECK: @llvm.ppc.altivec.stvx
   vec_stvx(vsc, 0, &param_sc);                 // CHECK: @llvm.ppc.altivec.stvx
   vec_stvx(vuc, 0, &vuc);                      // CHECK: @llvm.ppc.altivec.stvx
   vec_stvx(vuc, 0, &param_uc);                 // CHECK: @llvm.ppc.altivec.stvx
+  vec_stvx(vbc, 0, &param_uc);                 // CHECK: @llvm.ppc.altivec.stvx
+  vec_stvx(vbc, 0, &param_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, &param_s);                   // CHECK: @llvm.ppc.altivec.stvx
   vec_stvx(vus, 0, &vus);                      // CHECK: @llvm.ppc.altivec.stvx
   vec_stvx(vus, 0, &param_us);                 // CHECK: @llvm.ppc.altivec.stvx
+  vec_stvx(vbs, 0, &param_s);                  // CHECK: @llvm.ppc.altivec.stvx
+  vec_stvx(vbs, 0, &param_us);                 // CHECK: @llvm.ppc.altivec.stvx
+  vec_stvx(vbs, 0, &vbs);                      // CHECK: @llvm.ppc.altivec.stvx
+  vec_stvx(vp, 0, &param_s);                   // CHECK: @llvm.ppc.altivec.stvx
+  vec_stvx(vp, 0, &param_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, &param_i);                   // CHECK: @llvm.ppc.altivec.stvx
   vec_stvx(vui, 0, &vui);                      // CHECK: @llvm.ppc.altivec.stvx
   vec_stvx(vui, 0, &param_ui);                 // CHECK: @llvm.ppc.altivec.stvx
+  vec_stvx(vbi, 0, &param_i);                  // CHECK: @llvm.ppc.altivec.stvx
+  vec_stvx(vbi, 0, &param_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, &param_f);                   // CHECK: @llvm.ppc.altivec.stvx
 
   /* vec_ste */
   vec_ste(vsc, 0, &param_sc);                  // CHECK: @llvm.ppc.altivec.stvebx
   vec_ste(vuc, 0, &param_uc);                  // CHECK: @llvm.ppc.altivec.stvebx
+  vec_ste(vbc, 0, &param_sc);                  // CHECK: @llvm.ppc.altivec.stvebx
+  vec_ste(vbc, 0, &param_uc);                  // CHECK: @llvm.ppc.altivec.stvebx
   vec_ste(vs, 0, &param_s);                    // CHECK: @llvm.ppc.altivec.stvehx
   vec_ste(vus, 0, &param_us);                  // CHECK: @llvm.ppc.altivec.stvehx
+  vec_ste(vbs, 0, &param_s);                   // CHECK: @llvm.ppc.altivec.stvehx
+  vec_ste(vbs, 0, &param_us);                  // CHECK: @llvm.ppc.altivec.stvehx
+  vec_ste(vp, 0, &param_s);                    // CHECK: @llvm.ppc.altivec.stvehx
+  vec_ste(vp, 0, &param_us);                   // CHECK: @llvm.ppc.altivec.stvehx
   vec_ste(vi, 0, &param_i);                    // CHECK: @llvm.ppc.altivec.stvewx
   vec_ste(vui, 0, &param_ui);                  // CHECK: @llvm.ppc.altivec.stvewx
+  vec_ste(vbi, 0, &param_i);                   // CHECK: @llvm.ppc.altivec.stvewx
+  vec_ste(vbi, 0, &param_ui);                  // CHECK: @llvm.ppc.altivec.stvewx
   vec_ste(vf, 0, &param_f);                    // CHECK: @llvm.ppc.altivec.stvewx
   vec_stvebx(vsc, 0, &param_sc);               // CHECK: @llvm.ppc.altivec.stvebx
   vec_stvebx(vuc, 0, &param_uc);               // CHECK: @llvm.ppc.altivec.stvebx
+  vec_stvebx(vbc, 0, &param_sc);               // CHECK: @llvm.ppc.altivec.stvebx
+  vec_stvebx(vbc, 0, &param_uc);               // CHECK: @llvm.ppc.altivec.stvebx
   vec_stvehx(vs, 0, &param_s);                 // CHECK: @llvm.ppc.altivec.stvehx
   vec_stvehx(vus, 0, &param_us);               // CHECK: @llvm.ppc.altivec.stvehx
+  vec_stvehx(vbs, 0, &param_s);                // CHECK: @llvm.ppc.altivec.stvehx
+  vec_stvehx(vbs, 0, &param_us);               // CHECK: @llvm.ppc.altivec.stvehx
+  vec_stvehx(vp, 0, &param_s);                 // CHECK: @llvm.ppc.altivec.stvehx
+  vec_stvehx(vp, 0, &param_us);                // CHECK: @llvm.ppc.altivec.stvehx
   vec_stvewx(vi, 0, &param_i);                 // CHECK: @llvm.ppc.altivec.stvewx
   vec_stvewx(vui, 0, &param_ui);               // CHECK: @llvm.ppc.altivec.stvewx
+  vec_stvewx(vbi, 0, &param_i);                // CHECK: @llvm.ppc.altivec.stvewx
+  vec_stvewx(vbi, 0, &param_ui);               // CHECK: @llvm.ppc.altivec.stvewx
   vec_stvewx(vf, 0, &param_f);                 // CHECK: @llvm.ppc.altivec.stvewx
 
   /* vec_stl */
@@ -1192,45 +1536,93 @@ int test6() {
   vec_stl(vsc, 0, &param_sc);                   // CHECK: @llvm.ppc.altivec.stvxl
   vec_stl(vuc, 0, &vuc);                        // CHECK: @llvm.ppc.altivec.stvxl
   vec_stl(vuc, 0, &param_uc);                   // CHECK: @llvm.ppc.altivec.stvxl
+  vec_stl(vbc, 0, &param_sc);                   // CHECK: @llvm.ppc.altivec.stvxl
+  vec_stl(vbc, 0, &param_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, &param_s);                     // CHECK: @llvm.ppc.altivec.stvxl
   vec_stl(vus, 0, &vus);                        // CHECK: @llvm.ppc.altivec.stvxl
   vec_stl(vus, 0, &param_us);                   // CHECK: @llvm.ppc.altivec.stvxl
+  vec_stl(vbs, 0, &param_s);                    // CHECK: @llvm.ppc.altivec.stvxl
+  vec_stl(vbs, 0, &param_us);                   // CHECK: @llvm.ppc.altivec.stvxl
+  vec_stl(vbs, 0, &vbs);                        // CHECK: @llvm.ppc.altivec.stvxl
+  vec_stl(vp, 0, &param_s);                     // CHECK: @llvm.ppc.altivec.stvxl
+  vec_stl(vp, 0, &param_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, &param_i);                     // CHECK: @llvm.ppc.altivec.stvxl
   vec_stl(vui, 0, &vui);                        // CHECK: @llvm.ppc.altivec.stvxl
   vec_stl(vui, 0, &param_ui);                   // CHECK: @llvm.ppc.altivec.stvxl
+  vec_stl(vbi, 0, &param_i);                    // CHECK: @llvm.ppc.altivec.stvxl
+  vec_stl(vbi, 0, &param_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, &param_f);                     // CHECK: @llvm.ppc.altivec.stvxl
   vec_stvxl(vsc, 0, &vsc);                      // CHECK: @llvm.ppc.altivec.stvxl
   vec_stvxl(vsc, 0, &param_sc);                 // CHECK: @llvm.ppc.altivec.stvxl
   vec_stvxl(vuc, 0, &vuc);                      // CHECK: @llvm.ppc.altivec.stvxl
   vec_stvxl(vuc, 0, &param_uc);                 // CHECK: @llvm.ppc.altivec.stvxl
+  vec_stvxl(vbc, 0, &param_sc);                 // CHECK: @llvm.ppc.altivec.stvxl
+  vec_stvxl(vbc, 0, &param_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, &param_s);                   // CHECK: @llvm.ppc.altivec.stvxl
   vec_stvxl(vus, 0, &vus);                      // CHECK: @llvm.ppc.altivec.stvxl
   vec_stvxl(vus, 0, &param_us);                 // CHECK: @llvm.ppc.altivec.stvxl
+  vec_stvxl(vbs, 0, &param_s);                  // CHECK: @llvm.ppc.altivec.stvxl
+  vec_stvxl(vbs, 0, &param_us);                 // CHECK: @llvm.ppc.altivec.stvxl
+  vec_stvxl(vbs, 0, &vbs);                      // CHECK: @llvm.ppc.altivec.stvxl
+  vec_stvxl(vp, 0, &param_s);                  // CHECK: @llvm.ppc.altivec.stvxl
+  vec_stvxl(vp, 0, &param_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, &param_i);                   // CHECK: @llvm.ppc.altivec.stvxl
   vec_stvxl(vui, 0, &vui);                      // CHECK: @llvm.ppc.altivec.stvxl
   vec_stvxl(vui, 0, &param_ui);                 // CHECK: @llvm.ppc.altivec.stvxl
+  vec_stvxl(vbi, 0, &param_i);                  // CHECK: @llvm.ppc.altivec.stvxl
+  vec_stvxl(vbi, 0, &param_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, &param_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 */
@@ -1239,17 +1631,41 @@ int test6() {
 
   /* 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
@@ -1272,32 +1688,78 @@ int test6() {
   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 -------------------------------------- */
 
@@ -1441,6 +1903,4 @@ int test6() {
 
   /* vec_any_out */
   res_i = vec_any_out(vf, vf);                  // CHECK: @llvm.ppc.altivec.vcmpbfp.p
-
-  return 0;
 }