Next: PowerPC Hardware Transactional Memory Built-in Functions, Previous: PowerPC Built-in Functions, Up: Target Builtins [Contents][Index]

#### 6.60.22 PowerPC AltiVec Built-in Functions

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 `<altivec.h>` and using `-maltivec` and `-mabi=altivec`. The interface supports the following vector types.

    vector unsigned char
    vector signed char
    vector bool char

    vector unsigned short
    vector signed short
    vector bool short
    vector pixel

    vector unsigned int
    vector signed int
    vector bool int
    vector float

If `-mvsx` is used the following additional vector types are implemented.

    vector unsigned long
    vector signed long
    vector double

The long types are only implemented for 64-bit code generation, and the long type is only used in the floating point/integer conversion instructions.

GCC’s implementation of the high-level language interface available from C and C++ code differs from Motorola’s documentation in several ways.

- A vector constant is a list of constant expressions within curly braces.
- A vector initializer requires no cast if the vector constant is of the same type as the variable it is initializing.
- If `signed` or `unsigned` is omitted, the signedness of the vector type is the default signedness of the base type. The default varies depending on the operating system, so a portable program should always specify the signedness.
- Compiling with `-maltivec` adds keywords `__vector`, `vector`, `__pixel`, `pixel`, `__bool` and `bool`. When compiling ISO C, the context-sensitive substitution of the keywords `vector`, `pixel` and `bool` is disabled. To use them, you must include `<altivec.h>` instead.
- GCC allows using a `typedef` name as the type specifier for a vector type.
- For C, overloaded functions are implemented with macros so the following does not work:

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

  Since `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.

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.

GCC complies with the OpenPOWER 64-Bit ELF V2 ABI Specification, which may be found at http://openpowerfoundation.org/wp-content/uploads/resources/leabi-prd/content/index.html. Appendix A of this document lists the vector API interfaces that must be provided by compliant compilers. Programmers should preferentially use the interfaces described therein. However, historically GCC has provided additional interfaces for access to vector instructions. These are briefly described below.

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.

Arguments that are documented as `const int` require literal integral values within the range required for that operation.

    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 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 bool short,
                                   vector unsigned short);
    vector unsigned short vec_add (vector unsigned 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 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 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 bool short,
                                    vector unsigned short);
    vector unsigned short vec_adds (vector unsigned 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 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 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 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 bool short,
                                   vector unsigned short);
    vector unsigned short vec_and (vector unsigned 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 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 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 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 bool short,
                                    vector unsigned short);
    vector unsigned short vec_andc (vector unsigned 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 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);

    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 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_copysign (vector float);

    vector float vec_ceil (vector float);

    vector signed int vec_cmpb (vector float, vector float);

    vector bool char vec_cmpeq (vector bool char, vector bool char);
    vector bool short vec_cmpeq (vector bool short, vector bool short);
    vector bool int vec_cmpeq (vector bool int, vector bool int);
    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 bool int vec_vcmpeqfp (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 bool short vec_vcmpequh (vector signed short,
                                    vector signed short);
    vector bool short vec_vcmpequh (vector unsigned short,
                                    vector unsigned short);

    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 bool int vec_vcmpgtfp (vector float, vector float);

    vector bool int vec_vcmpgtsw (vector signed int, vector signed int);

    vector bool int vec_vcmpgtuw (vector unsigned int, vector unsigned int);

    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_cpsgn (vector float, vector float);

    vector float vec_ctf (vector unsigned int, const int);
    vector float vec_ctf (vector signed int, const int);
    vector double vec_ctf (vector unsigned long, const int);
    vector double vec_ctf (vector signed long, 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 signed long vec_cts (vector double, const int);

    vector unsigned int vec_ctu (vector float, const int);
    vector unsigned long vec_ctu (vector double, const int);

    void vec_dss (const int);

    void vec_dssall (void);

    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, 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);

    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 bool short,
                                   vector unsigned short);
    vector unsigned short vec_max (vector unsigned 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 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 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 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 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 bool short,
                                   vector unsigned short);
    vector unsigned short vec_min (vector unsigned 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 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 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,
                                   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 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);

    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 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);
    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 signed char vec_nabs (vector signed char);
    vector signed short vec_nabs (vector signed short);
    vector signed int vec_nabs (vector signed int);
    vector float vec_nabs (vector float);
    vector double vec_nabs (vector double);

    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 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 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 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 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 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,
                                     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 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 unsigned char);
    vector unsigned int vec_perm (vector unsigned int,
                                  vector unsigned int,
                                  vector unsigned char);
    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 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 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_recip (vector float, vector float);

    vector float vec_rsqrt (vector float);

    vector float vec_rsqrte (vector float);

    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 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 bool int);
    vector unsigned int vec_sel (vector unsigned int,
                                 vector unsigned int,
                                 vector unsigned int);
    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 bool short);
    vector unsigned short vec_sel (vector unsigned short,
                                   vector unsigned short,
                                   vector unsigned short);
    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 bool char);
    vector unsigned char vec_sel (vector unsigned char,
                                  vector unsigned 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 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 double vec_sld (vector double, vector double, 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 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 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 unsigned int vec_sll (vector unsigned int,
                                 vector unsigned short);
    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 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);
    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 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);
    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 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 signed long vec_splat (vector signed long, const int);
    vector unsigned long vec_splat (vector unsigned long, const int);

    vector signed char vec_splats (signed char);
    vector unsigned char vec_splats (unsigned char);
    vector signed short vec_splats (signed short);
    vector unsigned short vec_splats (unsigned short);
    vector signed int vec_splats (signed int);
    vector unsigned int vec_splats (unsigned int);
    vector float vec_splats (float);

    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_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 char vec_splat_s8 (const int);

    vector signed short vec_splat_s16 (const int);

    vector signed int vec_splat_s32 (const int);

    vector unsigned char vec_splat_u8 (const int);

    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 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);
    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_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);
    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);
    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 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);
    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, 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 unsigned int, int, vector unsigned int *);
    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 signed short, int, short *);
    void vec_st (vector unsigned short, int, vector unsigned short *);
    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 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, 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 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 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 unsigned int, int, vector unsigned int *);
    void vec_stl (vector unsigned int, int, unsigned int *);
    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 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 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 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 bool short,
                                   vector unsigned short);
    vector unsigned short vec_sub (vector unsigned 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 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 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 bool short,
                                    vector unsigned short);
    vector unsigned short vec_subs (vector unsigned 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 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);

    vector float vec_trunc (vector float);

    vector signed short vec_unpackh (vector signed char);
    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 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 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 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 bool short,
                                   vector unsigned short);
    vector unsigned short vec_xor (vector unsigned 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 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);

    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);

If the vector/scalar (VSX) instruction set is available, the following additional functions are available:

    vector double vec_abs (vector double);
    vector double vec_add (vector double, vector double);
    vector double vec_and (vector double, vector double);
    vector double vec_and (vector double, vector bool long);
    vector double vec_and (vector bool long, vector double);
    vector long vec_and (vector long, vector long);
    vector long vec_and (vector long, vector bool long);
    vector long vec_and (vector bool long, vector long);
    vector unsigned long vec_and (vector unsigned long, vector unsigned long);
    vector unsigned long vec_and (vector unsigned long, vector bool long);
    vector unsigned long vec_and (vector bool long, vector unsigned long);
    vector double vec_andc (vector double, vector double);
    vector double vec_andc (vector double, vector bool long);
    vector double vec_andc (vector bool long, vector double);
    vector long vec_andc (vector long, vector long);
    vector long vec_andc (vector long, vector bool long);
    vector long vec_andc (vector bool long, vector long);
    vector unsigned long vec_andc (vector unsigned long, vector unsigned long);
    vector unsigned long vec_andc (vector unsigned long, vector bool long);
    vector unsigned long vec_andc (vector bool long, vector unsigned long);
    vector double vec_ceil (vector double);
    vector bool long vec_cmpeq (vector double, vector double);
    vector bool long vec_cmpge (vector double, vector double);
    vector bool long vec_cmpgt (vector double, vector double);
    vector bool long vec_cmple (vector double, vector double);
    vector bool long vec_cmplt (vector double, vector double);
    vector double vec_cpsgn (vector double, vector double);
    vector float vec_div (vector float, vector float);
    vector double vec_div (vector double, vector double);
    vector long vec_div (vector long, vector long);
    vector unsigned long vec_div (vector unsigned long, vector unsigned long);
    vector double vec_floor (vector double);
    vector double vec_ld (int, const vector double *);
    vector double vec_ld (int, const double *);
    vector double vec_ldl (int, const vector double *);
    vector double vec_ldl (int, const double *);
    vector unsigned char vec_lvsl (int, const volatile double *);
    vector unsigned char vec_lvsr (int, const volatile double *);
    vector double vec_madd (vector double, vector double, vector double);
    vector double vec_max (vector double, vector double);
    vector signed long vec_mergeh (vector signed long, vector signed long);
    vector signed long vec_mergeh (vector signed long, vector bool long);
    vector signed long vec_mergeh (vector bool long, vector signed long);
    vector unsigned long vec_mergeh (vector unsigned long, vector unsigned long);
    vector unsigned long vec_mergeh (vector unsigned long, vector bool long);
    vector unsigned long vec_mergeh (vector bool long, vector unsigned long);
    vector signed long vec_mergel (vector signed long, vector signed long);
    vector signed long vec_mergel (vector signed long, vector bool long);
    vector signed long vec_mergel (vector bool long, vector signed long);
    vector unsigned long vec_mergel (vector unsigned long, vector unsigned long);
    vector unsigned long vec_mergel (vector unsigned long, vector bool long);
    vector unsigned long vec_mergel (vector bool long, vector unsigned long);
    vector double vec_min (vector double, vector double);
    vector float vec_msub (vector float, vector float, vector float);
    vector double vec_msub (vector double, vector double, vector double);
    vector float vec_mul (vector float, vector float);
    vector double vec_mul (vector double, vector double);
    vector long vec_mul (vector long, vector long);
    vector unsigned long vec_mul (vector unsigned long, vector unsigned long);
    vector float vec_nearbyint (vector float);
    vector double vec_nearbyint (vector double);
    vector float vec_nmadd (vector float, vector float, vector float);
    vector double vec_nmadd (vector double, vector double, vector double);
    vector double vec_nmsub (vector double, vector double, vector double);
    vector double vec_nor (vector double, vector double);
    vector long vec_nor (vector long, vector long);
    vector long vec_nor (vector long, vector bool long);
    vector long vec_nor (vector bool long, vector long);
    vector unsigned long vec_nor (vector unsigned long, vector unsigned long);
    vector unsigned long vec_nor (vector unsigned long, vector bool long);
    vector unsigned long vec_nor (vector bool long, vector unsigned long);
    vector double vec_or (vector double, vector double);
    vector double vec_or (vector double, vector bool long);
    vector double vec_or (vector bool long, vector double);
    vector long vec_or (vector long, vector long);
    vector long vec_or (vector long, vector bool long);
    vector long vec_or (vector bool long, vector long);
    vector unsigned long vec_or (vector unsigned long, vector unsigned long);
    vector unsigned long vec_or (vector unsigned long, vector bool long);
    vector unsigned long vec_or (vector bool long, vector unsigned long);
    vector double vec_perm (vector double, vector double, vector unsigned char);
    vector long vec_perm (vector long, vector long, vector unsigned char);
    vector unsigned long vec_perm (vector unsigned long, vector unsigned long,
                                   vector unsigned char);
    vector double vec_rint (vector double);
    vector double vec_recip (vector double, vector double);
    vector double vec_rsqrt (vector double);
    vector double vec_rsqrte (vector double);
    vector double vec_sel (vector double, vector double, vector bool long);
    vector double vec_sel (vector double, vector double, vector unsigned long);
    vector long vec_sel (vector long, vector long, vector long);
    vector long vec_sel (vector long, vector long, vector unsigned long);
    vector long vec_sel (vector long, vector long, vector bool long);
    vector unsigned long vec_sel (vector unsigned long, vector unsigned long,
                                  vector long);
    vector unsigned long vec_sel (vector unsigned long, vector unsigned long,
                                  vector unsigned long);
    vector unsigned long vec_sel (vector unsigned long, vector unsigned long,
                                  vector bool long);
    vector double vec_splats (double);
    vector signed long vec_splats (signed long);
    vector unsigned long vec_splats (unsigned long);
    vector float vec_sqrt (vector float);
    vector double vec_sqrt (vector double);
    void vec_st (vector double, int, vector double *);
    void vec_st (vector double, int, double *);
    vector double vec_sub (vector double, vector double);
    vector double vec_trunc (vector double);
    vector double vec_xl (int, vector double *);
    vector double vec_xl (int, double *);
    vector long long vec_xl (int, vector long long *);
    vector long long vec_xl (int, long long *);
    vector unsigned long long vec_xl (int, vector unsigned long long *);
    vector unsigned long long vec_xl (int, unsigned long long *);
    vector float vec_xl (int, vector float *);
    vector float vec_xl (int, float *);
    vector int vec_xl (int, vector int *);
    vector int vec_xl (int, int *);
    vector unsigned int vec_xl (int, vector unsigned int *);
    vector unsigned int vec_xl (int, unsigned int *);
    vector double vec_xor (vector double, vector double);
    vector double vec_xor (vector double, vector bool long);
    vector double vec_xor (vector bool long, vector double);
    vector long vec_xor (vector long, vector long);
    vector long vec_xor (vector long, vector bool long);
    vector long vec_xor (vector bool long, vector long);
    vector unsigned long vec_xor (vector unsigned long, vector unsigned long);
    vector unsigned long vec_xor (vector unsigned long, vector bool long);
    vector unsigned long vec_xor (vector bool long, vector unsigned long);
    void vec_xst (vector double, int, vector double *);
    void vec_xst (vector double, int, double *);
    void vec_xst (vector long long, int, vector long long *);
    void vec_xst (vector long long, int, long long *);
    void vec_xst (vector unsigned long long, int, vector unsigned long long *);
    void vec_xst (vector unsigned long long, int, unsigned long long *);
    void vec_xst (vector float, int, vector float *);
    void vec_xst (vector float, int, float *);
    void vec_xst (vector int, int, vector int *);
    void vec_xst (vector int, int, int *);
    void vec_xst (vector unsigned int, int, vector unsigned int *);
    void vec_xst (vector unsigned int, int, unsigned int *);
    int vec_all_eq (vector double, vector double);
    int vec_all_ge (vector double, vector double);
    int vec_all_gt (vector double, vector double);
    int vec_all_le (vector double, vector double);
    int vec_all_lt (vector double, vector double);
    int vec_all_nan (vector double);
    int vec_all_ne (vector double, vector double);
    int vec_all_nge (vector double, vector double);
    int vec_all_ngt (vector double, vector double);
    int vec_all_nle (vector double, vector double);
    int vec_all_nlt (vector double, vector double);
    int vec_all_numeric (vector double);
    int vec_any_eq (vector double, vector double);
    int vec_any_ge (vector double, vector double);
    int vec_any_gt (vector double, vector double);
    int vec_any_le (vector double, vector double);
    int vec_any_lt (vector double, vector double);
    int vec_any_nan (vector double);
    int vec_any_ne (vector double, vector double);
    int vec_any_nge (vector double, vector double);
    int vec_any_ngt (vector double, vector double);
    int vec_any_nle (vector double, vector double);
    int vec_any_nlt (vector double, vector double);
    int vec_any_numeric (vector double);

    vector double vec_vsx_ld (int, const vector double *);
    vector double vec_vsx_ld (int, const double *);
    vector float vec_vsx_ld (int, const vector float *);
    vector float vec_vsx_ld (int, const float *);
    vector bool int vec_vsx_ld (int, const vector bool int *);
    vector signed int vec_vsx_ld (int, const vector signed int *);
    vector signed int vec_vsx_ld (int, const int *);
    vector signed int vec_vsx_ld (int, const long *);
    vector unsigned int vec_vsx_ld (int, const vector unsigned int *);
    vector unsigned int vec_vsx_ld (int, const unsigned int *);
    vector unsigned int vec_vsx_ld (int, const unsigned long *);
    vector bool short vec_vsx_ld (int, const vector bool short *);
    vector pixel vec_vsx_ld (int, const vector pixel *);
    vector signed short vec_vsx_ld (int, const vector signed short *);
    vector signed short vec_vsx_ld (int, const short *);
    vector unsigned short vec_vsx_ld (int, const vector unsigned short *);
    vector unsigned short vec_vsx_ld (int, const unsigned short *);
    vector bool char vec_vsx_ld (int, const vector bool char *);
    vector signed char vec_vsx_ld (int, const vector signed char *);
    vector signed char vec_vsx_ld (int, const signed char *);
    vector unsigned char vec_vsx_ld (int, const vector unsigned char *);
    vector unsigned char vec_vsx_ld (int, const unsigned char *);

    void vec_vsx_st (vector double, int, vector double *);
    void vec_vsx_st (vector double, int, double *);
    void vec_vsx_st (vector float, int, vector float *);
    void vec_vsx_st (vector float, int, float *);
    void vec_vsx_st (vector signed int, int, vector signed int *);
    void vec_vsx_st (vector signed int, int, int *);
    void vec_vsx_st (vector unsigned int, int, vector unsigned int *);
    void vec_vsx_st (vector unsigned int, int, unsigned int *);
    void vec_vsx_st (vector bool int, int, vector bool int *);
    void vec_vsx_st (vector bool int, int, unsigned int *);
    void vec_vsx_st (vector bool int, int, int *);
    void vec_vsx_st (vector signed short, int, vector signed short *);
    void vec_vsx_st (vector signed short, int, short *);
    void vec_vsx_st (vector unsigned short, int, vector unsigned short *);
    void vec_vsx_st (vector unsigned short, int, unsigned short *);
    void vec_vsx_st (vector bool short, int, vector bool short *);
    void vec_vsx_st (vector bool short, int, unsigned short *);
    void vec_vsx_st (vector pixel, int, vector pixel *);
    void vec_vsx_st (vector pixel, int, unsigned short *);
    void vec_vsx_st (vector pixel, int, short *);
    void vec_vsx_st (vector bool short, int, short *);
    void vec_vsx_st (vector signed char, int, vector signed char *);
    void vec_vsx_st (vector signed char, int, signed char *);
    void vec_vsx_st (vector unsigned char, int, vector unsigned char *);
    void vec_vsx_st (vector unsigned char, int, unsigned char *);
    void vec_vsx_st (vector bool char, int, vector bool char *);
    void vec_vsx_st (vector bool char, int, unsigned char *);
    void vec_vsx_st (vector bool char, int, signed char *);

    vector double vec_xxpermdi (vector double, vector double, const int);
    vector float vec_xxpermdi (vector float, vector float, const int);
    vector long long vec_xxpermdi (vector long long, vector long long, const int);
    vector unsigned long long vec_xxpermdi (vector unsigned long long,
                                            vector unsigned long long, const int);
    vector int vec_xxpermdi (vector int, vector int, const int);
    vector unsigned int vec_xxpermdi (vector unsigned int,
                                      vector unsigned int, const int);
    vector short vec_xxpermdi (vector short, vector short, const int);
    vector unsigned short vec_xxpermdi (vector unsigned short,
                                        vector unsigned short, const int);
    vector signed char vec_xxpermdi (vector signed char, vector signed char,
                                     const int);
    vector unsigned char vec_xxpermdi (vector unsigned char,
                                       vector unsigned char, const int);

    vector double vec_xxsldi (vector double, vector double, int);
    vector float vec_xxsldi (vector float, vector float, int);
    vector long long vec_xxsldi (vector long long, vector long long, int);
    vector unsigned long long vec_xxsldi (vector unsigned long long,
                                          vector unsigned long long, int);
    vector int vec_xxsldi (vector int, vector int, int);
    vector unsigned int vec_xxsldi (vector unsigned int, vector unsigned int, int);
    vector short vec_xxsldi (vector short, vector short, int);
    vector unsigned short vec_xxsldi (vector unsigned short,
                                      vector unsigned short, int);
    vector signed char vec_xxsldi (vector signed char, vector signed char, int);
    vector unsigned char vec_xxsldi (vector unsigned char,
                                     vector unsigned char, int);

Note that the ‘`vec_ld`’ and ‘`vec_st`’ built-in functions always generate the AltiVec ‘`LVX`’ and ‘`STVX`’ instructions even if the VSX instruction set is available. The ‘`vec_vsx_ld`’ and ‘`vec_vsx_st`’ built-in functions always generate the VSX ‘`LXVD2X`’, ‘`LXVW4X`’, ‘`STXVD2X`’, and ‘`STXVW4X`’ instructions.

If the ISA 2.07 additions to the vector/scalar (power8-vector) instruction set are available, the following additional functions are available for both 32-bit and 64-bit targets. For 64-bit targets, you can use vector long instead of vector long long, vector bool long instead of vector bool long long, and vector unsigned long instead of vector unsigned long long.

    vector long long vec_abs (vector long long);

    vector long long vec_add (vector long long, vector long long);
    vector unsigned long long vec_add (vector unsigned long long,
                                       vector unsigned long long);

    int vec_all_eq (vector long long, vector long long);
    int vec_all_eq (vector unsigned long long, vector unsigned long long);
    int vec_all_ge (vector long long, vector long long);
    int vec_all_ge (vector unsigned long long, vector unsigned long long);
    int vec_all_gt (vector long long, vector long long);
    int vec_all_gt (vector unsigned long long, vector unsigned long long);
    int vec_all_le (vector long long, vector long long);
    int vec_all_le (vector unsigned long long, vector unsigned long long);
    int vec_all_lt (vector long long, vector long long);
    int vec_all_lt (vector unsigned long long, vector unsigned long long);
    int vec_all_ne (vector long long, vector long long);
    int vec_all_ne (vector unsigned long long, vector unsigned long long);

    int vec_any_eq (vector long long, vector long long);
    int vec_any_eq (vector unsigned long long, vector unsigned long long);
    int vec_any_ge (vector long long, vector long long);
    int vec_any_ge (vector unsigned long long, vector unsigned long long);
    int vec_any_gt (vector long long, vector long long);
    int vec_any_gt (vector unsigned long long, vector unsigned long long);
    int vec_any_le (vector long long, vector long long);
    int vec_any_le (vector unsigned long long, vector unsigned long long);
    int vec_any_lt (vector long long, vector long long);
    int vec_any_lt (vector unsigned long long, vector unsigned long long);
    int vec_any_ne (vector long long, vector long long);
    int vec_any_ne (vector unsigned long long, vector unsigned long long);

    vector bool long long vec_cmpeq (vector bool long long, vector bool long long);

    vector long long vec_eqv (vector long long, vector long long);
    vector long long vec_eqv (vector bool long long, vector long long);
    vector long long vec_eqv (vector long long, vector bool long long);
    vector unsigned long long vec_eqv (vector unsigned long long,
                                       vector unsigned long long);
    vector unsigned long long vec_eqv (vector bool long long,
                                       vector unsigned long long);
    vector unsigned long long vec_eqv (vector unsigned long long,
                                       vector bool long long);
    vector int vec_eqv (vector int, vector int);
    vector int vec_eqv (vector bool int, vector int);
    vector int vec_eqv (vector int, vector bool int);
    vector unsigned int vec_eqv (vector unsigned int, vector unsigned int);
    vector unsigned int vec_eqv (vector bool unsigned int,
                                 vector unsigned int);
    vector unsigned int vec_eqv (vector unsigned int,
                                 vector bool unsigned int);
    vector short vec_eqv (vector short, vector short);
    vector short vec_eqv (vector bool short, vector short);
    vector short vec_eqv (vector short, vector bool short);
    vector unsigned short vec_eqv (vector unsigned short, vector unsigned short);
    vector unsigned short vec_eqv (vector bool unsigned short,
                                   vector unsigned short);
    vector unsigned short vec_eqv (vector unsigned short,
                                   vector bool unsigned short);
    vector signed char vec_eqv (vector signed char, vector signed char);
    vector signed char vec_eqv (vector bool signed char, vector signed char);
    vector signed char vec_eqv (vector signed char, vector bool signed char);
    vector unsigned char vec_eqv (vector unsigned char, vector unsigned char);
    vector unsigned char vec_eqv (vector bool unsigned char, vector unsigned char);
    vector unsigned char vec_eqv (vector unsigned char, vector bool unsigned char);

    vector long long vec_max (vector long long, vector long long);
    vector unsigned long long vec_max (vector unsigned long long,
                                       vector unsigned long long);

    vector signed int vec_mergee (vector signed int, vector signed int);
    vector unsigned int vec_mergee (vector unsigned int, vector unsigned int);
    vector bool int vec_mergee (vector bool int, vector bool int);

    vector signed int vec_mergeo (vector signed int, vector signed int);
    vector unsigned int vec_mergeo (vector unsigned int, vector unsigned int);
    vector bool int vec_mergeo (vector bool int, vector bool int);

    vector long long vec_min (vector long long, vector long long);
    vector unsigned long long vec_min (vector unsigned long long,
                                       vector unsigned long long);

    vector signed long long vec_nabs (vector signed long long);

    vector long long vec_nand (vector long long, vector long long);
    vector long long vec_nand (vector bool long long, vector long long);
    vector long long vec_nand (vector long long, vector bool long long);
    vector unsigned long long vec_nand (vector unsigned long long,
                                        vector unsigned long long);
    vector unsigned long long vec_nand (vector bool long long,
                                       vector unsigned long long);
    vector unsigned long long vec_nand (vector unsigned long long,
                                        vector bool long long);
    vector int vec_nand (vector int, vector int);
    vector int vec_nand (vector bool int, vector int);
    vector int vec_nand (vector int, vector bool int);
    vector unsigned int vec_nand (vector unsigned int, vector unsigned int);
    vector unsigned int vec_nand (vector bool unsigned int,
                                  vector unsigned int);
    vector unsigned int vec_nand (vector unsigned int,
                                  vector bool unsigned int);
    vector short vec_nand (vector short, vector short);
    vector short vec_nand (vector bool short, vector short);
    vector short vec_nand (vector short, vector bool short);
    vector unsigned short vec_nand (vector unsigned short, vector unsigned short);
    vector unsigned short vec_nand (vector bool unsigned short,
                                    vector unsigned short);
    vector unsigned short vec_nand (vector unsigned short,
                                    vector bool unsigned short);
    vector signed char vec_nand (vector signed char, vector signed char);
    vector signed char vec_nand (vector bool signed char, vector signed char);
    vector signed char vec_nand (vector signed char, vector bool signed char);
    vector unsigned char vec_nand (vector unsigned char, vector unsigned char);
    vector unsigned char vec_nand (vector bool unsigned char, vector unsigned char);
    vector unsigned char vec_nand (vector unsigned char, vector bool unsigned char);

    vector long long vec_orc (vector long long, vector long long);
    vector long long vec_orc (vector bool long long, vector long long);
    vector long long vec_orc (vector long long, vector bool long long);
    vector unsigned long long vec_orc (vector unsigned long long,
                                       vector unsigned long long);
    vector unsigned long long vec_orc (vector bool long long,
                                       vector unsigned long long);
    vector unsigned long long vec_orc (vector unsigned long long,
                                       vector bool long long);
    vector int vec_orc (vector int, vector int);
    vector int vec_orc (vector bool int, vector int);
    vector int vec_orc (vector int, vector bool int);
    vector unsigned int vec_orc (vector unsigned int, vector unsigned int);
    vector unsigned int vec_orc (vector bool unsigned int,
                                 vector unsigned int);
    vector unsigned int vec_orc (vector unsigned int,
                                 vector bool unsigned int);
    vector short vec_orc (vector short, vector short);
    vector short vec_orc (vector bool short, vector short);
    vector short vec_orc (vector short, vector bool short);
    vector unsigned short vec_orc (vector unsigned short, vector unsigned short);
    vector unsigned short vec_orc (vector bool unsigned short,
                                   vector unsigned short);
    vector unsigned short vec_orc (vector unsigned short,
                                   vector bool unsigned short);
    vector signed char vec_orc (vector signed char, vector signed char);
    vector signed char vec_orc (vector bool signed char, vector signed char);
    vector signed char vec_orc (vector signed char, vector bool signed char);
    vector unsigned char vec_orc (vector unsigned char, vector unsigned char);
    vector unsigned char vec_orc (vector bool unsigned char, vector unsigned char);
    vector unsigned char vec_orc (vector unsigned char, vector bool unsigned char);

    vector int vec_pack (vector long long, vector long long);
    vector unsigned int vec_pack (vector unsigned long long,
                                  vector unsigned long long);
    vector bool int vec_pack (vector bool long long, vector bool long long);
    vector float vec_pack (vector double, vector double);

    vector int vec_packs (vector long long, vector long long);
    vector unsigned int vec_packs (vector unsigned long long,
                                   vector unsigned long long);

    vector unsigned int vec_packsu (vector long long, vector long long);
    vector unsigned int vec_packsu (vector unsigned long long,
                                    vector unsigned long long);

    vector long long vec_rl (vector long long,
                             vector unsigned long long);
    vector long long vec_rl (vector unsigned long long,
                             vector unsigned long long);

    vector long long vec_sl (vector long long, vector unsigned long long);
    vector long long vec_sl (vector unsigned long long,
                             vector unsigned long long);

    vector long long vec_sr (vector long long, vector unsigned long long);
    vector unsigned long long char vec_sr (vector unsigned long long,
                                           vector unsigned long long);

    vector long long vec_sra (vector long long, vector unsigned long long);
    vector unsigned long long vec_sra (vector unsigned long long,
                                       vector unsigned long long);

    vector long long vec_sub (vector long long, vector long long);
    vector unsigned long long vec_sub (vector unsigned long long,
                                       vector unsigned long long);

    vector long long vec_unpackh (vector int);
    vector unsigned long long vec_unpackh (vector unsigned int);

    vector long long vec_unpackl (vector int);
    vector unsigned long long vec_unpackl (vector unsigned int);

    vector long long vec_vaddudm (vector long long, vector long long);
    vector long long vec_vaddudm (vector bool long long, vector long long);
    vector long long vec_vaddudm (vector long long, vector bool long long);
    vector unsigned long long vec_vaddudm (vector unsigned long long,
                                           vector unsigned long long);
    vector unsigned long long vec_vaddudm (vector bool unsigned long long,
                                           vector unsigned long long);
    vector unsigned long long vec_vaddudm (vector unsigned long long,
                                           vector bool unsigned long long);

    vector long long vec_vbpermq (vector signed char, vector signed char);
    vector long long vec_vbpermq (vector unsigned char, vector unsigned char);

    vector unsigned char vec_bperm (vector unsigned char, vector unsigned char);
    vector unsigned long long vec_bperm (vector unsigned __int128,
                                         vector unsigned char);

    vector long long vec_cntlz (vector long long);
    vector unsigned long long vec_cntlz (vector unsigned long long);
    vector int vec_cntlz (vector int);
    vector unsigned int vec_cntlz (vector int);
    vector short vec_cntlz (vector short);
    vector unsigned short vec_cntlz (vector unsigned short);
    vector signed char vec_cntlz (vector signed char);
    vector unsigned char vec_cntlz (vector unsigned char);

    vector long long vec_vclz (vector long long);
    vector unsigned long long vec_vclz (vector unsigned long long);
    vector int vec_vclz (vector int);
    vector unsigned int vec_vclz (vector int);
    vector short vec_vclz (vector short);
    vector unsigned short vec_vclz (vector unsigned short);
    vector signed char vec_vclz (vector signed char);
    vector unsigned char vec_vclz (vector unsigned char);

    vector signed char vec_vclzb (vector signed char);
    vector unsigned char vec_vclzb (vector unsigned char);

    vector long long vec_vclzd (vector long long);
    vector unsigned long long vec_vclzd (vector unsigned long long);

    vector short vec_vclzh (vector short);
    vector unsigned short vec_vclzh (vector unsigned short);

    vector int vec_vclzw (vector int);
    vector unsigned int vec_vclzw (vector int);

    vector signed char vec_vgbbd (vector signed char);
    vector unsigned char vec_vgbbd (vector unsigned char);

    vector long long vec_vmaxsd (vector long long, vector long long);

    vector unsigned long long vec_vmaxud (vector unsigned long long,
                                          unsigned vector long long);

    vector long long vec_vminsd (vector long long, vector long long);

    vector unsigned long long vec_vminud (vector long long,
                                          vector long long);

    vector int vec_vpksdss (vector long long, vector long long);
    vector unsigned int vec_vpksdss (vector long long, vector long long);

    vector unsigned int vec_vpkudus (vector unsigned long long,
                                     vector unsigned long long);

    vector int vec_vpkudum (vector long long, vector long long);
    vector unsigned int vec_vpkudum (vector unsigned long long,
                                     vector unsigned long long);
    vector bool int vec_vpkudum (vector bool long long, vector bool long long);

    vector long long vec_vpopcnt (vector long long);
    vector unsigned long long vec_vpopcnt (vector unsigned long long);
    vector int vec_vpopcnt (vector int);
    vector unsigned int vec_vpopcnt (vector int);
    vector short vec_vpopcnt (vector short);
    vector unsigned short vec_vpopcnt (vector unsigned short);
    vector signed char vec_vpopcnt (vector signed char);
    vector unsigned char vec_vpopcnt (vector unsigned char);

    vector signed char vec_vpopcntb (vector signed char);
    vector unsigned char vec_vpopcntb (vector unsigned char);

    vector long long vec_vpopcntd (vector long long);
    vector unsigned long long vec_vpopcntd (vector unsigned long long);

    vector short vec_vpopcnth (vector short);
    vector unsigned short vec_vpopcnth (vector unsigned short);

    vector int vec_vpopcntw (vector int);
    vector unsigned int vec_vpopcntw (vector int);

    vector long long vec_vrld (vector long long, vector unsigned long long);
    vector unsigned long long vec_vrld (vector unsigned long long,
                                        vector unsigned long long);

    vector long long vec_vsld (vector long long, vector unsigned long long);
    vector long long vec_vsld (vector unsigned long long,
                               vector unsigned long long);

    vector long long vec_vsrad (vector long long, vector unsigned long long);
    vector unsigned long long vec_vsrad (vector unsigned long long,
                                         vector unsigned long long);

    vector long long vec_vsrd (vector long long, vector unsigned long long);
    vector unsigned long long char vec_vsrd (vector unsigned long long,
                                             vector unsigned long long);

    vector long long vec_vsubudm (vector long long, vector long long);
    vector long long vec_vsubudm (vector bool long long, vector long long);
    vector long long vec_vsubudm (vector long long, vector bool long long);
    vector unsigned long long vec_vsubudm (vector unsigned long long,
                                           vector unsigned long long);
    vector unsigned long long vec_vsubudm (vector bool long long,
                                           vector unsigned long long);
    vector unsigned long long vec_vsubudm (vector unsigned long long,
                                           vector bool long long);

    vector long long vec_vupkhsw (vector int);
    vector unsigned long long vec_vupkhsw (vector unsigned int);

    vector long long vec_vupklsw (vector int);
    vector unsigned long long vec_vupklsw (vector int);

If the ISA 2.07 additions to the vector/scalar (power8-vector) instruction set are available, the following additional functions are available for 64-bit targets. New vector types (vector __int128_t and vector __uint128_t) are available to hold the __int128_t and __uint128_t types to use these builtins.

The normal vector extract, and set operations work on vector __int128_t and vector __uint128_t types, but the index value must be 0.

    vector __int128_t vec_vaddcuq (vector __int128_t, vector __int128_t);
    vector __uint128_t vec_vaddcuq (vector __uint128_t, vector __uint128_t);

    vector __int128_t vec_vadduqm (vector __int128_t, vector __int128_t);
    vector __uint128_t vec_vadduqm (vector __uint128_t, vector __uint128_t);

    vector __int128_t vec_vaddecuq (vector __int128_t, vector __int128_t,
                                    vector __int128_t);
    vector __uint128_t vec_vaddecuq (vector __uint128_t, vector __uint128_t,
                                     vector __uint128_t);

    vector __int128_t vec_vaddeuqm (vector __int128_t, vector __int128_t,
                                    vector __int128_t);
    vector __uint128_t vec_vaddeuqm (vector __uint128_t, vector __uint128_t,
                                     vector __uint128_t);

    vector __int128_t vec_vsubecuq (vector __int128_t, vector __int128_t,
                                    vector __int128_t);
    vector __uint128_t vec_vsubecuq (vector __uint128_t, vector __uint128_t,
                                     vector __uint128_t);

    vector __int128_t vec_vsubeuqm (vector __int128_t, vector __int128_t,
                                    vector __int128_t);
    vector __uint128_t vec_vsubeuqm (vector __uint128_t, vector __uint128_t,
                                     vector __uint128_t);

    vector __int128_t vec_vsubcuq (vector __int128_t, vector __int128_t);
    vector __uint128_t vec_vsubcuq (vector __uint128_t, vector __uint128_t);

    __int128_t vec_vsubuqm (__int128_t, __int128_t);
    __uint128_t vec_vsubuqm (__uint128_t, __uint128_t);

    vector __int128_t __builtin_bcdadd (vector __int128_t, vector__int128_t);
    int __builtin_bcdadd_lt (vector __int128_t, vector__int128_t);
    int __builtin_bcdadd_eq (vector __int128_t, vector__int128_t);
    int __builtin_bcdadd_gt (vector __int128_t, vector__int128_t);
    int __builtin_bcdadd_ov (vector __int128_t, vector__int128_t);
    vector __int128_t bcdsub (vector __int128_t, vector__int128_t);
    int __builtin_bcdsub_lt (vector __int128_t, vector__int128_t);
    int __builtin_bcdsub_eq (vector __int128_t, vector__int128_t);
    int __builtin_bcdsub_gt (vector __int128_t, vector__int128_t);
    int __builtin_bcdsub_ov (vector __int128_t, vector__int128_t);

If the ISA 3.0 instruction set additions (`-mcpu=power9`) are available:

    vector unsigned long long vec_bperm (vector unsigned long long,
                                         vector unsigned char);

    vector bool char vec_cmpne (vector bool char, vector bool char);
    vector bool short vec_cmpne (vector bool short, vector bool short);
    vector bool int vec_cmpne (vector bool int, vector bool int);
    vector bool long long vec_cmpne (vector bool long long, vector bool long long);

    vector long long vec_vctz (vector long long);
    vector unsigned long long vec_vctz (vector unsigned long long);
    vector int vec_vctz (vector int);
    vector unsigned int vec_vctz (vector int);
    vector short vec_vctz (vector short);
    vector unsigned short vec_vctz (vector unsigned short);
    vector signed char vec_vctz (vector signed char);
    vector unsigned char vec_vctz (vector unsigned char);

    vector signed char vec_vctzb (vector signed char);
    vector unsigned char vec_vctzb (vector unsigned char);

    vector long long vec_vctzd (vector long long);
    vector unsigned long long vec_vctzd (vector unsigned long long);

    vector short vec_vctzh (vector short);
    vector unsigned short vec_vctzh (vector unsigned short);

    vector int vec_vctzw (vector int);
    vector unsigned int vec_vctzw (vector int);

    long long vec_vextract4b (const vector signed char, const int);
    long long vec_vextract4b (const vector unsigned char, const int);

    vector signed char vec_insert4b (vector int, vector signed char, const int);
    vector unsigned char vec_insert4b (vector unsigned int, vector unsigned char,
                                       const int);
    vector signed char vec_insert4b (long long, vector signed char, const int);
    vector unsigned char vec_insert4b (long long, vector unsigned char, const int);

    vector int vec_vprtyb (vector int);
    vector unsigned int vec_vprtyb (vector unsigned int);
    vector long long vec_vprtyb (vector long long);
    vector unsigned long long vec_vprtyb (vector unsigned long long);

    vector int vec_vprtybw (vector int);
    vector unsigned int vec_vprtybw (vector unsigned int);

    vector long long vec_vprtybd (vector long long);
    vector unsigned long long vec_vprtybd (vector unsigned long long);

On 64-bit targets, if the ISA 3.0 additions (`-mcpu=power9`) are available:

    vector long vec_vprtyb (vector long);
    vector unsigned long vec_vprtyb (vector unsigned long);
    vector __int128_t vec_vprtyb (vector __int128_t);
    vector __uint128_t vec_vprtyb (vector __uint128_t);

    vector long vec_vprtybd (vector long);
    vector unsigned long vec_vprtybd (vector unsigned long);

    vector __int128_t vec_vprtybq (vector __int128_t);
    vector __uint128_t vec_vprtybd (vector __uint128_t);

The following built-in vector functions are available for the PowerPC family of processors, starting with ISA 3.0 or later (`-mcpu=power9`):

    __vector unsigned char
    vec_slv (__vector unsigned char src, __vector unsigned char shift_distance);
    __vector unsigned char
    vec_srv (__vector unsigned char src, __vector unsigned char shift_distance);

The `vec_slv` and `vec_srv` functions operate on all of the bytes of their `src` and `shift_distance` arguments in parallel. The behavior of the `vec_slv` is as if there existed a temporary array of 17 unsigned characters `slv_array` within which elements 0 through 15 are the same as the entries in the `src` array and element 16 equals 0. The result returned from the `vec_slv` function is a `__vector` of 16 unsigned characters within which element `i` is computed using the C expression `0xff & (*((unsigned short *)(slv_array + i)) << (0x07 & shift_distance[i]))`, with this resulting value coerced to the `unsigned char` type. The behavior of the `vec_srv` is as if there existed a temporary array of 17 unsigned characters `srv_array` within which element 0 equals zero and elements 1 through 16 equal the elements 0 through 15 of the `src` array. The result returned from the `vec_srv` function is a `__vector` of 16 unsigned characters within which element `i` is computed using the C expression `0xff & (*((unsigned short *)(srv_array + i)) >> (0x07 & shift_distance[i]))`, with this resulting value coerced to the `unsigned char` type.

The following built-in functions are available for the PowerPC family of processors, starting with ISA 3.0 or later (`-mcpu=power9`):

    __vector unsigned char
    vec_absd (__vector unsigned char arg1, __vector unsigned char arg2);
    __vector unsigned short
    vec_absd (__vector unsigned short arg1, __vector unsigned short arg2);
    __vector unsigned int
    vec_absd (__vector unsigned int arg1, __vector unsigned int arg2);

    __vector unsigned char
    vec_absdb (__vector unsigned char arg1, __vector unsigned char arg2);
    __vector unsigned short
    vec_absdh (__vector unsigned short arg1, __vector unsigned short arg2);
    __vector unsigned int
    vec_absdw (__vector unsigned int arg1, __vector unsigned int arg2);

The `vec_absd`, `vec_absdb`, `vec_absdh`, and `vec_absdw` built-in functions each computes the absolute differences of the pairs of vector elements supplied in its two vector arguments, placing the absolute differences into the corresponding elements of the vector result.

The following built-in functions are available for the PowerPC family of processors, starting with ISA 3.0 or later (`-mcpu=power9`):

    __vector unsigned int
    vec_extract_exp (__vector float source);
    __vector unsigned long long int
    vec_extract_exp (__vector double source);

    __vector unsigned int
    vec_extract_sig (__vector float source);
    __vector unsigned long long int
    vec_extract_sig (__vector double source);

    __vector float
    vec_insert_exp (__vector unsigned int significands,
                    __vector unsigned int exponents);
    __vector float
    vec_insert_exp (__vector unsigned float significands,
                    __vector unsigned int exponents);
    __vector double
    vec_insert_exp (__vector unsigned long long int significands,
                    __vector unsigned long long int exponents);
    __vector double
    vec_insert_exp (__vector unsigned double significands,
                    __vector unsigned long long int exponents);

    __vector bool int vec_test_data_class (__vector float source,
                                           const int condition);
    __vector bool long long int vec_test_data_class (__vector double source,
                                                     const int condition);

The `vec_extract_sig` and `vec_extract_exp` built-in functions return vectors representing the significands and biased exponent values of their `source` arguments respectively. Within the result vector returned by `vec_extract_sig`, the `0x800000` bit of each vector element returned when the function’s `source` argument is of type `float` is set to 1 if the corresponding floating point value is in normalized form. Otherwise, this bit is set to 0. When the `source` argument is of type `double`, the `0x10000000000000` bit within each of the result vector’s elements is set according to the same rules. Note that the sign of the significand is not represented in the result returned from the `vec_extract_sig` function. To extract the sign bits, use the `vec_cpsgn` function, which returns a new vector within which all of the sign bits of its second argument vector are overwritten with the sign bits copied from the coresponding elements of its first argument vector, and all other (non-sign) bits of the second argument vector are copied unchanged into the result vector.

The `vec_insert_exp` built-in functions return a vector of single- or double-precision floating point values constructed by assembling the values of their `significands` and `exponents` arguments into the corresponding elements of the returned vector. The sign of each element of the result is copied from the most significant bit of the corresponding entry within the `significands` argument. Note that the relevant bits of the `significands` argument are the same, for both integer and floating point types. The significand and exponent components of each element of the result are composed of the least significant bits of the corresponding `significands` element and the least significant bits of the corresponding `exponents` element.

The `vec_test_data_class` built-in function returns a vector representing the results of testing the `source` vector for the condition selected by the `condition` argument. The `condition` argument must be a compile-time constant integer with value not exceeding 127. The `condition` argument is encoded as a bitmask with each bit enabling the testing of a different condition, as characterized by the following:

    0x40    Test for NaN
    0x20    Test for +Infinity
    0x10    Test for -Infinity
    0x08    Test for +Zero
    0x04    Test for -Zero
    0x02    Test for +Denormal
    0x01    Test for -Denormal

If any of the enabled test conditions is true, the corresponding entry in the result vector is -1. Otherwise (all of the enabled test conditions are false), the corresponding entry of the result vector is 0.

The following built-in functions are available for the PowerPC family of processors, starting with ISA 3.0 or later (`-mcpu=power9`):

    vector unsigned int vec_rlmi (vector unsigned int, vector unsigned int,
                                  vector unsigned int);
    vector unsigned long long vec_rlmi (vector unsigned long long,
                                        vector unsigned long long,
                                        vector unsigned long long);
    vector unsigned int vec_rlnm (vector unsigned int, vector unsigned int,
                                  vector unsigned int);
    vector unsigned long long vec_rlnm (vector unsigned long long,
                                        vector unsigned long long,
                                        vector unsigned long long);
    vector unsigned int vec_vrlnm (vector unsigned int, vector unsigned int);
    vector unsigned long long vec_vrlnm (vector unsigned long long,
                                         vector unsigned long long);

The result of `vec_rlmi` is obtained by rotating each element of the first argument vector left and inserting it under mask into the second argument vector. The third argument vector contains the mask beginning in bits 11:15, the mask end in bits 19:23, and the shift count in bits 27:31, of each element.

The result of `vec_rlnm` is obtained by rotating each element of the first argument vector left and ANDing it with a mask specified by the second and third argument vectors. The second argument vector contains the shift count for each element in the low-order byte. The third argument vector contains the mask end for each element in the low-order byte, with the mask begin in the next higher byte.

The result of `vec_vrlnm` is obtained by rotating each element of the first argument vector left and ANDing it with a mask. The second argument vector contains the mask beginning in bits 11:15, the mask end in bits 19:23, and the shift count in bits 27:31, of each element.

If the ISA 3.0 instruction set additions (`-mcpu=power9`) are available:

    vector signed char vec_revb (vector signed char);
    vector unsigned char vec_revb (vector unsigned char);
    vector short vec_revb (vector short);
    vector unsigned short vec_revb (vector unsigned short);
    vector int vec_revb (vector int);
    vector unsigned int vec_revb (vector unsigned int);
    vector float vec_revb (vector float);
    vector long long vec_revb (vector long long);
    vector unsigned long long vec_revb (vector unsigned long long);
    vector double vec_revb (vector double);

On 64-bit targets, if the ISA 3.0 additions (`-mcpu=power9`) are available:

    vector long vec_revb (vector long);
    vector unsigned long vec_revb (vector unsigned long);
    vector __int128_t vec_revb (vector __int128_t);
    vector __uint128_t vec_revb (vector __uint128_t);

The `vec_revb` built-in function reverses the bytes on an element by element basis. A vector of `vector unsigned char` or `vector signed char` reverses the bytes in the whole word.

If the cryptographic instructions are enabled (`-mcrypto` or `-mcpu=power8`), the following builtins are enabled.

    vector unsigned long long __builtin_crypto_vsbox (vector unsigned long long);

    vector unsigned long long __builtin_crypto_vcipher (vector unsigned long long,
                                                        vector unsigned long long);

    vector unsigned long long __builtin_crypto_vcipherlast
                                         (vector unsigned long long,
                                          vector unsigned long long);

    vector unsigned long long __builtin_crypto_vncipher (vector unsigned long long,
                                                         vector unsigned long long);

    vector unsigned long long __builtin_crypto_vncipherlast
                                         (vector unsigned long long,
                                          vector unsigned long long);

    vector unsigned char __builtin_crypto_vpermxor (vector unsigned char,
                                                    vector unsigned char,
                                                    vector unsigned char);

    vector unsigned short __builtin_crypto_vpermxor (vector unsigned short,
                                                     vector unsigned short,
                                                     vector unsigned short);

    vector unsigned int __builtin_crypto_vpermxor (vector unsigned int,
                                                   vector unsigned int,
                                                   vector unsigned int);

    vector unsigned long long __builtin_crypto_vpermxor (vector unsigned long long,
                                                         vector unsigned long long,
                                                         vector unsigned long long);

    vector unsigned char __builtin_crypto_vpmsumb (vector unsigned char,
                                                   vector unsigned char);

    vector unsigned short __builtin_crypto_vpmsumb (vector unsigned short,
                                                    vector unsigned short);

    vector unsigned int __builtin_crypto_vpmsumb (vector unsigned int,
                                                  vector unsigned int);

    vector unsigned long long __builtin_crypto_vpmsumb (vector unsigned long long,
                                                        vector unsigned long long);

    vector unsigned long long __builtin_crypto_vshasigmad
                                   (vector unsigned long long, int, int);

    vector unsigned int __builtin_crypto_vshasigmaw (vector unsigned int,
                                                     int, int);

The second argument to __builtin_crypto_vshasigmad and __builtin_crypto_vshasigmaw must be a constant integer that is 0 or 1. The third argument to these built-in functions must be a constant integer in the range of 0 to 15.

If the ISA 3.0 instruction set additions are enabled (`-mcpu=power9`), the following additional functions are available for both 32-bit and 64-bit targets.

vector short vec_xl (int, vector short *); vector short vec_xl (int, short *); vector unsigned short vec_xl (int, vector unsigned short *); vector unsigned short vec_xl (int, unsigned short *); vector char vec_xl (int, vector char *); vector char vec_xl (int, char *); vector unsigned char vec_xl (int, vector unsigned char *); vector unsigned char vec_xl (int, unsigned char *);

void vec_xst (vector short, int, vector short *); void vec_xst (vector short, int, short *); void vec_xst (vector unsigned short, int, vector unsigned short *); void vec_xst (vector unsigned short, int, unsigned short *); void vec_xst (vector char, int, vector char *); void vec_xst (vector char, int, char *); void vec_xst (vector unsigned char, int, vector unsigned char *); void vec_xst (vector unsigned char, int, unsigned char *);

Next: PowerPC Hardware Transactional Memory Built-in Functions, Previous: PowerPC Built-in Functions, Up: Target Builtins [Contents][Index]