This is gcc.info, produced by makeinfo version 4.2 from
/usr/src/gnu/usr.bin/gcc/gcc/doc/gcc.texi.

Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1999, 2000, 2001, 2002, 2003 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
any later version published by the Free Software Foundation; with the
Invariant Sections being "GNU General Public License" and "Funding Free
Software", the Front-Cover texts being (a) (see below), and with the
Back-Cover Texts being (b) (see below).  A copy of the license is
included in the section entitled "GNU Free Documentation License".

   (a) The FSF's Front-Cover Text is:

   A GNU Manual

   (b) The FSF's Back-Cover Text is:

   You have freedom to copy and modify this GNU Manual, like GNU
software.  Copies published by the Free Software Foundation raise
funds for GNU development.
INFO-DIR-SECTION Programming
START-INFO-DIR-ENTRY
* gcc: (gcc).                  The GNU Compiler Collection.
END-INFO-DIR-ENTRY
   This file documents the use of the GNU compilers.

   Published by the Free Software Foundation
59 Temple Place - Suite 330
Boston, MA 02111-1307 USA

File: gcc.info,  Node: PowerPC AltiVec Built-in Functions,  Prev: X86 Built-in Functions,  Up: Target Builtins

PowerPC AltiVec Built-in Functions
----------------------------------

   These built-in functions are available for the PowerPC family of
computers, depending on the command-line switches used.

   The following machine modes are available for use with AltiVec
built-in functions (*note Vector Extensions::): `V4SI' for a vector of
four 32-bit integers, `V4SF' for a vector of four 32-bit floating point
numbers, `V8HI' for a vector of eight 16-bit integers, and `V16QI' for
a vector of sixteen 8-bit integers.

   The following functions are made available by including
`<altivec.h>' and using `-maltivec' and `-mabi=altivec'.  The functions
implement the functionality described in Motorola's AltiVec Programming
Interface Manual.

   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
`vector bool' type is deprecated and will be discontinued in further
revisions.  Use `vector signed' instead.  If `signed' or `unsigned' is
omitted, the vector type will default to `signed'.  Lastly, all
overloaded functions are implemented with macros for the C
implementation.  So code the following example will not work:

       vec_add ((vector signed int){1, 2, 3, 4}, foo);

   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.

   _Note:_ Only the `<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.

     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);
     
     vector signed char vec_abss (vector signed char, vector signed char);
     vector signed short vec_abss (vector signed short, vector signed short);
     
     vector signed char vec_add (vector signed char, vector signed char);
     vector unsigned char vec_add (vector signed char, vector unsigned char);
     
     vector unsigned char vec_add (vector unsigned char, vector signed char);
     
     vector unsigned char vec_add (vector unsigned char,
                                   vector unsigned char);
     vector signed short vec_add (vector signed short, vector signed short);
     vector unsigned short vec_add (vector signed short,
                                    vector unsigned short);
     vector unsigned short vec_add (vector unsigned short,
                                    vector signed short);
     vector unsigned short vec_add (vector unsigned short,
                                    vector unsigned short);
     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 unsigned int, vector unsigned int);
     vector float vec_add (vector float, vector float);
     
     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 unsigned char,
                                    vector unsigned char);
     vector signed char vec_adds (vector signed char, vector signed char);
     vector unsigned short vec_adds (vector signed short,
                                     vector unsigned short);
     vector unsigned short vec_adds (vector unsigned short,
                                     vector signed short);
     vector unsigned short vec_adds (vector unsigned short,
                                     vector unsigned 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 unsigned int, vector unsigned int);
     
     vector signed int vec_adds (vector signed int, vector signed int);
     
     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 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 unsigned int, vector unsigned int);
     vector signed short vec_and (vector signed short, vector signed short);
     vector unsigned short vec_and (vector signed short,
                                    vector unsigned short);
     vector unsigned short vec_and (vector unsigned short,
                                    vector signed short);
     vector unsigned short vec_and (vector unsigned short,
                                    vector unsigned short);
     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 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 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 unsigned int, vector unsigned int);
     
     vector signed short vec_andc (vector signed short, vector signed short);
     
     vector unsigned short vec_andc (vector signed short,
                                     vector unsigned short);
     vector unsigned short vec_andc (vector unsigned short,
                                     vector signed short);
     vector unsigned short vec_andc (vector unsigned short,
                                     vector unsigned short);
     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 unsigned char,
                                    vector unsigned char);
     
     vector unsigned char vec_avg (vector unsigned char,
                                   vector unsigned char);
     vector signed char vec_avg (vector signed char, vector signed char);
     vector unsigned short vec_avg (vector unsigned short,
                                    vector unsigned short);
     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 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 signed int vec_cmpge (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 signed int vec_cmple (vector float, vector float);
     
     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 float vec_ctf (vector unsigned int, const char);
     vector float vec_ctf (vector signed int, const char);
     
     vector signed int vec_cts (vector float, const char);
     
     vector unsigned int vec_ctu (vector float, const char);
     
     void vec_dss (const char);
     
     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 *);
     
     vector float vec_loge (vector float);
     
     vector unsigned char vec_lvsl (int, void *, int *);
     
     vector unsigned char vec_lvsr (int, void *, int *);
     
     vector float vec_madd (vector float, vector float, vector float);
     
     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 unsigned char,
                                   vector unsigned char);
     vector signed char vec_max (vector signed char, vector signed char);
     vector unsigned short vec_max (vector signed short,
                                    vector unsigned short);
     vector unsigned short vec_max (vector unsigned short,
                                    vector signed short);
     vector unsigned short vec_max (vector unsigned short,
                                    vector unsigned 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 unsigned int, vector unsigned int);
     vector signed int vec_max (vector signed int, vector signed int);
     vector float vec_max (vector float, vector float);
     
     vector signed char vec_mergeh (vector signed char, vector signed char);
     vector unsigned char vec_mergeh (vector unsigned char,
                                      vector unsigned char);
     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 signed int vec_mergeh (vector signed int, vector signed int);
     vector unsigned int vec_mergeh (vector unsigned int,
                                     vector unsigned int);
     
     vector signed char vec_mergel (vector signed char, vector signed char);
     vector unsigned char vec_mergel (vector unsigned char,
                                      vector unsigned char);
     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 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 unsigned char vec_min (vector signed char, vector unsigned char);
     
     vector unsigned char vec_min (vector unsigned char, vector signed char);
     
     vector unsigned char vec_min (vector unsigned char,
                                   vector unsigned char);
     vector signed char vec_min (vector signed char, vector signed char);
     vector unsigned short vec_min (vector signed short,
                                    vector unsigned short);
     vector unsigned short vec_min (vector unsigned short,
                                    vector signed short);
     vector unsigned short vec_min (vector unsigned short,
                                    vector unsigned 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 unsigned int, vector unsigned 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 signed short);
     vector signed short vec_mladd (vector signed short,
                                    vector unsigned short,
                                    vector unsigned short);
     vector signed short vec_mladd (vector unsigned short,
                                    vector signed short,
                                    vector signed short);
     vector unsigned short vec_mladd (vector unsigned short,
                                      vector unsigned short,
                                      vector unsigned short);
     
     vector signed short vec_mradds (vector signed short,
                                     vector signed short,
                                     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);
     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);
     
     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);
     
     void vec_mtvscr (vector signed int);
     void vec_mtvscr (vector unsigned int);
     void vec_mtvscr (vector signed short);
     void vec_mtvscr (vector unsigned short);
     void vec_mtvscr (vector signed char);
     void vec_mtvscr (vector unsigned char);
     
     vector unsigned short vec_mule (vector unsigned char,
                                     vector unsigned 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 unsigned short vec_mulo (vector unsigned char,
                                     vector unsigned char);
     vector signed short vec_mulo (vector signed char, vector signed char);
     vector unsigned int vec_mulo (vector unsigned short,
                                   vector unsigned short);
     vector signed int vec_mulo (vector signed short, vector signed short);
     
     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 signed short vec_nor (vector signed short, vector signed short);
     vector unsigned short vec_nor (vector unsigned short,
                                    vector unsigned short);
     vector signed char vec_nor (vector signed char, vector signed char);
     vector unsigned char vec_nor (vector unsigned char,
                                   vector unsigned 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 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 unsigned int, vector unsigned int);
     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 unsigned short,
                                   vector unsigned short);
     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 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 signed short vec_pack (vector signed int, vector signed int);
     vector unsigned short vec_pack (vector unsigned int,
                                     vector unsigned int);
     
     vector signed short 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 unsigned char vec_packsu (vector unsigned short,
                                      vector unsigned short);
     vector unsigned char vec_packsu (vector signed short,
                                      vector signed short);
     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 char);
     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 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 unsigned char);
     vector unsigned char vec_perm (vector unsigned char,
                                    vector unsigned char,
                                    vector unsigned char);
     
     vector float vec_re (vector float);
     
     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 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 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 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);
     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 unsigned short);
     vector unsigned short vec_sel (vector unsigned short,
                                    vector unsigned short,
                                    vector signed 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 unsigned char);
     vector unsigned char vec_sel (vector unsigned char,
                                   vector unsigned char,
                                   vector signed 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 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 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 char vec_sld (vector unsigned char,
                                   vector unsigned char,
                                   const char);
     
     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 signed short vec_sll (vector signed short,
                                  vector unsigned short);
     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 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);
     vector unsigned char vec_sll (vector unsigned char,
                                   vector unsigned int);
     vector unsigned char vec_sll (vector unsigned char,
                                   vector unsigned short);
     vector unsigned char vec_sll (vector unsigned char,
                                   vector unsigned char);
     
     vector float vec_slo (vector float, vector signed char);
     vector float vec_slo (vector float, vector unsigned char);
     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 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_s8 (const char);
     
     vector signed short vec_splat_s16 (const char);
     
     vector signed int vec_splat_s32 (const char);
     
     vector unsigned char vec_splat_u8 (const char);
     
     vector unsigned short vec_splat_u16 (const char);
     
     vector unsigned int vec_splat_u32 (const char);
     
     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 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 char vec_sra (vector signed char, vector unsigned char);
     vector unsigned char vec_sra (vector unsigned char,
                                   vector unsigned char);
     vector signed short vec_sra (vector signed short,
                                  vector unsigned short);
     vector unsigned short vec_sra (vector unsigned short,
                                    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_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);
     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 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 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);
     vector unsigned char vec_srl (vector unsigned char,
                                   vector unsigned int);
     vector unsigned char vec_srl (vector unsigned char,
                                   vector unsigned short);
     vector unsigned char vec_srl (vector unsigned char,
                                   vector unsigned char);
     
     vector float vec_sro (vector float, vector signed char);
     vector float vec_sro (vector float, vector unsigned char);
     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 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 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 signed short, int, vector signed short *);
     void vec_st (vector unsigned short, int, unsigned 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 signed char, int, vector signed char *);
     void vec_st (vector unsigned char, int, unsigned char *);
     void vec_st (vector unsigned char, int, vector unsigned 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 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 signed int, int, int *);
     void vec_ste (vector unsigned int, int, unsigned int *);
     void vec_ste (vector float, int, float *);
     
     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 signed short, int, vector signed 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 signed char, int, vector signed char *);
     void vec_stl (vector unsigned char, int, unsigned char *);
     void vec_stl (vector unsigned char, int, vector unsigned 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 unsigned char,
                                   vector unsigned char);
     vector signed short vec_sub (vector signed short, vector signed short);
     vector unsigned short vec_sub (vector signed short,
                                    vector unsigned short);
     vector unsigned short vec_sub (vector unsigned short,
                                    vector signed short);
     vector unsigned short vec_sub (vector unsigned short,
                                    vector unsigned short);
     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 unsigned int, vector unsigned int);
     vector float vec_sub (vector float, vector float);
     
     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 unsigned char,
                                    vector unsigned char);
     vector signed char vec_subs (vector signed char, vector signed char);
     vector unsigned short vec_subs (vector signed short,
                                     vector unsigned short);
     vector unsigned short vec_subs (vector unsigned short,
                                     vector signed short);
     vector unsigned short vec_subs (vector unsigned short,
                                     vector unsigned 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 unsigned int, vector unsigned int);
     
     vector signed int vec_subs (vector signed int, vector signed int);
     
     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_sum2s (vector signed int, vector signed int);
     
     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 signed int vec_unpackh (vector signed short);
     
     vector signed short vec_unpackl (vector signed char);
     vector unsigned int vec_unpackl (vector signed short);
     vector signed int vec_unpackl (vector signed short);
     
     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 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 unsigned int, vector unsigned int);
     vector signed short vec_xor (vector signed short, vector signed short);
     vector unsigned short vec_xor (vector signed short,
                                    vector unsigned short);
     vector unsigned short vec_xor (vector unsigned short,
                                    vector signed short);
     vector unsigned short vec_xor (vector unsigned short,
                                    vector unsigned short);
     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 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);

