Gcc 3.4.4 release.

6 files changed, 1570 insertions, 654 deletions

diff --git a/contrib/gcc/doc/extend.texi b/contrib/gcc/doc/extend.texi
index 3785cee..4638645 100644
--- a/contrib/gcc/doc/extend.texi
+++ b/contrib/gcc/doc/extend.texi
@@ -2048,6 +2048,8 @@ typedef void voidfn ();
 volatile voidfn fatal;
 @end smallexample
 
+This approach does not work in GNU C++.
+
 @cindex @code{noinline} function attribute
 @item noinline
 This function attribute prevents a function from being considered for
@@ -6121,139 +6123,264 @@ v2si __builtin_ia32_pswapdsi (v2si)
 @node PowerPC AltiVec Built-in Functions
 @subsection PowerPC AltiVec Built-in Functions
 
-These built-in functions are available for the PowerPC family
-of computers, depending on the command-line switches used.
+GCC provides an interface for the PowerPC family of processors to access
+the AltiVec operations described in Motorola's AltiVec Programming
+Interface Manual.  The interface is made available by including
+@code{<altivec.h>} and using @option{-maltivec} and
+@option{-mabi=altivec}.  The interface supports the following vector
+types.
 
-The following machine modes are available for use with AltiVec built-in
-functions (@pxref{Vector Extensions}): @code{V4SI} for a vector of four
-32-bit integers, @code{V4SF} for a vector of four 32-bit floating point
-numbers, @code{V8HI} for a vector of eight 16-bit integers, and
-@code{V16QI} for a vector of sixteen 8-bit integers.
+@smallexample
+vector unsigned char
+vector signed char
+vector bool char
 
-The following functions are made available by including
-@code{<altivec.h>} and using @option{-maltivec} and
-@option{-mabi=altivec}.  The functions implement the functionality
-described in Motorola's AltiVec Programming Interface Manual.
+vector unsigned short
+vector signed short
+vector bool short
+vector pixel
+
+vector unsigned int
+vector signed int
+vector bool int
+vector float
+@end smallexample
+
+GCC's implementation of the high-level language interface available from
+C and C++ code differs from Motorola's documentation in several ways.
+
+@itemize @bullet
+
+@item
+A vector constant is a list of constant expressions within curly braces.
+
+@item
+A vector initializer requires no cast if the vector constant is of the
+same type as the variable it is initializing.
 
-There are a few differences from Motorola's documentation and GCC's
-implementation.  Vector constants are done with curly braces (not
-parentheses).  Vector initializers require no casts if the vector
-constant is of the same type as the variable it is initializing.  The
-@code{vector bool} type is deprecated and will be discontinued in
-further revisions.  Use @code{vector signed} instead.  If @code{signed}
-or @code{unsigned} is omitted, the vector type will default to
-@code{signed}.  Lastly, all overloaded functions are implemented with macros
-for the C implementation.  So code the following example will not work:
+@item
+If @code{signed} or @code{unsigned} is omitted, the vector type defaults
+to @code{signed} for @code{vector int} or @code{vector short} and to
+@code{unsigned} for @code{vector char}.
+                                                                                
+@item
+Compiling with @option{-maltivec} adds keywords @code{__vector},
+@code{__pixel}, and @code{__bool}.  Macros @option{vector},
+@code{pixel}, and @code{bool} are defined in @code{<altivec.h>} and can
+be undefined.
+                                                                                
+@item
+GCC allows using a @code{typedef} name as the type specifier for a
+vector type.
+
+@item
+For C, overloaded functions are implemented with macros so the following
+does not work:
 
 @smallexample
   vec_add ((vector signed int)@{1, 2, 3, 4@}, foo);
 @end smallexample
 
-Since vec_add is a macro, the vector constant in the above example will
-be treated as four different arguments.  Wrap the entire argument in
-parentheses for this to work.  The C++ implementation does not use
-macros.
+Since @code{vec_add} is a macro, the vector constant in the example
+is treated as four separate arguments.  Wrap the entire argument in
+parentheses for this to work.
+@end itemize
 
 @emph{Note:} Only the @code{<altivec.h>} interface is supported.
 Internally, GCC uses built-in functions to achieve the functionality in
 the aforementioned header file, but they are not supported and are
 subject to change without notice.
 
-@smallexample
-vector signed char vec_abs (vector signed char, vector signed char);
-vector signed short vec_abs (vector signed short, vector signed short);
-vector signed int vec_abs (vector signed int, vector signed int);
-vector signed float vec_abs (vector signed float, vector signed float);
+The following interfaces are supported for the generic and specific
+AltiVec operations and the AltiVec predicates.  In cases where there
+is a direct mapping between generic and specific operations, only the
+generic names are shown here, although the specific operations can also
+be used.
 
-vector signed char vec_abss (vector signed char, vector signed char);
-vector signed short vec_abss (vector signed short, vector signed short);
+Arguments that are documented as @code{const int} require literal
+integral values within the range required for that operation.
 
-vector signed char vec_add (vector signed char, vector signed char);
-vector unsigned char vec_add (vector signed char, vector unsigned char);
+@smallexample
+vector signed char vec_abs (vector signed char);
+vector signed short vec_abs (vector signed short);
+vector signed int vec_abs (vector signed int);
+vector float vec_abs (vector float);
 
-vector unsigned char vec_add (vector unsigned char, vector signed char);
+vector signed char vec_abss (vector signed char);
+vector signed short vec_abss (vector signed short);
+vector signed int vec_abss (vector signed int);
 
+vector signed char vec_add (vector bool char, vector signed char);
+vector signed char vec_add (vector signed char, vector bool char);
+vector signed char vec_add (vector signed char, vector signed char);
+vector unsigned char vec_add (vector bool char, vector unsigned char);
+vector unsigned char vec_add (vector unsigned char, vector bool char);
 vector unsigned char vec_add (vector unsigned char,
                               vector unsigned char);
+vector signed short vec_add (vector bool short, vector signed short);
+vector signed short vec_add (vector signed short, vector bool short);
 vector signed short vec_add (vector signed short, vector signed short);
-vector unsigned short vec_add (vector signed short,
+vector unsigned short vec_add (vector bool short,
                                vector unsigned short);
 vector unsigned short vec_add (vector unsigned short,
-                               vector signed short);
+                               vector bool short);
 vector unsigned short vec_add (vector unsigned short,
                                vector unsigned short);
+vector signed int vec_add (vector bool int, vector signed int);
+vector signed int vec_add (vector signed int, vector bool int);
 vector signed int vec_add (vector signed int, vector signed int);
-vector unsigned int vec_add (vector signed int, vector unsigned int);
-vector unsigned int vec_add (vector unsigned int, vector signed int);
+vector unsigned int vec_add (vector bool int, vector unsigned int);
+vector unsigned int vec_add (vector unsigned int, vector bool int);
 vector unsigned int vec_add (vector unsigned int, vector unsigned int);
 vector float vec_add (vector float, vector float);
 
+vector float vec_vaddfp (vector float, vector float);
+
+vector signed int vec_vadduwm (vector bool int, vector signed int);
+vector signed int vec_vadduwm (vector signed int, vector bool int);
+vector signed int vec_vadduwm (vector signed int, vector signed int);
+vector unsigned int vec_vadduwm (vector bool int, vector unsigned int);
+vector unsigned int vec_vadduwm (vector unsigned int, vector bool int);
+vector unsigned int vec_vadduwm (vector unsigned int,
+                                 vector unsigned int);
+
+vector signed short vec_vadduhm (vector bool short,
+                                 vector signed short);
+vector signed short vec_vadduhm (vector signed short,
+                                 vector bool short);
+vector signed short vec_vadduhm (vector signed short,
+                                 vector signed short);
+vector unsigned short vec_vadduhm (vector bool short,
+                                   vector unsigned short);
+vector unsigned short vec_vadduhm (vector unsigned short,
+                                   vector bool short);
+vector unsigned short vec_vadduhm (vector unsigned short,
+                                   vector unsigned short);
+
+vector signed char vec_vaddubm (vector bool char, vector signed char);
+vector signed char vec_vaddubm (vector signed char, vector bool char);
+vector signed char vec_vaddubm (vector signed char, vector signed char);
+vector unsigned char vec_vaddubm (vector bool char,
+                                  vector unsigned char);
+vector unsigned char vec_vaddubm (vector unsigned char,
+                                  vector bool char);
+vector unsigned char vec_vaddubm (vector unsigned char,
+                                  vector unsigned char);
+
 vector unsigned int vec_addc (vector unsigned int, vector unsigned int);
 
-vector unsigned char vec_adds (vector signed char,
-                               vector unsigned char);
-vector unsigned char vec_adds (vector unsigned char,
-                               vector signed char);
+vector unsigned char vec_adds (vector bool char, vector unsigned char);
+vector unsigned char vec_adds (vector unsigned char, vector bool char);
 vector unsigned char vec_adds (vector unsigned char,
                                vector unsigned char);
+vector signed char vec_adds (vector bool char, vector signed char);
+vector signed char vec_adds (vector signed char, vector bool char);
 vector signed char vec_adds (vector signed char, vector signed char);
-vector unsigned short vec_adds (vector signed short,
+vector unsigned short vec_adds (vector bool short,
                                 vector unsigned short);
 vector unsigned short vec_adds (vector unsigned short,
-                                vector signed short);
+                                vector bool short);
 vector unsigned short vec_adds (vector unsigned short,
                                 vector unsigned short);
+vector signed short vec_adds (vector bool short, vector signed short);
+vector signed short vec_adds (vector signed short, vector bool short);
 vector signed short vec_adds (vector signed short, vector signed short);
-
-vector unsigned int vec_adds (vector signed int, vector unsigned int);
-vector unsigned int vec_adds (vector unsigned int, vector signed int);
+vector unsigned int vec_adds (vector bool int, vector unsigned int);
+vector unsigned int vec_adds (vector unsigned int, vector bool int);
 vector unsigned int vec_adds (vector unsigned int, vector unsigned int);
-
+vector signed int vec_adds (vector bool int, vector signed int);
+vector signed int vec_adds (vector signed int, vector bool int);
 vector signed int vec_adds (vector signed int, vector signed int);
 
+vector signed int vec_vaddsws (vector bool int, vector signed int);
+vector signed int vec_vaddsws (vector signed int, vector bool int);
+vector signed int vec_vaddsws (vector signed int, vector signed int);
+
+vector unsigned int vec_vadduws (vector bool int, vector unsigned int);
+vector unsigned int vec_vadduws (vector unsigned int, vector bool int);
+vector unsigned int vec_vadduws (vector unsigned int,
+                                 vector unsigned int);
+
+vector signed short vec_vaddshs (vector bool short,
+                                 vector signed short);
+vector signed short vec_vaddshs (vector signed short,
+                                 vector bool short);
+vector signed short vec_vaddshs (vector signed short,
+                                 vector signed short);
+
+vector unsigned short vec_vadduhs (vector bool short,
+                                   vector unsigned short);
+vector unsigned short vec_vadduhs (vector unsigned short,
+                                   vector bool short);
+vector unsigned short vec_vadduhs (vector unsigned short,
+                                   vector unsigned short);
+
+vector signed char vec_vaddsbs (vector bool char, vector signed char);
+vector signed char vec_vaddsbs (vector signed char, vector bool char);
+vector signed char vec_vaddsbs (vector signed char, vector signed char);
+
+vector unsigned char vec_vaddubs (vector bool char,
+                                  vector unsigned char);
+vector unsigned char vec_vaddubs (vector unsigned char,
+                                  vector bool char);
+vector unsigned char vec_vaddubs (vector unsigned char,
+                                  vector unsigned char);
+
 vector float vec_and (vector float, vector float);
-vector float vec_and (vector float, vector signed int);
-vector float vec_and (vector signed int, vector float);
+vector float vec_and (vector float, vector bool int);
+vector float vec_and (vector bool int, vector float);
+vector bool int vec_and (vector bool int, vector bool int);
+vector signed int vec_and (vector bool int, vector signed int);
+vector signed int vec_and (vector signed int, vector bool int);
 vector signed int vec_and (vector signed int, vector signed int);
-vector unsigned int vec_and (vector signed int, vector unsigned int);
-vector unsigned int vec_and (vector unsigned int, vector signed int);
+vector unsigned int vec_and (vector bool int, vector unsigned int);
+vector unsigned int vec_and (vector unsigned int, vector bool int);
 vector unsigned int vec_and (vector unsigned int, vector unsigned int);
+vector bool short vec_and (vector bool short, vector bool short);
+vector signed short vec_and (vector bool short, vector signed short);
+vector signed short vec_and (vector signed short, vector bool short);
 vector signed short vec_and (vector signed short, vector signed short);
-vector unsigned short vec_and (vector signed short,
+vector unsigned short vec_and (vector bool short,
                                vector unsigned short);
 vector unsigned short vec_and (vector unsigned short,
-                               vector signed short);
+                               vector bool short);
 vector unsigned short vec_and (vector unsigned short,
                                vector unsigned short);
+vector signed char vec_and (vector bool char, vector signed char);
+vector bool char vec_and (vector bool char, vector bool char);
+vector signed char vec_and (vector signed char, vector bool char);
 vector signed char vec_and (vector signed char, vector signed char);
-vector unsigned char vec_and (vector signed char, vector unsigned char);
-
-vector unsigned char vec_and (vector unsigned char, vector signed char);
-
+vector unsigned char vec_and (vector bool char, vector unsigned char);
+vector unsigned char vec_and (vector unsigned char, vector bool char);
 vector unsigned char vec_and (vector unsigned char,
                               vector unsigned char);
 
 vector float vec_andc (vector float, vector float);
-vector float vec_andc (vector float, vector signed int);
-vector float vec_andc (vector signed int, vector float);
+vector float vec_andc (vector float, vector bool int);
+vector float vec_andc (vector bool int, vector float);
+vector bool int vec_andc (vector bool int, vector bool int);
+vector signed int vec_andc (vector bool int, vector signed int);
+vector signed int vec_andc (vector signed int, vector bool int);
 vector signed int vec_andc (vector signed int, vector signed int);
-vector unsigned int vec_andc (vector signed int, vector unsigned int);
-vector unsigned int vec_andc (vector unsigned int, vector signed int);
+vector unsigned int vec_andc (vector bool int, vector unsigned int);
+vector unsigned int vec_andc (vector unsigned int, vector bool int);
 vector unsigned int vec_andc (vector unsigned int, vector unsigned int);
-
+vector bool short vec_andc (vector bool short, vector bool short);
+vector signed short vec_andc (vector bool short, vector signed short);
+vector signed short vec_andc (vector signed short, vector bool short);
 vector signed short vec_andc (vector signed short, vector signed short);
-
-vector unsigned short vec_andc (vector signed short,
+vector unsigned short vec_andc (vector bool short,
                                 vector unsigned short);
 vector unsigned short vec_andc (vector unsigned short,
-                                vector signed short);
+                                vector bool short);
 vector unsigned short vec_andc (vector unsigned short,
                                 vector unsigned short);
+vector signed char vec_andc (vector bool char, vector signed char);
+vector bool char vec_andc (vector bool char, vector bool char);
+vector signed char vec_andc (vector signed char, vector bool char);
 vector signed char vec_andc (vector signed char, vector signed char);
-vector unsigned char vec_andc (vector signed char,
-                               vector unsigned char);
-vector unsigned char vec_andc (vector unsigned char,
-                               vector signed char);
+vector unsigned char vec_andc (vector bool char, vector unsigned char);
+vector unsigned char vec_andc (vector unsigned char, vector bool char);
 vector unsigned char vec_andc (vector unsigned char,
                                vector unsigned char);
 
@@ -6266,185 +6393,471 @@ vector signed short vec_avg (vector signed short, vector signed short);
 vector unsigned int vec_avg (vector unsigned int, vector unsigned int);
 vector signed int vec_avg (vector signed int, vector signed int);
 
+vector signed int vec_vavgsw (vector signed int, vector signed int);
+
+vector unsigned int vec_vavguw (vector unsigned int,
+                                vector unsigned int);
+
+vector signed short vec_vavgsh (vector signed short,
+                                vector signed short);
+
+vector unsigned short vec_vavguh (vector unsigned short,
+                                  vector unsigned short);
+
+vector signed char vec_vavgsb (vector signed char, vector signed char);
+
+vector unsigned char vec_vavgub (vector unsigned char,
+                                 vector unsigned char);
+
 vector float vec_ceil (vector float);
 
 vector signed int vec_cmpb (vector float, vector float);
 
-vector signed char vec_cmpeq (vector signed char, vector signed char);
-vector signed char vec_cmpeq (vector unsigned char,
-                              vector unsigned char);
-vector signed short vec_cmpeq (vector signed short,
-                               vector signed short);
-vector signed short vec_cmpeq (vector unsigned short,
-                               vector unsigned short);
-vector signed int vec_cmpeq (vector signed int, vector signed int);
-vector signed int vec_cmpeq (vector unsigned int, vector unsigned int);
-vector signed int vec_cmpeq (vector float, vector float);
+vector bool char vec_cmpeq (vector signed char, vector signed char);
+vector bool char vec_cmpeq (vector unsigned char, vector unsigned char);
+vector bool short vec_cmpeq (vector signed short, vector signed short);
+vector bool short vec_cmpeq (vector unsigned short,
+                             vector unsigned short);
+vector bool int vec_cmpeq (vector signed int, vector signed int);
+vector bool int vec_cmpeq (vector unsigned int, vector unsigned int);
+vector bool int vec_cmpeq (vector float, vector float);
 
-vector signed int vec_cmpge (vector float, vector float);
+vector bool int vec_vcmpeqfp (vector float, vector float);
 
-vector signed char vec_cmpgt (vector unsigned char,
-                              vector unsigned char);
-vector signed char vec_cmpgt (vector signed char, vector signed char);
-vector signed short vec_cmpgt (vector unsigned short,
-                               vector unsigned short);
-vector signed short vec_cmpgt (vector signed short,
-                               vector signed short);
-vector signed int vec_cmpgt (vector unsigned int, vector unsigned int);
-vector signed int vec_cmpgt (vector signed int, vector signed int);
-vector signed int vec_cmpgt (vector float, vector float);
+vector bool int vec_vcmpequw (vector signed int, vector signed int);
+vector bool int vec_vcmpequw (vector unsigned int, vector unsigned int);
 
-vector signed int vec_cmple (vector float, vector float);
+vector bool short vec_vcmpequh (vector signed short,
+                                vector signed short);
+vector bool short vec_vcmpequh (vector unsigned short,
+                                vector unsigned short);
 
-vector signed char vec_cmplt (vector unsigned char,
-                              vector unsigned char);
-vector signed char vec_cmplt (vector signed char, vector signed char);
-vector signed short vec_cmplt (vector unsigned short,
-                               vector unsigned short);
-vector signed short vec_cmplt (vector signed short,
-                               vector signed short);
-vector signed int vec_cmplt (vector unsigned int, vector unsigned int);
-vector signed int vec_cmplt (vector signed int, vector signed int);
-vector signed int vec_cmplt (vector float, vector float);
+vector bool char vec_vcmpequb (vector signed char, vector signed char);
+vector bool char vec_vcmpequb (vector unsigned char,
+                               vector unsigned char);
+
+vector bool int vec_cmpge (vector float, vector float);
+
+vector bool char vec_cmpgt (vector unsigned char, vector unsigned char);
+vector bool char vec_cmpgt (vector signed char, vector signed char);
+vector bool short vec_cmpgt (vector unsigned short,
+                             vector unsigned short);
+vector bool short vec_cmpgt (vector signed short, vector signed short);
+vector bool int vec_cmpgt (vector unsigned int, vector unsigned int);
+vector bool int vec_cmpgt (vector signed int, vector signed int);
+vector bool int vec_cmpgt (vector float, vector float);
 
-vector float vec_ctf (vector unsigned int, const char);
-vector float vec_ctf (vector signed int, const char);
+vector bool int vec_vcmpgtfp (vector float, vector float);
 
-vector signed int vec_cts (vector float, const char);
+vector bool int vec_vcmpgtsw (vector signed int, vector signed int);
 
-vector unsigned int vec_ctu (vector float, const char);
+vector bool int vec_vcmpgtuw (vector unsigned int, vector unsigned int);
 
-void vec_dss (const char);
+vector bool short vec_vcmpgtsh (vector signed short,
+                                vector signed short);
+
+vector bool short vec_vcmpgtuh (vector unsigned short,
+                                vector unsigned short);
+
+vector bool char vec_vcmpgtsb (vector signed char, vector signed char);
+
+vector bool char vec_vcmpgtub (vector unsigned char,
+                               vector unsigned char);
+
+vector bool int vec_cmple (vector float, vector float);
+
+vector bool char vec_cmplt (vector unsigned char, vector unsigned char);
+vector bool char vec_cmplt (vector signed char, vector signed char);
+vector bool short vec_cmplt (vector unsigned short,
+                             vector unsigned short);
+vector bool short vec_cmplt (vector signed short, vector signed short);
+vector bool int vec_cmplt (vector unsigned int, vector unsigned int);
+vector bool int vec_cmplt (vector signed int, vector signed int);
+vector bool int vec_cmplt (vector float, vector float);
+
+vector float vec_ctf (vector unsigned int, const int);
+vector float vec_ctf (vector signed int, const int);
+
+vector float vec_vcfsx (vector signed int, const int);
+
+vector float vec_vcfux (vector unsigned int, const int);
+
+vector signed int vec_cts (vector float, const int);
+
+vector unsigned int vec_ctu (vector float, const int);
+
+void vec_dss (const int);
 
 void vec_dssall (void);
 
-void vec_dst (void *, int, const char);
-
-void vec_dstst (void *, int, const char);
-
-void vec_dststt (void *, int, const char);
-
-void vec_dstt (void *, int, const char);
-
-vector float vec_expte (vector float, vector float);
-
-vector float vec_floor (vector float, vector float);
-
-vector float vec_ld (int, vector float *);
-vector float vec_ld (int, float *):
-vector signed int vec_ld (int, int *);
-vector signed int vec_ld (int, vector signed int *);
-vector unsigned int vec_ld (int, vector unsigned int *);
-vector unsigned int vec_ld (int, unsigned int *);
-vector signed short vec_ld (int, short *, vector signed short *);
-vector unsigned short vec_ld (int, unsigned short *,
-                              vector unsigned short *);
-vector signed char vec_ld (int, signed char *);
-vector signed char vec_ld (int, vector signed char *);
-vector unsigned char vec_ld (int, unsigned char *);
-vector unsigned char vec_ld (int, vector unsigned char *);
-
-vector signed char vec_lde (int, signed char *);
-vector unsigned char vec_lde (int, unsigned char *);
-vector signed short vec_lde (int, short *);
-vector unsigned short vec_lde (int, unsigned short *);
-vector float vec_lde (int, float *);
-vector signed int vec_lde (int, int *);
-vector unsigned int vec_lde (int, unsigned int *);
-
-void float vec_ldl (int, float *);
-void float vec_ldl (int, vector float *);
-void signed int vec_ldl (int, vector signed int *);
-void signed int vec_ldl (int, int *);
-void unsigned int vec_ldl (int, unsigned int *);
-void unsigned int vec_ldl (int, vector unsigned int *);
-void signed short vec_ldl (int, vector signed short *);
-void signed short vec_ldl (int, short *);
-void unsigned short vec_ldl (int, vector unsigned short *);
-void unsigned short vec_ldl (int, unsigned short *);
-void signed char vec_ldl (int, vector signed char *);
-void signed char vec_ldl (int, signed char *);
-void unsigned char vec_ldl (int, vector unsigned char *);
-void unsigned char vec_ldl (int, unsigned char *);
+void vec_dst (const vector unsigned char *, int, const int);
+void vec_dst (const vector signed char *, int, const int);
+void vec_dst (const vector bool char *, int, const int);
+void vec_dst (const vector unsigned short *, int, const int);
+void vec_dst (const vector signed short *, int, const int);
+void vec_dst (const vector bool short *, int, const int);
+void vec_dst (const vector pixel *, int, const int);
+void vec_dst (const vector unsigned int *, int, const int);
+void vec_dst (const vector signed int *, int, const int);
+void vec_dst (const vector bool int *, int, const int);
+void vec_dst (const vector float *, int, const int);
+void vec_dst (const unsigned char *, int, const int);
+void vec_dst (const signed char *, int, const int);
+void vec_dst (const unsigned short *, int, const int);
+void vec_dst (const short *, int, const int);
+void vec_dst (const unsigned int *, int, const int);
+void vec_dst (const int *, int, const int);
+void vec_dst (const unsigned long *, int, const int);
+void vec_dst (const long *, int, const int);
+void vec_dst (const float *, int, const int);
+
+void vec_dstst (const vector unsigned char *, int, const int);
+void vec_dstst (const vector signed char *, int, const int);
+void vec_dstst (const vector bool char *, int, const int);
+void vec_dstst (const vector unsigned short *, int, const int);
+void vec_dstst (const vector signed short *, int, const int);
+void vec_dstst (const vector bool short *, int, const int);
+void vec_dstst (const vector pixel *, int, const int);
+void vec_dstst (const vector unsigned int *, int, const int);
+void vec_dstst (const vector signed int *, int, const int);
+void vec_dstst (const vector bool int *, int, const int);
+void vec_dstst (const vector float *, int, const int);
+void vec_dstst (const unsigned char *, int, const int);
+void vec_dstst (const signed char *, int, const int);
+void vec_dstst (const unsigned short *, int, const int);
+void vec_dstst (const short *, int, const int);
+void vec_dstst (const unsigned int *, int, const int);
+void vec_dstst (const int *, int, const int);
+void vec_dstst (const unsigned long *, int, const int);
+void vec_dstst (const long *, int, const int);
+void vec_dstst (const float *, int, const int);
+
+void vec_dststt (const vector unsigned char *, int, const int);
+void vec_dststt (const vector signed char *, int, const int);
+void vec_dststt (const vector bool char *, int, const int);
+void vec_dststt (const vector unsigned short *, int, const int);
+void vec_dststt (const vector signed short *, int, const int);
+void vec_dststt (const vector bool short *, int, const int);
+void vec_dststt (const vector pixel *, int, const int);
+void vec_dststt (const vector unsigned int *, int, const int);
+void vec_dststt (const vector signed int *, int, const int);
+void vec_dststt (const vector bool int *, int, const int);
+void vec_dststt (const vector float *, int, const int);
+void vec_dststt (const unsigned char *, int, const int);
+void vec_dststt (const signed char *, int, const int);
+void vec_dststt (const unsigned short *, int, const int);
+void vec_dststt (const short *, int, const int);
+void vec_dststt (const unsigned int *, int, const int);
+void vec_dststt (const int *, int, const int);
+void vec_dststt (const unsigned long *, int, const int);
+void vec_dststt (const long *, int, const int);
+void vec_dststt (const float *, int, const int);
+
+void vec_dstt (const vector unsigned char *, int, const int);
+void vec_dstt (const vector signed char *, int, const int);
+void vec_dstt (const vector bool char *, int, const int);
+void vec_dstt (const vector unsigned short *, int, const int);
+void vec_dstt (const vector signed short *, int, const int);
+void vec_dstt (const vector bool short *, int, const int);
+void vec_dstt (const vector pixel *, int, const int);
+void vec_dstt (const vector unsigned int *, int, const int);
+void vec_dstt (const vector signed int *, int, const int);
+void vec_dstt (const vector bool int *, int, const int);
+void vec_dstt (const vector float *, int, const int);
+void vec_dstt (const unsigned char *, int, const int);
+void vec_dstt (const signed char *, int, const int);
+void vec_dstt (const unsigned short *, int, const int);
+void vec_dstt (const short *, int, const int);
+void vec_dstt (const unsigned int *, int, const int);
+void vec_dstt (const int *, int, const int);
+void vec_dstt (const unsigned long *, int, const int);
+void vec_dstt (const long *, int, const int);
+void vec_dstt (const float *, int, const int);
+
+vector float vec_expte (vector float);
+
+vector float vec_floor (vector float);
+
+vector float vec_ld (int, const vector float *);
+vector float vec_ld (int, const float *);
+vector bool int vec_ld (int, const vector bool int *);
+vector signed int vec_ld (int, const vector signed int *);
+vector signed int vec_ld (int, const int *);
+vector signed int vec_ld (int, const long *);
+vector unsigned int vec_ld (int, const vector unsigned int *);
+vector unsigned int vec_ld (int, const unsigned int *);
+vector unsigned int vec_ld (int, const unsigned long *);
+vector bool short vec_ld (int, const vector bool short *);
+vector pixel vec_ld (int, const vector pixel *);
+vector signed short vec_ld (int, const vector signed short *);
+vector signed short vec_ld (int, const short *);
+vector unsigned short vec_ld (int, const vector unsigned short *);
+vector unsigned short vec_ld (int, const unsigned short *);
+vector bool char vec_ld (int, const vector bool char *);
+vector signed char vec_ld (int, const vector signed char *);
+vector signed char vec_ld (int, const signed char *);
+vector unsigned char vec_ld (int, const vector unsigned char *);
+vector unsigned char vec_ld (int, const unsigned char *);
+
+vector signed char vec_lde (int, const signed char *);
+vector unsigned char vec_lde (int, const unsigned char *);
+vector signed short vec_lde (int, const short *);
+vector unsigned short vec_lde (int, const unsigned short *);
+vector float vec_lde (int, const float *);
+vector signed int vec_lde (int, const int *);
+vector unsigned int vec_lde (int, const unsigned int *);
+vector signed int vec_lde (int, const long *);
+vector unsigned int vec_lde (int, const unsigned long *);
+
+vector float vec_lvewx (int, float *);
+vector signed int vec_lvewx (int, int *);
+vector unsigned int vec_lvewx (int, unsigned int *);
+vector signed int vec_lvewx (int, long *);
+vector unsigned int vec_lvewx (int, unsigned long *);
+
+vector signed short vec_lvehx (int, short *);
+vector unsigned short vec_lvehx (int, unsigned short *);
+
+vector signed char vec_lvebx (int, char *);
+vector unsigned char vec_lvebx (int, unsigned char *);
+
+vector float vec_ldl (int, const vector float *);
+vector float vec_ldl (int, const float *);
+vector bool int vec_ldl (int, const vector bool int *);
+vector signed int vec_ldl (int, const vector signed int *);
+vector signed int vec_ldl (int, const int *);
+vector signed int vec_ldl (int, const long *);
+vector unsigned int vec_ldl (int, const vector unsigned int *);
+vector unsigned int vec_ldl (int, const unsigned int *);
+vector unsigned int vec_ldl (int, const unsigned long *);
+vector bool short vec_ldl (int, const vector bool short *);
+vector pixel vec_ldl (int, const vector pixel *);
+vector signed short vec_ldl (int, const vector signed short *);
+vector signed short vec_ldl (int, const short *);
+vector unsigned short vec_ldl (int, const vector unsigned short *);
+vector unsigned short vec_ldl (int, const unsigned short *);
+vector bool char vec_ldl (int, const vector bool char *);
+vector signed char vec_ldl (int, const vector signed char *);
+vector signed char vec_ldl (int, const signed char *);
+vector unsigned char vec_ldl (int, const vector unsigned char *);
+vector unsigned char vec_ldl (int, const unsigned char *);
 
 vector float vec_loge (vector float);
 
-vector unsigned char vec_lvsl (int, void *, int *);
-
-vector unsigned char vec_lvsr (int, void *, int *);
+vector unsigned char vec_lvsl (int, const volatile unsigned char *);
+vector unsigned char vec_lvsl (int, const volatile signed char *);
+vector unsigned char vec_lvsl (int, const volatile unsigned short *);
+vector unsigned char vec_lvsl (int, const volatile short *);
+vector unsigned char vec_lvsl (int, const volatile unsigned int *);
+vector unsigned char vec_lvsl (int, const volatile int *);
+vector unsigned char vec_lvsl (int, const volatile unsigned long *);
+vector unsigned char vec_lvsl (int, const volatile long *);
+vector unsigned char vec_lvsl (int, const volatile float *);
+
+vector unsigned char vec_lvsr (int, const volatile unsigned char *);
+vector unsigned char vec_lvsr (int, const volatile signed char *);
+vector unsigned char vec_lvsr (int, const volatile unsigned short *);
+vector unsigned char vec_lvsr (int, const volatile short *);
+vector unsigned char vec_lvsr (int, const volatile unsigned int *);
+vector unsigned char vec_lvsr (int, const volatile int *);
+vector unsigned char vec_lvsr (int, const volatile unsigned long *);
+vector unsigned char vec_lvsr (int, const volatile long *);
+vector unsigned char vec_lvsr (int, const volatile float *);
 
 vector float vec_madd (vector float, vector float, vector float);
 
-vector signed short vec_madds (vector signed short, vector signed short,
+vector signed short vec_madds (vector signed short,
+                               vector signed short,
                                vector signed short);
 
-vector unsigned char vec_max (vector signed char, vector unsigned char);
-
-vector unsigned char vec_max (vector unsigned char, vector signed char);
-
+vector unsigned char vec_max (vector bool char, vector unsigned char);
+vector unsigned char vec_max (vector unsigned char, vector bool char);
 vector unsigned char vec_max (vector unsigned char,
                               vector unsigned char);
+vector signed char vec_max (vector bool char, vector signed char);
+vector signed char vec_max (vector signed char, vector bool char);
 vector signed char vec_max (vector signed char, vector signed char);
-vector unsigned short vec_max (vector signed short,
+vector unsigned short vec_max (vector bool short,
                                vector unsigned short);
 vector unsigned short vec_max (vector unsigned short,
-                               vector signed short);
+                               vector bool short);
 vector unsigned short vec_max (vector unsigned short,
                                vector unsigned short);
+vector signed short vec_max (vector bool short, vector signed short);
+vector signed short vec_max (vector signed short, vector bool short);
 vector signed short vec_max (vector signed short, vector signed short);
-vector unsigned int vec_max (vector signed int, vector unsigned int);
-vector unsigned int vec_max (vector unsigned int, vector signed int);
+vector unsigned int vec_max (vector bool int, vector unsigned int);
+vector unsigned int vec_max (vector unsigned int, vector bool int);
 vector unsigned int vec_max (vector unsigned int, vector unsigned int);
+vector signed int vec_max (vector bool int, vector signed int);
+vector signed int vec_max (vector signed int, vector bool int);
 vector signed int vec_max (vector signed int, vector signed int);
 vector float vec_max (vector float, vector float);
 
+vector float vec_vmaxfp (vector float, vector float);
+
+vector signed int vec_vmaxsw (vector bool int, vector signed int);
+vector signed int vec_vmaxsw (vector signed int, vector bool int);
+vector signed int vec_vmaxsw (vector signed int, vector signed int);
+
+vector unsigned int vec_vmaxuw (vector bool int, vector unsigned int);
+vector unsigned int vec_vmaxuw (vector unsigned int, vector bool int);
+vector unsigned int vec_vmaxuw (vector unsigned int,
+                                vector unsigned int);
+
+vector signed short vec_vmaxsh (vector bool short, vector signed short);
+vector signed short vec_vmaxsh (vector signed short, vector bool short);
+vector signed short vec_vmaxsh (vector signed short,
+                                vector signed short);
+
+vector unsigned short vec_vmaxuh (vector bool short,
+                                  vector unsigned short);
+vector unsigned short vec_vmaxuh (vector unsigned short,
+                                  vector bool short);
+vector unsigned short vec_vmaxuh (vector unsigned short,
+                                  vector unsigned short);
+
+vector signed char vec_vmaxsb (vector bool char, vector signed char);
+vector signed char vec_vmaxsb (vector signed char, vector bool char);
+vector signed char vec_vmaxsb (vector signed char, vector signed char);
+
+vector unsigned char vec_vmaxub (vector bool char,
+                                 vector unsigned char);
+vector unsigned char vec_vmaxub (vector unsigned char,
+                                 vector bool char);
+vector unsigned char vec_vmaxub (vector unsigned char,
+                                 vector unsigned char);
+
+vector bool char vec_mergeh (vector bool char, vector bool char);
 vector signed char vec_mergeh (vector signed char, vector signed char);
 vector unsigned char vec_mergeh (vector unsigned char,
                                  vector unsigned char);
+vector bool short vec_mergeh (vector bool short, vector bool short);
+vector pixel vec_mergeh (vector pixel, vector pixel);
 vector signed short vec_mergeh (vector signed short,
                                 vector signed short);
 vector unsigned short vec_mergeh (vector unsigned short,
                                   vector unsigned short);
 vector float vec_mergeh (vector float, vector float);
+vector bool int vec_mergeh (vector bool int, vector bool int);
 vector signed int vec_mergeh (vector signed int, vector signed int);
 vector unsigned int vec_mergeh (vector unsigned int,
                                 vector unsigned int);
 
+vector float vec_vmrghw (vector float, vector float);
+vector bool int vec_vmrghw (vector bool int, vector bool int);
+vector signed int vec_vmrghw (vector signed int, vector signed int);
+vector unsigned int vec_vmrghw (vector unsigned int,
+                                vector unsigned int);
+
+vector bool short vec_vmrghh (vector bool short, vector bool short);
+vector signed short vec_vmrghh (vector signed short,
+                                vector signed short);
+vector unsigned short vec_vmrghh (vector unsigned short,
+                                  vector unsigned short);
+vector pixel vec_vmrghh (vector pixel, vector pixel);
+
+vector bool char vec_vmrghb (vector bool char, vector bool char);
+vector signed char vec_vmrghb (vector signed char, vector signed char);
+vector unsigned char vec_vmrghb (vector unsigned char,
+                                 vector unsigned char);
+
+vector bool char vec_mergel (vector bool char, vector bool char);
 vector signed char vec_mergel (vector signed char, vector signed char);
 vector unsigned char vec_mergel (vector unsigned char,
                                  vector unsigned char);
+vector bool short vec_mergel (vector bool short, vector bool short);
+vector pixel vec_mergel (vector pixel, vector pixel);
 vector signed short vec_mergel (vector signed short,
                                 vector signed short);
 vector unsigned short vec_mergel (vector unsigned short,
                                   vector unsigned short);
 vector float vec_mergel (vector float, vector float);
+vector bool int vec_mergel (vector bool int, vector bool int);
 vector signed int vec_mergel (vector signed int, vector signed int);
 vector unsigned int vec_mergel (vector unsigned int,
                                 vector unsigned int);
 
-vector unsigned short vec_mfvscr (void);
+vector float vec_vmrglw (vector float, vector float);
+vector signed int vec_vmrglw (vector signed int, vector signed int);
+vector unsigned int vec_vmrglw (vector unsigned int,
+                                vector unsigned int);
+vector bool int vec_vmrglw (vector bool int, vector bool int);
+
+vector bool short vec_vmrglh (vector bool short, vector bool short);
+vector signed short vec_vmrglh (vector signed short,
+                                vector signed short);
+vector unsigned short vec_vmrglh (vector unsigned short,
+                                  vector unsigned short);
+vector pixel vec_vmrglh (vector pixel, vector pixel);
 
-vector unsigned char vec_min (vector signed char, vector unsigned char);
+vector bool char vec_vmrglb (vector bool char, vector bool char);
+vector signed char vec_vmrglb (vector signed char, vector signed char);
+vector unsigned char vec_vmrglb (vector unsigned char,
+                                 vector unsigned char);
 
-vector unsigned char vec_min (vector unsigned char, vector signed char);
+vector unsigned short vec_mfvscr (void);
 
+vector unsigned char vec_min (vector bool char, vector unsigned char);
+vector unsigned char vec_min (vector unsigned char, vector bool char);
 vector unsigned char vec_min (vector unsigned char,
                               vector unsigned char);
+vector signed char vec_min (vector bool char, vector signed char);
+vector signed char vec_min (vector signed char, vector bool char);
 vector signed char vec_min (vector signed char, vector signed char);
-vector unsigned short vec_min (vector signed short,
+vector unsigned short vec_min (vector bool short,
                                vector unsigned short);
 vector unsigned short vec_min (vector unsigned short,
-                               vector signed short);
+                               vector bool short);
 vector unsigned short vec_min (vector unsigned short,
                                vector unsigned short);
+vector signed short vec_min (vector bool short, vector signed short);
+vector signed short vec_min (vector signed short, vector bool short);
 vector signed short vec_min (vector signed short, vector signed short);
-vector unsigned int vec_min (vector signed int, vector unsigned int);
-vector unsigned int vec_min (vector unsigned int, vector signed int);
+vector unsigned int vec_min (vector bool int, vector unsigned int);
+vector unsigned int vec_min (vector unsigned int, vector bool int);
 vector unsigned int vec_min (vector unsigned int, vector unsigned int);
+vector signed int vec_min (vector bool int, vector signed int);
+vector signed int vec_min (vector signed int, vector bool int);
 vector signed int vec_min (vector signed int, vector signed int);
 vector float vec_min (vector float, vector float);
 
-vector signed short vec_mladd (vector signed short, vector signed short,
+vector float vec_vminfp (vector float, vector float);
+
+vector signed int vec_vminsw (vector bool int, vector signed int);
+vector signed int vec_vminsw (vector signed int, vector bool int);
+vector signed int vec_vminsw (vector signed int, vector signed int);
+
+vector unsigned int vec_vminuw (vector bool int, vector unsigned int);
+vector unsigned int vec_vminuw (vector unsigned int, vector bool int);
+vector unsigned int vec_vminuw (vector unsigned int,
+                                vector unsigned int);
+
+vector signed short vec_vminsh (vector bool short, vector signed short);
+vector signed short vec_vminsh (vector signed short, vector bool short);
+vector signed short vec_vminsh (vector signed short,
+                                vector signed short);
+
+vector unsigned short vec_vminuh (vector bool short,
+                                  vector unsigned short);
+vector unsigned short vec_vminuh (vector unsigned short,
+                                  vector bool short);
+vector unsigned short vec_vminuh (vector unsigned short,
+                                  vector unsigned short);
+
+vector signed char vec_vminsb (vector bool char, vector signed char);
+vector signed char vec_vminsb (vector signed char, vector bool char);
+vector signed char vec_vminsb (vector signed char, vector signed char);
+
+vector unsigned char vec_vminub (vector bool char,
+                                 vector unsigned char);
+vector unsigned char vec_vminub (vector unsigned char,
+                                 vector bool char);
+vector unsigned char vec_vminub (vector unsigned char,
+                                 vector unsigned char);
+
+vector signed short vec_mladd (vector signed short,
+                               vector signed short,
                                vector signed short);
 vector signed short vec_mladd (vector signed short,
                                vector unsigned short,
@@ -6463,34 +6876,78 @@ vector signed short vec_mradds (vector signed short,
 vector unsigned int vec_msum (vector unsigned char,
                               vector unsigned char,
                               vector unsigned int);
-vector signed int vec_msum (vector signed char, vector unsigned char,
+vector signed int vec_msum (vector signed char,
+                            vector unsigned char,
                             vector signed int);
 vector unsigned int vec_msum (vector unsigned short,
                               vector unsigned short,
                               vector unsigned int);
-vector signed int vec_msum (vector signed short, vector signed short,
+vector signed int vec_msum (vector signed short,
+                            vector signed short,
                             vector signed int);
 
+vector signed int vec_vmsumshm (vector signed short,
+                                vector signed short,
+                                vector signed int);
+
+vector unsigned int vec_vmsumuhm (vector unsigned short,
+                                  vector unsigned short,
+                                  vector unsigned int);
+
+vector signed int vec_vmsummbm (vector signed char,
+                                vector unsigned char,
+                                vector signed int);
+
+vector unsigned int vec_vmsumubm (vector unsigned char,
+                                  vector unsigned char,
+                                  vector unsigned int);
+
 vector unsigned int vec_msums (vector unsigned short,
                                vector unsigned short,
                                vector unsigned int);
-vector signed int vec_msums (vector signed short, vector signed short,
+vector signed int vec_msums (vector signed short,
+                             vector signed short,
                              vector signed int);
 
+vector signed int vec_vmsumshs (vector signed short,
+                                vector signed short,
+                                vector signed int);
+
+vector unsigned int vec_vmsumuhs (vector unsigned short,
+                                  vector unsigned short,
+                                  vector unsigned int);
+
 void vec_mtvscr (vector signed int);
 void vec_mtvscr (vector unsigned int);
+void vec_mtvscr (vector bool int);
 void vec_mtvscr (vector signed short);
 void vec_mtvscr (vector unsigned short);
+void vec_mtvscr (vector bool short);
+void vec_mtvscr (vector pixel);
 void vec_mtvscr (vector signed char);
 void vec_mtvscr (vector unsigned char);
+void vec_mtvscr (vector bool char);
 
 vector unsigned short vec_mule (vector unsigned char,
                                 vector unsigned char);
-vector signed short vec_mule (vector signed char, vector signed char);
+vector signed short vec_mule (vector signed char,
+                              vector signed char);
 vector unsigned int vec_mule (vector unsigned short,
                               vector unsigned short);
 vector signed int vec_mule (vector signed short, vector signed short);
 
+vector signed int vec_vmulesh (vector signed short,
+                               vector signed short);
+
+vector unsigned int vec_vmuleuh (vector unsigned short,
+                                 vector unsigned short);
+
+vector signed short vec_vmulesb (vector signed char,
+                                 vector signed char);
+
+vector unsigned short vec_vmuleub (vector unsigned char,
+                                  vector unsigned char);
+
 vector unsigned short vec_mulo (vector unsigned char,
                                 vector unsigned char);
 vector signed short vec_mulo (vector signed char, vector signed char);
@@ -6498,56 +6955,100 @@ vector unsigned int vec_mulo (vector unsigned short,
                               vector unsigned short);
 vector signed int vec_mulo (vector signed short, vector signed short);
 
+vector signed int vec_vmulosh (vector signed short,
+                               vector signed short);
+
+vector unsigned int vec_vmulouh (vector unsigned short,
+                                 vector unsigned short);
+
+vector signed short vec_vmulosb (vector signed char,
+                                 vector signed char);
+
+vector unsigned short vec_vmuloub (vector unsigned char,
+                                   vector unsigned char);
+
 vector float vec_nmsub (vector float, vector float, vector float);
 
 vector float vec_nor (vector float, vector float);
 vector signed int vec_nor (vector signed int, vector signed int);
 vector unsigned int vec_nor (vector unsigned int, vector unsigned int);
+vector bool int vec_nor (vector bool int, vector bool int);
 vector signed short vec_nor (vector signed short, vector signed short);
 vector unsigned short vec_nor (vector unsigned short,
                                vector unsigned short);
+vector bool short vec_nor (vector bool short, vector bool short);
 vector signed char vec_nor (vector signed char, vector signed char);
 vector unsigned char vec_nor (vector unsigned char,
                               vector unsigned char);
+vector bool char vec_nor (vector bool char, vector bool char);
 
 vector float vec_or (vector float, vector float);
-vector float vec_or (vector float, vector signed int);
-vector float vec_or (vector signed int, vector float);
+vector float vec_or (vector float, vector bool int);
+vector float vec_or (vector bool int, vector float);
+vector bool int vec_or (vector bool int, vector bool int);
+vector signed int vec_or (vector bool int, vector signed int);
+vector signed int vec_or (vector signed int, vector bool int);
 vector signed int vec_or (vector signed int, vector signed int);
-vector unsigned int vec_or (vector signed int, vector unsigned int);
-vector unsigned int vec_or (vector unsigned int, vector signed int);
+vector unsigned int vec_or (vector bool int, vector unsigned int);
+vector unsigned int vec_or (vector unsigned int, vector bool int);
 vector unsigned int vec_or (vector unsigned int, vector unsigned int);
+vector bool short vec_or (vector bool short, vector bool short);
+vector signed short vec_or (vector bool short, vector signed short);
+vector signed short vec_or (vector signed short, vector bool short);
 vector signed short vec_or (vector signed short, vector signed short);
-vector unsigned short vec_or (vector signed short,
-                              vector unsigned short);
-vector unsigned short vec_or (vector unsigned short,
-                              vector signed short);
+vector unsigned short vec_or (vector bool short, vector unsigned short);
+vector unsigned short vec_or (vector unsigned short, vector bool short);
 vector unsigned short vec_or (vector unsigned short,
                               vector unsigned short);
+vector signed char vec_or (vector bool char, vector signed char);
+vector bool char vec_or (vector bool char, vector bool char);
+vector signed char vec_or (vector signed char, vector bool char);
 vector signed char vec_or (vector signed char, vector signed char);
-vector unsigned char vec_or (vector signed char, vector unsigned char);
-vector unsigned char vec_or (vector unsigned char, vector signed char);
+vector unsigned char vec_or (vector bool char, vector unsigned char);
+vector unsigned char vec_or (vector unsigned char, vector bool char);
 vector unsigned char vec_or (vector unsigned char,
                              vector unsigned char);
 
 vector signed char vec_pack (vector signed short, vector signed short);
 vector unsigned char vec_pack (vector unsigned short,
                                vector unsigned short);
+vector bool char vec_pack (vector bool short, vector bool short);
 vector signed short vec_pack (vector signed int, vector signed int);
 vector unsigned short vec_pack (vector unsigned int,
                                 vector unsigned int);
+vector bool short vec_pack (vector bool int, vector bool int);
 
-vector signed short vec_packpx (vector unsigned int,
-                                vector unsigned int);
+vector bool short vec_vpkuwum (vector bool int, vector bool int);
+vector signed short vec_vpkuwum (vector signed int, vector signed int);
+vector unsigned short vec_vpkuwum (vector unsigned int,
+                                   vector unsigned int);
+
+vector bool char vec_vpkuhum (vector bool short, vector bool short);
+vector signed char vec_vpkuhum (vector signed short,
+                                vector signed short);
+vector unsigned char vec_vpkuhum (vector unsigned short,
+                                  vector unsigned short);
+
+vector pixel vec_packpx (vector unsigned int, vector unsigned int);
 
 vector unsigned char vec_packs (vector unsigned short,
                                 vector unsigned short);
 vector signed char vec_packs (vector signed short, vector signed short);
-
 vector unsigned short vec_packs (vector unsigned int,
                                  vector unsigned int);
 vector signed short vec_packs (vector signed int, vector signed int);
 
+vector signed short vec_vpkswss (vector signed int, vector signed int);
+
+vector unsigned short vec_vpkuwus (vector unsigned int,
+                                   vector unsigned int);
+
+vector signed char vec_vpkshss (vector signed short,
+                                vector signed short);
+
+vector unsigned char vec_vpkuhus (vector unsigned short,
+                                  vector unsigned short);
+
 vector unsigned char vec_packsu (vector unsigned short,
                                  vector unsigned short);
 vector unsigned char vec_packsu (vector signed short,
@@ -6556,114 +7057,221 @@ vector unsigned short vec_packsu (vector unsigned int,
                                   vector unsigned int);
 vector unsigned short vec_packsu (vector signed int, vector signed int);
 
-vector float vec_perm (vector float, vector float,
+vector unsigned short vec_vpkswus (vector signed int,
+                                   vector signed int);
+
+vector unsigned char vec_vpkshus (vector signed short,
+                                  vector signed short);
+
+vector float vec_perm (vector float,
+                       vector float,
                        vector unsigned char);
-vector signed int vec_perm (vector signed int, vector signed int,
+vector signed int vec_perm (vector signed int,
+                            vector signed int,
                             vector unsigned char);
-vector unsigned int vec_perm (vector unsigned int, vector unsigned int,
+vector unsigned int vec_perm (vector unsigned int,
+                              vector unsigned int,
                               vector unsigned char);
-vector signed short vec_perm (vector signed short, vector signed short,
+vector bool int vec_perm (vector bool int,
+                          vector bool int,
+                          vector unsigned char);
+vector signed short vec_perm (vector signed short,
+                              vector signed short,
                               vector unsigned char);
 vector unsigned short vec_perm (vector unsigned short,
                                 vector unsigned short,
                                 vector unsigned char);
-vector signed char vec_perm (vector signed char, vector signed char,
+vector bool short vec_perm (vector bool short,
+                            vector bool short,
+                            vector unsigned char);
+vector pixel vec_perm (vector pixel,
+                       vector pixel,
+                       vector unsigned char);
+vector signed char vec_perm (vector signed char,
+                             vector signed char,
                              vector unsigned char);
 vector unsigned char vec_perm (vector unsigned char,
                                vector unsigned char,
                                vector unsigned char);
+vector bool char vec_perm (vector bool char,
+                           vector bool char,
+                           vector unsigned char);
 
 vector float vec_re (vector float);
 
-vector signed char vec_rl (vector signed char, vector unsigned char);
+vector signed char vec_rl (vector signed char,
+                           vector unsigned char);
 vector unsigned char vec_rl (vector unsigned char,
                              vector unsigned char);
 vector signed short vec_rl (vector signed short, vector unsigned short);
-
 vector unsigned short vec_rl (vector unsigned short,
                               vector unsigned short);
 vector signed int vec_rl (vector signed int, vector unsigned int);
 vector unsigned int vec_rl (vector unsigned int, vector unsigned int);
 
+vector signed int vec_vrlw (vector signed int, vector unsigned int);
+vector unsigned int vec_vrlw (vector unsigned int, vector unsigned int);
+
+vector signed short vec_vrlh (vector signed short,
+                              vector unsigned short);
+vector unsigned short vec_vrlh (vector unsigned short,
+                                vector unsigned short);
+
+vector signed char vec_vrlb (vector signed char, vector unsigned char);
+vector unsigned char vec_vrlb (vector unsigned char,
+                               vector unsigned char);
+
 vector float vec_round (vector float);
 
 vector float vec_rsqrte (vector float);
 
-vector float vec_sel (vector float, vector float, vector signed int);
+vector float vec_sel (vector float, vector float, vector bool int);
 vector float vec_sel (vector float, vector float, vector unsigned int);
-vector signed int vec_sel (vector signed int, vector signed int,
-                           vector signed int);
-vector signed int vec_sel (vector signed int, vector signed int,
+vector signed int vec_sel (vector signed int,
+                           vector signed int,
+                           vector bool int);
+vector signed int vec_sel (vector signed int,
+                           vector signed int,
                            vector unsigned int);
-vector unsigned int vec_sel (vector unsigned int, vector unsigned int,
-                             vector signed int);
-vector unsigned int vec_sel (vector unsigned int, vector unsigned int,
+vector unsigned int vec_sel (vector unsigned int,
+                             vector unsigned int,
+                             vector bool int);
+vector unsigned int vec_sel (vector unsigned int,
+                             vector unsigned int,
                              vector unsigned int);
-vector signed short vec_sel (vector signed short, vector signed short,
-                             vector signed short);
-vector signed short vec_sel (vector signed short, vector signed short,
+vector bool int vec_sel (vector bool int,
+                         vector bool int,
+                         vector bool int);
+vector bool int vec_sel (vector bool int,
+                         vector bool int,
+                         vector unsigned int);
+vector signed short vec_sel (vector signed short,
+                             vector signed short,
+                             vector bool short);
+vector signed short vec_sel (vector signed short,
+                             vector signed short,
                              vector unsigned short);
 vector unsigned short vec_sel (vector unsigned short,
                                vector unsigned short,
-                               vector signed short);
+                               vector bool short);
 vector unsigned short vec_sel (vector unsigned short,
                                vector unsigned short,
                                vector unsigned short);
-vector signed char vec_sel (vector signed char, vector signed char,
-                            vector signed char);
-vector signed char vec_sel (vector signed char, vector signed char,
+vector bool short vec_sel (vector bool short,
+                           vector bool short,
+                           vector bool short);
+vector bool short vec_sel (vector bool short,
+                           vector bool short,
+                           vector unsigned short);
+vector signed char vec_sel (vector signed char,
+                            vector signed char,
+                            vector bool char);
+vector signed char vec_sel (vector signed char,
+                            vector signed char,
                             vector unsigned char);
 vector unsigned char vec_sel (vector unsigned char,
                               vector unsigned char,
-                              vector signed char);
+                              vector bool char);
 vector unsigned char vec_sel (vector unsigned char,
                               vector unsigned char,
                               vector unsigned char);
-
-vector signed char vec_sl (vector signed char, vector unsigned char);
+vector bool char vec_sel (vector bool char,
+                          vector bool char,
+                          vector bool char);
+vector bool char vec_sel (vector bool char,
+                          vector bool char,
+                          vector unsigned char);
+
+vector signed char vec_sl (vector signed char,
+                           vector unsigned char);
 vector unsigned char vec_sl (vector unsigned char,
                              vector unsigned char);
 vector signed short vec_sl (vector signed short, vector unsigned short);
-
 vector unsigned short vec_sl (vector unsigned short,
                               vector unsigned short);
 vector signed int vec_sl (vector signed int, vector unsigned int);
 vector unsigned int vec_sl (vector unsigned int, vector unsigned int);
 
-vector float vec_sld (vector float, vector float, const char);
-vector signed int vec_sld (vector signed int, vector signed int,
-                           const char);
-vector unsigned int vec_sld (vector unsigned int, vector unsigned int,
-                             const char);
-vector signed short vec_sld (vector signed short, vector signed short,
-                             const char);
+vector signed int vec_vslw (vector signed int, vector unsigned int);
+vector unsigned int vec_vslw (vector unsigned int, vector unsigned int);
+
+vector signed short vec_vslh (vector signed short,
+                              vector unsigned short);
+vector unsigned short vec_vslh (vector unsigned short,
+                                vector unsigned short);
+
+vector signed char vec_vslb (vector signed char, vector unsigned char);
+vector unsigned char vec_vslb (vector unsigned char,
+                               vector unsigned char);
+
+vector float vec_sld (vector float, vector float, const int);
+vector signed int vec_sld (vector signed int,
+                           vector signed int,
+                           const int);
+vector unsigned int vec_sld (vector unsigned int,
+                             vector unsigned int,
+                             const int);
+vector bool int vec_sld (vector bool int,
+                         vector bool int,
+                         const int);
+vector signed short vec_sld (vector signed short,
+                             vector signed short,
+                             const int);
 vector unsigned short vec_sld (vector unsigned short,
-                               vector unsigned short, const char);
-vector signed char vec_sld (vector signed char, vector signed char,
-                            const char);
+                               vector unsigned short,
+                               const int);
+vector bool short vec_sld (vector bool short,
+                           vector bool short,
+                           const int);
+vector pixel vec_sld (vector pixel,
+                      vector pixel,
+                      const int);
+vector signed char vec_sld (vector signed char,
+                            vector signed char,
+                            const int);
 vector unsigned char vec_sld (vector unsigned char,
                               vector unsigned char,
-                              const char);
+                              const int);
+vector bool char vec_sld (vector bool char,
+                          vector bool char,
+                          const int);
 
-vector signed int vec_sll (vector signed int, vector unsigned int);
-vector signed int vec_sll (vector signed int, vector unsigned short);
-vector signed int vec_sll (vector signed int, vector unsigned char);
-vector unsigned int vec_sll (vector unsigned int, vector unsigned int);
+vector signed int vec_sll (vector signed int,
+                           vector unsigned int);
+vector signed int vec_sll (vector signed int,
+                           vector unsigned short);
+vector signed int vec_sll (vector signed int,
+                           vector unsigned char);
+vector unsigned int vec_sll (vector unsigned int,
+                             vector unsigned int);
 vector unsigned int vec_sll (vector unsigned int,
                              vector unsigned short);
-vector unsigned int vec_sll (vector unsigned int, vector unsigned char);
-
-vector signed short vec_sll (vector signed short, vector unsigned int);
+vector unsigned int vec_sll (vector unsigned int,
+                             vector unsigned char);
+vector bool int vec_sll (vector bool int,
+                         vector unsigned int);
+vector bool int vec_sll (vector bool int,
+                         vector unsigned short);
+vector bool int vec_sll (vector bool int,
+                         vector unsigned char);
+vector signed short vec_sll (vector signed short,
+                             vector unsigned int);
 vector signed short vec_sll (vector signed short,
                              vector unsigned short);
-vector signed short vec_sll (vector signed short, vector unsigned char);
-
+vector signed short vec_sll (vector signed short,
+                             vector unsigned char);
 vector unsigned short vec_sll (vector unsigned short,
                                vector unsigned int);
 vector unsigned short vec_sll (vector unsigned short,
                                vector unsigned short);
 vector unsigned short vec_sll (vector unsigned short,
                                vector unsigned char);
+vector bool short vec_sll (vector bool short, vector unsigned int);
+vector bool short vec_sll (vector bool short, vector unsigned short);
+vector bool short vec_sll (vector bool short, vector unsigned char);
+vector pixel vec_sll (vector pixel, vector unsigned int);
+vector pixel vec_sll (vector pixel, vector unsigned short);
+vector pixel vec_sll (vector pixel, vector unsigned char);
 vector signed char vec_sll (vector signed char, vector unsigned int);
 vector signed char vec_sll (vector signed char, vector unsigned short);
 vector signed char vec_sll (vector signed char, vector unsigned char);
@@ -6673,6 +7281,9 @@ vector unsigned char vec_sll (vector unsigned char,
                               vector unsigned short);
 vector unsigned char vec_sll (vector unsigned char,
                               vector unsigned char);
+vector bool char vec_sll (vector bool char, vector unsigned int);
+vector bool char vec_sll (vector bool char, vector unsigned short);
+vector bool char vec_sll (vector bool char, vector unsigned char);
 
 vector float vec_slo (vector float, vector signed char);
 vector float vec_slo (vector float, vector unsigned char);
@@ -6680,51 +7291,80 @@ vector signed int vec_slo (vector signed int, vector signed char);
 vector signed int vec_slo (vector signed int, vector unsigned char);
 vector unsigned int vec_slo (vector unsigned int, vector signed char);
 vector unsigned int vec_slo (vector unsigned int, vector unsigned char);
-
 vector signed short vec_slo (vector signed short, vector signed char);
 vector signed short vec_slo (vector signed short, vector unsigned char);
-
 vector unsigned short vec_slo (vector unsigned short,
                                vector signed char);
 vector unsigned short vec_slo (vector unsigned short,
                                vector unsigned char);
+vector pixel vec_slo (vector pixel, vector signed char);
+vector pixel vec_slo (vector pixel, vector unsigned char);
 vector signed char vec_slo (vector signed char, vector signed char);
 vector signed char vec_slo (vector signed char, vector unsigned char);
 vector unsigned char vec_slo (vector unsigned char, vector signed char);
-
 vector unsigned char vec_slo (vector unsigned char,
                               vector unsigned char);
 
-vector signed char vec_splat (vector signed char, const char);
-vector unsigned char vec_splat (vector unsigned char, const char);
-vector signed short vec_splat (vector signed short, const char);
-vector unsigned short vec_splat (vector unsigned short, const char);
-vector float vec_splat (vector float, const char);
-vector signed int vec_splat (vector signed int, const char);
-vector unsigned int vec_splat (vector unsigned int, const char);
+vector signed char vec_splat (vector signed char, const int);
+vector unsigned char vec_splat (vector unsigned char, const int);
+vector bool char vec_splat (vector bool char, const int);
+vector signed short vec_splat (vector signed short, const int);
+vector unsigned short vec_splat (vector unsigned short, const int);
+vector bool short vec_splat (vector bool short, const int);
+vector pixel vec_splat (vector pixel, const int);
+vector float vec_splat (vector float, const int);
+vector signed int vec_splat (vector signed int, const int);
+vector unsigned int vec_splat (vector unsigned int, const int);
+vector bool int vec_splat (vector bool int, const int);
+
+vector float vec_vspltw (vector float, const int);
+vector signed int vec_vspltw (vector signed int, const int);
+vector unsigned int vec_vspltw (vector unsigned int, const int);
+vector bool int vec_vspltw (vector bool int, const int);
+
+vector bool short vec_vsplth (vector bool short, const int);
+vector signed short vec_vsplth (vector signed short, const int);
+vector unsigned short vec_vsplth (vector unsigned short, const int);
+vector pixel vec_vsplth (vector pixel, const int);
 
-vector signed char vec_splat_s8 (const char);
+vector signed char vec_vspltb (vector signed char, const int);
+vector unsigned char vec_vspltb (vector unsigned char, const int);
+vector bool char vec_vspltb (vector bool char, const int);
 
-vector signed short vec_splat_s16 (const char);
+vector signed char vec_splat_s8 (const int);
 
-vector signed int vec_splat_s32 (const char);
+vector signed short vec_splat_s16 (const int);
 
-vector unsigned char vec_splat_u8 (const char);
+vector signed int vec_splat_s32 (const int);
 
-vector unsigned short vec_splat_u16 (const char);
+vector unsigned char vec_splat_u8 (const int);
 
-vector unsigned int vec_splat_u32 (const char);
+vector unsigned short vec_splat_u16 (const int);
+
+vector unsigned int vec_splat_u32 (const int);
 
 vector signed char vec_sr (vector signed char, vector unsigned char);
 vector unsigned char vec_sr (vector unsigned char,
                              vector unsigned char);
-vector signed short vec_sr (vector signed short, vector unsigned short);
-
+vector signed short vec_sr (vector signed short,
+                            vector unsigned short);
 vector unsigned short vec_sr (vector unsigned short,
                               vector unsigned short);
 vector signed int vec_sr (vector signed int, vector unsigned int);
 vector unsigned int vec_sr (vector unsigned int, vector unsigned int);
 
+vector signed int vec_vsrw (vector signed int, vector unsigned int);
+vector unsigned int vec_vsrw (vector unsigned int, vector unsigned int);
+
+vector signed short vec_vsrh (vector signed short,
+                              vector unsigned short);
+vector unsigned short vec_vsrh (vector unsigned short,
+                                vector unsigned short);
+
+vector signed char vec_vsrb (vector signed char, vector unsigned char);
+vector unsigned char vec_vsrb (vector unsigned char,
+                               vector unsigned char);
+
 vector signed char vec_sra (vector signed char, vector unsigned char);
 vector unsigned char vec_sra (vector unsigned char,
                               vector unsigned char);
@@ -6735,6 +7375,19 @@ vector unsigned short vec_sra (vector unsigned short,
 vector signed int vec_sra (vector signed int, vector unsigned int);
 vector unsigned int vec_sra (vector unsigned int, vector unsigned int);
 
+vector signed int vec_vsraw (vector signed int, vector unsigned int);
+vector unsigned int vec_vsraw (vector unsigned int,
+                               vector unsigned int);
+
+vector signed short vec_vsrah (vector signed short,
+                               vector unsigned short);
+vector unsigned short vec_vsrah (vector unsigned short,
+                                 vector unsigned short);
+
+vector signed char vec_vsrab (vector signed char, vector unsigned char);
+vector unsigned char vec_vsrab (vector unsigned char,
+                                vector unsigned char);
+
 vector signed int vec_srl (vector signed int, vector unsigned int);
 vector signed int vec_srl (vector signed int, vector unsigned short);
 vector signed int vec_srl (vector signed int, vector unsigned char);
@@ -6742,18 +7395,25 @@ vector unsigned int vec_srl (vector unsigned int, vector unsigned int);
 vector unsigned int vec_srl (vector unsigned int,
                              vector unsigned short);
 vector unsigned int vec_srl (vector unsigned int, vector unsigned char);
-
+vector bool int vec_srl (vector bool int, vector unsigned int);
+vector bool int vec_srl (vector bool int, vector unsigned short);
+vector bool int vec_srl (vector bool int, vector unsigned char);
 vector signed short vec_srl (vector signed short, vector unsigned int);
 vector signed short vec_srl (vector signed short,
                              vector unsigned short);
 vector signed short vec_srl (vector signed short, vector unsigned char);
-
 vector unsigned short vec_srl (vector unsigned short,
                                vector unsigned int);
 vector unsigned short vec_srl (vector unsigned short,
                                vector unsigned short);
 vector unsigned short vec_srl (vector unsigned short,
                                vector unsigned char);
+vector bool short vec_srl (vector bool short, vector unsigned int);
+vector bool short vec_srl (vector bool short, vector unsigned short);
+vector bool short vec_srl (vector bool short, vector unsigned char);
+vector pixel vec_srl (vector pixel, vector unsigned int);
+vector pixel vec_srl (vector pixel, vector unsigned short);
+vector pixel vec_srl (vector pixel, vector unsigned char);
 vector signed char vec_srl (vector signed char, vector unsigned int);
 vector signed char vec_srl (vector signed char, vector unsigned short);
 vector signed char vec_srl (vector signed char, vector unsigned char);
@@ -6763,6 +7423,9 @@ vector unsigned char vec_srl (vector unsigned char,
                               vector unsigned short);
 vector unsigned char vec_srl (vector unsigned char,
                               vector unsigned char);
+vector bool char vec_srl (vector bool char, vector unsigned int);
+vector bool char vec_srl (vector bool char, vector unsigned short);
+vector bool char vec_srl (vector bool char, vector unsigned char);
 
 vector float vec_sro (vector float, vector signed char);
 vector float vec_sro (vector float, vector unsigned char);
@@ -6770,115 +7433,236 @@ vector signed int vec_sro (vector signed int, vector signed char);
 vector signed int vec_sro (vector signed int, vector unsigned char);
 vector unsigned int vec_sro (vector unsigned int, vector signed char);
 vector unsigned int vec_sro (vector unsigned int, vector unsigned char);
-
 vector signed short vec_sro (vector signed short, vector signed char);
 vector signed short vec_sro (vector signed short, vector unsigned char);
-
 vector unsigned short vec_sro (vector unsigned short,
                                vector signed char);
 vector unsigned short vec_sro (vector unsigned short,
                                vector unsigned char);
+vector pixel vec_sro (vector pixel, vector signed char);
+vector pixel vec_sro (vector pixel, vector unsigned char);
 vector signed char vec_sro (vector signed char, vector signed char);
 vector signed char vec_sro (vector signed char, vector unsigned char);
 vector unsigned char vec_sro (vector unsigned char, vector signed char);
-
 vector unsigned char vec_sro (vector unsigned char,
                               vector unsigned char);
 
-void vec_st (vector float, int, float *);
 void vec_st (vector float, int, vector float *);
+void vec_st (vector float, int, float *);
+void vec_st (vector signed int, int, vector signed int *);
 void vec_st (vector signed int, int, int *);
-void vec_st (vector signed int, int, unsigned int *);
-void vec_st (vector unsigned int, int, unsigned int *);
 void vec_st (vector unsigned int, int, vector unsigned int *);
-void vec_st (vector signed short, int, short *);
-void vec_st (vector signed short, int, vector unsigned short *);
+void vec_st (vector unsigned int, int, unsigned int *);
+void vec_st (vector bool int, int, vector bool int *);
+void vec_st (vector bool int, int, unsigned int *);
+void vec_st (vector bool int, int, int *);
 void vec_st (vector signed short, int, vector signed short *);
-void vec_st (vector unsigned short, int, unsigned short *);
+void vec_st (vector signed short, int, short *);
 void vec_st (vector unsigned short, int, vector unsigned short *);
-void vec_st (vector signed char, int, signed char *);
-void vec_st (vector signed char, int, unsigned char *);
+void vec_st (vector unsigned short, int, unsigned short *);
+void vec_st (vector bool short, int, vector bool short *);
+void vec_st (vector bool short, int, unsigned short *);
+void vec_st (vector pixel, int, vector pixel *);
+void vec_st (vector pixel, int, unsigned short *);
+void vec_st (vector pixel, int, short *);
+void vec_st (vector bool short, int, short *);
 void vec_st (vector signed char, int, vector signed char *);
-void vec_st (vector unsigned char, int, unsigned char *);
+void vec_st (vector signed char, int, signed char *);
 void vec_st (vector unsigned char, int, vector unsigned char *);
+void vec_st (vector unsigned char, int, unsigned char *);
+void vec_st (vector bool char, int, vector bool char *);
+void vec_st (vector bool char, int, unsigned char *);
+void vec_st (vector bool char, int, signed char *);
 
-void vec_ste (vector signed char, int, unsigned char *);
 void vec_ste (vector signed char, int, signed char *);
 void vec_ste (vector unsigned char, int, unsigned char *);
+void vec_ste (vector bool char, int, signed char *);
+void vec_ste (vector bool char, int, unsigned char *);
 void vec_ste (vector signed short, int, short *);
-void vec_ste (vector signed short, int, unsigned short *);
-void vec_ste (vector unsigned short, int, void *);
-void vec_ste (vector signed int, int, unsigned int *);
+void vec_ste (vector unsigned short, int, unsigned short *);
+void vec_ste (vector bool short, int, short *);
+void vec_ste (vector bool short, int, unsigned short *);
+void vec_ste (vector pixel, int, short *);
+void vec_ste (vector pixel, int, unsigned short *);
+void vec_ste (vector float, int, float *);
 void vec_ste (vector signed int, int, int *);
 void vec_ste (vector unsigned int, int, unsigned int *);
-void vec_ste (vector float, int, float *);
+void vec_ste (vector bool int, int, int *);
+void vec_ste (vector bool int, int, unsigned int *);
+
+void vec_stvewx (vector float, int, float *);
+void vec_stvewx (vector signed int, int, int *);
+void vec_stvewx (vector unsigned int, int, unsigned int *);
+void vec_stvewx (vector bool int, int, int *);
+void vec_stvewx (vector bool int, int, unsigned int *);
+
+void vec_stvehx (vector signed short, int, short *);
+void vec_stvehx (vector unsigned short, int, unsigned short *);
+void vec_stvehx (vector bool short, int, short *);
+void vec_stvehx (vector bool short, int, unsigned short *);
+void vec_stvehx (vector pixel, int, short *);
+void vec_stvehx (vector pixel, int, unsigned short *);
+
+void vec_stvebx (vector signed char, int, signed char *);
+void vec_stvebx (vector unsigned char, int, unsigned char *);
+void vec_stvebx (vector bool char, int, signed char *);
+void vec_stvebx (vector bool char, int, unsigned char *);
 
 void vec_stl (vector float, int, vector float *);
 void vec_stl (vector float, int, float *);
 void vec_stl (vector signed int, int, vector signed int *);
 void vec_stl (vector signed int, int, int *);
-void vec_stl (vector signed int, int, unsigned int *);
 void vec_stl (vector unsigned int, int, vector unsigned int *);
 void vec_stl (vector unsigned int, int, unsigned int *);
-void vec_stl (vector signed short, int, short *);
-void vec_stl (vector signed short, int, unsigned short *);
+void vec_stl (vector bool int, int, vector bool int *);
+void vec_stl (vector bool int, int, unsigned int *);
+void vec_stl (vector bool int, int, int *);
 void vec_stl (vector signed short, int, vector signed short *);
+void vec_stl (vector signed short, int, short *);
+void vec_stl (vector unsigned short, int, vector unsigned short *);
 void vec_stl (vector unsigned short, int, unsigned short *);
-void vec_stl (vector unsigned short, int, vector signed short *);
-void vec_stl (vector signed char, int, signed char *);
-void vec_stl (vector signed char, int, unsigned char *);
+void vec_stl (vector bool short, int, vector bool short *);
+void vec_stl (vector bool short, int, unsigned short *);
+void vec_stl (vector bool short, int, short *);
+void vec_stl (vector pixel, int, vector pixel *);
+void vec_stl (vector pixel, int, unsigned short *);
+void vec_stl (vector pixel, int, short *);
 void vec_stl (vector signed char, int, vector signed char *);
-void vec_stl (vector unsigned char, int, unsigned char *);
+void vec_stl (vector signed char, int, signed char *);
 void vec_stl (vector unsigned char, int, vector unsigned char *);
+void vec_stl (vector unsigned char, int, unsigned char *);
+void vec_stl (vector bool char, int, vector bool char *);
+void vec_stl (vector bool char, int, unsigned char *);
+void vec_stl (vector bool char, int, signed char *);
 
+vector signed char vec_sub (vector bool char, vector signed char);
+vector signed char vec_sub (vector signed char, vector bool char);
 vector signed char vec_sub (vector signed char, vector signed char);
-vector unsigned char vec_sub (vector signed char, vector unsigned char);
-
-vector unsigned char vec_sub (vector unsigned char, vector signed char);
-
+vector unsigned char vec_sub (vector bool char, vector unsigned char);
+vector unsigned char vec_sub (vector unsigned char, vector bool char);
 vector unsigned char vec_sub (vector unsigned char,
                               vector unsigned char);
+vector signed short vec_sub (vector bool short, vector signed short);
+vector signed short vec_sub (vector signed short, vector bool short);
 vector signed short vec_sub (vector signed short, vector signed short);
-vector unsigned short vec_sub (vector signed short,
+vector unsigned short vec_sub (vector bool short,
                                vector unsigned short);
 vector unsigned short vec_sub (vector unsigned short,
-                               vector signed short);
+                               vector bool short);
 vector unsigned short vec_sub (vector unsigned short,
                                vector unsigned short);
+vector signed int vec_sub (vector bool int, vector signed int);
+vector signed int vec_sub (vector signed int, vector bool int);
 vector signed int vec_sub (vector signed int, vector signed int);
-vector unsigned int vec_sub (vector signed int, vector unsigned int);
-vector unsigned int vec_sub (vector unsigned int, vector signed int);
+vector unsigned int vec_sub (vector bool int, vector unsigned int);
+vector unsigned int vec_sub (vector unsigned int, vector bool int);
 vector unsigned int vec_sub (vector unsigned int, vector unsigned int);
 vector float vec_sub (vector float, vector float);
 
+vector float vec_vsubfp (vector float, vector float);
+
+vector signed int vec_vsubuwm (vector bool int, vector signed int);
+vector signed int vec_vsubuwm (vector signed int, vector bool int);
+vector signed int vec_vsubuwm (vector signed int, vector signed int);
+vector unsigned int vec_vsubuwm (vector bool int, vector unsigned int);
+vector unsigned int vec_vsubuwm (vector unsigned int, vector bool int);
+vector unsigned int vec_vsubuwm (vector unsigned int,
+                                 vector unsigned int);
+
+vector signed short vec_vsubuhm (vector bool short,
+                                 vector signed short);
+vector signed short vec_vsubuhm (vector signed short,
+                                 vector bool short);
+vector signed short vec_vsubuhm (vector signed short,
+                                 vector signed short);
+vector unsigned short vec_vsubuhm (vector bool short,
+                                   vector unsigned short);
+vector unsigned short vec_vsubuhm (vector unsigned short,
+                                   vector bool short);
+vector unsigned short vec_vsubuhm (vector unsigned short,
+                                   vector unsigned short);
+
+vector signed char vec_vsububm (vector bool char, vector signed char);
+vector signed char vec_vsububm (vector signed char, vector bool char);
+vector signed char vec_vsububm (vector signed char, vector signed char);
+vector unsigned char vec_vsububm (vector bool char,
+                                  vector unsigned char);
+vector unsigned char vec_vsububm (vector unsigned char,
+                                  vector bool char);
+vector unsigned char vec_vsububm (vector unsigned char,
+                                  vector unsigned char);
+
 vector unsigned int vec_subc (vector unsigned int, vector unsigned int);
 
-vector unsigned char vec_subs (vector signed char,
-                               vector unsigned char);
-vector unsigned char vec_subs (vector unsigned char,
-                               vector signed char);
+vector unsigned char vec_subs (vector bool char, vector unsigned char);
+vector unsigned char vec_subs (vector unsigned char, vector bool char);
 vector unsigned char vec_subs (vector unsigned char,
                                vector unsigned char);
+vector signed char vec_subs (vector bool char, vector signed char);
+vector signed char vec_subs (vector signed char, vector bool char);
 vector signed char vec_subs (vector signed char, vector signed char);
-vector unsigned short vec_subs (vector signed short,
+vector unsigned short vec_subs (vector bool short,
                                 vector unsigned short);
 vector unsigned short vec_subs (vector unsigned short,
-                                vector signed short);
+                                vector bool short);
 vector unsigned short vec_subs (vector unsigned short,
                                 vector unsigned short);
+vector signed short vec_subs (vector bool short, vector signed short);
+vector signed short vec_subs (vector signed short, vector bool short);
 vector signed short vec_subs (vector signed short, vector signed short);
-
-vector unsigned int vec_subs (vector signed int, vector unsigned int);
-vector unsigned int vec_subs (vector unsigned int, vector signed int);
+vector unsigned int vec_subs (vector bool int, vector unsigned int);
+vector unsigned int vec_subs (vector unsigned int, vector bool int);
 vector unsigned int vec_subs (vector unsigned int, vector unsigned int);
-
+vector signed int vec_subs (vector bool int, vector signed int);
+vector signed int vec_subs (vector signed int, vector bool int);
 vector signed int vec_subs (vector signed int, vector signed int);
 
+vector signed int vec_vsubsws (vector bool int, vector signed int);
+vector signed int vec_vsubsws (vector signed int, vector bool int);
+vector signed int vec_vsubsws (vector signed int, vector signed int);
+
+vector unsigned int vec_vsubuws (vector bool int, vector unsigned int);
+vector unsigned int vec_vsubuws (vector unsigned int, vector bool int);
+vector unsigned int vec_vsubuws (vector unsigned int,
+                                 vector unsigned int);
+
+vector signed short vec_vsubshs (vector bool short,
+                                 vector signed short);
+vector signed short vec_vsubshs (vector signed short,
+                                 vector bool short);
+vector signed short vec_vsubshs (vector signed short,
+                                 vector signed short);
+
+vector unsigned short vec_vsubuhs (vector bool short,
+                                   vector unsigned short);
+vector unsigned short vec_vsubuhs (vector unsigned short,
+                                   vector bool short);
+vector unsigned short vec_vsubuhs (vector unsigned short,
+                                   vector unsigned short);
+
+vector signed char vec_vsubsbs (vector bool char, vector signed char);
+vector signed char vec_vsubsbs (vector signed char, vector bool char);
+vector signed char vec_vsubsbs (vector signed char, vector signed char);
+
+vector unsigned char vec_vsububs (vector bool char,
+                                  vector unsigned char);
+vector unsigned char vec_vsububs (vector unsigned char,
+                                  vector bool char);
+vector unsigned char vec_vsububs (vector unsigned char,
+                                  vector unsigned char);
+
 vector unsigned int vec_sum4s (vector unsigned char,
                                vector unsigned int);
 vector signed int vec_sum4s (vector signed char, vector signed int);
 vector signed int vec_sum4s (vector signed short, vector signed int);
 
+vector signed int vec_vsum4shs (vector signed short, vector signed int);
+
+vector signed int vec_vsum4sbs (vector signed char, vector signed int);
+
+vector unsigned int vec_vsum4ubs (vector unsigned char,
+                                  vector unsigned int);
+
 vector signed int vec_sum2s (vector signed int, vector signed int);
 
 vector signed int vec_sums (vector signed int, vector signed int);
@@ -6886,326 +7670,345 @@ vector signed int vec_sums (vector signed int, vector signed int);
 vector float vec_trunc (vector float);
 
 vector signed short vec_unpackh (vector signed char);
-vector unsigned int vec_unpackh (vector signed short);
+vector bool short vec_unpackh (vector bool char);
 vector signed int vec_unpackh (vector signed short);
+vector bool int vec_unpackh (vector bool short);
+vector unsigned int vec_unpackh (vector pixel);
+
+vector bool int vec_vupkhsh (vector bool short);
+vector signed int vec_vupkhsh (vector signed short);
+
+vector unsigned int vec_vupkhpx (vector pixel);
+
+vector bool short vec_vupkhsb (vector bool char);
+vector signed short vec_vupkhsb (vector signed char);
 
 vector signed short vec_unpackl (vector signed char);
-vector unsigned int vec_unpackl (vector signed short);
+vector bool short vec_unpackl (vector bool char);
+vector unsigned int vec_unpackl (vector pixel);
 vector signed int vec_unpackl (vector signed short);
+vector bool int vec_unpackl (vector bool short);
+
+vector unsigned int vec_vupklpx (vector pixel);
+
+vector bool int vec_vupklsh (vector bool short);
+vector signed int vec_vupklsh (vector signed short);
+
+vector bool short vec_vupklsb (vector bool char);
+vector signed short vec_vupklsb (vector signed char);
 
 vector float vec_xor (vector float, vector float);
-vector float vec_xor (vector float, vector signed int);
-vector float vec_xor (vector signed int, vector float);
+vector float vec_xor (vector float, vector bool int);
+vector float vec_xor (vector bool int, vector float);
+vector bool int vec_xor (vector bool int, vector bool int);
+vector signed int vec_xor (vector bool int, vector signed int);
+vector signed int vec_xor (vector signed int, vector bool int);
 vector signed int vec_xor (vector signed int, vector signed int);
-vector unsigned int vec_xor (vector signed int, vector unsigned int);
-vector unsigned int vec_xor (vector unsigned int, vector signed int);
+vector unsigned int vec_xor (vector bool int, vector unsigned int);
+vector unsigned int vec_xor (vector unsigned int, vector bool int);
 vector unsigned int vec_xor (vector unsigned int, vector unsigned int);
+vector bool short vec_xor (vector bool short, vector bool short);
+vector signed short vec_xor (vector bool short, vector signed short);
+vector signed short vec_xor (vector signed short, vector bool short);
 vector signed short vec_xor (vector signed short, vector signed short);
-vector unsigned short vec_xor (vector signed short,
+vector unsigned short vec_xor (vector bool short,
                                vector unsigned short);
 vector unsigned short vec_xor (vector unsigned short,
-                               vector signed short);
+                               vector bool short);
 vector unsigned short vec_xor (vector unsigned short,
                                vector unsigned short);
+vector signed char vec_xor (vector bool char, vector signed char);
+vector bool char vec_xor (vector bool char, vector bool char);
+vector signed char vec_xor (vector signed char, vector bool char);
 vector signed char vec_xor (vector signed char, vector signed char);
-vector unsigned char vec_xor (vector signed char, vector unsigned char);
-
-vector unsigned char vec_xor (vector unsigned char, vector signed char);
-
+vector unsigned char vec_xor (vector bool char, vector unsigned char);
+vector unsigned char vec_xor (vector unsigned char, vector bool char);
 vector unsigned char vec_xor (vector unsigned char,
                               vector unsigned char);
 
-vector signed int vec_all_eq (vector signed char, vector unsigned char);
-
-vector signed int vec_all_eq (vector signed char, vector signed char);
-vector signed int vec_all_eq (vector unsigned char, vector signed char);
-
-vector signed int vec_all_eq (vector unsigned char,
-                              vector unsigned char);
-vector signed int vec_all_eq (vector signed short,
-                              vector unsigned short);
-vector signed int vec_all_eq (vector signed short, vector signed short);
-
-vector signed int vec_all_eq (vector unsigned short,
-                              vector signed short);
-vector signed int vec_all_eq (vector unsigned short,
-                              vector unsigned short);
-vector signed int vec_all_eq (vector signed int, vector unsigned int);
-vector signed int vec_all_eq (vector signed int, vector signed int);
-vector signed int vec_all_eq (vector unsigned int, vector signed int);
-vector signed int vec_all_eq (vector unsigned int, vector unsigned int);
-
-vector signed int vec_all_eq (vector float, vector float);
-
-vector signed int vec_all_ge (vector signed char, vector unsigned char);
-
-vector signed int vec_all_ge (vector unsigned char, vector signed char);
-
-vector signed int vec_all_ge (vector unsigned char,
-                              vector unsigned char);
-vector signed int vec_all_ge (vector signed char, vector signed char);
-vector signed int vec_all_ge (vector signed short,
-                              vector unsigned short);
-vector signed int vec_all_ge (vector unsigned short,
-                              vector signed short);
-vector signed int vec_all_ge (vector unsigned short,
-                              vector unsigned short);
-vector signed int vec_all_ge (vector signed short, vector signed short);
-
-vector signed int vec_all_ge (vector signed int, vector unsigned int);
-vector signed int vec_all_ge (vector unsigned int, vector signed int);
-vector signed int vec_all_ge (vector unsigned int, vector unsigned int);
-
-vector signed int vec_all_ge (vector signed int, vector signed int);
-vector signed int vec_all_ge (vector float, vector float);
-
-vector signed int vec_all_gt (vector signed char, vector unsigned char);
-
-vector signed int vec_all_gt (vector unsigned char, vector signed char);
-
-vector signed int vec_all_gt (vector unsigned char,
-                              vector unsigned char);
-vector signed int vec_all_gt (vector signed char, vector signed char);
-vector signed int vec_all_gt (vector signed short,
-                              vector unsigned short);
-vector signed int vec_all_gt (vector unsigned short,
-                              vector signed short);
-vector signed int vec_all_gt (vector unsigned short,
-                              vector unsigned short);
-vector signed int vec_all_gt (vector signed short, vector signed short);
-
-vector signed int vec_all_gt (vector signed int, vector unsigned int);
-vector signed int vec_all_gt (vector unsigned int, vector signed int);
-vector signed int vec_all_gt (vector unsigned int, vector unsigned int);
-
-vector signed int vec_all_gt (vector signed int, vector signed int);
-vector signed int vec_all_gt (vector float, vector float);
-
-vector signed int vec_all_in (vector float, vector float);
-
-vector signed int vec_all_le (vector signed char, vector unsigned char);
-
-vector signed int vec_all_le (vector unsigned char, vector signed char);
-
-vector signed int vec_all_le (vector unsigned char,
-                              vector unsigned char);
-vector signed int vec_all_le (vector signed char, vector signed char);
-vector signed int vec_all_le (vector signed short,
-                              vector unsigned short);
-vector signed int vec_all_le (vector unsigned short,
-                              vector signed short);
-vector signed int vec_all_le (vector unsigned short,
-                              vector unsigned short);
-vector signed int vec_all_le (vector signed short, vector signed short);
-
-vector signed int vec_all_le (vector signed int, vector unsigned int);
-vector signed int vec_all_le (vector unsigned int, vector signed int);
-vector signed int vec_all_le (vector unsigned int, vector unsigned int);
-
-vector signed int vec_all_le (vector signed int, vector signed int);
-vector signed int vec_all_le (vector float, vector float);
-
-vector signed int vec_all_lt (vector signed char, vector unsigned char);
-
-vector signed int vec_all_lt (vector unsigned char, vector signed char);
-
-vector signed int vec_all_lt (vector unsigned char,
-                              vector unsigned char);
-vector signed int vec_all_lt (vector signed char, vector signed char);
-vector signed int vec_all_lt (vector signed short,
-                              vector unsigned short);
-vector signed int vec_all_lt (vector unsigned short,
-                              vector signed short);
-vector signed int vec_all_lt (vector unsigned short,
-                              vector unsigned short);
-vector signed int vec_all_lt (vector signed short, vector signed short);
-
-vector signed int vec_all_lt (vector signed int, vector unsigned int);
-vector signed int vec_all_lt (vector unsigned int, vector signed int);
-vector signed int vec_all_lt (vector unsigned int, vector unsigned int);
-
-vector signed int vec_all_lt (vector signed int, vector signed int);
-vector signed int vec_all_lt (vector float, vector float);
-
-vector signed int vec_all_nan (vector float);
-
-vector signed int vec_all_ne (vector signed char, vector unsigned char);
-
-vector signed int vec_all_ne (vector signed char, vector signed char);
-vector signed int vec_all_ne (vector unsigned char, vector signed char);
-
-vector signed int vec_all_ne (vector unsigned char,
-                              vector unsigned char);
-vector signed int vec_all_ne (vector signed short,
-                              vector unsigned short);
-vector signed int vec_all_ne (vector signed short, vector signed short);
-
-vector signed int vec_all_ne (vector unsigned short,
-                              vector signed short);
-vector signed int vec_all_ne (vector unsigned short,
-                              vector unsigned short);
-vector signed int vec_all_ne (vector signed int, vector unsigned int);
-vector signed int vec_all_ne (vector signed int, vector signed int);
-vector signed int vec_all_ne (vector unsigned int, vector signed int);
-vector signed int vec_all_ne (vector unsigned int, vector unsigned int);
-
-vector signed int vec_all_ne (vector float, vector float);
-
-vector signed int vec_all_nge (vector float, vector float);
-
-vector signed int vec_all_ngt (vector float, vector float);
-
-vector signed int vec_all_nle (vector float, vector float);
-
-vector signed int vec_all_nlt (vector float, vector float);
-
-vector signed int vec_all_numeric (vector float);
-
-vector signed int vec_any_eq (vector signed char, vector unsigned char);
-
-vector signed int vec_any_eq (vector signed char, vector signed char);
-vector signed int vec_any_eq (vector unsigned char, vector signed char);
-
-vector signed int vec_any_eq (vector unsigned char,
-                              vector unsigned char);
-vector signed int vec_any_eq (vector signed short,
-                              vector unsigned short);
-vector signed int vec_any_eq (vector signed short, vector signed short);
-
-vector signed int vec_any_eq (vector unsigned short,
-                              vector signed short);
-vector signed int vec_any_eq (vector unsigned short,
-                              vector unsigned short);
-vector signed int vec_any_eq (vector signed int, vector unsigned int);
-vector signed int vec_any_eq (vector signed int, vector signed int);
-vector signed int vec_any_eq (vector unsigned int, vector signed int);
-vector signed int vec_any_eq (vector unsigned int, vector unsigned int);
-
-vector signed int vec_any_eq (vector float, vector float);
-
-vector signed int vec_any_ge (vector signed char, vector unsigned char);
-
-vector signed int vec_any_ge (vector unsigned char, vector signed char);
-
-vector signed int vec_any_ge (vector unsigned char,
-                              vector unsigned char);
-vector signed int vec_any_ge (vector signed char, vector signed char);
-vector signed int vec_any_ge (vector signed short,
-                              vector unsigned short);
-vector signed int vec_any_ge (vector unsigned short,
-                              vector signed short);
-vector signed int vec_any_ge (vector unsigned short,
-                              vector unsigned short);
-vector signed int vec_any_ge (vector signed short, vector signed short);
-
-vector signed int vec_any_ge (vector signed int, vector unsigned int);
-vector signed int vec_any_ge (vector unsigned int, vector signed int);
-vector signed int vec_any_ge (vector unsigned int, vector unsigned int);
-
-vector signed int vec_any_ge (vector signed int, vector signed int);
-vector signed int vec_any_ge (vector float, vector float);
-
-vector signed int vec_any_gt (vector signed char, vector unsigned char);
-
-vector signed int vec_any_gt (vector unsigned char, vector signed char);
-
-vector signed int vec_any_gt (vector unsigned char,
-                              vector unsigned char);
-vector signed int vec_any_gt (vector signed char, vector signed char);
-vector signed int vec_any_gt (vector signed short,
-                              vector unsigned short);
-vector signed int vec_any_gt (vector unsigned short,
-                              vector signed short);
-vector signed int vec_any_gt (vector unsigned short,
-                              vector unsigned short);
-vector signed int vec_any_gt (vector signed short, vector signed short);
-
-vector signed int vec_any_gt (vector signed int, vector unsigned int);
-vector signed int vec_any_gt (vector unsigned int, vector signed int);
-vector signed int vec_any_gt (vector unsigned int, vector unsigned int);
-
-vector signed int vec_any_gt (vector signed int, vector signed int);
-vector signed int vec_any_gt (vector float, vector float);
-
-vector signed int vec_any_le (vector signed char, vector unsigned char);
-
-vector signed int vec_any_le (vector unsigned char, vector signed char);
-
-vector signed int vec_any_le (vector unsigned char,
-                              vector unsigned char);
-vector signed int vec_any_le (vector signed char, vector signed char);
-vector signed int vec_any_le (vector signed short,
-                              vector unsigned short);
-vector signed int vec_any_le (vector unsigned short,
-                              vector signed short);
-vector signed int vec_any_le (vector unsigned short,
-                              vector unsigned short);
-vector signed int vec_any_le (vector signed short, vector signed short);
-
-vector signed int vec_any_le (vector signed int, vector unsigned int);
-vector signed int vec_any_le (vector unsigned int, vector signed int);
-vector signed int vec_any_le (vector unsigned int, vector unsigned int);
-
-vector signed int vec_any_le (vector signed int, vector signed int);
-vector signed int vec_any_le (vector float, vector float);
-
-vector signed int vec_any_lt (vector signed char, vector unsigned char);
-
-vector signed int vec_any_lt (vector unsigned char, vector signed char);
-
-vector signed int vec_any_lt (vector unsigned char,
-                              vector unsigned char);
-vector signed int vec_any_lt (vector signed char, vector signed char);
-vector signed int vec_any_lt (vector signed short,
-                              vector unsigned short);
-vector signed int vec_any_lt (vector unsigned short,
-                              vector signed short);
-vector signed int vec_any_lt (vector unsigned short,
-                              vector unsigned short);
-vector signed int vec_any_lt (vector signed short, vector signed short);
-
-vector signed int vec_any_lt (vector signed int, vector unsigned int);
-vector signed int vec_any_lt (vector unsigned int, vector signed int);
-vector signed int vec_any_lt (vector unsigned int, vector unsigned int);
-
-vector signed int vec_any_lt (vector signed int, vector signed int);
-vector signed int vec_any_lt (vector float, vector float);
-
-vector signed int vec_any_nan (vector float);
-
-vector signed int vec_any_ne (vector signed char, vector unsigned char);
-
-vector signed int vec_any_ne (vector signed char, vector signed char);
-vector signed int vec_any_ne (vector unsigned char, vector signed char);
-
-vector signed int vec_any_ne (vector unsigned char,
-                              vector unsigned char);
-vector signed int vec_any_ne (vector signed short,
-                              vector unsigned short);
-vector signed int vec_any_ne (vector signed short, vector signed short);
-
-vector signed int vec_any_ne (vector unsigned short,
-                              vector signed short);
-vector signed int vec_any_ne (vector unsigned short,
-                              vector unsigned short);
-vector signed int vec_any_ne (vector signed int, vector unsigned int);
-vector signed int vec_any_ne (vector signed int, vector signed int);
-vector signed int vec_any_ne (vector unsigned int, vector signed int);
-vector signed int vec_any_ne (vector unsigned int, vector unsigned int);
-
-vector signed int vec_any_ne (vector float, vector float);
-
-vector signed int vec_any_nge (vector float, vector float);
-
-vector signed int vec_any_ngt (vector float, vector float);
-
-vector signed int vec_any_nle (vector float, vector float);
-
-vector signed int vec_any_nlt (vector float, vector float);
-
-vector signed int vec_any_numeric (vector float);
-
-vector signed int vec_any_out (vector float, vector float);
+int vec_all_eq (vector signed char, vector bool char);
+int vec_all_eq (vector signed char, vector signed char);
+int vec_all_eq (vector unsigned char, vector bool char);
+int vec_all_eq (vector unsigned char, vector unsigned char);
+int vec_all_eq (vector bool char, vector bool char);
+int vec_all_eq (vector bool char, vector unsigned char);
+int vec_all_eq (vector bool char, vector signed char);
+int vec_all_eq (vector signed short, vector bool short);
+int vec_all_eq (vector signed short, vector signed short);
+int vec_all_eq (vector unsigned short, vector bool short);
+int vec_all_eq (vector unsigned short, vector unsigned short);
+int vec_all_eq (vector bool short, vector bool short);
+int vec_all_eq (vector bool short, vector unsigned short);
+int vec_all_eq (vector bool short, vector signed short);
+int vec_all_eq (vector pixel, vector pixel);
+int vec_all_eq (vector signed int, vector bool int);
+int vec_all_eq (vector signed int, vector signed int);
+int vec_all_eq (vector unsigned int, vector bool int);
+int vec_all_eq (vector unsigned int, vector unsigned int);
+int vec_all_eq (vector bool int, vector bool int);
+int vec_all_eq (vector bool int, vector unsigned int);
+int vec_all_eq (vector bool int, vector signed int);
+int vec_all_eq (vector float, vector float);
+
+int vec_all_ge (vector bool char, vector unsigned char);
+int vec_all_ge (vector unsigned char, vector bool char);
+int vec_all_ge (vector unsigned char, vector unsigned char);
+int vec_all_ge (vector bool char, vector signed char);
+int vec_all_ge (vector signed char, vector bool char);
+int vec_all_ge (vector signed char, vector signed char);
+int vec_all_ge (vector bool short, vector unsigned short);
+int vec_all_ge (vector unsigned short, vector bool short);
+int vec_all_ge (vector unsigned short, vector unsigned short);
+int vec_all_ge (vector signed short, vector signed short);
+int vec_all_ge (vector bool short, vector signed short);
+int vec_all_ge (vector signed short, vector bool short);
+int vec_all_ge (vector bool int, vector unsigned int);
+int vec_all_ge (vector unsigned int, vector bool int);
+int vec_all_ge (vector unsigned int, vector unsigned int);
+int vec_all_ge (vector bool int, vector signed int);
+int vec_all_ge (vector signed int, vector bool int);
+int vec_all_ge (vector signed int, vector signed int);
+int vec_all_ge (vector float, vector float);
+
+int vec_all_gt (vector bool char, vector unsigned char);
+int vec_all_gt (vector unsigned char, vector bool char);
+int vec_all_gt (vector unsigned char, vector unsigned char);
+int vec_all_gt (vector bool char, vector signed char);
+int vec_all_gt (vector signed char, vector bool char);
+int vec_all_gt (vector signed char, vector signed char);
+int vec_all_gt (vector bool short, vector unsigned short);
+int vec_all_gt (vector unsigned short, vector bool short);
+int vec_all_gt (vector unsigned short, vector unsigned short);
+int vec_all_gt (vector bool short, vector signed short);
+int vec_all_gt (vector signed short, vector bool short);
+int vec_all_gt (vector signed short, vector signed short);
+int vec_all_gt (vector bool int, vector unsigned int);
+int vec_all_gt (vector unsigned int, vector bool int);
+int vec_all_gt (vector unsigned int, vector unsigned int);
+int vec_all_gt (vector bool int, vector signed int);
+int vec_all_gt (vector signed int, vector bool int);
+int vec_all_gt (vector signed int, vector signed int);
+int vec_all_gt (vector float, vector float);
+
+int vec_all_in (vector float, vector float);
+
+int vec_all_le (vector bool char, vector unsigned char);
+int vec_all_le (vector unsigned char, vector bool char);
+int vec_all_le (vector unsigned char, vector unsigned char);
+int vec_all_le (vector bool char, vector signed char);
+int vec_all_le (vector signed char, vector bool char);
+int vec_all_le (vector signed char, vector signed char);
+int vec_all_le (vector bool short, vector unsigned short);
+int vec_all_le (vector unsigned short, vector bool short);
+int vec_all_le (vector unsigned short, vector unsigned short);
+int vec_all_le (vector bool short, vector signed short);
+int vec_all_le (vector signed short, vector bool short);
+int vec_all_le (vector signed short, vector signed short);
+int vec_all_le (vector bool int, vector unsigned int);
+int vec_all_le (vector unsigned int, vector bool int);
+int vec_all_le (vector unsigned int, vector unsigned int);
+int vec_all_le (vector bool int, vector signed int);
+int vec_all_le (vector signed int, vector bool int);
+int vec_all_le (vector signed int, vector signed int);
+int vec_all_le (vector float, vector float);
+
+int vec_all_lt (vector bool char, vector unsigned char);
+int vec_all_lt (vector unsigned char, vector bool char);
+int vec_all_lt (vector unsigned char, vector unsigned char);
+int vec_all_lt (vector bool char, vector signed char);
+int vec_all_lt (vector signed char, vector bool char);
+int vec_all_lt (vector signed char, vector signed char);
+int vec_all_lt (vector bool short, vector unsigned short);
+int vec_all_lt (vector unsigned short, vector bool short);
+int vec_all_lt (vector unsigned short, vector unsigned short);
+int vec_all_lt (vector bool short, vector signed short);
+int vec_all_lt (vector signed short, vector bool short);
+int vec_all_lt (vector signed short, vector signed short);
+int vec_all_lt (vector bool int, vector unsigned int);
+int vec_all_lt (vector unsigned int, vector bool int);
+int vec_all_lt (vector unsigned int, vector unsigned int);
+int vec_all_lt (vector bool int, vector signed int);
+int vec_all_lt (vector signed int, vector bool int);
+int vec_all_lt (vector signed int, vector signed int);
+int vec_all_lt (vector float, vector float);
+
+int vec_all_nan (vector float);
+
+int vec_all_ne (vector signed char, vector bool char);
+int vec_all_ne (vector signed char, vector signed char);
+int vec_all_ne (vector unsigned char, vector bool char);
+int vec_all_ne (vector unsigned char, vector unsigned char);
+int vec_all_ne (vector bool char, vector bool char);
+int vec_all_ne (vector bool char, vector unsigned char);
+int vec_all_ne (vector bool char, vector signed char);
+int vec_all_ne (vector signed short, vector bool short);
+int vec_all_ne (vector signed short, vector signed short);
+int vec_all_ne (vector unsigned short, vector bool short);
+int vec_all_ne (vector unsigned short, vector unsigned short);
+int vec_all_ne (vector bool short, vector bool short);
+int vec_all_ne (vector bool short, vector unsigned short);
+int vec_all_ne (vector bool short, vector signed short);
+int vec_all_ne (vector pixel, vector pixel);
+int vec_all_ne (vector signed int, vector bool int);
+int vec_all_ne (vector signed int, vector signed int);
+int vec_all_ne (vector unsigned int, vector bool int);
+int vec_all_ne (vector unsigned int, vector unsigned int);
+int vec_all_ne (vector bool int, vector bool int);
+int vec_all_ne (vector bool int, vector unsigned int);
+int vec_all_ne (vector bool int, vector signed int);
+int vec_all_ne (vector float, vector float);
+
+int vec_all_nge (vector float, vector float);
+
+int vec_all_ngt (vector float, vector float);
+
+int vec_all_nle (vector float, vector float);
+
+int vec_all_nlt (vector float, vector float);
+
+int vec_all_numeric (vector float);
+
+int vec_any_eq (vector signed char, vector bool char);
+int vec_any_eq (vector signed char, vector signed char);
+int vec_any_eq (vector unsigned char, vector bool char);
+int vec_any_eq (vector unsigned char, vector unsigned char);
+int vec_any_eq (vector bool char, vector bool char);
+int vec_any_eq (vector bool char, vector unsigned char);
+int vec_any_eq (vector bool char, vector signed char);
+int vec_any_eq (vector signed short, vector bool short);
+int vec_any_eq (vector signed short, vector signed short);
+int vec_any_eq (vector unsigned short, vector bool short);
+int vec_any_eq (vector unsigned short, vector unsigned short);
+int vec_any_eq (vector bool short, vector bool short);
+int vec_any_eq (vector bool short, vector unsigned short);
+int vec_any_eq (vector bool short, vector signed short);
+int vec_any_eq (vector pixel, vector pixel);
+int vec_any_eq (vector signed int, vector bool int);
+int vec_any_eq (vector signed int, vector signed int);
+int vec_any_eq (vector unsigned int, vector bool int);
+int vec_any_eq (vector unsigned int, vector unsigned int);
+int vec_any_eq (vector bool int, vector bool int);
+int vec_any_eq (vector bool int, vector unsigned int);
+int vec_any_eq (vector bool int, vector signed int);
+int vec_any_eq (vector float, vector float);
+
+int vec_any_ge (vector signed char, vector bool char);
+int vec_any_ge (vector unsigned char, vector bool char);
+int vec_any_ge (vector unsigned char, vector unsigned char);
+int vec_any_ge (vector signed char, vector signed char);
+int vec_any_ge (vector bool char, vector unsigned char);
+int vec_any_ge (vector bool char, vector signed char);
+int vec_any_ge (vector unsigned short, vector bool short);
+int vec_any_ge (vector unsigned short, vector unsigned short);
+int vec_any_ge (vector signed short, vector signed short);
+int vec_any_ge (vector signed short, vector bool short);
+int vec_any_ge (vector bool short, vector unsigned short);
+int vec_any_ge (vector bool short, vector signed short);
+int vec_any_ge (vector signed int, vector bool int);
+int vec_any_ge (vector unsigned int, vector bool int);
+int vec_any_ge (vector unsigned int, vector unsigned int);
+int vec_any_ge (vector signed int, vector signed int);
+int vec_any_ge (vector bool int, vector unsigned int);
+int vec_any_ge (vector bool int, vector signed int);
+int vec_any_ge (vector float, vector float);
+
+int vec_any_gt (vector bool char, vector unsigned char);
+int vec_any_gt (vector unsigned char, vector bool char);
+int vec_any_gt (vector unsigned char, vector unsigned char);
+int vec_any_gt (vector bool char, vector signed char);
+int vec_any_gt (vector signed char, vector bool char);
+int vec_any_gt (vector signed char, vector signed char);
+int vec_any_gt (vector bool short, vector unsigned short);
+int vec_any_gt (vector unsigned short, vector bool short);
+int vec_any_gt (vector unsigned short, vector unsigned short);
+int vec_any_gt (vector bool short, vector signed short);
+int vec_any_gt (vector signed short, vector bool short);
+int vec_any_gt (vector signed short, vector signed short);
+int vec_any_gt (vector bool int, vector unsigned int);
+int vec_any_gt (vector unsigned int, vector bool int);
+int vec_any_gt (vector unsigned int, vector unsigned int);
+int vec_any_gt (vector bool int, vector signed int);
+int vec_any_gt (vector signed int, vector bool int);
+int vec_any_gt (vector signed int, vector signed int);
+int vec_any_gt (vector float, vector float);
+
+int vec_any_le (vector bool char, vector unsigned char);
+int vec_any_le (vector unsigned char, vector bool char);
+int vec_any_le (vector unsigned char, vector unsigned char);
+int vec_any_le (vector bool char, vector signed char);
+int vec_any_le (vector signed char, vector bool char);
+int vec_any_le (vector signed char, vector signed char);
+int vec_any_le (vector bool short, vector unsigned short);
+int vec_any_le (vector unsigned short, vector bool short);
+int vec_any_le (vector unsigned short, vector unsigned short);
+int vec_any_le (vector bool short, vector signed short);
+int vec_any_le (vector signed short, vector bool short);
+int vec_any_le (vector signed short, vector signed short);
+int vec_any_le (vector bool int, vector unsigned int);
+int vec_any_le (vector unsigned int, vector bool int);
+int vec_any_le (vector unsigned int, vector unsigned int);
+int vec_any_le (vector bool int, vector signed int);
+int vec_any_le (vector signed int, vector bool int);
+int vec_any_le (vector signed int, vector signed int);
+int vec_any_le (vector float, vector float);
+
+int vec_any_lt (vector bool char, vector unsigned char);
+int vec_any_lt (vector unsigned char, vector bool char);
+int vec_any_lt (vector unsigned char, vector unsigned char);
+int vec_any_lt (vector bool char, vector signed char);
+int vec_any_lt (vector signed char, vector bool char);
+int vec_any_lt (vector signed char, vector signed char);
+int vec_any_lt (vector bool short, vector unsigned short);
+int vec_any_lt (vector unsigned short, vector bool short);
+int vec_any_lt (vector unsigned short, vector unsigned short);
+int vec_any_lt (vector bool short, vector signed short);
+int vec_any_lt (vector signed short, vector bool short);
+int vec_any_lt (vector signed short, vector signed short);
+int vec_any_lt (vector bool int, vector unsigned int);
+int vec_any_lt (vector unsigned int, vector bool int);
+int vec_any_lt (vector unsigned int, vector unsigned int);
+int vec_any_lt (vector bool int, vector signed int);
+int vec_any_lt (vector signed int, vector bool int);
+int vec_any_lt (vector signed int, vector signed int);
+int vec_any_lt (vector float, vector float);
+
+int vec_any_nan (vector float);
+
+int vec_any_ne (vector signed char, vector bool char);
+int vec_any_ne (vector signed char, vector signed char);
+int vec_any_ne (vector unsigned char, vector bool char);
+int vec_any_ne (vector unsigned char, vector unsigned char);
+int vec_any_ne (vector bool char, vector bool char);
+int vec_any_ne (vector bool char, vector unsigned char);
+int vec_any_ne (vector bool char, vector signed char);
+int vec_any_ne (vector signed short, vector bool short);
+int vec_any_ne (vector signed short, vector signed short);
+int vec_any_ne (vector unsigned short, vector bool short);
+int vec_any_ne (vector unsigned short, vector unsigned short);
+int vec_any_ne (vector bool short, vector bool short);
+int vec_any_ne (vector bool short, vector unsigned short);
+int vec_any_ne (vector bool short, vector signed short);
+int vec_any_ne (vector pixel, vector pixel);
+int vec_any_ne (vector signed int, vector bool int);
+int vec_any_ne (vector signed int, vector signed int);
+int vec_any_ne (vector unsigned int, vector bool int);
+int vec_any_ne (vector unsigned int, vector unsigned int);
+int vec_any_ne (vector bool int, vector bool int);
+int vec_any_ne (vector bool int, vector unsigned int);
+int vec_any_ne (vector bool int, vector signed int);
+int vec_any_ne (vector float, vector float);
+
+int vec_any_nge (vector float, vector float);
+
+int vec_any_ngt (vector float, vector float);
+
+int vec_any_nle (vector float, vector float);
+
+int vec_any_nlt (vector float, vector float);
+
+int vec_any_numeric (vector float);
+
+int vec_any_out (vector float, vector float);
 @end smallexample
 
 @node Pragmas
diff --git a/contrib/gcc/doc/include/gcc-common.texi b/contrib/gcc/doc/include/gcc-common.texi
index 49725ab..b5e8891 100644
--- a/contrib/gcc/doc/include/gcc-common.texi
+++ b/contrib/gcc/doc/include/gcc-common.texi
@@ -4,7 +4,7 @@
 
 @c Common values used in the GCC manuals:
 
-@set version-GCC 3.4.2
+@set version-GCC 3.4.4
 
 @c DEVELOPMENT is set to indicate an in-development version,
 @c as compared to a release version.  When making a release
diff --git a/contrib/gcc/doc/invoke.texi b/contrib/gcc/doc/invoke.texi
index 7e88bd5..3475408 100644
--- a/contrib/gcc/doc/invoke.texi
+++ b/contrib/gcc/doc/invoke.texi
@@ -1,12 +1,12 @@
 @c Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-@c 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+@c 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
 @c This is part of the GCC manual.
 @c For copying conditions, see the file gcc.texi.
 
 @ignore
 @c man begin COPYRIGHT
 Copyright @copyright{} 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
-1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
 
 Permission is granted to copy, distribute and/or modify this document
 under the terms of the GNU Free Documentation License, Version 1.2 or
@@ -188,7 +188,7 @@ in the following sections.
 -Weffc++  -Wno-deprecated @gol
 -Wno-non-template-friend  -Wold-style-cast @gol
 -Woverloaded-virtual  -Wno-pmf-conversions @gol
--Wsign-promo  -Wsynth}
+-Wsign-promo}
 
 @item Objective-C Language Options
 @xref{Objective-C Dialect Options,,Options Controlling Objective-C Dialect}.
@@ -421,7 +421,7 @@ in the following sections.
 -mpowerpc-gfxopt  -mno-powerpc-gfxopt @gol
 -mnew-mnemonics  -mold-mnemonics @gol
 -mfull-toc   -mminimal-toc  -mno-fp-in-toc  -mno-sum-in-toc @gol
--m64  -m32  -mxl-call  -mno-xl-call  -mpe @gol
+-m64  -m32  -mxl-compat  -mno-xl-compat  -mpe @gol
 -malign-power  -malign-natural @gol
 -msoft-float  -mhard-float  -mmultiple  -mno-multiple @gol
 -mstring  -mno-string  -mupdate  -mno-update @gol
@@ -605,8 +605,11 @@ in the following sections.
 -mconstant-gp  -mauto-pic  -minline-float-divide-min-latency @gol
 -minline-float-divide-max-throughput @gol
 -minline-int-divide-min-latency @gol
--minline-int-divide-max-throughput  -mno-dwarf2-asm @gol
--mfixed-range=@var{register-range}}
+-minline-int-divide-max-throughput  @gol
+-minline-sqrt-min-latency -minline-sqrt-max-throughput @gol
+-mno-dwarf2-asm -mearly-stop-bits @gol
+-mfixed-range=@var{register-range} -mtls-size=@var{tls-size} @gol
+-mtune=@var{cpu-type} -mt -pthread -milp32 -mlp64}
 
 @emph{D30V Options}
 @gccoptlist{-mextmem  -mextmemory  -monchip  -mno-asm-optimize @gol
@@ -1701,13 +1704,6 @@ enumerated type to a signed type, over a conversion to an unsigned type of
 the same size.  Previous versions of G++ would try to preserve
 unsignedness, but the standard mandates the current behavior.
 
-@item -Wsynth @r{(C++ only)}
-@opindex Wsynth
-@cindex warning for synthesized methods
-@cindex synthesized methods, warning
-Warn when G++'s synthesis behavior does not match that of cfront.  For
-instance:
-
 @smallexample
 struct A @{
   operator int ();
@@ -4198,8 +4194,8 @@ Enabled at levels @option{-O2}, @option{-O3}.
 @opindex freorder-functions
 Reorder basic blocks in the compiled function in order to reduce number of
 taken branches and improve code locality. This is implemented by using special
-subsections @code{text.hot} for most frequently executed functions and
-@code{text.unlikely} for unlikely executed functions.  Reordering is done by
+subsections @code{.text.hot} for most frequently executed functions and
+@code{.text.unlikely} for unlikely executed functions.  Reordering is done by
 the linker so object file format must support named sections and linker must
 place them in a reasonable way.
 
@@ -4829,6 +4825,12 @@ order to make tracer effective.
 
 Maximum number of basic blocks on path that cse considers.
 
+@item max-last-value-rtl
+
+The maximum size measured as number of RTLs that can be recorded in an
+expression in combiner for a pseudo register as last known value of that
+register.  The default is 10000.
+
 @item ggc-min-expand
 
 GCC uses a garbage collector to manage its own memory allocation.  This
@@ -6161,7 +6163,7 @@ These @samp{-m} options are supported on the SPARC:
 @opindex mapp-regs
 Specify @option{-mapp-regs} to generate output using the global registers
 2 through 4, which the SPARC SVR4 ABI reserves for applications.  This
-is the default.
+is the default, except on Solaris.
 
 To be fully SVR4 ABI compliant at the cost of some performance loss,
 specify @option{-mno-app-regs}.  You should compile libraries and system
@@ -6384,7 +6386,7 @@ on SPARC-V9 processors in 64-bit environments:
 @item -mlittle-endian
 @opindex mlittle-endian
 Generate code for a processor running in little-endian mode. It is only
-available for a few configurations and most notably not on Solaris.
+available for a few configurations and most notably not on Solaris and Linux.
 
 @item -m32
 @itemx -m64
@@ -7050,7 +7052,7 @@ Supported values for @var{cpu_type} are @samp{401}, @samp{403},
 @samp{601}, @samp{602}, @samp{603}, @samp{603e}, @samp{604},
 @samp{604e}, @samp{620}, @samp{630}, @samp{740}, @samp{7400},
 @samp{7450}, @samp{750}, @samp{801}, @samp{821}, @samp{823},
-@samp{860}, @samp{970}, @samp{common}, @samp{ec603e}, @samp{G3},
+@samp{860}, @samp{970}, @samp{8540}, @samp{common}, @samp{ec603e}, @samp{G3},
 @samp{G4}, @samp{G5}, @samp{power}, @samp{power2}, @samp{power3},
 @samp{power4}, @samp{power5}, @samp{powerpc}, @samp{powerpc64},
 @samp{rios}, @samp{rios1}, @samp{rios2}, @samp{rsc}, and @samp{rs64a}.
@@ -7178,13 +7180,17 @@ Specifying @option{-maix64} implies @option{-mpowerpc64} and
 @option{-mpowerpc}, while @option{-maix32} disables the 64-bit ABI and
 implies @option{-mno-powerpc64}.  GCC defaults to @option{-maix32}.
 
-@item -mxl-call
-@itemx -mno-xl-call
-@opindex mxl-call
-@opindex mno-xl-call
-On AIX, pass floating-point arguments to prototyped functions beyond the
-register save area (RSA) on the stack in addition to argument FPRs.  The
-AIX calling convention was extended but not initially documented to
+@item -mxl-compat
+@itemx -mno-xl-compat
+@opindex mxl-compat
+@opindex mno-xl-compat
+Produce code that conforms more closely to IBM XLC semantics when using
+AIX-compatible ABI.  Pass floating-point arguments to prototyped
+functions beyond the register save area (RSA) on the stack in addition
+to argument FPRs.  Do not assume that most significant double in 128
+bit long double value is properly rounded when comparing values.
+
+The AIX calling convention was extended but not initially documented to
 handle an obscure K&R C case of calling a function that takes the
 address of its arguments with fewer arguments than declared.  AIX XL
 compilers access floating point arguments which do not fit in the
@@ -10031,6 +10037,16 @@ using the minimum latency algorithm.
 Generate code for inline divides of integer values
 using the maximum throughput algorithm.
 
+@item -minline-sqrt-min-latency
+@opindex minline-sqrt-min-latency
+Generate code for inline square roots
+using the minimum latency algorithm.
+
+@item -minline-sqrt-max-throughput
+@opindex minline-sqrt-max-throughput
+Generate code for inline square roots
+using the maximum throughput algorithm.
+
 @item -mno-dwarf2-asm
 @itemx -mdwarf2-asm
 @opindex mno-dwarf2-asm
@@ -10038,6 +10054,14 @@ using the maximum throughput algorithm.
 Don't (or do) generate assembler code for the DWARF2 line number debugging
 info.  This may be useful when not using the GNU assembler.
 
+@item -mearly-stop-bits
+@itemx -mno-early-stop-bits
+@opindex mearly-stop-bits
+@opindex mno-early-stop-bits
+Allow stop bits to be placed earlier than immediately preceding the
+instruction that triggered the stop bit.  This can improve instruction
+scheduling, but does not always do so.
+
 @item -mfixed-range=@var{register-range}
 @opindex mfixed-range
 Generate code treating the given register range as fixed registers.
@@ -10046,13 +10070,34 @@ useful when compiling kernel code.  A register range is specified as
 two registers separated by a dash.  Multiple register ranges can be
 specified separated by a comma.
 
-@item -mearly-stop-bits
-@itemx -mno-early-stop-bits
-@opindex mearly-stop-bits
-@opindex mno-early-stop-bits
-Allow stop bits to be placed earlier than immediately preceding the
-instruction that triggered the stop bit.  This can improve instruction
-scheduling, but does not always do so.
+@item -mtls-size=@var{tls-size}
+@opindex mtls-size
+Specify bit size of immediate TLS offsets.  Valid values are 14, 22, and
+64.
+
+@item -mtune-arch=@var{cpu-type}
+@opindex mtune-arch
+Tune the instruction scheduling for a particular CPU, Valid values are
+itanium, itanium1, merced, itanium2, and mckinley.
+
+@item -mt
+@itemx -pthread
+@opindex mt
+@opindex pthread
+Add support for multithreading using the POSIX threads library.  This
+option sets flags for both the preprocessor and linker.  It does
+not affect the thread safety of object code produced by the compiler or
+that of libraries supplied with it.  These are HP-UX specific flags.
+
+@item -milp32
+@itemx -mlp64
+@opindex milp32
+@opindex mlp64
+Generate code for a 32-bit or 64-bit environment.
+The 32-bit environment sets int, long and pointer to 32 bits.
+The 64-bit environment sets int to 32 bits and long and pointer
+to 64 bits.  These are HP-UX specific flags.
+
 @end table
 
 @node D30V Options
@@ -11269,8 +11314,8 @@ localization information that allow GCC to work with different
 national conventions.  GCC inspects the locale categories
 @env{LC_CTYPE} and @env{LC_MESSAGES} if it has been configured to do
 so.  These locale categories can be set to any value supported by your
-installation.  A typical value is @samp{en_UK} for English in the United
-Kingdom.
+installation.  A typical value is @samp{en_GB.UTF-8} for English in the United
+Kingdom encoded in UTF-8.
 
 The @env{LC_CTYPE} environment variable specifies character
 classification.  GCC uses it to determine the character boundaries in
diff --git a/contrib/gcc/doc/md.texi b/contrib/gcc/doc/md.texi
index 11e2915..b73f325 100644
--- a/contrib/gcc/doc/md.texi
+++ b/contrib/gcc/doc/md.texi
@@ -1257,7 +1257,9 @@ instruction is defined:
 @end smallexample
 @end ifset
 GCC can only handle one commutative pair in an asm; if you use more,
-the compiler may fail.
+the compiler may fail.  Note that you need not use the modifier if
+the two alternatives are strictly identical; this would only waste
+time in the reload pass.
 
 @cindex @samp{#} in constraint
 @item #
diff --git a/contrib/gcc/doc/tm.texi b/contrib/gcc/doc/tm.texi
index 03c1c4e..73b8ec2 100644
--- a/contrib/gcc/doc/tm.texi
+++ b/contrib/gcc/doc/tm.texi
@@ -291,6 +291,26 @@ the value of @code{LIB_SPEC}.
 
 If this macro is not defined, the GCC driver provides a default that
 passes the string @option{-lgcc} to the linker.
+
+By default, if @code{ENABLE_SHARED_LIBGCC} is defined, the
+@code{LIBGCC_SPEC} is not directly used by the driver program but is
+instead modified to refer to different versions of @file{libgcc.a}
+depending on the values of the command line flags @option{-static},
+@option{-shared}, @option{-static-libgcc}, and @option{-shared-libgcc}.
+@end defmac
+
+@defmac USE_LD_AS_NEEDED
+A macro that controls the modifications to @code{LIBGCC_SPEC}.
+If nonzero, a spec will be
+generated that uses --as-needed and the shared libgcc in place of the
+static exception handler library, when linking without any of
+@code{-static}, @code{-static-libgcc}, or @code{-shared-libgcc}.
+@end defmac
+
+@defmac LINK_EH_SPEC
+If defined, this C string constant is added to @code{LINK_SPEC}.
+When @code{USE_LD_AS_NEEDED} is zero or undefined, it also affects
+the modifications to @code{LIBGCC_SPEC}.
 @end defmac
 
 @defmac STARTFILE_SPEC
@@ -1502,6 +1522,34 @@ precedence for that field, but the alignment of the rest of the structure
 may affect its placement.
 @end deftypefn
 
+@deftypefn {Target Hook} {const char *} TARGET_MANGLE_FUNDAMENTAL_TYPE (tree @var{type})
+If your target defines any fundamental types, define this hook to
+return the appropriate encoding for these types as part of a C++
+mangled name.  The @var{type} argument is the tree structure
+representing the type to be mangled.  The hook may be applied to trees
+which are not target-specific fundamental types; it should return
+@code{NULL} for all such types, as well as arguments it does not
+recognize.  If the return value is not @code{NULL}, it must point to
+a statically-allocated string constant.
+
+Target-specific fundamental types might be new fundamental types or
+qualified versions of ordinary fundamental types.  Encode new
+fundamental types as @samp{@w{u @var{n} @var{name}}}, where @var{name}
+is the name used for the type in source code, and @var{n} is the
+length of @var{name} in decimal.  Encode qualified versions of
+ordinary types as @samp{@w{U @var{n} @var{name} @var{code}}}, where
+@var{name} is the name used for the type qualifier in source code,
+@var{n} is the length of @var{name} as above, and @var{code} is the
+code used to represent the unqualified version of this type.  (See
+@code{write_builtin_type} in @file{cp/mangle.c} for the list of
+codes.)  In both cases the spaces are for clarity; do not include any
+spaces in your string.
+
+The default version of this hook always returns @code{NULL}, which is
+appropriate for a target that does not define any new fundamental
+types.
+@end deftypefn
+
 @node Type Layout
 @section Layout of Source Language Data Types
 
@@ -2929,6 +2977,14 @@ general register, but an alternate column needs to be used for
 signal frames.
 @end defmac
 
+@defmac DWARF_ZERO_REG
+A C expression whose value is an integer giving a DWARF 2 register
+number that is considered to always have the value zero.  This should
+only be defined if the target has an architected zero register, and
+someone decided it was a good idea to use that register number to
+terminate the stack backtrace.  New ports should avoid this.
+@end defmac
+
 @defmac INCOMING_FRAME_SP_OFFSET
 A C expression whose value is an integer giving the offset, in bytes,
 from the value of the stack pointer register to the top of the stack
@@ -4278,7 +4334,7 @@ You need not define this macro if you did not define
 @code{DELAY_SLOTS_FOR_EPILOGUE}.
 @end defmac
 
-@deftypefn {Target Hook} void TARGET_ASM_OUTPUT_MI_THUNK (FILE *@var{file}, tree @var{thunk_fndecl}, HOST_WIDE_INT @var{delta}, tree @var{function})
+@deftypefn {Target Hook} void TARGET_ASM_OUTPUT_MI_THUNK (FILE *@var{file}, tree @var{thunk_fndecl}, HOST_WIDE_INT @var{delta}, HOST_WIDE_INT @var{vcall_offset}, tree @var{function})
 A function that outputs the assembler code for a thunk
 function, used to implement C++ virtual function calls with multiple
 inheritance.  The thunk acts as a wrapper around a virtual function,
@@ -4292,7 +4348,15 @@ in C++.  This is the incoming argument @emph{before} the function prologue,
 e.g.@: @samp{%o0} on a sparc.  The addition must preserve the values of
 all other incoming arguments.
 
-After the addition, emit code to jump to @var{function}, which is a
+Then, if @var{vcall_offset} is nonzero, an additional adjustment should be
+made after adding @code{delta}.  In particular, if @var{p} is the
+adjusted pointer, the following adjustment should be made:
+
+@smallexample
+p += (*((ptrdiff_t **)p))[vcall_offset/sizeof(ptrdiff_t)]
+@end smallexample
+
+After the additions, emit code to jump to @var{function}, which is a
 @code{FUNCTION_DECL}.  This is a direct pure jump, not a call, and does
 not touch the return address.  Hence returning from @var{FUNCTION} will
 return to whoever called the current @samp{thunk}.
@@ -4312,19 +4376,12 @@ front end will generate a less efficient heavyweight thunk that calls
 not support varargs.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_ASM_OUTPUT_MI_VCALL_THUNK (FILE *@var{file}, tree @var{thunk_fndecl}, HOST_WIDE_INT @var{delta}, int @var{vcall_offset}, tree @var{function})
-A function like @code{TARGET_ASM_OUTPUT_MI_THUNK}, except that if
-@var{vcall_offset} is nonzero, an additional adjustment should be made
-after adding @code{delta}.  In particular, if @var{p} is the
-adjusted pointer, the following adjustment should be made:
-
-@smallexample
-p += (*((ptrdiff_t **)p))[vcall_offset/sizeof(ptrdiff_t)]
-@end smallexample
-
-@noindent
-If this function is defined, it will always be used in place of
-@code{TARGET_ASM_OUTPUT_MI_THUNK}.
+@deftypefn {Target Hook} bool TARGET_ASM_CAN_OUTPUT_MI_THUNK (tree @var{thunk_fndecl}, HOST_WIDE_INT @var{delta}, HOST_WIDE_INT @var{vcall_offset}, tree @var{function})
+A function that returns true if TARGET_ASM_OUTPUT_MI_THUNK would be able
+to output the assembler code for the thunk function specified by the
+arguments it is passed, and false otherwise.  In the latter case, the
+generic approach will be used by the C++ front end, with the limitations
+previously exposed.
 @end deftypefn
 
 @node Profiling
@@ -6896,6 +6953,15 @@ If @code{SET_ASM_OP} is defined, a default definition is provided which is
 correct for most systems.
 @end defmac
 
+@defmac TARGET_DEFERRED_OUTPUT_DEFS (@var{decl_of_name}, @var{decl_of_value})
+A C statement that evaluates to true if the assembler code which defines
+(equates) the symbol whose tree node is @var{decl_of_name} to have the value
+of the tree node @var{decl_of_value} should be emitted near the end of the
+current compilation unit.  The default is to not defer output of defines.
+This macro affects defines output by @samp{ASM_OUTPUT_DEF} and
+@samp{ASM_OUTPUT_DEF_FROM_DECLS}.
+@end defmac
+
 @defmac ASM_OUTPUT_WEAK_ALIAS (@var{stream}, @var{name}, @var{value})
 A C statement to output to the stdio stream @var{stream} assembler code
 which defines (equates) the weak symbol @var{name} to have the value
diff --git a/contrib/gcc/doc/trouble.texi b/contrib/gcc/doc/trouble.texi
index a1b86bc..170bbad 100644
--- a/contrib/gcc/doc/trouble.texi
+++ b/contrib/gcc/doc/trouble.texi
@@ -1067,7 +1067,7 @@ forces it to remain until the end of the scope of the name.  For
 example:
 
 @smallexample
-string& tmp = strfunc ();
+const string& tmp = strfunc ();
 charfunc (tmp.c_str ());
 @end smallexample