PR14964: intrinsic headers using non-reserved identifiers

Several of the intrinsic headers were using plain non-reserved identifiers.
C++11 17.6.4.3.2 [global.names] p1 reservers names containing a double
begining with an underscore followed by an uppercase letter for any use.

I think I got them all, but open to being corrected. For the most part I
didn't bother updating function-like macro parameter names because I don't
believe they're subject to any such collission - though some function-like
macros already follow this convention (I didn't update them in part because
the churn was more significant as several function-like macros use the double
underscore prefixed version of the same name as a parameter in their
implementation)

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@172666 91177308-0d34-0410-b5e6-96231b3b80d8

12 files changed, 5333 insertions, 5325 deletions

diff --git a/lib/Headers/altivec.h b/lib/Headers/altivec.h
index 2bf53fb43b..c243676a2f 100644
--- a/lib/Headers/altivec.h
+++ b/lib/Headers/altivec.h
@@ -37,41 +37,41 @@
 #define __ATTRS_o_ai __attribute__((__overloadable__, __always_inline__))
 
 static vector signed char __ATTRS_o_ai
-vec_perm(vector signed char a, vector signed char b, vector unsigned char c);
+vec_perm(vector signed char __a, vector signed char __b, vector unsigned char __c);
 
 static vector unsigned char __ATTRS_o_ai
-vec_perm(vector unsigned char a,
-         vector unsigned char b, 
-         vector unsigned char c);
+vec_perm(vector unsigned char __a,
+         vector unsigned char __b,
+         vector unsigned char __c);
 
 static vector bool char __ATTRS_o_ai
-vec_perm(vector bool char a, vector bool char b, vector unsigned char c);
+vec_perm(vector bool char __a, vector bool char __b, vector unsigned char __c);
 
 static vector short __ATTRS_o_ai
-vec_perm(vector short a, vector short b, vector unsigned char c);
+vec_perm(vector short __a, vector short __b, vector unsigned char __c);
 
 static vector unsigned short __ATTRS_o_ai
-vec_perm(vector unsigned short a,
-         vector unsigned short b, 
-         vector unsigned char c);
+vec_perm(vector unsigned short __a,
+         vector unsigned short __b,
+         vector unsigned char __c);
 
 static vector bool short __ATTRS_o_ai
-vec_perm(vector bool short a, vector bool short b, vector unsigned char c);
+vec_perm(vector bool short __a, vector bool short __b, vector unsigned char __c);
 
 static vector pixel __ATTRS_o_ai
-vec_perm(vector pixel a, vector pixel b, vector unsigned char c);
+vec_perm(vector pixel __a, vector pixel __b, vector unsigned char __c);
 
 static vector int __ATTRS_o_ai
-vec_perm(vector int a, vector int b, vector unsigned char c);
+vec_perm(vector int __a, vector int __b, vector unsigned char __c);
 
 static vector unsigned int __ATTRS_o_ai
-vec_perm(vector unsigned int a, vector unsigned int b, vector unsigned char c);
+vec_perm(vector unsigned int __a, vector unsigned int __b, vector unsigned char __c);
 
 static vector bool int __ATTRS_o_ai
-vec_perm(vector bool int a, vector bool int b, vector unsigned char c);
+vec_perm(vector bool int __a, vector bool int __b, vector unsigned char __c);
 
 static vector float __ATTRS_o_ai
-vec_perm(vector float a, vector float b, vector unsigned char c);
+vec_perm(vector float __a, vector float __b, vector unsigned char __c);
 
 /* vec_abs */
 
@@ -80,29 +80,29 @@ vec_perm(vector float a, vector float b, vector unsigned char c);
 #define __builtin_altivec_abs_v4si  vec_abs
 
 static vector signed char __ATTRS_o_ai
-vec_abs(vector signed char a)
+vec_abs(vector signed char __a)
 {
-  return __builtin_altivec_vmaxsb(a, -a);
+  return __builtin_altivec_vmaxsb(__a, -__a);
 }
 
 static vector signed short __ATTRS_o_ai
-vec_abs(vector signed short a)
+vec_abs(vector signed short __a)
 {
-  return __builtin_altivec_vmaxsh(a, -a);
+  return __builtin_altivec_vmaxsh(__a, -__a);
 }
 
 static vector signed int __ATTRS_o_ai
-vec_abs(vector signed int a)
+vec_abs(vector signed int __a)
 {
-  return __builtin_altivec_vmaxsw(a, -a);
+  return __builtin_altivec_vmaxsw(__a, -__a);
 }
 
 static vector float __ATTRS_o_ai
-vec_abs(vector float a)
+vec_abs(vector float __a)
 {
-  vector unsigned int res = (vector unsigned int)a 
+  vector unsigned int __res = (vector unsigned int)__a
                             & (vector unsigned int)(0x7FFFFFFF);
-  return (vector float)res;
+  return (vector float)__res;
 }
 
 /* vec_abss */
@@ -112,140 +112,140 @@ vec_abs(vector float a)
 #define __builtin_altivec_abss_v4si  vec_abss
 
 static vector signed char __ATTRS_o_ai
-vec_abss(vector signed char a)
+vec_abss(vector signed char __a)
 {
   return __builtin_altivec_vmaxsb
-           (a, __builtin_altivec_vsubsbs((vector signed char)(0), a));
+           (__a, __builtin_altivec_vsubsbs((vector signed char)(0), __a));
 }
 
 static vector signed short __ATTRS_o_ai
-vec_abss(vector signed short a)
+vec_abss(vector signed short __a)
 {
   return __builtin_altivec_vmaxsh
-           (a, __builtin_altivec_vsubshs((vector signed short)(0), a));
+           (__a, __builtin_altivec_vsubshs((vector signed short)(0), __a));
 }
 
 static vector signed int __ATTRS_o_ai
-vec_abss(vector signed int a)
+vec_abss(vector signed int __a)
 {
   return __builtin_altivec_vmaxsw
-           (a, __builtin_altivec_vsubsws((vector signed int)(0), a));
+           (__a, __builtin_altivec_vsubsws((vector signed int)(0), __a));
 }
 
 /* vec_add */
 
 static vector signed char __ATTRS_o_ai
-vec_add(vector signed char a, vector signed char b)
+vec_add(vector signed char __a, vector signed char __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_add(vector bool char a, vector signed char b)
+vec_add(vector bool char __a, vector signed char __b)
 {
-  return (vector signed char)a + b;
+  return (vector signed char)__a + __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_add(vector signed char a, vector bool char b)
+vec_add(vector signed char __a, vector bool char __b)
 {
-  return a + (vector signed char)b;
+  return __a + (vector signed char)__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_add(vector unsigned char a, vector unsigned char b)
+vec_add(vector unsigned char __a, vector unsigned char __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_add(vector bool char a, vector unsigned char b)
+vec_add(vector bool char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)a + b;
+  return (vector unsigned char)__a + __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_add(vector unsigned char a, vector bool char b)
+vec_add(vector unsigned char __a, vector bool char __b)
 {
-  return a + (vector unsigned char)b;
+  return __a + (vector unsigned char)__b;
 }
 
 static vector short __ATTRS_o_ai
-vec_add(vector short a, vector short b)
+vec_add(vector short __a, vector short __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_add(vector bool short a, vector short b)
+vec_add(vector bool short __a, vector short __b)
 {
-  return (vector short)a + b;
+  return (vector short)__a + __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_add(vector short a, vector bool short b)
+vec_add(vector short __a, vector bool short __b)
 {
-  return a + (vector short)b;
+  return __a + (vector short)__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_add(vector unsigned short a, vector unsigned short b)
+vec_add(vector unsigned short __a, vector unsigned short __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_add(vector bool short a, vector unsigned short b)
+vec_add(vector bool short __a, vector unsigned short __b)
 {
-  return (vector unsigned short)a + b;
+  return (vector unsigned short)__a + __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_add(vector unsigned short a, vector bool short b)
+vec_add(vector unsigned short __a, vector bool short __b)
 {
-  return a + (vector unsigned short)b;
+  return __a + (vector unsigned short)__b;
 }
 
 static vector int __ATTRS_o_ai
-vec_add(vector int a, vector int b)
+vec_add(vector int __a, vector int __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_add(vector bool int a, vector int b)
+vec_add(vector bool int __a, vector int __b)
 {
-  return (vector int)a + b;
+  return (vector int)__a + __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_add(vector int a, vector bool int b)
+vec_add(vector int __a, vector bool int __b)
 {
-  return a + (vector int)b;
+  return __a + (vector int)__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_add(vector unsigned int a, vector unsigned int b)
+vec_add(vector unsigned int __a, vector unsigned int __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_add(vector bool int a, vector unsigned int b)
+vec_add(vector bool int __a, vector unsigned int __b)
 {
-  return (vector unsigned int)a + b;
+  return (vector unsigned int)__a + __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_add(vector unsigned int a, vector bool int b)
+vec_add(vector unsigned int __a, vector bool int __b)
 {
-  return a + (vector unsigned int)b;
+  return __a + (vector unsigned int)__b;
 }
 
 static vector float __ATTRS_o_ai
-vec_add(vector float a, vector float b)
+vec_add(vector float __a, vector float __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 /* vec_vaddubm */
@@ -253,39 +253,39 @@ vec_add(vector float a, vector float b)
 #define __builtin_altivec_vaddubm vec_vaddubm
 
 static vector signed char __ATTRS_o_ai
-vec_vaddubm(vector signed char a, vector signed char b)
+vec_vaddubm(vector signed char __a, vector signed char __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vaddubm(vector bool char a, vector signed char b)
+vec_vaddubm(vector bool char __a, vector signed char __b)
 {
-  return (vector signed char)a + b;
+  return (vector signed char)__a + __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vaddubm(vector signed char a, vector bool char b)
+vec_vaddubm(vector signed char __a, vector bool char __b)
 {
-  return a + (vector signed char)b;
+  return __a + (vector signed char)__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vaddubm(vector unsigned char a, vector unsigned char b)
+vec_vaddubm(vector unsigned char __a, vector unsigned char __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vaddubm(vector bool char a, vector unsigned char b)
+vec_vaddubm(vector bool char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)a + b;
+  return (vector unsigned char)__a + __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vaddubm(vector unsigned char a, vector bool char b)
+vec_vaddubm(vector unsigned char __a, vector bool char __b)
 {
-  return a + (vector unsigned char)b;
+  return __a + (vector unsigned char)__b;
 }
 
 /* vec_vadduhm */
@@ -293,39 +293,39 @@ vec_vaddubm(vector unsigned char a, vector bool char b)
 #define __builtin_altivec_vadduhm vec_vadduhm
 
 static vector short __ATTRS_o_ai
-vec_vadduhm(vector short a, vector short b)
+vec_vadduhm(vector short __a, vector short __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_vadduhm(vector bool short a, vector short b)
+vec_vadduhm(vector bool short __a, vector short __b)
 {
-  return (vector short)a + b;
+  return (vector short)__a + __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_vadduhm(vector short a, vector bool short b)
+vec_vadduhm(vector short __a, vector bool short __b)
 {
-  return a + (vector short)b;
+  return __a + (vector short)__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vadduhm(vector unsigned short a, vector unsigned short b)
+vec_vadduhm(vector unsigned short __a, vector unsigned short __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vadduhm(vector bool short a, vector unsigned short b)
+vec_vadduhm(vector bool short __a, vector unsigned short __b)
 {
-  return (vector unsigned short)a + b;
+  return (vector unsigned short)__a + __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vadduhm(vector unsigned short a, vector bool short b)
+vec_vadduhm(vector unsigned short __a, vector bool short __b)
 {
-  return a + (vector unsigned short)b;
+  return __a + (vector unsigned short)__b;
 }
 
 /* vec_vadduwm */
@@ -333,39 +333,39 @@ vec_vadduhm(vector unsigned short a, vector bool short b)
 #define __builtin_altivec_vadduwm vec_vadduwm
 
 static vector int __ATTRS_o_ai
-vec_vadduwm(vector int a, vector int b)
+vec_vadduwm(vector int __a, vector int __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_vadduwm(vector bool int a, vector int b)
+vec_vadduwm(vector bool int __a, vector int __b)
 {
-  return (vector int)a + b;
+  return (vector int)__a + __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_vadduwm(vector int a, vector bool int b)
+vec_vadduwm(vector int __a, vector bool int __b)
 {
-  return a + (vector int)b;
+  return __a + (vector int)__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vadduwm(vector unsigned int a, vector unsigned int b)
+vec_vadduwm(vector unsigned int __a, vector unsigned int __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vadduwm(vector bool int a, vector unsigned int b)
+vec_vadduwm(vector bool int __a, vector unsigned int __b)
 {
-  return (vector unsigned int)a + b;
+  return (vector unsigned int)__a + __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vadduwm(vector unsigned int a, vector bool int b)
+vec_vadduwm(vector unsigned int __a, vector bool int __b)
 {
-  return a + (vector unsigned int)b;
+  return __a + (vector unsigned int)__b;
 }
 
 /* vec_vaddfp */
@@ -373,255 +373,255 @@ vec_vadduwm(vector unsigned int a, vector bool int b)
 #define __builtin_altivec_vaddfp  vec_vaddfp
 
 static vector float __attribute__((__always_inline__))
-vec_vaddfp(vector float a, vector float b)
+vec_vaddfp(vector float __a, vector float __b)
 {
-  return a + b;
+  return __a + __b;
 }
 
 /* vec_addc */
 
 static vector unsigned int __attribute__((__always_inline__))
-vec_addc(vector unsigned int a, vector unsigned int b)
+vec_addc(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vaddcuw(a, b);
+  return __builtin_altivec_vaddcuw(__a, __b);
 }
 
 /* vec_vaddcuw */
 
 static vector unsigned int __attribute__((__always_inline__))
-vec_vaddcuw(vector unsigned int a, vector unsigned int b)
+vec_vaddcuw(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vaddcuw(a, b);
+  return __builtin_altivec_vaddcuw(__a, __b);
 }
 
 /* vec_adds */
 
 static vector signed char __ATTRS_o_ai
-vec_adds(vector signed char a, vector signed char b)
+vec_adds(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vaddsbs(a, b);
+  return __builtin_altivec_vaddsbs(__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_adds(vector bool char a, vector signed char b)
+vec_adds(vector bool char __a, vector signed char __b)
 {
-  return __builtin_altivec_vaddsbs((vector signed char)a, b);
+  return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_adds(vector signed char a, vector bool char b)
+vec_adds(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vaddsbs(a, (vector signed char)b);
+  return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_adds(vector unsigned char a, vector unsigned char b)
+vec_adds(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vaddubs(a, b);
+  return __builtin_altivec_vaddubs(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_adds(vector bool char a, vector unsigned char b)
+vec_adds(vector bool char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vaddubs((vector unsigned char)a, b);
+  return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_adds(vector unsigned char a, vector bool char b)
+vec_adds(vector unsigned char __a, vector bool char __b)
 {
-  return __builtin_altivec_vaddubs(a, (vector unsigned char)b);
+  return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
 }
 
 static vector short __ATTRS_o_ai
-vec_adds(vector short a, vector short b)
+vec_adds(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vaddshs(a, b);
+  return __builtin_altivec_vaddshs(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_adds(vector bool short a, vector short b)
+vec_adds(vector bool short __a, vector short __b)
 {
-  return __builtin_altivec_vaddshs((vector short)a, b);
+  return __builtin_altivec_vaddshs((vector short)__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_adds(vector short a, vector bool short b)
+vec_adds(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vaddshs(a, (vector short)b);
+  return __builtin_altivec_vaddshs(__a, (vector short)__b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_adds(vector unsigned short a, vector unsigned short b)
+vec_adds(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vadduhs(a, b);
+  return __builtin_altivec_vadduhs(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_adds(vector bool short a, vector unsigned short b)
+vec_adds(vector bool short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vadduhs((vector unsigned short)a, b);
+  return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_adds(vector unsigned short a, vector bool short b)
+vec_adds(vector unsigned short __a, vector bool short __b)
 {
-  return __builtin_altivec_vadduhs(a, (vector unsigned short)b);
+  return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
 }
 
 static vector int __ATTRS_o_ai
-vec_adds(vector int a, vector int b)
+vec_adds(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vaddsws(a, b);
+  return __builtin_altivec_vaddsws(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_adds(vector bool int a, vector int b)
+vec_adds(vector bool int __a, vector int __b)
 {
-  return __builtin_altivec_vaddsws((vector int)a, b);
+  return __builtin_altivec_vaddsws((vector int)__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_adds(vector int a, vector bool int b)
+vec_adds(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vaddsws(a, (vector int)b);
+  return __builtin_altivec_vaddsws(__a, (vector int)__b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_adds(vector unsigned int a, vector unsigned int b)
+vec_adds(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vadduws(a, b);
+  return __builtin_altivec_vadduws(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_adds(vector bool int a, vector unsigned int b)
+vec_adds(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vadduws((vector unsigned int)a, b);
+  return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_adds(vector unsigned int a, vector bool int b)
+vec_adds(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vadduws(a, (vector unsigned int)b);
+  return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
 }
 
 /* vec_vaddsbs */
 
 static vector signed char __ATTRS_o_ai
-vec_vaddsbs(vector signed char a, vector signed char b)
+vec_vaddsbs(vector signed char __a, vector signed char __b)
 {
-  return __builtin_altivec_vaddsbs(a, b);
+  return __builtin_altivec_vaddsbs(__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vaddsbs(vector bool char a, vector signed char b)
+vec_vaddsbs(vector bool char __a, vector signed char __b)
 {
-  return __builtin_altivec_vaddsbs((vector signed char)a, b);
+  return __builtin_altivec_vaddsbs((vector signed char)__a, __b);
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vaddsbs(vector signed char a, vector bool char b)
+vec_vaddsbs(vector signed char __a, vector bool char __b)
 {
-  return __builtin_altivec_vaddsbs(a, (vector signed char)b);
+  return __builtin_altivec_vaddsbs(__a, (vector signed char)__b);
 }
 
 /* vec_vaddubs */
 
 static vector unsigned char __ATTRS_o_ai
-vec_vaddubs(vector unsigned char a, vector unsigned char b)
+vec_vaddubs(vector unsigned char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vaddubs(a, b);
+  return __builtin_altivec_vaddubs(__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vaddubs(vector bool char a, vector unsigned char b)
+vec_vaddubs(vector bool char __a, vector unsigned char __b)
 {
-  return __builtin_altivec_vaddubs((vector unsigned char)a, b);
+  return __builtin_altivec_vaddubs((vector unsigned char)__a, __b);
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vaddubs(vector unsigned char a, vector bool char b)
+vec_vaddubs(vector unsigned char __a, vector bool char __b)
 {
-  return __builtin_altivec_vaddubs(a, (vector unsigned char)b);
+  return __builtin_altivec_vaddubs(__a, (vector unsigned char)__b);
 }
 
 /* vec_vaddshs */
 
 static vector short __ATTRS_o_ai
-vec_vaddshs(vector short a, vector short b)
+vec_vaddshs(vector short __a, vector short __b)
 {
-  return __builtin_altivec_vaddshs(a, b);
+  return __builtin_altivec_vaddshs(__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vaddshs(vector bool short a, vector short b)
+vec_vaddshs(vector bool short __a, vector short __b)
 {
-  return __builtin_altivec_vaddshs((vector short)a, b);
+  return __builtin_altivec_vaddshs((vector short)__a, __b);
 }
 
 static vector short __ATTRS_o_ai
-vec_vaddshs(vector short a, vector bool short b)
+vec_vaddshs(vector short __a, vector bool short __b)
 {
-  return __builtin_altivec_vaddshs(a, (vector short)b);
+  return __builtin_altivec_vaddshs(__a, (vector short)__b);
 }
 
 /* vec_vadduhs */
 
 static vector unsigned short __ATTRS_o_ai
-vec_vadduhs(vector unsigned short a, vector unsigned short b)
+vec_vadduhs(vector unsigned short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vadduhs(a, b);
+  return __builtin_altivec_vadduhs(__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vadduhs(vector bool short a, vector unsigned short b)
+vec_vadduhs(vector bool short __a, vector unsigned short __b)
 {
-  return __builtin_altivec_vadduhs((vector unsigned short)a, b);
+  return __builtin_altivec_vadduhs((vector unsigned short)__a, __b);
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_vadduhs(vector unsigned short a, vector bool short b)
+vec_vadduhs(vector unsigned short __a, vector bool short __b)
 {
-  return __builtin_altivec_vadduhs(a, (vector unsigned short)b);
+  return __builtin_altivec_vadduhs(__a, (vector unsigned short)__b);
 }
 
 /* vec_vaddsws */
 
 static vector int __ATTRS_o_ai
-vec_vaddsws(vector int a, vector int b)
+vec_vaddsws(vector int __a, vector int __b)
 {
-  return __builtin_altivec_vaddsws(a, b);
+  return __builtin_altivec_vaddsws(__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vaddsws(vector bool int a, vector int b)
+vec_vaddsws(vector bool int __a, vector int __b)
 {
-  return __builtin_altivec_vaddsws((vector int)a, b);
+  return __builtin_altivec_vaddsws((vector int)__a, __b);
 }
 
 static vector int __ATTRS_o_ai
-vec_vaddsws(vector int a, vector bool int b)
+vec_vaddsws(vector int __a, vector bool int __b)
 {
-  return __builtin_altivec_vaddsws(a, (vector int)b);
+  return __builtin_altivec_vaddsws(__a, (vector int)__b);
 }
 
 /* vec_vadduws */
 
 static vector unsigned int __ATTRS_o_ai
-vec_vadduws(vector unsigned int a, vector unsigned int b)
+vec_vadduws(vector unsigned int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vadduws(a, b);
+  return __builtin_altivec_vadduws(__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vadduws(vector bool int a, vector unsigned int b)
+vec_vadduws(vector bool int __a, vector unsigned int __b)
 {
-  return __builtin_altivec_vadduws((vector unsigned int)a, b);
+  return __builtin_altivec_vadduws((vector unsigned int)__a, __b);
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_vadduws(vector unsigned int a, vector bool int b)
+vec_vadduws(vector unsigned int __a, vector bool int __b)
 {
-  return __builtin_altivec_vadduws(a, (vector unsigned int)b);
+  return __builtin_altivec_vadduws(__a, (vector unsigned int)__b);
 }
 
 /* vec_and */
@@ -629,299 +629,299 @@ vec_vadduws(vector unsigned int a, vector bool int b)
 #define __builtin_altivec_vand vec_and
 
 static vector signed char __ATTRS_o_ai
-vec_and(vector signed char a, vector signed char b)
+vec_and(vector signed char __a, vector signed char __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_and(vector bool char a, vector signed char b)
+vec_and(vector bool char __a, vector signed char __b)
 {
-  return (vector signed char)a & b;
+  return (vector signed char)__a & __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_and(vector signed char a, vector bool char b)
+vec_and(vector signed char __a, vector bool char __b)
 {
-  return a & (vector signed char)b;
+  return __a & (vector signed char)__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_and(vector unsigned char a, vector unsigned char b)
+vec_and(vector unsigned char __a, vector unsigned char __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_and(vector bool char a, vector unsigned char b)
+vec_and(vector bool char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)a & b;
+  return (vector unsigned char)__a & __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_and(vector unsigned char a, vector bool char b)
+vec_and(vector unsigned char __a, vector bool char __b)
 {
-  return a & (vector unsigned char)b;
+  return __a & (vector unsigned char)__b;
 }
 
 static vector bool char __ATTRS_o_ai
-vec_and(vector bool char a, vector bool char b)
+vec_and(vector bool char __a, vector bool char __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_and(vector short a, vector short b)
+vec_and(vector short __a, vector short __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_and(vector bool short a, vector short b)
+vec_and(vector bool short __a, vector short __b)
 {
-  return (vector short)a & b;
+  return (vector short)__a & __b;
 }
 
 static vector short __ATTRS_o_ai
-vec_and(vector short a, vector bool short b)
+vec_and(vector short __a, vector bool short __b)
 {
-  return a & (vector short)b;
+  return __a & (vector short)__b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_and(vector unsigned short a, vector unsigned short b)
+vec_and(vector unsigned short __a, vector unsigned short __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_and(vector bool short a, vector unsigned short b)
+vec_and(vector bool short __a, vector unsigned short __b)
 {
-  return (vector unsigned short)a & b;
+  return (vector unsigned short)__a & __b;
 }
 
 static vector unsigned short __ATTRS_o_ai
-vec_and(vector unsigned short a, vector bool short b)
+vec_and(vector unsigned short __a, vector bool short __b)
 {
-  return a & (vector unsigned short)b;
+  return __a & (vector unsigned short)__b;
 }
 
 static vector bool short __ATTRS_o_ai
-vec_and(vector bool short a, vector bool short b)
+vec_and(vector bool short __a, vector bool short __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_and(vector int a, vector int b)
+vec_and(vector int __a, vector int __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_and(vector bool int a, vector int b)
+vec_and(vector bool int __a, vector int __b)
 {
-  return (vector int)a & b;
+  return (vector int)__a & __b;
 }
 
 static vector int __ATTRS_o_ai
-vec_and(vector int a, vector bool int b)
+vec_and(vector int __a, vector bool int __b)
 {
-  return a & (vector int)b;
+  return __a & (vector int)__b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_and(vector unsigned int a, vector unsigned int b)
+vec_and(vector unsigned int __a, vector unsigned int __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_and(vector bool int a, vector unsigned int b)
+vec_and(vector bool int __a, vector unsigned int __b)
 {
-  return (vector unsigned int)a & b;
+  return (vector unsigned int)__a & __b;
 }
 
 static vector unsigned int __ATTRS_o_ai
-vec_and(vector unsigned int a, vector bool int b)
+vec_and(vector unsigned int __a, vector bool int __b)
 {
-  return a & (vector unsigned int)b;
+  return __a & (vector unsigned int)__b;
 }
 
 static vector bool int __ATTRS_o_ai
-vec_and(vector bool int a, vector bool int b)
+vec_and(vector bool int __a, vector bool int __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector float __ATTRS_o_ai
-vec_and(vector float a, vector float b)
+vec_and(vector float __a, vector float __b)
 {
-  vector unsigned int res = (vector unsigned int)a & (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a & (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_and(vector bool int a, vector float b)
+vec_and(vector bool int __a, vector float __b)
 {
-  vector unsigned int res = (vector unsigned int)a & (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a & (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 static vector float __ATTRS_o_ai
-vec_and(vector float a, vector bool int b)
+vec_and(vector float __a, vector bool int __b)
 {
-  vector unsigned int res = (vector unsigned int)a & (vector unsigned int)b;
-  return (vector float)res;
+  vector unsigned int __res = (vector unsigned int)__a & (vector unsigned int)__b;
+  return (vector float)__res;
 }
 
 /* vec_vand */
 
 static vector signed char __ATTRS_o_ai
-vec_vand(vector signed char a, vector signed char b)
+vec_vand(vector signed char __a, vector signed char __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vand(vector bool char a, vector signed char b)
+vec_vand(vector bool char __a, vector signed char __b)
 {
-  return (vector signed char)a & b;
+  return (vector signed char)__a & __b;
 }
 
 static vector signed char __ATTRS_o_ai
-vec_vand(vector signed char a, vector bool char b)
+vec_vand(vector signed char __a, vector bool char __b)
 {
-  return a & (vector signed char)b;
+  return __a & (vector signed char)__b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vand(vector unsigned char a, vector unsigned char b)
+vec_vand(vector unsigned char __a, vector unsigned char __b)
 {
-  return a & b;
+  return __a & __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vand(vector bool char a, vector unsigned char b)
+vec_vand(vector bool char __a, vector unsigned char __b)
 {
-  return (vector unsigned char)a & b;
+  return (vector unsigned char)__a & __b;
 }
 
 static vector unsigned char __ATTRS_o_ai
-vec_vand(vector unsigned char a, vector bool char b)
+vec_vand(vector unsigned char __a, vector bool char __b)
 {
-  return a & (vector unsigned char)b;
+  return __a & (vector unsigned char)__b;
 }
 
 static vector bool char __ATTRS_o_ai
-vec_vand(vector bool char a, vector bool char b)