CbC/CbC_gcc: gcc/doc/extend.texi comparison

comparison gcc/doc/extend.texi @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
-c Copyright (C) 1988-2017 Free Software Foundation, Inc.
+c Copyright (C) 1988-2018 Free Software Foundation, Inc.
 @c This is part of the GCC manual.
 @c For copying conditions, see the file gcc.texi.
 @node C Extensions
 @menu
 * Statement Exprs::     Putting statements and declarations inside expressions.
 * Local Labels::        Labels local to a block.
 * Labels as Values::    Getting pointers to labels, and computed gotos.
-* Nested Functions::    As in Algol and Pascal, lexical scoping of functions.
+* Nested Functions::    Nested function in GNU C.
 * Constructing Calls::  Dispatching a call to another function.
 * Typeof::              @code{typeof}: referring to the type of an expression.
 * Conditionals::        Omitting the middle operand of a @samp{?:} expression.
 * __int128::		128-bit integers---@code{__int128}.
 * Long Long::           Double-word integers---@code{long long int}.
 * Integer Overflow Builtins:: Built-in functions to perform arithmetics and
 arithmetic overflow checking.
 * x86 specific memory model extensions for transactional memory:: x86 memory models.
 * Object Size Checking:: Built-in functions for limited buffer overflow
 checking.
-* Pointer Bounds Checker builtins:: Built-in functions for Pointer Bounds Checker.
-* Cilk Plus Builtins::  Built-in functions for the Cilk Plus language extension.
 * Other Builtins::      Other built-in functions.
 * Target Builtins::     Built-in functions specific to particular targets.
 * Target Format Checks:: Format checks specific to particular targets.
 * Pragmas::             Pragmas accepted by GCC.
 * Unnamed Fields::      Unnamed struct/union fields within structs/unions.
 @cindex double-word arithmetic
 @cindex multiprecision arithmetic
 @cindex @code{LL} integer suffix
 @cindex @code{ULL} integer suffix
-ISO C99 supports data types for integers that are at least 64 bits wide,
+ISO C99 and ISO C++11 support data types for integers that are at least
-and as an extension GCC supports them in C90 mode and in C++.
+64 bits wide, and as an extension GCC supports them in C90 and C++98 modes.
 Simply write @code{long long int} for a signed integer, or
 @code{unsigned long long int} for an unsigned integer.  To make an
 integer constant of type @code{long long int}, add the suffix @samp{LL}
 to the integer.  To make an integer constant of type @code{unsigned long
 long int}, add the suffix @samp{ULL} to the integer.
 value, but you can form any complex value you like by adding one to a
 real constant.  This is a GNU extension; if you have an ISO C99
 conforming C library (such as the GNU C Library), and want to construct complex
 constants of floating type, you should include @code{<complex.h>} and
 use the macros @code{I} or @code{_Complex_I} instead.
+The ISO C++14 library also defines the @samp{i} suffix, so C++14 code
+that includes the @samp{<complex>} header cannot use @samp{i} for the
+GNU extension.  The @samp{j} suffix still has the GNU meaning.
 @cindex @code{__real__} keyword
 @cindex @code{__imag__} keyword
 To extract the real part of a complex-valued expression @var{exp}, write
 @code{__real__ @var{exp}}.  Likewise, use @code{__imag__} to
 arithmetic and other operations, @code{__fp16} values in C or C++
 expressions are automatically promoted to @code{float}.
 The ARM target provides hardware support for conversions between
 @code{__fp16} and @code{float} values
-as an extension to VFP and NEON (Advanced SIMD), and from ARMv8 provides
+as an extension to VFP and NEON (Advanced SIMD), and from ARMv8-A provides
 hardware support for conversions between @code{__fp16} and @code{double}
 values.  GCC generates code using these hardware instructions if you
 compile with options to select an FPU that provides them;
 for example, @option{-mfpu=neon-fp16 -mfloat-abi=softfp},
 in addition to the @option{-mfp16-format} option to select
 @node Hex Floats
 @section Hex Floats
 @cindex hex floats
-ISO C99 supports floating-point numbers written not only in the usual
+ISO C99 and ISO C++17 support floating-point numbers written not only in
-decimal notation, such as @code{1.55e1}, but also numbers such as
+the usual decimal notation, such as @code{1.55e1}, but also numbers such as
 @code{0x1.fp3} written in hexadecimal format.  As a GNU extension, GCC
 supports this in C90 mode (except in some cases when strictly
-conforming) and in C++.  In that format the
+conforming) and in C++98, C++11 and C++14 modes.  In that format the
 @samp{0x} hex introducer and the @samp{p} or @samp{P} exponent field are
 mandatory.  The exponent is a decimal number that indicates the power of
 2 by which the significant part is multiplied.  Thus @samp{0x1.f} is
 @tex
 $1 {15\over16}$,
 @cindex arrays of length zero
 @cindex zero-length arrays
 @cindex length-zero arrays
 @cindex flexible array members
-Zero-length arrays are allowed in GNU C@.  They are very useful as the
+Declaring zero-length arrays is allowed in GNU C as an extension.
-last element of a structure that is really a header for a variable-length
+A zero-length array can be useful as the last element of a structure
-object:
+that is really a header for a variable-length object:
 @smallexample
 struct line @{
 int length;
 char contents[0];
 struct line *thisline = (struct line *)
 malloc (sizeof (struct line) + this_length);
 thisline->length = this_length;
 @end smallexample
-In ISO C90, you would have to give @code{contents} a length of 1, which
+Although the size of a zero-length array is zero, an array member of
-means either you waste space or complicate the argument to @code{malloc}.
+this kind may increase the size of the enclosing type as a result of tail
+padding.  The offset of a zero-length array member from the beginning
-In ISO C99, you would use a @dfn{flexible array member}, which is
+of the enclosing structure is the same as the offset of an array with
-slightly different in syntax and semantics:
+one or more elements of the same type.  The alignment of a zero-length
+array is the same as the alignment of its elements.
+Declaring zero-length arrays in other contexts, including as interior
+members of structure objects or as non-member objects, is discouraged.
+Accessing elements of zero-length arrays declared in such contexts is
+undefined and may be diagnosed.
+In the absence of the zero-length array extension, in ISO C90
+the @code{contents} array in the example above would typically be declared
+to have a single element.  Unlike a zero-length array which only contributes
+to the size of the enclosing structure for the purposes of alignment,
+a one-element array always occupies at least as much space as a single
+object of the type.  Although using one-element arrays this way is
+discouraged, GCC handles accesses to trailing one-element array members
+analogously to zero-length arrays.
+The preferred mechanism to declare variable-length types like
+@code{struct line} above is the ISO C99 @dfn{flexible array member},
+with slightly different syntax and semantics:
 @itemize @bullet
 @item
 Flexible array members are written as @code{contents[]} without
 the @code{0}.
 @smallexample
 int widths[] = @{ [0 ... 9] = 1, [10 ... 99] = 2, [100] = 3 @};
 @end smallexample
 @noindent
-If the value in it has side-effects, the side-effects happen only once,
+If the value in it has side effects, the side effects happen only once,
 not for each initialized field by the range initializer.
 @noindent
 Note that the length of the array is the highest value specified
 plus one.
 @end smallexample
 @noindent
 If the same field is initialized multiple times, it has the value from
 the last initialization.  If any such overridden initialization has
-side-effect, it is unspecified whether the side-effect happens or not.
+side effect, it is unspecified whether the side effect happens or not.
 Currently, GCC discards them and issues a warning.
 @node Case Ranges
 @section Case Ranges
 @cindex case ranges
 Function attributes are introduced by the @code{__attribute__} keyword
 on a declaration, followed by an attribute specification inside double
 parentheses.  You can specify multiple attributes in a declaration by
 separating them by commas within the double parentheses or by
 immediately following an attribute declaration with another attribute
-declaration.  @xref{Attribute Syntax}, for the exact rules on
+declaration.  @xref{Attribute Syntax}, for the exact rules on attribute
-attribute syntax and placement.
+syntax and placement.  Compatible attribute specifications on distinct
+declarations of the same function are merged.  An attribute specification
+that is not compatible with attributes already applied to a declaration
+of the same function is ignored with a warning.
 GCC also supports attributes on
 variable declarations (@pxref{Variable Attributes}),
 labels (@pxref{Label Attributes}),
 enumerators (@pxref{Enumerator Attributes}),
 * ARC Function Attributes::
 * ARM Function Attributes::
 * AVR Function Attributes::
 * Blackfin Function Attributes::
 * CR16 Function Attributes::
+* C-SKY Function Attributes::
 * Epiphany Function Attributes::
 * H8/300 Function Attributes::
 * IA-64 Function Attributes::
 * M32C Function Attributes::
 * M32R/D Function Attributes::
 * MSP430 Function Attributes::
 * NDS32 Function Attributes::
 * Nios II Function Attributes::
 * Nvidia PTX Function Attributes::
 * PowerPC Function Attributes::
+* RISC-V Function Attributes::
 * RL78 Function Attributes::
 * RX Function Attributes::
 * S/390 Function Attributes::
 * SH Function Attributes::
 * SPU Function Attributes::
 @noindent
 declares that @code{my_alloc1} returns 16-byte aligned pointer and
 that @code{my_alloc2} returns a pointer whose value modulo 32 is equal
 to 8.
-@item bnd_instrument
-@cindex @code{bnd_instrument} function attribute
-The @code{bnd_instrument} attribute on functions is used to inform the
-compiler that the function should be instrumented when compiled
-with the @option{-fchkp-instrument-marked-only} option.
-@item bnd_legacy
-@cindex @code{bnd_legacy} function attribute
-@cindex Pointer Bounds Checker attributes
-The @code{bnd_legacy} attribute on functions is used to inform the
-compiler that the function should not be instrumented when compiled
-with the @option{-fcheck-pointer-bounds} option.
 @item cold
 @cindex @code{cold} function attribute
 The @code{cold} attribute on functions is used to inform the compiler that
 the function is unlikely to be executed.  The function is optimized for
 size rather than speed and on many targets it is placed into a special
 @item const
 @cindex @code{const} function attribute
 @cindex functions that have no side effects
 Many functions do not examine any values except their arguments, and
-have no effects except the return value.  Basically this is just slightly
+have no effects except to return a value.  Calls to such functions lend
-more strict class than the @code{pure} attribute below, since function is not
+themselves to optimization such as common subexpression elimination.
-allowed to read global memory.
+The @code{const} attribute imposes greater restrictions on a function's
+definition than the similar @code{pure} attribute below because it prohibits
+the function from reading global variables.  Consequently, the presence of
+the attribute on a function declaration allows GCC to emit more efficient
+code for some calls to the function.  Decorating the same function with
+both the @code{const} and the @code{pure} attribute is diagnosed.
 @cindex pointer arguments
 Note that a function that has pointer arguments and examines the data
 pointed to must @emph{not} be declared @code{const}.  Likewise, a
 function that calls a non-@code{const} function usually must not be
-@code{const}.  It does not make sense for a @code{const} function to
+@code{const}.  Because a @code{const} function cannot have any side
-return @code{void}.
+effects it does not make sense for such a function to return @code{void}.
+Declaring such a function is diagnosed.
 @item constructor
 @itemx destructor
 @itemx constructor (@var{priority})
 @itemx destructor (@var{priority})
 present.
 The @code{deprecated} attribute can also be used for variables and
 types (@pxref{Variable Attributes}, @pxref{Type Attributes}.)
+The message attached to the attribute is affected by the setting of
+the @option{-fmessage-length} option.
 @item error ("@var{message}")
 @itemx warning ("@var{message}")
 @cindex @code{error} function attribute
 @cindex @code{warning} function attribute
 If the @code{error} or @code{warning} attribute
 @item flatten
 @cindex @code{flatten} function attribute
 Generally, inlining into a function is limited.  For a function marked with
 this attribute, every call inside this function is inlined, if possible.
-Whether the function itself is considered for inlining depends on its size and
+Functions declared with attribute @code{noinline} and similar are not
-the current inlining parameters.
+inlined.  Whether the function itself is considered for inlining depends
+on its size and the current inlining parameters.
 @item format (@var{archetype}, @var{string-index}, @var{first-to-check})
 @cindex @code{format} function attribute
 @cindex functions with @code{printf}, @code{scanf}, @code{strftime} or @code{strfmon} style arguments
 @opindex Wformat
 Target Machines}.
 @item format_arg (@var{string-index})
 @cindex @code{format_arg} function attribute
 @opindex Wformat-nonliteral
-The @code{format_arg} attribute specifies that a function takes a format
+The @code{format_arg} attribute specifies that a function takes one or
-string for a @code{printf}, @code{scanf}, @code{strftime} or
+more format strings for a @code{printf}, @code{scanf}, @code{strftime} or
 @code{strfmon} style function and modifies it (for example, to translate
 it into another language), so the result can be passed to a
 @code{printf}, @code{scanf}, @code{strftime} or @code{strfmon} style
 function (with the remaining arguments to the format function the same
-as they would have been for the unmodified string).  For example, the
+as they would have been for the unmodified string).  Multiple
+@code{format_arg} attributes may be applied to the same function, each
+designating a distinct parameter as a format string.  For example, the
 declaration:
 @smallexample
 extern char *
 my_dgettext (char *my_domain, const char *my_format)
 @code{format_arg} attribute had not been specified, all the compiler
 could tell in such calls to format functions would be that the format
 string argument is not constant; this would generate a warning when
 @option{-Wformat-nonliteral} is used, but the calls could not be checked
 without the attribute.
+In calls to a function declared with more than one @code{format_arg}
+attribute, each with a distinct argument value, the corresponding
+actual function arguments are checked against all format strings
+designated by the attributes.  This capability is designed to support
+the GNU @code{ngettext} family of functions.
 The parameter @var{string-index} specifies which argument is the format
 string argument (starting from one).  Since non-static C++ methods have
 an implicit @code{this} argument, the arguments of such methods should
 be counted from two.
 This tells the compiler that a function is @code{malloc}-like, i.e.,
 that the pointer @var{P} returned by the function cannot alias any
 other pointer valid when the function returns, and moreover no
 pointers to valid objects occur in any storage addressed by @var{P}.
-Using this attribute can improve optimization.  Functions like
+Using this attribute can improve optimization.  Compiler predicts
+that a function with the attribute returns non-null in most cases.
+Functions like
 @code{malloc} and @code{calloc} have this property because they return
 a pointer to uninitialized or zeroed-out storage.  However, functions
 like @code{realloc} do not have this property, as they can return a
 pointer to storage containing pointers.
 @option{-fsanitize} option can be provided.
 @smallexample
 void __attribute__ ((no_sanitize ("alignment", "object-size")))
 f () @{ /* @r{Do something.} */; @}
+void __attribute__ ((no_sanitize ("alignment,object-size")))
+g () @{ /* @r{Do something.} */; @}
 @end smallexample
 @item no_sanitize_address
 @itemx no_address_safety_analysis
 @cindex @code{no_sanitize_address} function attribute
 @cindex @code{noinline} function attribute
 This function attribute prevents a function from being considered for
 inlining.
 @c Don't enumerate the optimizations by name here; we try to be
 @c future-compatible with this mechanism.
-If the function does not have side-effects, there are optimizations
+If the function does not have side effects, there are optimizations
 other than inlining that cause function calls to be optimized away,
 although the function call is live.  To keep such calls from being
 optimized away, put
 @smallexample
 asm ("");
 @end smallexample
 @noindent
 (@pxref{Extended Asm}) in the called function, to serve as a special
-side-effect.
+side effect.
 @item noipa
 @cindex @code{noipa} function attribute
 Disable interprocedural optimizations between the function with this
 attribute and its callers, as if the body of the function is not available
 existing and future optimizations employing interprocedural analysis,
 including those that do not have an attribute suitable for disabling
 them individually.  This attribute is supported mainly for the purpose
 of testing the compiler.
-@item nonnull (@var{arg-index}, @dots{})
+@item nonnull
+@itemx nonnull (@var{arg-index}, @dots{})
 @cindex @code{nonnull} function attribute
 @cindex functions with non-null pointer arguments
 The @code{nonnull} attribute specifies that some function parameters should
 be non-null pointers.  For instance, the declaration:
 @noindent
 causes the compiler to check that, in calls to @code{my_memcpy},
 arguments @var{dest} and @var{src} are non-null.  If the compiler
 determines that a null pointer is passed in an argument slot marked
 as non-null, and the @option{-Wnonnull} option is enabled, a warning
-is issued.  The compiler may also choose to make optimizations based
+is issued.  @xref{Warning Options}.  Unless disabled by
-on the knowledge that certain function arguments will never be null.
+the @option{-fno-delete-null-pointer-checks} option the compiler may
+also perform optimizations based on the knowledge that certain function
-If no argument index list is given to the @code{nonnull} attribute,
+arguments cannot be null. In addition,
+the @option{-fisolate-erroneous-paths-attribute} option can be specified
+to have GCC transform calls with null arguments to non-null functions
+into traps. @xref{Optimize Options}.
+If no @var{arg-index} is given to the @code{nonnull} attribute,
 all pointer arguments are marked as non-null.  To illustrate, the
 following declaration is equivalent to the previous example:
 @smallexample
 extern void *
 uninitialized variables.
 The @code{noreturn} keyword does not affect the exceptional path when that
 applies: a @code{noreturn}-marked function may still return to the caller
 by throwing an exception or calling @code{longjmp}.
+In order to preserve backtraces, GCC will never turn calls to
+@code{noreturn} functions into tail calls.
 Do not assume that registers saved by the calling function are
 restored before calling the @code{noreturn} function.
 It does not make sense for a @code{noreturn} function to have a return
 @item pure
 @cindex @code{pure} function attribute
 @cindex functions that have no side effects
 Many functions have no effects except the return value and their
 return value depends only on the parameters and/or global variables.
-Such a function can be subject
+Calls to such functions can be subject
 to common subexpression elimination and loop optimization just as an
 arithmetic operator would be.  These functions should be declared
 with the attribute @code{pure}.  For example,
 @smallexample
 Some common examples of pure functions are @code{strlen} or @code{memcmp}.
 Interesting non-pure functions are functions with infinite loops or those
 depending on volatile memory or other system resource, that may change between
 two consecutive calls (such as @code{feof} in a multithreading environment).
+The @code{pure} attribute imposes similar but looser restrictions on
+a function's defintion than the @code{const} attribute: it allows the
+function to read global variables.  Decorating the same function with
+both the @code{pure} and the @code{const} attribute is diagnosed.
+Because a @code{pure} function cannot have any side effects it does not
+make sense for such a function to return @code{void}.  Declaring such
+a function is diagnosed.
 @item returns_nonnull
 @cindex @code{returns_nonnull} function attribute
 The @code{returns_nonnull} attribute specifies that the function
 return value should be a non-null pointer.  For instance, the declaration:
 The optional argument @var{mask} may have the value
 @code{notinbranch} or @code{inbranch},
 and instructs the compiler to generate non-masked or masked
 clones correspondingly. By default, all clones are generated.
-The attribute should not be used together with Cilk Plus @code{vector}
-attribute on the same function.
 If the attribute is specified and @code{#pragma omp declare simd} is
 present on a declaration and the @option{-fopenmp} or @option{-fopenmp-simd}
 switch is specified, then the attribute is ignored.
 @item stack_protect
 Indicates that code should be generated for a particular code model for
 this function.  The behavior and permissible arguments are the same as
 for the command line option @option{-mcmodel=}.
 @item strict-align
+@itemx no-strict-align
 @cindex @code{strict-align} function attribute, AArch64
-Indicates that the compiler should not assume that unaligned memory references
+@code{strict-align} indicates that the compiler should not assume that unaligned
-are handled by the system.  The behavior is the same as for the command-line
+memory references are handled by the system.  To allow the compiler to assume
-option @option{-mstrict-align}.
+that aligned memory references are handled by the system, the inverse attribute
+@code{no-strict-align} can be specified.  The behavior is same as for the
+command-line option @option{-mstrict-align} and @option{-mno-strict-align}.
 @item omit-leaf-frame-pointer
 @cindex @code{omit-leaf-frame-pointer} function attribute, AArch64
 Indicates that the frame pointer should be omitted for a leaf function call.
 To keep the frame pointer, the inverse attribute
 branch-and-link instruction, which has a 25-bit offset from
 the call site.  A function marked with the @code{short_call}
 attribute will always be close enough to be called with a conditional
 branch-and-link instruction, which has a 21-bit offset from
 the call site.
+@item jli_always
+@cindex @code{jli_always} function attribute, ARC
+Forces a particular function to be called using @code{jli}
+instruction.  The @code{jli} instruction makes use of a table stored
+into @code{.jlitab} section, which holds the location of the functions
+which are addressed using this instruction.
+@item jli_fixed
+@cindex @code{jli_fixed} function attribute, ARC
+Identical like the above one, but the location of the function in the
+@code{jli} table is known and given as an attribute parameter.
+@item secure_call
+@cindex @code{secure_call} function attribute, ARC
+This attribute allows one to mark secure-code functions that are
+callable from normal mode.  The location of the secure call function
+into the @code{sjli} table needs to be passed as argument.
 @end table
 @node ARM Function Attributes
 @subsection ARM Function Attributes
 @item fpu=
 @cindex @code{target("fpu=")} function attribute, ARM
 Specifies the fpu for which to tune the performance of this function.
 The behavior and permissible arguments are the same as for the @option{-mfpu=}
 command-line option.
+@item arch=
+@cindex @code{arch=} function attribute, ARM
+Specifies the architecture version and architectural extensions to use
+for this function.  The behavior and permissible arguments are the same as
+for the @option{-march=} command-line option.
+The above target attributes can be specified as follows:
+@smallexample
+__attribute__((target("arch=armv8-a+crc")))
+int
+f (int a)
+@{
+return a + 5;
+@}
+@end smallexample
+Additionally, the architectural extension string may be specified on its
+own.  This can be used to turn on and off particular architectural extensions
+without having to specify a particular architecture version or core.  Example:
+@smallexample
+__attribute__((target("+crc+nocrypto")))
+int
+foo (int a)
+@{
+return a + 5;
+@}
+@end smallexample
+In this example @code{target("+crc+nocrypto")} enables the @code{crc}
+extension and disables the @code{crypto} extension for the function @code{foo}
+without modifying an existing @option{-march=} or @option{-mcpu} option.
 @end table
 @end table
 Use this attribute to indicate
 that the specified function is an interrupt handler.  The compiler generates
 function entry and exit sequences suitable for use in an interrupt handler
 when this attribute is present.
 @end table
+@node C-SKY Function Attributes
+@subsection C-SKY Function Attributes
+These function attributes are supported by the C-SKY back end:
+@table @code
+@item interrupt
+@itemx isr
+@cindex @code{interrupt} function attribute, C-SKY
+@cindex @code{isr} function attribute, C-SKY
+Use these attributes to indicate that the specified function
+is an interrupt handler.
+The compiler generates function entry and exit sequences suitable for
+use in an interrupt handler when either of these attributes are present.
+Use of these options requires the @option{-mistack} command-line option
+to enable support for the necessary interrupt stack instructions.  They
+are ignored with a warning otherwise.  @xref{C-SKY Options}.
+@item naked
+@cindex @code{naked} function attribute, C-SKY
+This attribute allows the compiler to construct the
+requisite function declaration, while allowing the body of the
+function to be assembly code. The specified function will not have
+prologue/epilogue sequences generated by the compiler. Only basic
+@code{asm} statements can safely be included in naked functions
+(@pxref{Basic Asm}). While using extended @code{asm} or a mixture of
+basic @code{asm} and C code may appear to work, they cannot be
+depended upon to work reliably and are not supported.
+@end table
 @node Epiphany Function Attributes
 @subsection Epiphany Function Attributes
 These function attributes are supported by the Epiphany back end:
 On the PowerPC, the inliner does not inline a
 function that has different target options than the caller, unless the
 callee has a subset of the target options of the caller.
 @end table
+@node RISC-V Function Attributes
+@subsection RISC-V Function Attributes
+These function attributes are supported by the RISC-V back end:
+@table @code
+@item naked
+@cindex @code{naked} function attribute, RISC-V
+This attribute allows the compiler to construct the
+requisite function declaration, while allowing the body of the
+function to be assembly code. The specified function will not have
+prologue/epilogue sequences generated by the compiler. Only basic
+@code{asm} statements can safely be included in naked functions
+(@pxref{Basic Asm}). While using extended @code{asm} or a mixture of
+basic @code{asm} and C code may appear to work, they cannot be
+depended upon to work reliably and are not supported.
+@item interrupt
+@cindex @code{interrupt} function attribute, RISC-V
+Use this attribute to indicate that the specified function is an interrupt
+handler.  The compiler generates function entry and exit sequences suitable
+for use in an interrupt handler when this attribute is present.
+You can specify the kind of interrupt to be handled by adding an optional
+parameter to the interrupt attribute like this:
+@smallexample
+void f (void) __attribute__ ((interrupt ("user")));
+@end smallexample
+Permissible values for this parameter are @code{user}, @code{supervisor},
+and @code{machine}.  If there is no parameter, then it defaults to
+@code{machine}.
+@end table
 @node RL78 Function Attributes
 @subsection RL78 Function Attributes
 These function attributes are supported by the RL78 back end:
 Use this attribute to indicate
 that the specified function is an interrupt handler.  The compiler generates
 function entry and exit sequences suitable for use in an interrupt handler
 when this attribute is present.
-On RX targets, you may specify one or more vector numbers as arguments
+On RX and RL78 targets, you may specify one or more vector numbers as arguments
 to the attribute, as well as naming an alternate table name.
 Parameters are handled sequentially, so one handler can be assigned to
 multiple entries in multiple tables.  One may also pass the magic
 string @code{"$default"} which causes the function to be used for any
 unfilled slots in the current table.
 Use this attribute to indicate that the specified function has no
 caller-saved registers. That is, all registers are callee-saved. For
 example, this attribute can be used for a function called from an
 interrupt handler. The compiler generates proper function entry and
 exit sequences to save and restore any modified registers, except for
-the EFLAGS register.  Since GCC doesn't preserve MPX, SSE, MMX nor x87
+the EFLAGS register.  Since GCC doesn't preserve SSE, MMX nor x87
 states, the GCC option @option{-mgeneral-regs-only} should be used to
 compile functions with @code{no_caller_saved_registers} attribute.
 @item interrupt
 @cindex @code{interrupt} function attribute, x86
 entry and exit sequences suitable for use in an interrupt handler when
 this attribute is present.  The @code{IRET} instruction, instead of the
 @code{RET} instruction, is used to return from interrupt handlers.  All
 registers, except for the EFLAGS register which is restored by the
 @code{IRET} instruction, are preserved by the compiler.  Since GCC
-doesn't preserve MPX, SSE, MMX nor x87 states, the GCC option
+doesn't preserve SSE, MMX nor x87 states, the GCC option
 @option{-mgeneral-regs-only} should be used to compile interrupt and
 exception handlers.
 Any interruptible-without-stack-switch code must be compiled with
 @option{-mno-red-zone} since interrupt handlers can and will, because
 @cindex @code{target("fpmath=@var{FPMATH}")} function attribute, x86
 Specify which floating-point unit to use.  You must specify the
 @code{target("fpmath=sse,387")} option as
 @code{target("fpmath=sse+387")} because the comma would separate
 different options.
+@item indirect_branch("@var{choice}")
+@cindex @code{indirect_branch} function attribute, x86
+On x86 targets, the @code{indirect_branch} attribute causes the compiler
+to convert indirect call and jump with @var{choice}.  @samp{keep}
+keeps indirect call and jump unmodified.  @samp{thunk} converts indirect
+call and jump to call and return thunk.  @samp{thunk-inline} converts
+indirect call and jump to inlined call and return thunk.
+@samp{thunk-extern} converts indirect call and jump to external call
+and return thunk provided in a separate object file.
+@item function_return("@var{choice}")
+@cindex @code{function_return} function attribute, x86
+On x86 targets, the @code{function_return} attribute causes the compiler
+to convert function return with @var{choice}.  @samp{keep} keeps function
+return unmodified.  @samp{thunk} converts function return to call and
+return thunk.  @samp{thunk-inline} converts function return to inlined
+call and return thunk.  @samp{thunk-extern} converts function return to
+external call and return thunk provided in a separate object file.
 @item nocf_check
 @cindex @code{nocf_check} function attribute
 The @code{nocf_check} attribute on a function is used to inform the
 compiler that the function's prologue should not be instrumented when
 @{
 int foo (void) __attribute__(nocf_check);
 void (*foo1)(void) __attribute__(nocf_check);
 void (*foo2)(void);
+/* foo's address is assumed to be valid.  */
 int
-foo (void) /* The function's address is assumed to be valid.  */
+foo (void)
-/* This call site is not checked for control-flow validity.  */
+/* This call site is not checked for control-flow
+validity.  */
 (*foo1)();
-foo1 = foo2; /* A warning is printed about attribute mismatch.  */
+/* A warning is issued about attribute mismatch.  */
-/* This call site is still not checked for control-flow validity.  */
+foo1 = foo2;
+/* This call site is still not checked.  */
 (*foo1)();
-/* This call site is checked for control-flow validity.  */
+/* This call site is checked.  */
 (*foo2)();
-foo2 = foo1; /* A warning is printed about attribute mismatch.  */
+/* A warning is issued about attribute mismatch.  */
-/* This call site is still checked for control-flow validity.  */
+foo2 = foo1;
+/* This call site is still checked.  */
 (*foo2)();
 return 0;
 @}
 @end smallexample
+@item indirect_return
+@cindex @code{indirect_return} function attribute, x86
+The @code{indirect_return} attribute can be applied to a function,
+as well as variable or type of function pointer to inform the
+compiler that the function may return via indirect branch.
 @end table
 On the x86, the inliner does not inline a
 function that has different target options than the caller, unless the
 @xref{Attribute Syntax}, for details of the exact syntax for using
 attributes.
 @menu
 * Common Variable Attributes::
+* ARC Variable Attributes::
 * AVR Variable Attributes::
 * Blackfin Variable Attributes::
 * H8/300 Variable Attributes::
 * IA-64 Variable Attributes::
 * M32R/D Variable Attributes::
 The @code{deprecated} attribute can also be used for functions and
 types (@pxref{Common Function Attributes},
 @pxref{Common Type Attributes}).
-@item nonstring (@var{nonstring})
+The message attached to the attribute is affected by the setting of
-@cindex @code{nonstring} variable attribute
+the @option{-fmessage-length} option.
-The @code{nonstring} variable attribute specifies that an object or member
-declaration with type array of @code{char} or pointer to @code{char} is
-intended to store character arrays that do not necessarily contain
-a terminating @code{NUL} character.  This is useful to avoid warnings
-when such an array or pointer is used as an argument to a bounded string
-manipulation function such as @code{strncpy}.  For example, without the
-attribute, GCC will issue a warning for the call below because it may
-truncate the copy without appending the terminating NUL character.  Using
-the attribute makes it possible to suppress the warning.
-@smallexample
-struct Data
-@{
-char name [32] __attribute__ ((nonstring));
-@};
-void f (struct Data *pd, const char *s)
-@{
-strncpy (pd->name, s, sizeof pd->name);
-@dots{}
-@}
-@end smallexample
 @item mode (@var{mode})
 @cindex @code{mode} variable attribute
 This attribute specifies the data type for the declaration---whichever
 type corresponds to the mode @var{mode}.  This in effect lets you
 You may also specify a mode of @code{byte} or @code{__byte__} to
 indicate the mode corresponding to a one-byte integer, @code{word} or
 @code{__word__} for the mode of a one-word integer, and @code{pointer}
 or @code{__pointer__} for the mode used to represent pointers.
+@item nonstring
+@cindex @code{nonstring} variable attribute
+The @code{nonstring} variable attribute specifies that an object or member
+declaration with type array of @code{char}, @code{signed char}, or
+@code{unsigned char}, or pointer to such a type is intended to store
+character arrays that do not necessarily contain a terminating @code{NUL}.
+This is useful in detecting uses of such arrays or pointers with functions
+that expect @code{NUL}-terminated strings, and to avoid warnings when such
+an array or pointer is used as an argument to a bounded string manipulation
+function such as @code{strncpy}.  For example, without the attribute, GCC
+will issue a warning for the @code{strncpy} call below because it may
+truncate the copy without appending the terminating @code{NUL} character.
+Using the attribute makes it possible to suppress the warning.  However,
+when the array is declared with the attribute the call to @code{strlen} is
+diagnosed because when the array doesn't contain a @code{NUL}-terminated
+string the call is undefined.  To copy, compare, of search non-string
+character arrays use the @code{memcpy}, @code{memcmp}, @code{memchr},
+and other functions that operate on arrays of bytes.  In addition,
+calling @code{strnlen} and @code{strndup} with such arrays is safe
+provided a suitable bound is specified, and not diagnosed.
+@smallexample
+struct Data
+@{
+char name [32] __attribute__ ((nonstring));
+@};
+int f (struct Data *pd, const char *s)
+@{
+strncpy (pd->name, s, sizeof pd->name);
+@dots{}
+return strlen (pd->name);   // unsafe, gets a warning
+@}
+@end smallexample
 @item packed
 @cindex @code{packed} variable attribute
-The @code{packed} attribute specifies that a variable or structure field
+The @code{packed} attribute specifies that a structure member should have
-should have the smallest possible alignment---one byte for a variable,
+the smallest possible alignment---one bit for a bit-field and one byte
-and one bit for a field, unless you specify a larger value with the
+otherwise, unless a larger value is specified with the @code{aligned}
-@code{aligned} attribute.
+attribute.  The attribute does not apply to non-member objects.
-Here is a structure in which the field @code{x} is packed, so that it
+For example in the structure below, the member array @code{x} is packed
-immediately follows @code{a}:
+so that it immediately follows @code{a} with no intervening padding:
 @smallexample
 struct foo
 @{
 char a;
 @item weak
 @cindex @code{weak} variable attribute
 The @code{weak} attribute is described in
 @ref{Common Function Attributes}.
+@end table
+@node ARC Variable Attributes
+@subsection ARC Variable Attributes
+@table @code
+@item aux
+@cindex @code{aux} variable attribute, ARC
+The @code{aux} attribute is used to directly access the ARC's
+auxiliary register space from C.  The auxilirary register number is
+given via attribute argument.
 @end table
 @node AVR Variable Attributes
 @subsection AVR Variable Attributes
 @xref{Attribute Syntax}, for details of the exact syntax for using
 attributes.
 @menu
 * Common Type Attributes::
+* ARC Type Attributes::
 * ARM Type Attributes::
 * MeP Type Attributes::
 * PowerPC Type Attributes::
 * SPU Type Attributes::
 * x86 Type Attributes::
 __u64 x;
 @} __attribute__((aligned(8)));
 @end smallexample
 This warning can be disabled by @option{-Wno-if-not-aligned}.
-@item bnd_variable_size
-@cindex @code{bnd_variable_size} type attribute
-@cindex Pointer Bounds Checker attributes
-When applied to a structure field, this attribute tells Pointer
-Bounds Checker that the size of this field should not be computed
-using static type information.  It may be used to mark variably-sized
-static array fields placed at the end of a structure.
-@smallexample
-struct S
-@{
-int size;
-char data[1];
-@}
-S *p = (S *)malloc (sizeof(S) + 100);
-p->data[10] = 0; //Bounds violation
-@end smallexample
-@noindent
-By using an attribute for the field we may avoid unwanted bound
-violation checks:
-@smallexample
-struct S
-@{
-int size;
-char data[1] __attribute__((bnd_variable_size));
-@}
-S *p = (S *)malloc (sizeof(S) + 100);
-p->data[10] = 0; //OK
-@end smallexample
 @item deprecated
 @itemx deprecated (@var{msg})
 @cindex @code{deprecated} type attribute
 The @code{deprecated} attribute results in a warning if the type
 results in a warning on line 2 and 3 but not lines 4, 5, or 6.  No
 warning is issued for line 4 because T2 is not explicitly
 deprecated.  Line 5 has no warning because T3 is explicitly
 deprecated.  Similarly for line 6.  The optional @var{msg}
 argument, which must be a string, is printed in the warning if
-present.
+present.  Control characters in the string will be replaced with
+escape sequences, and if the @option{-fmessage-length} option is set
+to 0 (its default value) then any newline characters will be ignored.
 The @code{deprecated} attribute can also be used for functions and
 variables (@pxref{Function Attributes}, @pxref{Variable Attributes}.)
+The message attached to the attribute is affected by the setting of
+the @option{-fmessage-length} option.
 @item designated_init
 @cindex @code{designated_init} type attribute
 This attribute may only be applied to structure types.  It indicates
 that any initialization of an object of this type must use designated
 If you replaced @code{short_a} with @code{short} in the variable
 declaration, the above program would abort when compiled with
 @option{-fstrict-aliasing}, which is on by default at @option{-O2} or
 above.
+@item mode (@var{mode})
+@cindex @code{mode} type attribute
+This attribute specifies the data type for the declaration---whichever
+type corresponds to the mode @var{mode}.  This in effect lets you
+request an integer or floating-point type according to its width.
+@xref{Machine Modes,,, gccint, GNU Compiler Collection (GCC) Internals},
+for a list of the possible keywords for @var{mode}.
+You may also specify a mode of @code{byte} or @code{__byte__} to
+indicate the mode corresponding to a one-byte integer, @code{word} or
+@code{__word__} for the mode of a one-word integer, and @code{pointer}
+or @code{__pointer__} for the mode used to represent pointers.
 @item packed
 @cindex @code{packed} type attribute
 This attribute, attached to @code{struct} or @code{union} type
 definition, specifies that each member (other than zero-width bit-fields)
 of the structure or union is placed to minimize the memory required.  When
 @end table
 To specify multiple attributes, separate them by commas within the
 double parentheses: for example, @samp{__attribute__ ((aligned (16),
 packed))}.
+@node ARC Type Attributes
+@subsection ARC Type Attributes
+@cindex @code{uncached} type attribute, ARC
+Declaring objects with @code{uncached} allows you to exclude
+data-cache participation in load and store operations on those objects
+without involving the additional semantic implications of
+@code{volatile}.  The @code{.di} instruction suffix is used for all
+loads and stores of data declared @code{uncached}.
 @node ARM Type Attributes
 @subsection ARM Type Attributes
 @cindex @code{notshared} type attribute, ARM
 GCC implements three different semantics of declaring a function
 inline.  One is available with @option{-std=gnu89} or
 @option{-fgnu89-inline} or when @code{gnu_inline} attribute is present
 on all inline declarations, another when
-@option{-std=c99}, @option{-std=c11},
+@option{-std=c99},
-@option{-std=gnu99} or @option{-std=gnu11}
+@option{-std=gnu99} or an option for a later C version is used
 (without @option{-fgnu89-inline}), and the third
 is used when compiling C++.
 To declare a function inline, use the @code{inline} keyword in its
 declaration, like this:
 top:
 asm volatile goto ("some assembler instructions here"
 : /* No outputs. */
-: "q" (iInt), "X" (sizeof(unsigned char) + 1)
+: "q" (iInt), "X" (sizeof(unsigned char) + 1), "i" (42)
 : /* No clobbers. */
 : top);
 @}
 @end example
-With no modifiers, this is what the output from the operands would be for the
+With no modifiers, this is what the output from the operands would be
-@samp{att} and @samp{intel} dialects of assembler:
+for the @samp{att} and @samp{intel} dialects of assembler:
 @multitable {Operand} {$.L2} {OFFSET FLAT:.L2}
 @headitem Operand @tab @samp{att} @tab @samp{intel}
 @item @code{%0}
 @tab @code{%eax}
 @tab @code{eax}
 @item @code{%1}
 @tab @code{$2}
 @tab @code{2}
-@item @code{%2}
+@item @code{%3}
-@tab @code{$.L2}
+@tab @code{$.L3}
-@tab @code{OFFSET FLAT:.L2}
+@tab @code{OFFSET FLAT:.L3}
 @end multitable
 The table below shows the list of supported modifiers and their effects.
 @multitable {Modifier} {Print the opcode suffix for the size of th} {Operand} {@samp{att}} {@samp{intel}}
 @headitem Modifier @tab Description @tab Operand @tab @samp{att} @tab @samp{intel}
+@item @code{a}
+@tab Print an absolute memory reference.
+@tab @code{%A0}
+@tab @code{*%rax}
+@tab @code{rax}
+@item @code{b}
+@tab Print the QImode name of the register.
+@tab @code{%b0}
+@tab @code{%al}
+@tab @code{al}
+@item @code{c}
+@tab Require a constant operand and print the constant expression with no punctuation.
+@tab @code{%c1}
+@tab @code{2}
+@tab @code{2}
+@item @code{E}
+@tab Print the address in Double Integer (DImode) mode (8 bytes) when the target is 64-bit.
+Otherwise mode is unspecified (VOIDmode).
+@tab @code{%E1}
+@tab @code{%(rax)}
+@tab @code{[rax]}
+@item @code{h}
+@tab Print the QImode name for a ``high'' register.
+@tab @code{%h0}
+@tab @code{%ah}
+@tab @code{ah}
+@item @code{H}
+@tab Add 8 bytes to an offsettable memory reference. Useful when accessing the
+high 8 bytes of SSE values. For a memref in (%rax), it generates
+@tab @code{%H0}
+@tab @code{8(%rax)}
+@tab @code{8[rax]}
+@item @code{k}
+@tab Print the SImode name of the register.
+@tab @code{%k0}
+@tab @code{%eax}
+@tab @code{eax}
+@item @code{l}
+@tab Print the label name with no punctuation.
+@tab @code{%l3}
+@tab @code{.L3}
+@tab @code{.L3}
+@item @code{p}
+@tab Print raw symbol name (without syntax-specific prefixes).
+@tab @code{%p2}
+@tab @code{42}
+@tab @code{42}
+@item @code{P}
+@tab If used for a function, print the PLT suffix and generate PIC code.
+For example, emit @code{foo@@PLT} instead of 'foo' for the function
+foo(). If used for a constant, drop all syntax-specific prefixes and
+issue the bare constant. See @code{p} above.
+@item @code{q}
+@tab Print the DImode name of the register.
+@tab @code{%q0}
+@tab @code{%rax}
+@tab @code{rax}
+@item @code{w}
+@tab Print the HImode name of the register.
+@tab @code{%w0}
+@tab @code{%ax}
+@tab @code{ax}
 @item @code{z}
 @tab Print the opcode suffix for the size of the current integer operand (one of @code{b}/@code{w}/@code{l}/@code{q}).
 @tab @code{%z0}
 @tab @code{l}
 @tab
-@item @code{b}
-@tab Print the QImode name of the register.
-@tab @code{%b0}
-@tab @code{%al}
-@tab @code{al}
-@item @code{h}
-@tab Print the QImode name for a ``high'' register.
-@tab @code{%h0}
-@tab @code{%ah}
-@tab @code{ah}
-@item @code{w}
-@tab Print the HImode name of the register.
-@tab @code{%w0}
-@tab @code{%ax}
-@tab @code{ax}
-@item @code{k}
-@tab Print the SImode name of the register.
-@tab @code{%k0}
-@tab @code{%eax}
-@tab @code{eax}
-@item @code{q}
-@tab Print the DImode name of the register.
-@tab @code{%q0}
-@tab @code{%rax}
-@tab @code{rax}
-@item @code{l}
-@tab Print the label name with no punctuation.
-@tab @code{%l2}
-@tab @code{.L2}
-@tab @code{.L2}
-@item @code{c}
-@tab Require a constant operand and print the constant expression with no punctuation.
-@tab @code{%c1}
-@tab @code{2}
-@tab @code{2}
 @end multitable
+@code{V} is a special modifier which prints the name of the full integer
+register without @code{%}.
 @anchor{x86floatingpointasmoperands}
 @subsubsection x86 Floating-Point @code{asm} Operands
 On x86 targets, there are several rules on the usage of stack-like registers
 a global variable the declaration appears outside a function. The
 @code{register} keyword is required, and cannot be combined with
 @code{static}. The register name must be a valid register name for the
 target platform.
+Do not use type qualifiers such as @code{const} and @code{volatile}, as
+the outcome may be contrary to expectations.  In  particular, using the
+@code{volatile} qualifier does not fully prevent the compiler from
+optimizing accesses to the register.
 Registers are a scarce resource on most systems and allowing the
 compiler to manage their usage usually results in the best code. However,
 under special circumstances it can make sense to reserve some globally.
 For example this may be useful in programs such as programming language
 interpreters that have a couple of global variables that are accessed
 After defining a global register variable, for the current compilation
 unit:
 @itemize @bullet
-@item The register is reserved entirely for this use, and will not be
+@item If the register is a call-saved register, call ABI is affected:
-allocated for any other purpose.
+the register will not be restored in function epilogue sequences after
-@item The register is not saved and restored by any functions.
+the variable has been assigned.  Therefore, functions cannot safely
-@item Stores into this register are never deleted even if they appear to be
+return to callers that assume standard ABI.
-dead, but references may be deleted, moved or simplified.
+@item Conversely, if the register is a call-clobbered register, making
+calls to functions that use standard ABI may lose contents of the variable.
+Such calls may be created by the compiler even if none are evident in
+the original program, for example when libgcc functions are used to
+make up for unavailable instructions.
+@item Accesses to the variable may be optimized as usual and the register
+remains available for allocation and use in any computations, provided that
+observable values of the variable are not affected.
+@item If the variable is referenced in inline assembly, the type of access
+must be provided to the compiler via constraints (@pxref{Constraints}).
+Accesses from basic asms are not supported.
 @end itemize
 Note that these points @emph{only} apply to code that is compiled with the
 definition. The behavior of code that is merely linked in (for example
 code from libraries) is not affected.
 the comparison function unless the @code{qsort} function itself is rebuilt.
 Similarly, it is not safe to access the global register variables from signal
 handlers or from more than one thread of control. Unless you recompile
 them specially for the task at hand, the system library routines may
-temporarily use the register for other things.
+temporarily use the register for other things.  Furthermore, since the register
+is not reserved exclusively for the variable, accessing it from handlers of
+asynchronous signals may observe unrelated temporary values residing in the
+register.
 @cindex register variable after @code{longjmp}
 @cindex global register after @code{longjmp}
 @cindex value after @code{longjmp}
 @findex longjmp
 register variables. To be portable, the function that called @code{setjmp}
 should make other arrangements to save the values of the global register
 variables, and to restore them in a @code{longjmp}. This way, the same
 thing happens regardless of what @code{longjmp} does.
-Eventually there may be a way of asking the compiler to choose a register
-automatically, but first we need to figure out how it should choose and
-how to enable you to guide the choice.  No solution is evident.
 @node Local Register Variables
 @subsubsection Specifying Registers for Local Variables
 @anchor{Local Reg Vars}
 @cindex local variables, specifying registers
 @cindex specifying registers for local variables
 that this is the same syntax used for defining global register variables,
 but for a local variable the declaration appears within a function.  The
 @code{register} keyword is required, and cannot be combined with
 @code{static}.  The register name must be a valid register name for the
 target platform.
+Do not use type qualifiers such as @code{const} and @code{volatile}, as
+the outcome may be contrary to expectations. In particular, when the
+@code{const} qualifier is used, the compiler may substitute the
+variable with its initializer in @code{asm} statements, which may cause
+the corresponding operand to appear in a different register.
 As with global register variables, it is recommended that you choose
 a register that is normally saved and restored by function calls on your
 machine, so that calls to library routines will not clobber it.
 The built-in functions promote the first two operands into infinite precision signed type
 and perform addition on those promoted operands. The result is then
 cast to the type of the third argument.  If the cast result is equal to the infinite
 precision result, the built-in functions return false, otherwise they return true.
-The value of the third argument is ignored, just the side-effects in the third argument
+The value of the third argument is ignored, just the side effects in the third argument
 are evaluated, and no integral argument promotions are performed on the last argument.
 If the third argument is a bit-field, the type used for the result cast has the
 precision and signedness of the given bit-field, rather than precision and signedness
 of the underlying type.
 @deftypefn {Built-in Function} {size_t} __builtin_object_size (const void * @var{ptr}, int @var{type})
 is a built-in construct that returns a constant number of bytes from
 @var{ptr} to the end of the object @var{ptr} pointer points to
 (if known at compile time).  @code{__builtin_object_size} never evaluates
-its arguments for side-effects.  If there are any side-effects in them, it
+its arguments for side effects.  If there are any side effects in them, it
 returns @code{(size_t) -1} for @var{type} 0 or 1 and @code{(size_t) 0}
 for @var{type} 2 or 3.  If there are multiple objects @var{ptr} can
 point to and all of them are known at compile time, the returned number
 is the maximum of remaining byte counts in those objects if @var{type} & 2 is
 0 and minimum if nonzero.  If it is not possible to determine which objects
 These have just one additional argument, @var{flag}, right before
 format string @var{fmt}.  If the compiler is able to optimize them to
 @code{fputc} etc.@: functions, it does, otherwise the checking function
 is called and the @var{flag} argument passed to it.
-@node Pointer Bounds Checker builtins
-@section Pointer Bounds Checker Built-in Functions
-@cindex Pointer Bounds Checker builtins
-@findex __builtin___bnd_set_ptr_bounds
-@findex __builtin___bnd_narrow_ptr_bounds
-@findex __builtin___bnd_copy_ptr_bounds
-@findex __builtin___bnd_init_ptr_bounds
-@findex __builtin___bnd_null_ptr_bounds
-@findex __builtin___bnd_store_ptr_bounds
-@findex __builtin___bnd_chk_ptr_lbounds
-@findex __builtin___bnd_chk_ptr_ubounds
-@findex __builtin___bnd_chk_ptr_bounds
-@findex __builtin___bnd_get_ptr_lbound
-@findex __builtin___bnd_get_ptr_ubound
-GCC provides a set of built-in functions to control Pointer Bounds Checker
-instrumentation.  Note that all Pointer Bounds Checker builtins can be used
-even if you compile with Pointer Bounds Checker off
-(@option{-fno-check-pointer-bounds}).
-The behavior may differ in such case as documented below.
-@deftypefn {Built-in Function} {void *} __builtin___bnd_set_ptr_bounds (const void *@var{q}, size_t @var{size})
-This built-in function returns a new pointer with the value of @var{q}, and
-associate it with the bounds [@var{q}, @var{q}+@var{size}-1].  With Pointer
-Bounds Checker off, the built-in function just returns the first argument.
-@smallexample
-extern void *__wrap_malloc (size_t n)
-@{
-void *p = (void *)__real_malloc (n);
-if (!p) return __builtin___bnd_null_ptr_bounds (p);
-return __builtin___bnd_set_ptr_bounds (p, n);
-@}
-@end smallexample
-@end deftypefn
-@deftypefn {Built-in Function} {void *} __builtin___bnd_narrow_ptr_bounds (const void *@var{p}, const void *@var{q}, size_t  @var{size})
-This built-in function returns a new pointer with the value of @var{p}
-and associates it with the narrowed bounds formed by the intersection
-of bounds associated with @var{q} and the bounds
-[@var{p}, @var{p} + @var{size} - 1].
-With Pointer Bounds Checker off, the built-in function just returns the first
-argument.
-@smallexample
-void init_objects (object *objs, size_t size)
-@{
-size_t i;
-/* Initialize objects one-by-one passing pointers with bounds of
-an object, not the full array of objects.  */
-for (i = 0; i < size; i++)
-init_object (__builtin___bnd_narrow_ptr_bounds (objs + i, objs,
-sizeof(object)));
-@}
-@end smallexample
-@end deftypefn
-@deftypefn {Built-in Function} {void *} __builtin___bnd_copy_ptr_bounds (const void *@var{q}, const void *@var{r})
-This built-in function returns a new pointer with the value of @var{q},
-and associates it with the bounds already associated with pointer @var{r}.
-With Pointer Bounds Checker off, the built-in function just returns the first
-argument.
-@smallexample
-/* Here is a way to get pointer to object's field but
-still with the full object's bounds.  */
-int *field_ptr = __builtin___bnd_copy_ptr_bounds (&objptr->int_field,
-objptr);
-@end smallexample
-@end deftypefn
-@deftypefn {Built-in Function} {void *} __builtin___bnd_init_ptr_bounds (const void *@var{q})
-This built-in function returns a new pointer with the value of @var{q}, and
-associates it with INIT (allowing full memory access) bounds. With Pointer
-Bounds Checker off, the built-in function just returns the first argument.
-@end deftypefn
-@deftypefn {Built-in Function} {void *} __builtin___bnd_null_ptr_bounds (const void *@var{q})
-This built-in function returns a new pointer with the value of @var{q}, and
-associates it with NULL (allowing no memory access) bounds. With Pointer
-Bounds Checker off, the built-in function just returns the first argument.
-@end deftypefn
-@deftypefn {Built-in Function} void __builtin___bnd_store_ptr_bounds (const void **@var{ptr_addr}, const void *@var{ptr_val})
-This built-in function stores the bounds associated with pointer @var{ptr_val}
-and location @var{ptr_addr} into Bounds Table.  This can be useful to propagate
-bounds from legacy code without touching the associated pointer's memory when
-pointers are copied as integers.  With Pointer Bounds Checker off, the built-in
-function call is ignored.
-@end deftypefn
-@deftypefn {Built-in Function} void __builtin___bnd_chk_ptr_lbounds (const void *@var{q})
-This built-in function checks if the pointer @var{q} is within the lower
-bound of its associated bounds.  With Pointer Bounds Checker off, the built-in
-function call is ignored.
-@smallexample
-extern void *__wrap_memset (void *dst, int c, size_t len)
-@{
-if (len > 0)
-@{
-__builtin___bnd_chk_ptr_lbounds (dst);
-__builtin___bnd_chk_ptr_ubounds ((char *)dst + len - 1);
-__real_memset (dst, c, len);
-@}
-return dst;
-@}
-@end smallexample
-@end deftypefn
-@deftypefn {Built-in Function} void __builtin___bnd_chk_ptr_ubounds (const void *@var{q})
-This built-in function checks if the pointer @var{q} is within the upper
-bound of its associated bounds.  With Pointer Bounds Checker off, the built-in
-function call is ignored.
-@end deftypefn
-@deftypefn {Built-in Function} void __builtin___bnd_chk_ptr_bounds (const void *@var{q}, size_t @var{size})
-This built-in function checks if [@var{q}, @var{q} + @var{size} - 1] is within
-the lower and upper bounds associated with @var{q}.  With Pointer Bounds Checker
-off, the built-in function call is ignored.
-@smallexample
-extern void *__wrap_memcpy (void *dst, const void *src, size_t n)
-@{
-if (n > 0)
-@{
-__bnd_chk_ptr_bounds (dst, n);
-__bnd_chk_ptr_bounds (src, n);
-__real_memcpy (dst, src, n);
-@}
-return dst;
-@}
-@end smallexample
-@end deftypefn
-@deftypefn {Built-in Function} {const void *} __builtin___bnd_get_ptr_lbound (const void *@var{q})
-This built-in function returns the lower bound associated
-with the pointer @var{q}, as a pointer value.
-This is useful for debugging using @code{printf}.
-With Pointer Bounds Checker off, the built-in function returns 0.
-@smallexample
-void *lb = __builtin___bnd_get_ptr_lbound (q);
-void *ub = __builtin___bnd_get_ptr_ubound (q);
-printf ("q = %p  lb(q) = %p  ub(q) = %p", q, lb, ub);
-@end smallexample
-@end deftypefn
-@deftypefn {Built-in Function} {const void *} __builtin___bnd_get_ptr_ubound (const void *@var{q})
-This built-in function returns the upper bound (which is a pointer) associated
-with the pointer @var{q}.  With Pointer Bounds Checker off,
-the built-in function returns -1.
-@end deftypefn
-@node Cilk Plus Builtins
-@section Cilk Plus C/C++ Language Extension Built-in Functions
-GCC provides support for the following built-in reduction functions if Cilk Plus
-is enabled. Cilk Plus can be enabled using the @option{-fcilkplus} flag.
-@itemize @bullet
-@item @code{__sec_implicit_index}
-@item @code{__sec_reduce}
-@item @code{__sec_reduce_add}
-@item @code{__sec_reduce_all_nonzero}
-@item @code{__sec_reduce_all_zero}
-@item @code{__sec_reduce_any_nonzero}
-@item @code{__sec_reduce_any_zero}
-@item @code{__sec_reduce_max}
-@item @code{__sec_reduce_min}
-@item @code{__sec_reduce_max_ind}
-@item @code{__sec_reduce_min_ind}
-@item @code{__sec_reduce_mul}
-@item @code{__sec_reduce_mutating}
-@end itemize
-Further details and examples about these built-in functions are described
-in the Cilk Plus language manual which can be found at
-@uref{https://www.cilkplus.org}.
 @node Other Builtins
 @section Other Built-in Functions Provided by GCC
 @cindex built-in functions
 @findex __builtin_alloca
 @findex __builtin_alloca_with_align
 @findex __builtin_alloca_with_align_and_max
 @findex __builtin_call_with_static_chain
+@findex __builtin_extend_pointer
 @findex __builtin_fpclassify
 @findex __builtin_isfinite
 @findex __builtin_isnormal
 @findex __builtin_isgreater
 @findex __builtin_isgreaterequal
 @findex __builtin_islessgreater
 @findex __builtin_isunordered
 @findex __builtin_powi
 @findex __builtin_powif
 @findex __builtin_powil
+@findex __builtin_speculation_safe_value
 @findex _Exit
 @findex _exit
 @findex abort
 @findex abs
 @findex acos
 @findex strncasecmp
 @findex strncat
 @findex strncmp
 @findex strncpy
 @findex strndup
+@findex strnlen
 @findex strpbrk
 @findex strrchr
 @findex strspn
 @findex strstr
 @findex tan
 @code{signbit}, @code{signbitf}, @code{signbitl}, @code{signbitd32},
 @code{signbitd64}, @code{signbitd128}, @code{significandf},
 @code{significandl}, @code{significand}, @code{sincosf},
 @code{sincosl}, @code{sincos}, @code{stpcpy}, @code{stpncpy},
 @code{strcasecmp}, @code{strdup}, @code{strfmon}, @code{strncasecmp},
-@code{strndup}, @code{toascii}, @code{y0f}, @code{y0l}, @code{y0},
+@code{strndup}, @code{strnlen}, @code{toascii}, @code{y0f}, @code{y0l},
-@code{y1f}, @code{y1l}, @code{y1}, @code{ynf}, @code{ynl} and
+@code{y0}, @code{y1f}, @code{y1l}, @code{y1}, @code{ynf}, @code{ynl} and
 @code{yn}
 may be handled as built-in functions.
 All these functions have corresponding versions
 prefixed with @code{__builtin_}, which may be used even in strict C90
 mode.
 expression, it has no effect on code generation and no attempt is made to
 check its compatibility with @var{size}.
 @end deftypefn
+@deftypefn {Built-in Function} @var{type} __builtin_speculation_safe_value (@var{type} val, @var{type} failval)
+This built-in function can be used to help mitigate against unsafe
+speculative execution.  @var{type} may be any integral type or any
+pointer type.
+@enumerate
+@item
+If the CPU is not speculatively executing the code, then @var{val}
+is returned.
+@item
+If the CPU is executing speculatively then either:
+@itemize
+@item
+The function may cause execution to pause until it is known that the
+code is no-longer being executed speculatively (in which case
+@var{val} can be returned, as above); or
+@item
+The function may use target-dependent speculation tracking state to cause
+@var{failval} to be returned when it is known that speculative
+execution has incorrectly predicted a conditional branch operation.
+@end itemize
+@end enumerate
+The second argument, @var{failval}, is optional and defaults to zero
+if omitted.
+GCC defines the preprocessor macro
+@code{__HAVE_BUILTIN_SPECULATION_SAFE_VALUE} for targets that have been
+updated to support this builtin.
+The built-in function can be used where a variable appears to be used in a
+safe way, but the CPU, due to speculative execution may temporarily ignore
+the bounds checks.  Consider, for example, the following function:
+@smallexample
+int array[500];
+int f (unsigned untrusted_index)
+@{
+if (untrusted_index < 500)
+return array[untrusted_index];
+return 0;
+@}
+@end smallexample
+If the function is called repeatedly with @code{untrusted_index} less
+than the limit of 500, then a branch predictor will learn that the
+block of code that returns a value stored in @code{array} will be
+executed.  If the function is subsequently called with an
+out-of-range value it will still try to execute that block of code
+first until the CPU determines that the prediction was incorrect
+(the CPU will unwind any incorrect operations at that point).
+However, depending on how the result of the function is used, it might be
+possible to leave traces in the cache that can reveal what was stored
+at the out-of-bounds location.  The built-in function can be used to
+provide some protection against leaking data in this way by changing
+the code to:
+@smallexample
+int array[500];
+int f (unsigned untrusted_index)
+@{
+if (untrusted_index < 500)
+return array[__builtin_speculation_safe_value (untrusted_index)];
+return 0;
+@}
+@end smallexample
+The built-in function will either cause execution to stall until the
+conditional branch has been fully resolved, or it may permit
+speculative execution to continue, but using 0 instead of
+@code{untrusted_value} if that exceeds the limit.
+If accessing any memory location is potentially unsafe when speculative
+execution is incorrect, then the code can be rewritten as
+@smallexample
+int array[500];
+int f (unsigned untrusted_index)
+@{
+if (untrusted_index < 500)
+return *__builtin_speculation_safe_value (&array[untrusted_index], NULL);
+return 0;
+@}
+@end smallexample
+which will cause a @code{NULL} pointer to be used for the unsafe case.
+@end deftypefn
 @deftypefn {Built-in Function} int __builtin_types_compatible_p (@var{type1}, @var{type2})
 You can use the built-in function @code{__builtin_types_compatible_p} to
 determine whether two types are the same.
 This built-in function is analogous to the @samp{? :} operator in C,
 except that the expression returned has its type unaltered by promotion
 rules.  Also, the built-in function does not evaluate the expression
 that is not chosen.  For example, if @var{const_exp} evaluates to true,
-@var{exp2} is not evaluated even if it has side-effects.
+@var{exp2} is not evaluated even if it has side effects.
 This built-in function can return an lvalue if the chosen argument is an
 lvalue.
 If @var{exp1} is returned, the return type is the same as @var{exp1}'s
 @var{const_exp}) may still generate syntax errors.  This may change in
 future revisions.
 @end deftypefn
+@deftypefn {Built-in Function} @var{type} __builtin_tgmath (@var{functions}, @var{arguments})
+The built-in function @code{__builtin_tgmath}, available only for C
+and Objective-C, calls a function determined according to the rules of
+@code{<tgmath.h>} macros.  It is intended to be used in
+implementations of that header, so that expansions of macros from that
+header only expand each of their arguments once, to avoid problems
+when calls to such macros are nested inside the arguments of other
+calls to such macros; in addition, it results in better diagnostics
+for invalid calls to @code{<tgmath.h>} macros than implementations
+using other GNU C language features.  For example, the @code{pow}
+type-generic macro might be defined as:
+@smallexample
+#define pow(a, b) __builtin_tgmath (powf, pow, powl, \
+cpowf, cpow, cpowl, a, b)
+@end smallexample
+The arguments to @code{__builtin_tgmath} are at least two pointers to
+functions, followed by the arguments to the type-generic macro (which
+will be passed as arguments to the selected function).  All the
+pointers to functions must be pointers to prototyped functions, none
+of which may have variable arguments, and all of which must have the
+same number of parameters; the number of parameters of the first
+function determines how many arguments to @code{__builtin_tgmath} are
+interpreted as function pointers, and how many as the arguments to the
+called function.
+The types of the specified functions must all be different, but
+related to each other in the same way as a set of functions that may
+be selected between by a macro in @code{<tgmath.h>}.  This means that
+the functions are parameterized by a floating-point type @var{t},
+different for each such function.  The function return types may all
+be the same type, or they may be @var{t} for each function, or they
+may be the real type corresponding to @var{t} for each function (if
+some of the types @var{t} are complex).  Likewise, for each parameter
+position, the type of the parameter in that position may always be the
+same type, or may be @var{t} for each function (this case must apply
+for at least one parameter position), or may be the real type
+corresponding to @var{t} for each function.
+The standard rules for @code{<tgmath.h>} macros are used to find a
+common type @var{u} from the types of the arguments for parameters
+whose types vary between the functions; complex integer types (a GNU
+extension) are treated like @code{_Complex double} for this purpose
+(or @code{_Complex _Float64} if all the function return types are the
+same @code{_Float@var{n}} or @code{_Float@var{n}x} type).
+If the function return types vary, or are all the same integer type,
+the function called is the one for which @var{t} is @var{u}, and it is
+an error if there is no such function.  If the function return types
+are all the same floating-point type, the type-generic macro is taken
+to be one of those from TS 18661 that rounds the result to a narrower
+type; if there is a function for which @var{t} is @var{u}, it is
+called, and otherwise the first function, if any, for which @var{t}
+has at least the range and precision of @var{u} is called, and it is
+an error if there is no such function.
+@end deftypefn
 @deftypefn {Built-in Function} @var{type} __builtin_complex (@var{real}, @var{imag})
 The built-in function @code{__builtin_complex} is provided for use in
 implementing the ISO C11 macros @code{CMPLXF}, @code{CMPLX} and
 @code{CMPLXL}.  @var{real} and @var{imag} must have the same type, a
 foo (*ptr);
 @end smallexample
 @noindent
 when testing pointer or floating-point values.
+@end deftypefn
+@deftypefn {Built-in Function} long __builtin_expect_with_probability
+(long @var{exp}, long @var{c}, long @var{probability})
+The built-in has same semantics as @code{__builtin_expect_with_probability},
+but user can provide expected probability (in percent) for value of @var{exp}.
+Last argument @var{probability} is of float type and valid values
+are in inclusive range 0.0f and 1.0f.
 @end deftypefn
 @deftypefn {Built-in Function} void __builtin_trap (void)
 This function causes the program to exit abnormally.  GCC implements
 this function by using a target-dependent mechanism (such as
 @end deftypefn
 @deftypefn {Built-in Function} uint64_t __builtin_bswap64 (uint64_t x)
 Similar to @code{__builtin_bswap32}, except the argument and return types
 are 64 bit.
+@end deftypefn
+@deftypefn {Built-in Function} Pmode __builtin_extend_pointer (void * x)
+On targets where the user visible pointer size is smaller than the size
+of an actual hardware address this function returns the extended user
+pointer.  Targets where this is true included ILP32 mode on x86_64 or
+Aarch64.  This function is mainly useful when writing inline assembly
+code.
+@end deftypefn
+@deftypefn {Built-in Function} int __builtin_goacc_parlevel_id (int x)
+Returns the openacc gang, worker or vector id depending on whether @var{x} is
+0, 1 or 2.
+@end deftypefn
+@deftypefn {Built-in Function} int __builtin_goacc_parlevel_size (int x)
+Returns the openacc gang, worker or vector size depending on whether @var{x} is
+0, 1 or 2.
 @end deftypefn
 @node Target Builtins
 @section Built-in Functions Specific to Particular Target Machines
 * MIPS SIMD Architecture (MSA) Support::
 * Other MIPS Built-in Functions::
 * MSP430 Built-in Functions::
 * NDS32 Built-in Functions::
 * picoChip Built-in Functions::
-* PowerPC Built-in Functions::
+* Basic PowerPC Built-in Functions::
 * PowerPC AltiVec/VSX Built-in Functions::
 * PowerPC Hardware Transactional Memory Built-in Functions::
 * PowerPC Atomic Memory Operation Functions::
 * RX Built-in Functions::
 * S/390 System z Built-in Functions::
 * TI C6X Built-in Functions::
 * TILE-Gx Built-in Functions::
 * TILEPro Built-in Functions::
 * x86 Built-in Functions::
 * x86 transactional memory intrinsics::
+* x86 control-flow protection intrinsics::
 @end menu
 @node AArch64 Built-in Functions
 @subsection AArch64 Built-in Functions
 Halt.  The processor stops execution.  This built-in is useful for
 implementing assertions.
 @end table
-@node PowerPC Built-in Functions
+@node Basic PowerPC Built-in Functions
-@subsection PowerPC Built-in Functions
+@subsection Basic PowerPC Built-in Functions
-The following built-in functions are always available and can be used to
+@menu
-check the PowerPC target platform type:
+* Basic PowerPC Built-in Functions Available on all Configurations::
+* Basic PowerPC Built-in Functions Available on ISA 2.05::
+* Basic PowerPC Built-in Functions Available on ISA 2.06::
+* Basic PowerPC Built-in Functions Available on ISA 2.07::
+* Basic PowerPC Built-in Functions Available on ISA 3.0::
+@end menu
+This section describes PowerPC built-in functions that do not require
+the inclusion of any special header files to declare prototypes or
+provide macro definitions.  The sections that follow describe
+additional PowerPC built-in functions.
+@node Basic PowerPC Built-in Functions Available on all Configurations
+@subsubsection Basic PowerPC Built-in Functions Available on all Configurations
 @deftypefn {Built-in Function} void __builtin_cpu_init (void)
 This function is a @code{nop} on the PowerPC platform and is included solely
 to maintain API compatibility with the x86 builtins.
 @end deftypefn
 CPU supports the set of compatible performance monitoring events.
 @item booke
 CPU supports the Embedded ISA category.
 @item cellbe
 CPU has a CELL broadband engine.
+@item darn
+CPU supports the @code{darn} (deliver a random number) instruction.
 @item dfp
 CPU has a decimal floating point unit.
 @item dscr
 CPU supports the data stream control register.
 @item ebb
 CPU has a floating point unit.
 @item htm
 CPU has hardware transaction memory instructions.
 @item htm-nosc
 Kernel aborts hardware transactions when a syscall is made.
+@item htm-no-suspend
+CPU supports hardware transaction memory but does not support the
+@code{tsuspend.} instruction.
 @item ic_snoop
 CPU supports icache snooping capabilities.
 @item ieee128
 CPU supports 128-bit IEEE binary floating point instructions.
 @item isel
 CPU supports the old POWER ISA (eg, 601)
 @item ppc64
 CPU supports 64-bit mode execution.
 @item ppcle
 CPU supports a little-endian mode that uses address swizzling.
+@item scv
+Kernel supports system call vectored.
 @item smt
 CPU support simultaneous multi-threading.
 @item spe
 CPU has a signal processing extension unit.
 @item tar
 dst = __fadd (src1, src2); // Software FP addition function.
 @}
 @end smallexample
 @end deftypefn
-These built-in functions are available for the PowerPC family of
+The following built-in functions are also available on all PowerPC
 processors:
 @smallexample
-float __builtin_recipdivf (float, float);
-float __builtin_rsqrtf (float);
-double __builtin_recipdiv (double, double);
-double __builtin_rsqrt (double);
 uint64_t __builtin_ppc_get_timebase ();
 unsigned long __builtin_ppc_mftb ();
-double __builtin_unpack_longdouble (long double, int);
+__ibm128 __builtin_unpack_ibm128 (__ibm128, int);
-long double __builtin_pack_longdouble (double, double);
+__ibm128 __builtin_pack_ibm128 (double, double);
-@end smallexample
+double __builtin_mffs (void);
+void __builtin_mtfsb0 (const int);
-The @code{vec_rsqrt}, @code{__builtin_rsqrt}, and
+void __builtin_mtfsb1 (const int);
-@code{__builtin_rsqrtf} functions generate multiple instructions to
+void __builtin_set_fpscr_rn (int);
-implement the reciprocal sqrt functionality using reciprocal sqrt
+@end smallexample
-estimate instructions.
-The @code{__builtin_recipdiv}, and @code{__builtin_recipdivf}
-functions generate multiple instructions to implement division using
-the reciprocal estimate instructions.
 The @code{__builtin_ppc_get_timebase} and @code{__builtin_ppc_mftb}
 functions generate instructions to read the Time Base Register.  The
 @code{__builtin_ppc_get_timebase} function may generate multiple
 instructions and always returns the 64 bits of the Time Base Register.
 The @code{__builtin_ppc_mftb} function always generates one instruction and
 returns the Time Base Register value as an unsigned long, throwing away
-the most significant word on 32-bit environments.
+the most significant word on 32-bit environments.  The @code{__builtin_mffs}
+return the value of the FPSCR register.  Note, ISA 3.0 supports the
-Additional built-in functions are available for the 64-bit PowerPC
+@code{__builtin_mffsl()} which permits software to read the control and
-family of processors, for efficient use of 128-bit floating point
+non-sticky status bits in the FSPCR without the higher latency associated with
-(@code{__float128}) values.
+accessing the sticky status bits.  The
+@code{__builtin_mtfsb0} and @code{__builtin_mtfsb1} take the bit to change
-The following floating-point built-in functions are available with
+as an argument.  The valid bit range is between 0 and 31.  The builtins map to
-@code{-mfloat128} and Altivec support.  All of them implement the
+the @code{mtfsb0} and @code{mtfsb1} instructions which take the argument and
-function that is part of the name.
+add 32.  Hence these instructions only modify the FPSCR[32:63] bits by
+changing the specified bit to a zero or one respectively.  The
-@smallexample
+@code{__builtin_set_fpscr_rn} builtin allows changing both of the floating
-__float128 __builtin_fabsq (__float128)
+point rounding mode bits.  The argument is a 2-bit value.  The argument can
-__float128 __builtin_copysignq (__float128, __float128)
+either be a const int or stored in a variable. The builtin uses the ISA 3.0
-@end smallexample
+instruction @code{mffscrn} if available, otherwise it reads the FPSCR, masks
+the current rounding mode bits out and OR's in the new value.
-The following built-in functions are available with @code{-mfloat128}
-and Altivec support.
+@node Basic PowerPC Built-in Functions Available on ISA 2.05
+@subsubsection Basic PowerPC Built-in Functions Available on ISA 2.05
-@table @code
-@item __float128 __builtin_infq (void)
+The basic built-in functions described in this section are
-Similar to @code{__builtin_inf}, except the return type is @code{__float128}.
+available on the PowerPC family of processors starting with ISA 2.05
-@findex __builtin_infq
+or later.  Unless specific options are explicitly disabled on the
+command line, specifying option @option{-mcpu=power6} has the effect of
-@item __float128 __builtin_huge_valq (void)
+enabling the @option{-mpowerpc64}, @option{-mpowerpc-gpopt},
-Similar to @code{__builtin_huge_val}, except the return type is @code{__float128}.
+@option{-mpowerpc-gfxopt}, @option{-mmfcrf}, @option{-mpopcntb},
-@findex __builtin_huge_valq
+@option{-mfprnd}, @option{-mcmpb}, @option{-mhard-dfp}, and
+@option{-mrecip-precision} options.  Specify the
-@item __float128 __builtin_nanq (void)
+@option{-maltivec} and @option{-mfpgpr} options explicitly in
-Similar to @code{__builtin_nan}, except the return type is @code{__float128}.
+combination with the above options if they are desired.
-@findex __builtin_nanq
+The following functions require option @option{-mcmpb}.
-@item __float128 __builtin_nansq (void)
-Similar to @code{__builtin_nans}, except the return type is @code{__float128}.
-@findex __builtin_nansq
-@end table
-The following built-in functions are available on Linux 64-bit systems
-that use the ISA 3.0 instruction set.
-@table @code
-@item __float128 __builtin_sqrtf128 (__float128)
-Perform a 128-bit IEEE floating point square root operation.
-@findex __builtin_sqrtf128
-@item __float128 __builtin_fmaf128 (__float128, __float128, __float128)
-Perform a 128-bit IEEE floating point fused multiply and add operation.
-@findex __builtin_fmaf128
-@item __float128 __builtin_addf128_round_to_odd (__float128, __float128)
-Perform a 128-bit IEEE floating point add using round to odd as the
-rounding mode.
-@findex __builtin_addf128_round_to_odd
-@item __float128 __builtin_subf128_round_to_odd (__float128, __float128)
-Perform a 128-bit IEEE floating point subtract using round to odd as
-the rounding mode.
-@findex __builtin_subf128_round_to_odd
-@item __float128 __builtin_mulf128_round_to_odd (__float128, __float128)
-Perform a 128-bit IEEE floating point multiply using round to odd as
-the rounding mode.
-@findex __builtin_mulf128_round_to_odd
-@item __float128 __builtin_divf128_round_to_odd (__float128, __float128)
-Perform a 128-bit IEEE floating point divide using round to odd as
-the rounding mode.
-@findex __builtin_divf128_round_to_odd
-@item __float128 __builtin_sqrtf128_round_to_odd (__float128)
-Perform a 128-bit IEEE floating point square root using round to odd
-as the rounding mode.
-@findex __builtin_sqrtf128_round_to_odd
-@item __float128 __builtin_fmaf128 (__float128, __float128, __float128)
-Perform a 128-bit IEEE floating point fused multiply and add operation
-using round to odd as the rounding mode.
-@findex __builtin_fmaf128_round_to_odd
-@item double __builtin_truncf128_round_to_odd (__float128)
-Convert a 128-bit IEEE floating point value to @code{double} using
-round to odd as the rounding mode.
-@findex __builtin_truncf128_round_to_odd
-@end table
-The following built-in functions are available for the PowerPC family
-of processors, starting with ISA 2.05 or later (@option{-mcpu=power6}
-or @option{-mcmpb}):
 @smallexample
 unsigned long long __builtin_cmpb (unsigned long long int, unsigned long long int);
 unsigned int __builtin_cmpb (unsigned int, unsigned int);
 @end smallexample
 are not equal.  If either of the arguments to this built-in function
 is wider than 32 bits, the function call expands into the form that
 expects @code{unsigned long long int} arguments
 which is only available on 64-bit targets.
-The following built-in functions are available for the PowerPC family
+The following built-in functions are available
-of processors, starting with ISA 2.06 or later (@option{-mcpu=power7}
+when hardware decimal floating point
-or @option{-mpopcntd}):
+(@option{-mhard-dfp}) is available:
 @smallexample
-long __builtin_bpermd (long, long);
+void __builtin_set_fpscr_drn(int);
+_Decimal64 __builtin_ddedpd (int, _Decimal64);
+_Decimal128 __builtin_ddedpdq (int, _Decimal128);
+_Decimal64 __builtin_denbcd (int, _Decimal64);
+_Decimal128 __builtin_denbcdq (int, _Decimal128);
+_Decimal64 __builtin_diex (long long, _Decimal64);
+_Decimal128 _builtin_diexq (long long, _Decimal128);
+_Decimal64 __builtin_dscli (_Decimal64, int);
+_Decimal128 __builtin_dscliq (_Decimal128, int);
+_Decimal64 __builtin_dscri (_Decimal64, int);
+_Decimal128 __builtin_dscriq (_Decimal128, int);
+long long __builtin_dxex (_Decimal64);
+long long __builtin_dxexq (_Decimal128);
+_Decimal128 __builtin_pack_dec128 (unsigned long long, unsigned long long);
+unsigned long long __builtin_unpack_dec128 (_Decimal128, int);
+The @code{__builtin_set_fpscr_drn} builtin allows changing the three decimal
+floating point rounding mode bits.  The argument is a 3-bit value.  The
+argument can either be a const int or the value can be stored in a variable.
+The builtin uses the ISA 3.0 instruction @code{mffscdrn} if available.
+Otherwise the builtin reads the FPSCR, masks the current decimal rounding
+mode bits out and OR's in the new value.
+@end smallexample
+The following functions require @option{-mhard-float},
+@option{-mpowerpc-gfxopt}, and @option{-mpopcntb} options.
+@smallexample
+double __builtin_recipdiv (double, double);
+float __builtin_recipdivf (float, float);
+double __builtin_rsqrt (double);
+float __builtin_rsqrtf (float);
+@end smallexample
+The @code{vec_rsqrt}, @code{__builtin_rsqrt}, and
+@code{__builtin_rsqrtf} functions generate multiple instructions to
+implement the reciprocal sqrt functionality using reciprocal sqrt
+estimate instructions.
+The @code{__builtin_recipdiv}, and @code{__builtin_recipdivf}
+functions generate multiple instructions to implement division using
+the reciprocal estimate instructions.
+The following functions require @option{-mhard-float} and
+@option{-mmultiple} options.
+The @code{__builtin_unpack_longdouble} function takes a
+@code{long double} argument and a compile time constant of 0 or 1.  If
+the constant is 0, the first @code{double} within the
+@code{long double} is returned, otherwise the second @code{double}
+is returned.  The @code{__builtin_unpack_longdouble} function is only
+availble if @code{long double} uses the IBM extended double
+representation.
+The @code{__builtin_pack_longdouble} function takes two @code{double}
+arguments and returns a @code{long double} value that combines the two
+arguments.  The @code{__builtin_pack_longdouble} function is only
+availble if @code{long double} uses the IBM extended double
+representation.
+The @code{__builtin_unpack_ibm128} function takes a @code{__ibm128}
+argument and a compile time constant of 0 or 1.  If the constant is 0,
+the first @code{double} within the @code{__ibm128} is returned,
+otherwise the second @code{double} is returned.
+The @code{__builtin_pack_ibm128} function takes two @code{double}
+arguments and returns a @code{__ibm128} value that combines the two
+arguments.
+Additional built-in functions are available for the 64-bit PowerPC
+family of processors, for efficient use of 128-bit floating point
+(@code{__float128}) values.
+@node Basic PowerPC Built-in Functions Available on ISA 2.06
+@subsubsection Basic PowerPC Built-in Functions Available on ISA 2.06
+The basic built-in functions described in this section are
+available on the PowerPC family of processors starting with ISA 2.05
+or later.  Unless specific options are explicitly disabled on the
+command line, specifying option @option{-mcpu=power7} has the effect of
+enabling all the same options as for @option{-mcpu=power6} in
+addition to the @option{-maltivec}, @option{-mpopcntd}, and
+@option{-mvsx} options.
+The following basic built-in functions require @option{-mpopcntd}:
+@smallexample
+unsigned int __builtin_addg6s (unsigned int, unsigned int);
+long long __builtin_bpermd (long long, long long);
+unsigned int __builtin_cbcdtd (unsigned int);
+unsigned int __builtin_cdtbcd (unsigned int);
+long long __builtin_divde (long long, long long);
+unsigned long long __builtin_divdeu (unsigned long long, unsigned long long);
 int __builtin_divwe (int, int);
-int __builtin_divweo (int, int);
 unsigned int __builtin_divweu (unsigned int, unsigned int);
-unsigned int __builtin_divweuo (unsigned int, unsigned int);
+vector __int128 __builtin_pack_vector_int128 (long long, long long);
-long __builtin_divde (long, long);
+void __builtin_rs6000_speculation_barrier (void);
-long __builtin_divdeo (long, long);
+long long __builtin_unpack_vector_int128 (vector __int128, signed char);
-unsigned long __builtin_divdeu (unsigned long, unsigned long);
+@end smallexample
-unsigned long __builtin_divdeuo (unsigned long, unsigned long);
-unsigned int cdtbcd (unsigned int);
+Of these, the @code{__builtin_divde} and @code{__builtin_divdeu} functions
-unsigned int cbcdtd (unsigned int);
+require a 64-bit environment.
-unsigned int addg6s (unsigned int, unsigned int);
-@end smallexample
+The following basic built-in functions, which are also supported on
+x86 targets, require @option{-mfloat128}.
-The @code{__builtin_divde}, @code{__builtin_divdeo},
+@smallexample
-@code{__builtin_divdeu}, @code{__builtin_divdeou} functions require a
+__float128 __builtin_fabsq (__float128);
-64-bit environment support ISA 2.06 or later.
+__float128 __builtin_copysignq (__float128, __float128);
+__float128 __builtin_infq (void);
-The following built-in functions are available for the PowerPC family
+__float128 __builtin_huge_valq (void);
-of processors, starting with ISA 3.0 or later (@option{-mcpu=power9}):
+__float128 __builtin_nanq (void);
+__float128 __builtin_nansq (void);
+__float128 __builtin_sqrtf128 (__float128);
+__float128 __builtin_fmaf128 (__float128, __float128, __float128);
+@end smallexample
+@node Basic PowerPC Built-in Functions Available on ISA 2.07
+@subsubsection Basic PowerPC Built-in Functions Available on ISA 2.07
+The basic built-in functions described in this section are
+available on the PowerPC family of processors starting with ISA 2.07
+or later.  Unless specific options are explicitly disabled on the
+command line, specifying option @option{-mcpu=power8} has the effect of
+enabling all the same options as for @option{-mcpu=power7} in
+addition to the @option{-mpower8-fusion}, @option{-mpower8-vector},
+@option{-mcrypto}, @option{-mhtm}, @option{-mquad-memory}, and
+@option{-mquad-memory-atomic} options.
+This section intentionally empty.
+@node Basic PowerPC Built-in Functions Available on ISA 3.0
+@subsubsection Basic PowerPC Built-in Functions Available on ISA 3.0
+The basic built-in functions described in this section are
+available on the PowerPC family of processors starting with ISA 3.0
+or later.  Unless specific options are explicitly disabled on the
+command line, specifying option @option{-mcpu=power9} has the effect of
+enabling all the same options as for @option{-mcpu=power8} in
+addition to the @option{-misel} option.
+The following built-in functions are available on Linux 64-bit systems
+that use the ISA 3.0 instruction set (@option{-mcpu=power9}):
+@table @code
+@item __float128 __builtin_addf128_round_to_odd (__float128, __float128)
+Perform a 128-bit IEEE floating point add using round to odd as the
+rounding mode.
+@findex __builtin_addf128_round_to_odd
+@item __float128 __builtin_subf128_round_to_odd (__float128, __float128)
+Perform a 128-bit IEEE floating point subtract using round to odd as
+the rounding mode.
+@findex __builtin_subf128_round_to_odd
+@item __float128 __builtin_mulf128_round_to_odd (__float128, __float128)
+Perform a 128-bit IEEE floating point multiply using round to odd as
+the rounding mode.
+@findex __builtin_mulf128_round_to_odd
+@item __float128 __builtin_divf128_round_to_odd (__float128, __float128)
+Perform a 128-bit IEEE floating point divide using round to odd as
+the rounding mode.
+@findex __builtin_divf128_round_to_odd
+@item __float128 __builtin_sqrtf128_round_to_odd (__float128)
+Perform a 128-bit IEEE floating point square root using round to odd
+as the rounding mode.
+@findex __builtin_sqrtf128_round_to_odd
+@item __float128 __builtin_fmaf128_round_to_odd (__float128, __float128, __float128)
+Perform a 128-bit IEEE floating point fused multiply and add operation
+using round to odd as the rounding mode.
+@findex __builtin_fmaf128_round_to_odd
+@item double __builtin_truncf128_round_to_odd (__float128)
+Convert a 128-bit IEEE floating point value to @code{double} using
+round to odd as the rounding mode.
+@findex __builtin_truncf128_round_to_odd
+@end table
+The following additional built-in functions are also available for the
+PowerPC family of processors, starting with ISA 3.0 or later:
 @smallexample
 long long __builtin_darn (void);
 long long __builtin_darn_raw (void);
 int __builtin_darn_32 (void);
-unsigned int scalar_extract_exp (double source);
-unsigned long long int scalar_extract_exp (__ieee128 source);
-unsigned long long int scalar_extract_sig (double source);
-unsigned __int128 scalar_extract_sig (__ieee128 source);
-double
-scalar_insert_exp (unsigned long long int significand, unsigned long long int exponent);
-double
-scalar_insert_exp (double significand, unsigned long long int exponent);
-ieee_128
-scalar_insert_exp (unsigned __int128 significand, unsigned long long int exponent);
-ieee_128
-scalar_insert_exp (ieee_128 significand, unsigned long long int exponent);
-int scalar_cmp_exp_gt (double arg1, double arg2);
-int scalar_cmp_exp_lt (double arg1, double arg2);
-int scalar_cmp_exp_eq (double arg1, double arg2);
-int scalar_cmp_exp_unordered (double arg1, double arg2);
-bool scalar_test_data_class (float source, const int condition);
-bool scalar_test_data_class (double source, const int condition);
-bool scalar_test_data_class (__ieee128 source, const int condition);
-bool scalar_test_neg (float source);
-bool scalar_test_neg (double source);
-bool scalar_test_neg (__ieee128 source);
-int __builtin_byte_in_set (unsigned char u, unsigned long long set);
-int __builtin_byte_in_range (unsigned char u, unsigned int range);
-int __builtin_byte_in_either_range (unsigned char u, unsigned int ranges);
-int __builtin_dfp_dtstsfi_lt (unsigned int comparison, _Decimal64 value);
-int __builtin_dfp_dtstsfi_lt (unsigned int comparison, _Decimal128 value);
-int __builtin_dfp_dtstsfi_lt_dd (unsigned int comparison, _Decimal64 value);
-int __builtin_dfp_dtstsfi_lt_td (unsigned int comparison, _Decimal128 value);
-int __builtin_dfp_dtstsfi_gt (unsigned int comparison, _Decimal64 value);
-int __builtin_dfp_dtstsfi_gt (unsigned int comparison, _Decimal128 value);
-int __builtin_dfp_dtstsfi_gt_dd (unsigned int comparison, _Decimal64 value);
-int __builtin_dfp_dtstsfi_gt_td (unsigned int comparison, _Decimal128 value);
-int __builtin_dfp_dtstsfi_eq (unsigned int comparison, _Decimal64 value);
-int __builtin_dfp_dtstsfi_eq (unsigned int comparison, _Decimal128 value);
-int __builtin_dfp_dtstsfi_eq_dd (unsigned int comparison, _Decimal64 value);
-int __builtin_dfp_dtstsfi_eq_td (unsigned int comparison, _Decimal128 value);
-int __builtin_dfp_dtstsfi_ov (unsigned int comparison, _Decimal64 value);
-int __builtin_dfp_dtstsfi_ov (unsigned int comparison, _Decimal128 value);
-int __builtin_dfp_dtstsfi_ov_dd (unsigned int comparison, _Decimal64 value);
-int __builtin_dfp_dtstsfi_ov_td (unsigned int comparison, _Decimal128 value);
 @end smallexample
 The @code{__builtin_darn} and @code{__builtin_darn_raw}
 functions require a
 64-bit environment supporting ISA 3.0 or later.
 The @code{__builtin_darn} function provides a 64-bit conditioned
 random number.  The @code{__builtin_darn_raw} function provides a
 64-bit raw random number.  The @code{__builtin_darn_32} function
-provides a 32-bit random number.
+provides a 32-bit conditioned random number.
-The @code{scalar_extract_exp} and @code{scalar_extract_sig}
+The following additional built-in functions are also available for the
-functions require a 64-bit environment supporting ISA 3.0 or later.
+PowerPC family of processors, starting with ISA 3.0 or later:
-The @code{scalar_extract_exp} and @code{scalar_extract_sig} built-in
-functions return the significand and the biased exponent value
+@smallexample
-respectively of their @code{source} arguments.
+int __builtin_byte_in_set (unsigned char u, unsigned long long set);
-When supplied with a 64-bit @code{source} argument, the
+int __builtin_byte_in_range (unsigned char u, unsigned int range);
-result returned by @code{scalar_extract_sig} has
+int __builtin_byte_in_either_range (unsigned char u, unsigned int ranges);
-the @code{0x0010000000000000} bit set if the
-function's @code{source} argument is in normalized form.
+int __builtin_dfp_dtstsfi_lt (unsigned int comparison, _Decimal64 value);
-Otherwise, this bit is set to 0.
+int __builtin_dfp_dtstsfi_lt (unsigned int comparison, _Decimal128 value);
-When supplied with a 128-bit @code{source} argument, the
+int __builtin_dfp_dtstsfi_lt_dd (unsigned int comparison, _Decimal64 value);
-@code{0x00010000000000000000000000000000} bit of the result is
+int __builtin_dfp_dtstsfi_lt_td (unsigned int comparison, _Decimal128 value);
-treated similarly.
-Note that the sign of the significand is not represented in the result
+int __builtin_dfp_dtstsfi_gt (unsigned int comparison, _Decimal64 value);
-returned from the @code{scalar_extract_sig} function.  Use the
+int __builtin_dfp_dtstsfi_gt (unsigned int comparison, _Decimal128 value);
-@code{scalar_test_neg} function to test the sign of its @code{double}
+int __builtin_dfp_dtstsfi_gt_dd (unsigned int comparison, _Decimal64 value);
-argument.
+int __builtin_dfp_dtstsfi_gt_td (unsigned int comparison, _Decimal128 value);
-The @code{scalar_insert_exp}
+int __builtin_dfp_dtstsfi_eq (unsigned int comparison, _Decimal64 value);
-functions require a 64-bit environment supporting ISA 3.0 or later.
+int __builtin_dfp_dtstsfi_eq (unsigned int comparison, _Decimal128 value);
-When supplied with a 64-bit first argument, the
+int __builtin_dfp_dtstsfi_eq_dd (unsigned int comparison, _Decimal64 value);
-@code{scalar_insert_exp} built-in function returns a double-precision
+int __builtin_dfp_dtstsfi_eq_td (unsigned int comparison, _Decimal128 value);
-floating point value that is constructed by assembling the values of its
-@code{significand} and @code{exponent} arguments.  The sign of the
+int __builtin_dfp_dtstsfi_ov (unsigned int comparison, _Decimal64 value);
-result is copied from the most significant bit of the
+int __builtin_dfp_dtstsfi_ov (unsigned int comparison, _Decimal128 value);
-@code{significand} argument.  The significand and exponent components
+int __builtin_dfp_dtstsfi_ov_dd (unsigned int comparison, _Decimal64 value);
-of the result are composed of the least significant 11 bits of the
+int __builtin_dfp_dtstsfi_ov_td (unsigned int comparison, _Decimal128 value);
-@code{exponent} argument and the least significant 52 bits of the
-@code{significand} argument respectively.
+double __builtin_mffsl(void);
-When supplied with a 128-bit first argument, the
+@end smallexample
-@code{scalar_insert_exp} built-in function returns a quad-precision
-ieee floating point value.  The sign bit of the result is copied from
-the most significant bit of the @code{significand} argument.
-The significand and exponent components of the result are composed of
-the least significant 15 bits of the @code{exponent} argument and the
-least significant 112 bits of the @code{significand} argument respectively.
-The @code{scalar_cmp_exp_gt}, @code{scalar_cmp_exp_lt},
-@code{scalar_cmp_exp_eq}, and @code{scalar_cmp_exp_unordered} built-in
-functions return a non-zero value if @code{arg1} is greater than, less
-than, equal to, or not comparable to @code{arg2} respectively.  The
-arguments are not comparable if one or the other equals NaN (not a
-number).
-The @code{scalar_test_data_class} built-in function returns 1
-if any of the condition tests enabled by the value of the
-@code{condition} variable are true, and 0 otherwise.  The
-@code{condition} argument must be a compile-time constant integer with
-value not exceeding 127.  The
-@code{condition} argument is encoded as a bitmask with each bit
-enabling the testing of a different condition, as characterized by the
-following:
-@smallexample
-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
-@end smallexample
-The @code{scalar_test_neg} built-in function returns 1 if its
-@code{source} argument holds a negative value, 0 otherwise.
 The @code{__builtin_byte_in_set} function requires a
 64-bit environment supporting ISA 3.0 or later.  This function returns
 a non-zero value if and only if its @code{u} argument exactly equals one of
 the eight bytes contained within its 64-bit @code{set} argument.
 The @code{__builtin_dfp_dtstsfi_ov_dd} and
 @code{__builtin_dfp_dtstsfi_ov_td} functions behave similarly, but
 require that the type of the @code{value} argument be
 @code{__Decimal64} and @code{__Decimal128} respectively.
-The following built-in functions are also available for the PowerPC family
+The @code{__builtin_mffsl} uses the ISA 3.0 @code{mffsl} instruction to read
-of processors, starting with ISA 3.0 or later
+the FPSCR.  The instruction is a lower latency version of the @code{mffs}
-(@option{-mcpu=power9}).  These string functions are described
+instruction.  If the @code{mffsl} instruction is not available, then the
-separately in order to group the descriptions closer to the function
+builtin uses the older @code{mffs} instruction to read the FPSCR.
-prototypes:
-@smallexample
-int vec_all_nez (vector signed char, vector signed char);
-int vec_all_nez (vector unsigned char, vector unsigned char);
-int vec_all_nez (vector signed short, vector signed short);
-int vec_all_nez (vector unsigned short, vector unsigned short);
-int vec_all_nez (vector signed int, vector signed int);
-int vec_all_nez (vector unsigned int, vector unsigned int);
-int vec_any_eqz (vector signed char, vector signed char);
-int vec_any_eqz (vector unsigned char, vector unsigned char);
-int vec_any_eqz (vector signed short, vector signed short);
-int vec_any_eqz (vector unsigned short, vector unsigned short);
-int vec_any_eqz (vector signed int, vector signed int);
-int vec_any_eqz (vector unsigned int, vector unsigned int);
-vector bool char vec_cmpnez (vector signed char arg1, vector signed char arg2);
-vector bool char vec_cmpnez (vector unsigned char arg1, vector unsigned char arg2);
-vector bool short vec_cmpnez (vector signed short arg1, vector signed short arg2);
-vector bool short vec_cmpnez (vector unsigned short arg1, vector unsigned short arg2);
-vector bool int vec_cmpnez (vector signed int arg1, vector signed int arg2);
-vector bool int vec_cmpnez (vector unsigned int, vector unsigned int);
-vector signed char vec_cnttz (vector signed char);
-vector unsigned char vec_cnttz (vector unsigned char);
-vector signed short vec_cnttz (vector signed short);
-vector unsigned short vec_cnttz (vector unsigned short);
-vector signed int vec_cnttz (vector signed int);
-vector unsigned int vec_cnttz (vector unsigned int);
-vector signed long long vec_cnttz (vector signed long long);
-vector unsigned long long vec_cnttz (vector unsigned long long);
-signed int vec_cntlz_lsbb (vector signed char);
-signed int vec_cntlz_lsbb (vector unsigned char);
-signed int vec_cnttz_lsbb (vector signed char);
-signed int vec_cnttz_lsbb (vector unsigned char);
-vector unsigned short vec_pack_to_short_fp32 (vector float, vector float);
-vector signed char vec_xl_be (signed long long, signed char *);
-vector unsigned char vec_xl_be (signed long long, unsigned char *);
-vector signed int vec_xl_be (signed long long, signed int *);
-vector unsigned int vec_xl_be (signed long long, unsigned int *);
-vector signed __int128 vec_xl_be (signed long long, signed __int128 *);
-vector unsigned __int128 vec_xl_be (signed long long, unsigned __int128 *);
-vector signed long long vec_xl_be (signed long long, signed long long *);
-vector unsigned long long vec_xl_be (signed long long, unsigned long long *);
-vector signed short vec_xl_be (signed long long, signed short *);
-vector unsigned short vec_xl_be (signed long long, unsigned short *);
-vector double vec_xl_be (signed long long, double *);
-vector float vec_xl_be (signed long long, float *);
-vector signed char vec_xl_len (signed char *addr, size_t len);
-vector unsigned char vec_xl_len (unsigned char *addr, size_t len);
-vector signed int vec_xl_len (signed int *addr, size_t len);
-vector unsigned int vec_xl_len (unsigned int *addr, size_t len);
-vector signed __int128 vec_xl_len (signed __int128 *addr, size_t len);
-vector unsigned __int128 vec_xl_len (unsigned __int128 *addr, size_t len);
-vector signed long long vec_xl_len (signed long long *addr, size_t len);
-vector unsigned long long vec_xl_len (unsigned long long *addr, size_t len);
-vector signed short vec_xl_len (signed short *addr, size_t len);
-vector unsigned short vec_xl_len (unsigned short *addr, size_t len);
-vector double vec_xl_len (double *addr, size_t len);
-vector float vec_xl_len (float *addr, size_t len);
-vector unsigned char vec_xl_len_r (unsigned char *addr, size_t len);
-void vec_xst_len (vector signed char data, signed char *addr, size_t len);
-void vec_xst_len (vector unsigned char data, unsigned char *addr, size_t len);
-void vec_xst_len (vector signed int data, signed int *addr, size_t len);
-void vec_xst_len (vector unsigned int data, unsigned int *addr, size_t len);
-void vec_xst_len (vector unsigned __int128 data, unsigned __int128 *addr, size_t len);
-void vec_xst_len (vector signed long long data, signed long long *addr, size_t len);
-void vec_xst_len (vector unsigned long long data, unsigned long long *addr, size_t len);
-void vec_xst_len (vector signed short data, signed short *addr, size_t len);
-void vec_xst_len (vector unsigned short data, unsigned short *addr, size_t len);
-void vec_xst_len (vector signed __int128 data, signed __int128 *addr, size_t len);
-void vec_xst_len (vector double data, double *addr, size_t len);
-void vec_xst_len (vector float data, float *addr, size_t len);
-void vec_xst_len_r (vector unsigned char data, unsigned char *addr, size_t len);
-signed char vec_xlx (unsigned int index, vector signed char data);
-unsigned char vec_xlx (unsigned int index, vector unsigned char data);
-signed short vec_xlx (unsigned int index, vector signed short data);
-unsigned short vec_xlx (unsigned int index, vector unsigned short data);
-signed int vec_xlx (unsigned int index, vector signed int data);
-unsigned int vec_xlx (unsigned int index, vector unsigned int data);
-float vec_xlx (unsigned int index, vector float data);
-signed char vec_xrx (unsigned int index, vector signed char data);
-unsigned char vec_xrx (unsigned int index, vector unsigned char data);
-signed short vec_xrx (unsigned int index, vector signed short data);
-unsigned short vec_xrx (unsigned int index, vector unsigned short data);
-signed int vec_xrx (unsigned int index, vector signed int data);
-unsigned int vec_xrx (unsigned int index, vector unsigned int data);
-float vec_xrx (unsigned int index, vector float data);
-@end smallexample
-The @code{vec_all_nez}, @code{vec_any_eqz}, and @code{vec_cmpnez}
-perform pairwise comparisons between the elements at the same
-positions within their two vector arguments.
-The @code{vec_all_nez} function returns a
-non-zero value if and only if all pairwise comparisons are not
-equal and no element of either vector argument contains a zero.
-The @code{vec_any_eqz} function returns a
-non-zero value if and only if at least one pairwise comparison is equal
-or if at least one element of either vector argument contains a zero.
-The @code{vec_cmpnez} function returns a vector of the same type as
-its two arguments, within which each element consists of all ones to
-denote that either the corresponding elements of the incoming arguments are
-not equal or that at least one of the corresponding elements contains
-zero.  Otherwise, the element of the returned vector contains all zeros.
-The @code{vec_cntlz_lsbb} function returns the count of the number of
-consecutive leading byte elements (starting from position 0 within the
-supplied vector argument) for which the least-significant bit
-equals zero.  The @code{vec_cnttz_lsbb} function returns the count of
-the number of consecutive trailing byte elements (starting from
-position 15 and counting backwards within the supplied vector
-argument) for which the least-significant bit equals zero.
-The @code{vec_xl_len} and @code{vec_xst_len} functions require a
-64-bit environment supporting ISA 3.0 or later.  The @code{vec_xl_len}
-function loads a variable length vector from memory.  The
-@code{vec_xst_len} function stores a variable length vector to memory.
-With both the @code{vec_xl_len} and @code{vec_xst_len} functions, the
-@code{addr} argument represents the memory address to or from which
-data will be transferred, and the
-@code{len} argument represents the number of bytes to be
-transferred, as computed by the C expression @code{min((len & 0xff), 16)}.
-If this expression's value is not a multiple of the vector element's
-size, the behavior of this function is undefined.
-In the case that the underlying computer is configured to run in
-big-endian mode, the data transfer moves bytes 0 to @code{(len - 1)} of
-the corresponding vector.  In little-endian mode, the data transfer
-moves bytes @code{(16 - len)} to @code{15} of the corresponding
-vector.  For the load function, any bytes of the result vector that
-are not loaded from memory are set to zero.
-The value of the @code{addr} argument need not be aligned on a
-multiple of the vector's element size.
-The @code{vec_xlx} and @code{vec_xrx} functions extract the single
-element selected by the @code{index} argument from the vector
-represented by the @code{data} argument.  The @code{index} argument
-always specifies a byte offset, regardless of the size of the vector
-element.  With @code{vec_xlx}, @code{index} is the offset of the first
-byte of the element to be extracted.  With @code{vec_xrx}, @code{index}
-represents the last byte of the element to be extracted, measured
-from the right end of the vector.  In other words, the last byte of
-the element to be extracted is found at position @code{(15 - index)}.
-There is no requirement that @code{index} be a multiple of the vector
-element size.  However, if the size of the vector element added to
-@code{index} is greater than 15, the content of the returned value is
-undefined.
-The following built-in functions are available for the PowerPC family
-of processors when hardware decimal floating point
-(@option{-mhard-dfp}) is available:
-@smallexample
-long long __builtin_dxex (_Decimal64);
-long long __builtin_dxexq (_Decimal128);
-_Decimal64 __builtin_ddedpd (int, _Decimal64);
-_Decimal128 __builtin_ddedpdq (int, _Decimal128);
-_Decimal64 __builtin_denbcd (int, _Decimal64);
-_Decimal128 __builtin_denbcdq (int, _Decimal128);
-_Decimal64 __builtin_diex (long long, _Decimal64);
-_Decimal128 _builtin_diexq (long long, _Decimal128);
-_Decimal64 __builtin_dscli (_Decimal64, int);
-_Decimal128 __builtin_dscliq (_Decimal128, int);
-_Decimal64 __builtin_dscri (_Decimal64, int);
-_Decimal128 __builtin_dscriq (_Decimal128, int);
-unsigned long long __builtin_unpack_dec128 (_Decimal128, int);
-_Decimal128 __builtin_pack_dec128 (unsigned long long, unsigned long long);
-@end smallexample
-The following built-in functions are available for the PowerPC family
-of processors when the Vector Scalar (vsx) instruction set is
-available:
-@smallexample
-unsigned long long __builtin_unpack_vector_int128 (vector __int128_t, int);
-vector __int128_t __builtin_pack_vector_int128 (unsigned long long,
-unsigned long long);
-@end smallexample
 @node PowerPC AltiVec/VSX Built-in Functions
-@subsection PowerPC AltiVec Built-in Functions
+@subsection PowerPC AltiVec/VSX 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
 @code{<altivec.h>} and using @option{-maltivec} and
 vector unsigned int
 vector signed int
 vector bool int
 vector float
 @end smallexample
-If @option{-mvsx} is used the following additional vector types are
-implemented.
-@smallexample
-vector unsigned long
-vector signed long
-vector double
-@end smallexample
-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.
 @itemize @bullet
 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.
+@menu
+* PowerPC AltiVec Built-in Functions on ISA 2.05::
+* PowerPC AltiVec Built-in Functions Available on ISA 2.06::
+* PowerPC AltiVec Built-in Functions Available on ISA 2.07::
+* PowerPC AltiVec Built-in Functions Available on ISA 3.0::
+@end menu
+@node PowerPC AltiVec Built-in Functions on ISA 2.05
+@subsubsection PowerPC AltiVec Built-in Functions on ISA 2.05
 The following interfaces are supported for the generic and specific
 AltiVec operations and the AltiVec predicates.  In cases where there
 is a direct mapping between generic and specific operations, only the
 generic names are shown here, although the specific operations can also
 be used.
 vector signed char vec_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 vec_add (vector unsigned char, 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 vec_add (vector bool short, vector unsigned 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 vec_add (vector unsigned short, 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 vec_adds (vector unsigned char, 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 vec_adds (vector bool short, vector unsigned 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 vec_adds (vector unsigned short, 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);
-vector double vec_doublee (vector float);
-vector double vec_doublee (vector signed int);
-vector double vec_doublee (vector unsigned int);
-vector double vec_doubleo (vector float);
-vector double vec_doubleo (vector signed int);
-vector double vec_doubleo (vector unsigned int);
-vector double vec_doubleh (vector float);
-vector double vec_doubleh (vector signed int);
-vector double vec_doubleh (vector unsigned int);
-vector double vec_doublel (vector float);
-vector double vec_doublel (vector signed int);
-vector double vec_doublel (vector unsigned 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_float (vector signed int);
-vector float vec_float (vector unsigned int);
-vector float vec_float2 (vector signed long long, vector signed long long);
-vector float vec_float2 (vector unsigned long long, vector signed long long);
-vector float vec_floate (vector double);
-vector float vec_floate (vector signed long long);
-vector float vec_floate (vector unsigned long long);
-vector float vec_floato (vector double);
-vector float vec_floato (vector signed long long);
-vector float vec_floato (vector unsigned long long);
-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 unsigned long long vec_mule (vector unsigned int,
-vector unsigned int);
-vector signed long long vec_mule (vector signed int,
-vector signed int);
-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 unsigned long long vec_mulo (vector unsigned int,
-vector unsigned int);
-vector signed long long vec_mulo (vector signed int,
-vector signed int);
-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 signed char vec_neg (vector signed char);
-vector signed short vec_neg (vector signed short);
-vector signed int vec_neg (vector signed int);
-vector signed long long vec_neg (vector signed long long);
-vector float  char vec_neg (vector float);
-vector double vec_neg (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 bool char vec_reve (vector bool char);
-vector signed char vec_reve (vector signed char);
-vector unsigned char vec_reve (vector unsigned char);
-vector bool int vec_reve (vector bool int);
-vector signed int vec_reve (vector signed int);
-vector unsigned int vec_reve (vector unsigned int);
-vector bool long long vec_reve (vector bool long long);
-vector signed long long vec_reve (vector signed long long);
-vector unsigned long long vec_reve (vector unsigned long long);
-vector bool short vec_reve (vector bool short);
-vector signed short vec_reve (vector signed short);
-vector unsigned short vec_reve (vector unsigned short);
-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 long long vec_signed (vector double);
-vector signed int vec_signed (vector float);
-vector signed int vec_signede (vector double);
-vector signed int vec_signedo (vector double);
-vector signed int vec_signed2 (vector double, vector double);
-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 char vec_sldw (vector signed char,
-vector signed char,
-const int);
-vector unsigned char vec_sldw (vector unsigned char,
-vector unsigned char,
-const int);
-vector signed short vec_sldw (vector signed short,
-vector signed short,
-const int);
-vector unsigned short vec_sldw (vector unsigned short,
-vector unsigned short,
-const int);
-vector signed int vec_sldw (vector signed int,
-vector signed int,
-const int);
-vector unsigned int vec_sldw (vector unsigned int,
-vector unsigned int,
-const int);
-vector signed long long vec_sldw (vector signed long long,
-vector signed long long,
-const int);
-vector unsigned long long vec_sldw (vector unsigned long long,
-vector unsigned long long,
-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 long long vec_slo (vector signed long long, vector signed char);
-vector signed long long vec_slo (vector signed long long, vector unsigned char);
-vector unsigned long long vec_slo (vector unsigned long long, vector signed char);
-vector unsigned long long vec_slo (vector unsigned long long, 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 signed int vec_subc (vector signed int, vector signed int);
-vector unsigned int vec_subc (vector unsigned int, vector unsigned int);
-vector signed __int128 vec_subc (vector signed __int128,
-vector signed __int128);
-vector unsigned __int128 vec_subc (vector unsigned __int128,
-vector unsigned __int128);
-vector signed int vec_sube (vector signed int, vector signed int,
-vector signed int);
-vector unsigned int vec_sube (vector unsigned int, vector unsigned int,
-vector unsigned int);
-vector signed __int128 vec_sube (vector signed __int128,
-vector signed __int128,
-vector signed __int128);
-vector unsigned __int128 vec_sube (vector unsigned __int128,
-vector unsigned __int128,
-vector unsigned __int128);
-vector signed int vec_subec (vector signed int, vector signed int,
-vector signed int);
-vector unsigned int vec_subec (vector unsigned int, vector unsigned int,
-vector unsigned int);
-vector signed __int128 vec_subec (vector signed __int128,
-vector signed __int128,
-vector signed __int128);
-vector unsigned __int128 vec_subec (vector unsigned __int128,
-vector unsigned __int128,
-vector unsigned __int128);
-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 long long vec_unsigned (vector double);
-vector signed int vec_unsigned (vector float);
-vector signed int vec_unsignede (vector double);
-vector signed int vec_unsignedo (vector double);
-vector signed int vec_unsigned2 (vector double, vector double);
-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_nlt (vector float, vector float);
 int vec_all_numeric (vector float);
+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);
 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_nlt (vector float, vector float);
 int vec_any_numeric (vector float);
 int vec_any_out (vector float, vector float);
-@end smallexample
+vector unsigned char vec_avg (vector unsigned char, vector unsigned char);
-If the vector/scalar (VSX) instruction set is available, the following
+vector signed char vec_avg (vector signed char, vector signed char);
-additional functions are available:
+vector unsigned short vec_avg (vector unsigned short, vector unsigned short);
+vector signed short vec_avg (vector signed short, vector signed short);
-@smallexample
+vector unsigned int vec_avg (vector unsigned int, vector unsigned int);
+vector signed int vec_avg (vector signed int, vector signed int);
+vector float vec_ceil (vector float);
+vector signed int vec_cmpb (vector float, vector float);
+vector 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_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_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 signed int vec_cts (vector float, const int);
+vector unsigned int vec_ctu (vector float, const int);
+void vec_dss (const int);
+void vec_dssall (void);
+void vec_dst (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 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 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 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 unsigned int vec_ld (int, const vector unsigned int *);
+vector unsigned int vec_ld (int, const unsigned int *);
+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 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 unsigned int vec_ldl (int, const vector unsigned int *);
+vector unsigned int vec_ldl (int, const unsigned int *);
+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 signed char vec_lvebx (int, char *);
+vector unsigned char vec_lvebx (int, unsigned char *);
+vector signed short vec_lvehx (int, short *);
+vector unsigned short vec_lvehx (int, unsigned short *);
+vector float vec_lvewx (int, float *);
+vector signed int vec_lvewx (int, int *);
+vector unsigned int vec_lvewx (int, unsigned int *);
+vector unsigned char vec_lvsl (int, const unsigned char *);
+vector unsigned char vec_lvsl (int, const signed char *);
+vector unsigned char vec_lvsl (int, const unsigned short *);
+vector unsigned char vec_lvsl (int, const short *);
+vector unsigned char vec_lvsl (int, const unsigned int *);
+vector unsigned char vec_lvsl (int, const int *);
+vector unsigned char vec_lvsl (int, const float *);
+vector unsigned char vec_lvsr (int, const unsigned char *);
+vector unsigned char vec_lvsr (int, const signed char *);
+vector unsigned char vec_lvsr (int, const unsigned short *);
+vector unsigned char vec_lvsr (int, const short *);
+vector unsigned char vec_lvsr (int, const unsigned int *);
+vector unsigned char vec_lvsr (int, const int *);
+vector unsigned char vec_lvsr (int, const 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 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 bool char vec_mergel (vector bool char, vector bool char);
+vector signed char vec_mergel (vector signed char, vector signed char);
+vector unsigned char vec_mergel (vector unsigned char, vector unsigned char);
+vector bool short vec_mergel (vector bool short, vector bool short);
+vector pixel vec_mergel (vector pixel, vector pixel);
+vector signed short vec_mergel (vector signed short, vector signed short);
+vector unsigned short vec_mergel (vector unsigned short, vector unsigned short);
+vector float vec_mergel (vector float, vector float);
+vector bool int vec_mergel (vector bool int, vector bool int);
+vector signed int vec_mergel (vector signed int, vector signed int);
+vector unsigned int vec_mergel (vector unsigned int, vector unsigned int);
+vector unsigned short vec_mfvscr (void);
+vector 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 signed short vec_mladd (vector signed short, vector signed short,
+vector signed short);
+vector signed short vec_mladd (vector signed short, vector unsigned short,
+vector unsigned short);
+vector signed short vec_mladd (vector unsigned short, vector signed short,
+vector signed short);
+vector unsigned short vec_mladd (vector unsigned short, vector unsigned short,
+vector unsigned short);
+vector signed short vec_mradds (vector signed short, vector signed short,
+vector signed short);
+vector unsigned int vec_msum (vector unsigned char, vector unsigned char,
+vector unsigned int);
+vector signed int vec_msum (vector signed char, vector unsigned char,
+vector signed int);
+vector unsigned int vec_msum (vector unsigned short, vector unsigned short,
+vector unsigned int);
+vector signed int vec_msum (vector signed short, vector signed short,
+vector signed int);
+vector unsigned int vec_msums (vector unsigned short, vector unsigned short,
+vector unsigned int);
+vector signed int vec_msums (vector signed short, vector signed short,
+vector signed int);
+void vec_mtvscr (vector signed int);
+void vec_mtvscr (vector unsigned int);
+void vec_mtvscr (vector 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 float vec_mul (vector float, vector float);
+vector unsigned short vec_mule (vector unsigned char, vector unsigned char);
+vector signed short vec_mule (vector signed char, vector signed char);
+vector unsigned int vec_mule (vector unsigned short, vector unsigned short);
+vector signed int vec_mule (vector signed short, vector signed short);
+vector unsigned short vec_mulo (vector unsigned char, vector unsigned char);
+vector signed short vec_mulo (vector signed char, vector signed char);
+vector unsigned int vec_mulo (vector unsigned short, vector unsigned short);
+vector signed int vec_mulo (vector signed short, vector signed short);
+vector 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 float vec_nmsub (vector float, vector float, vector float);
+vector float vec_nor (vector float, vector float);
+vector signed int vec_nor (vector signed int, vector signed int);
+vector unsigned int vec_nor (vector unsigned int, vector unsigned int);
+vector bool int vec_nor (vector bool int, vector bool int);
+vector signed short vec_nor (vector signed short, vector signed short);
+vector unsigned short vec_nor (vector unsigned short, vector unsigned short);
+vector bool short vec_nor (vector bool short, vector bool short);
+vector signed char vec_nor (vector signed char, vector signed char);
+vector unsigned char vec_nor (vector unsigned char, vector unsigned char);
+vector bool char vec_nor (vector bool char, vector bool char);
+vector float vec_or (vector float, vector float);
+vector float vec_or (vector float, vector 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 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 unsigned char vec_packsu (vector unsigned short, vector unsigned short);
+vector unsigned char vec_packsu (vector signed short, vector signed short);
+vector unsigned short vec_packsu (vector unsigned int, vector unsigned int);
+vector unsigned short vec_packsu (vector signed int, vector signed int);
+vector float vec_perm (vector float, vector float, vector unsigned char);
+vector signed int vec_perm (vector signed int, vector signed int, vector unsigned char);
+vector unsigned int vec_perm (vector unsigned int, vector unsigned int,
+vector unsigned char);
+vector 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 bool char vec_reve (vector bool char);
+vector signed char vec_reve (vector signed char);
+vector unsigned char vec_reve (vector unsigned char);
+vector bool int vec_reve (vector bool int);
+vector signed int vec_reve (vector signed int);
+vector unsigned int vec_reve (vector unsigned int);
+vector bool short vec_reve (vector bool short);
+vector signed short vec_reve (vector signed short);
+vector unsigned short vec_reve (vector unsigned short);
+vector signed char vec_rl (vector signed char, vector unsigned char);
+vector unsigned char vec_rl (vector unsigned char, vector unsigned char);
+vector signed short vec_rl (vector signed short, vector unsigned short);
+vector unsigned short vec_rl (vector unsigned short, vector unsigned short);
+vector signed int vec_rl (vector signed int, vector unsigned int);
+vector unsigned int vec_rl (vector unsigned int, vector unsigned int);
+vector float vec_round (vector float);
+vector float vec_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 float vec_sld (vector float, vector float, const int);
+vector signed int vec_sld (vector signed int, vector signed int, const int);
+vector unsigned int vec_sld (vector unsigned int, vector unsigned int, const int);
+vector bool int vec_sld (vector bool int, vector bool int, const int);
+vector signed short vec_sld (vector signed short, vector signed short, const int);
+vector unsigned short vec_sld (vector unsigned short, vector unsigned short, const 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 short vec_splat_s16 (const int);
+vector signed int vec_splat_s32 (const int);
+vector signed char vec_splat_s8 (const int);
+vector unsigned short vec_splat_u16 (const int);
+vector unsigned int vec_splat_u32 (const int);
+vector unsigned char vec_splat_u8 (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 signed char vec_sr (vector signed char, vector unsigned char);
+vector unsigned char vec_sr (vector unsigned char, vector unsigned char);
+vector signed short vec_sr (vector signed short, vector unsigned short);
+vector unsigned short vec_sr (vector unsigned short, vector unsigned short);
+vector signed int vec_sr (vector signed int, vector unsigned int);
+vector unsigned int vec_sr (vector unsigned int, vector unsigned int);
+vector signed char vec_sra (vector signed char, vector unsigned char);
+vector unsigned char vec_sra (vector unsigned char, vector unsigned char);
+vector signed short vec_sra (vector signed short, vector unsigned short);
+vector unsigned short vec_sra (vector unsigned short, vector unsigned short);
+vector signed int vec_sra (vector signed int, vector unsigned int);
+vector unsigned int vec_sra (vector unsigned int, vector unsigned int);
+vector signed int vec_srl (vector signed int, vector unsigned int);
+vector signed int vec_srl (vector signed int, vector unsigned short);
+vector signed int vec_srl (vector signed int, vector unsigned char);
+vector unsigned int vec_srl (vector unsigned int, vector unsigned int);
+vector unsigned int vec_srl (vector unsigned int, vector unsigned short);
+vector unsigned int vec_srl (vector unsigned int, vector unsigned char);
+vector 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 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_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 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 *);
+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_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_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 *);
+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 signed int vec_subc (vector signed int, vector signed int);
+vector unsigned int vec_subc (vector unsigned int, vector unsigned int);
+vector signed int vec_sube (vector signed int, vector signed int,
+vector signed int);
+vector unsigned int vec_sube (vector unsigned int, vector unsigned int,
+vector unsigned int);
+vector signed int vec_subec (vector signed int, vector signed int,
+vector signed int);
+vector unsigned int vec_subec (vector unsigned int, 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_sum2s (vector signed int, vector signed int);
+vector unsigned int vec_sum4s (vector unsigned char, vector unsigned int);
+vector signed int vec_sum4s (vector signed char, vector signed int);
+vector signed int vec_sum4s (vector signed short, vector signed int);
+vector signed int vec_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 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 float vec_vaddfp (vector float, vector float);
+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 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 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 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 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 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 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 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 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 char vec_vavgsb (vector signed char, vector signed char);
+vector signed short vec_vavgsh (vector signed short, vector signed short);
+vector signed int vec_vavgsw (vector signed int, vector signed int);
+vector unsigned char vec_vavgub (vector unsigned char, vector unsigned char);
+vector unsigned short vec_vavguh (vector unsigned short, vector unsigned short);
+vector unsigned int vec_vavguw (vector unsigned int, vector unsigned int);
+vector float vec_vcfsx (vector signed int, const int);
+vector float vec_vcfux (vector unsigned int, const int);
+vector bool int vec_vcmpeqfp (vector float, vector float);
+vector bool char vec_vcmpequb (vector signed char, vector signed char);
+vector bool char vec_vcmpequb (vector unsigned char, vector unsigned char);
+vector bool short vec_vcmpequh (vector signed short, vector signed short);
+vector bool short vec_vcmpequh (vector unsigned short, vector unsigned short);
+vector bool int vec_vcmpequw (vector signed int, vector signed int);
+vector bool int vec_vcmpequw (vector unsigned int, vector unsigned int);
+vector bool int vec_vcmpgtfp (vector float, vector float);
+vector bool char vec_vcmpgtsb (vector signed char, vector signed char);
+vector bool short vec_vcmpgtsh (vector signed short, vector signed short);
+vector bool int vec_vcmpgtsw (vector signed int, vector signed int);
+vector bool char vec_vcmpgtub (vector unsigned char, vector unsigned char);
+vector bool short vec_vcmpgtuh (vector unsigned short, vector unsigned short);
+vector bool int vec_vcmpgtuw (vector unsigned int, vector unsigned int);
+vector float vec_vmaxfp (vector float, vector float);
+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 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 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 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 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 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 float vec_vminfp (vector float, vector float);
+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 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 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 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 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 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 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 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 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 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 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 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 signed int vec_vmsummbm (vector signed char, vector unsigned char,
+vector signed int);
+vector signed int vec_vmsumshm (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_vmsumubm (vector unsigned char, vector unsigned char,
+vector unsigned int);
+vector unsigned int vec_vmsumuhm (vector unsigned short, vector unsigned short,
+vector unsigned int);
+vector unsigned int vec_vmsumuhs (vector unsigned short, vector unsigned short,
+vector unsigned int);
+vector signed short vec_vmulesb (vector signed char, vector signed char);
+vector signed int vec_vmulesh (vector signed short, vector signed short);
+vector unsigned short vec_vmuleub (vector unsigned char, vector unsigned char);
+vector unsigned int vec_vmuleuh (vector unsigned short, vector unsigned short);
+vector signed short vec_vmulosb (vector signed char, vector signed char);
+vector signed int vec_vmulosh (vector signed short, vector signed short);
+vector unsigned short vec_vmuloub (vector unsigned char, vector unsigned char);
+vector unsigned int vec_vmulouh (vector unsigned short, vector unsigned short);
+vector signed char vec_vpkshss (vector signed short, vector signed short);
+vector unsigned char vec_vpkshus (vector signed short, vector signed short);
+vector signed short vec_vpkswss (vector signed int, vector signed int);
+vector unsigned short vec_vpkswus (vector signed int, vector signed 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 unsigned char vec_vpkuhus (vector unsigned short, vector unsigned short);
+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 unsigned short vec_vpkuwus (vector unsigned int, vector unsigned int);
+vector signed char vec_vrlb (vector signed char, vector unsigned char);
+vector unsigned char vec_vrlb (vector unsigned char, vector unsigned char);
+vector signed short vec_vrlh (vector signed short, vector unsigned short);
+vector unsigned short vec_vrlh (vector unsigned short, vector unsigned short);
+vector signed int vec_vrlw (vector signed int, vector unsigned int);
+vector unsigned int vec_vrlw (vector unsigned int, vector unsigned int);
+vector signed char vec_vslb (vector signed char, vector unsigned char);
+vector unsigned char vec_vslb (vector unsigned char, vector unsigned char);
+vector signed short vec_vslh (vector signed short, vector unsigned short);
+vector unsigned short vec_vslh (vector unsigned short, vector unsigned short);
+vector signed int vec_vslw (vector signed int, vector unsigned int);
+vector unsigned int vec_vslw (vector unsigned int, vector unsigned 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 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 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 signed char vec_vsrab (vector signed char, vector unsigned char);
+vector unsigned char vec_vsrab (vector unsigned char, vector unsigned char);
+vector signed short vec_vsrah (vector signed short, vector unsigned short);
+vector unsigned short vec_vsrah (vector unsigned short, vector unsigned short);
+vector signed int vec_vsraw (vector signed int, vector unsigned int);
+vector unsigned int vec_vsraw (vector unsigned int, vector unsigned int);
+vector signed char vec_vsrb (vector signed char, vector unsigned char);
+vector unsigned char vec_vsrb (vector unsigned char, vector unsigned char);
+vector signed short vec_vsrh (vector signed short, vector unsigned short);
+vector unsigned short vec_vsrh (vector unsigned short, vector unsigned short);
+vector signed int vec_vsrw (vector signed int, vector unsigned int);
+vector unsigned int vec_vsrw (vector unsigned int, vector unsigned int);
+vector float vec_vsubfp (vector float, vector float);
+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 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 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 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 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 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 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 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 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 int vec_vsum4sbs (vector signed char, vector signed int);
+vector signed int vec_vsum4shs (vector signed short, vector signed int);
+vector unsigned int vec_vsum4ubs (vector unsigned char, vector unsigned int);
+vector unsigned int vec_vupkhpx (vector pixel);
+vector bool short vec_vupkhsb (vector bool char);
+vector signed short vec_vupkhsb (vector signed char);
+vector bool int vec_vupkhsh (vector bool short);
+vector signed int vec_vupkhsh (vector signed short);
+vector unsigned int vec_vupklpx (vector pixel);
+vector bool short vec_vupklsb (vector bool char);
+vector signed short vec_vupklsb (vector signed char);
+vector bool int vec_vupklsh (vector bool short);
+vector signed int vec_vupklsh (vector signed short);
+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);
+@end smallexample
+@node PowerPC AltiVec Built-in Functions Available on ISA 2.06
+@subsubsection PowerPC AltiVec Built-in Functions Available on ISA 2.06
+The AltiVec built-in functions described in this section are
+available on the PowerPC family of processors starting with ISA 2.06
+or later.  These are normally enabled by adding @option{-mvsx} to the
+command line.
+When @option{-mvsx} is used, the following additional vector types are
+implemented.
+@smallexample
+vector unsigned __int128
+vector signed __int128
+vector unsigned long long int
+vector signed long long int
+vector double
+@end smallexample
+The long long types are only implemented for 64-bit code generation.
+@smallexample
+vector bool long long vec_and (vector bool long long int, vector bool long long);
+vector double vec_ctf (vector unsigned long, const int);
+vector double vec_ctf (vector signed long, const int);
+vector signed long vec_cts (vector double, const int);
+vector unsigned long vec_ctu (vector double, const int);
+void vec_dst (const unsigned long *, int, const int);
+void vec_dst (const long *, int, const int);
+void vec_dststt (const unsigned long *, int, const int);
+void vec_dststt (const long *, int, const int);
+void vec_dstt (const unsigned long *, int, const int);
+void vec_dstt (const long *, int, const int);
+vector unsigned char vec_lvsl (int, const unsigned long *);
+vector unsigned char vec_lvsl (int, const long *);
+vector unsigned char vec_lvsr (int, const unsigned long *);
+vector unsigned char vec_lvsr (int, const long *);
+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 unsigned long long vec_mule (vector unsigned int, vector unsigned int);
+vector signed long long vec_mule (vector signed int, vector signed int);
+vector unsigned long long vec_mulo (vector unsigned int, vector unsigned int);
+vector signed long long vec_mulo (vector signed int, vector signed int);
+vector double vec_nabs (vector double);
+vector bool long long vec_reve (vector bool long long);
+vector signed long long vec_reve (vector signed long long);
+vector unsigned long long vec_reve (vector unsigned long long);
+vector double vec_sld (vector double, vector double, const int);
+vector bool long long int vec_sld (vector bool long long int,
+vector bool long long int, const int);
+vector long long int vec_sld (vector long long int, vector  long long int, const int);
+vector unsigned long long int vec_sld (vector unsigned long long int,
+vector unsigned long long int, const int);
+vector long long int vec_sll (vector long long int, vector unsigned char);
+vector unsigned long long int vec_sll (vector unsigned long long int,
+vector unsigned char);
+vector signed long long vec_slo (vector signed long long, vector signed char);
+vector signed long long vec_slo (vector signed long long, vector unsigned char);
+vector unsigned long long vec_slo (vector unsigned long long, vector signed char);
+vector unsigned long long vec_slo (vector unsigned long long, vector unsigned char);
+vector signed long vec_splat (vector signed long, const int);
+vector unsigned long vec_splat (vector unsigned long, const int);
+vector long long int vec_srl (vector long long int, vector unsigned char);
+vector unsigned long long int vec_srl (vector unsigned long long int,
+vector unsigned char);
+vector long long int vec_sro (vector long long int, vector char);
+vector long long int vec_sro (vector long long int, vector unsigned char);
+vector unsigned long long int vec_sro (vector unsigned long long int, vector char);
+vector unsigned long long int vec_sro (vector unsigned long long int,
+vector unsigned char);
+vector signed __int128 vec_subc (vector signed __int128, vector signed __int128);
+vector unsigned __int128 vec_subc (vector unsigned __int128, vector unsigned __int128);
+vector signed __int128 vec_sube (vector signed __int128, vector signed __int128,
+vector signed __int128);
+vector unsigned __int128 vec_sube (vector unsigned __int128, vector unsigned __int128,
+vector unsigned __int128);
+vector signed __int128 vec_subec (vector signed __int128, vector signed __int128,
+vector signed __int128);
+vector unsigned __int128 vec_subec (vector unsigned __int128, vector unsigned __int128,
+vector unsigned __int128);
+vector double vec_unpackh (vector float);
+vector double vec_unpackl (vector float);
+vector double vec_doublee (vector float);
+vector double vec_doublee (vector signed int);
+vector double vec_doublee (vector unsigned int);
+vector double vec_doubleo (vector float);
+vector double vec_doubleo (vector signed int);
+vector double vec_doubleo (vector unsigned int);
+vector double vec_doubleh (vector float);
+vector double vec_doubleh (vector signed int);
+vector double vec_doubleh (vector unsigned int);
+vector double vec_doublel (vector float);
+vector double vec_doublel (vector signed int);
+vector double vec_doublel (vector unsigned int);
+vector float vec_float (vector signed int);
+vector float vec_float (vector unsigned int);
+vector float vec_float2 (vector signed long long, vector signed long long);
+vector float vec_float2 (vector unsigned long long, vector signed long long);
+vector float vec_floate (vector double);
+vector float vec_floate (vector signed long long);
+vector float vec_floate (vector unsigned long long);
+vector float vec_floato (vector double);
+vector float vec_floato (vector signed long long);
+vector float vec_floato (vector unsigned long long);
+vector signed long long vec_signed (vector double);
+vector signed int vec_signed (vector float);
+vector signed int vec_signede (vector double);
+vector signed int vec_signedo (vector double);
+vector signed char vec_sldw (vector signed char, vector signed char, const int);
+vector unsigned char vec_sldw (vector unsigned char, vector unsigned char, const int);
+vector signed short vec_sldw (vector signed short, vector signed short, const int);
+vector unsigned short vec_sldw (vector unsigned short,
+vector unsigned short, const int);
+vector signed int vec_sldw (vector signed int, vector signed int, const int);
+vector unsigned int vec_sldw (vector unsigned int, vector unsigned int, const int);
+vector signed long long vec_sldw (vector signed long long,
+vector signed long long, const int);
+vector unsigned long long vec_sldw (vector unsigned long long,
+vector unsigned long long, const int);
+vector signed long long vec_unsigned (vector double);
+vector signed int vec_unsigned (vector float);
+vector signed int vec_unsignede (vector double);
+vector signed int vec_unsignedo (vector double);
 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 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 __int128 vec_ld (int, const vector __int128 *);
+vector unsigned __int128 vec_ld (int, const vector unsigned __int128 *);
+vector __int128 vec_ld (int, const __int128 *);
+vector unsigned __int128 vec_ld (int, const unsigned __int128 *);
 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_lvsl (int, const double *);
-vector unsigned char vec_lvsr (int, const volatile double *);
+vector unsigned char vec_lvsr (int, const 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_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 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 bool char vec_permxor (vector bool char, vector bool char,
+vector bool char);
+vector unsigned char vec_permxor (vector signed char, vector signed char,
+vector signed char);
+vector unsigned char vec_permxor (vector unsigned char, vector unsigned char,
+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);
 generate the AltiVec @samp{LVX} and @samp{STVX} instructions even
 if the VSX instruction set is available.  The @samp{vec_vsx_ld} and
 @samp{vec_vsx_st} built-in functions always generate the VSX @samp{LXVD2X},
 @samp{LXVW4X}, @samp{STXVD2X}, and @samp{STXVW4X} instructions.
+@node PowerPC AltiVec Built-in Functions Available on ISA 2.07
+@subsubsection PowerPC AltiVec Built-in Functions Available on ISA 2.07
 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 @var{vector long} instead of @var{vector long long},
 @var{vector bool long} instead of @var{vector bool long long}, and
 @var{vector unsigned long} instead of @var{vector unsigned long long}.
 @smallexample
+vector signed char vec_neg (vector signed char);
+vector signed short vec_neg (vector signed short);
+vector signed int vec_neg (vector signed int);
+vector signed long long vec_neg (vector signed long long);
+vector float  char vec_neg (vector float);
+vector double vec_neg (vector double);
+vector signed int vec_signed2 (vector double, vector double);
+vector signed int vec_unsigned2 (vector double, vector double);
 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);
 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 vec_eqv (vector unsigned long long, 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 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 vec_eqv (vector bool unsigned int, vector unsigned int);
-vector unsigned int);
+vector unsigned int vec_eqv (vector unsigned int, vector bool 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 vec_eqv (vector bool unsigned short, vector unsigned short);
-vector unsigned short);
+vector unsigned short vec_eqv (vector unsigned short, vector bool 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 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 vec_nand (vector bool long long, vector unsigned long long);
-vector unsigned long long);
+vector unsigned long long vec_nand (vector unsigned long long, vector bool 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 vec_nand (vector bool unsigned int, vector unsigned int);
-vector unsigned int);
+vector unsigned int vec_nand (vector unsigned int, vector bool 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 vec_nand (vector bool unsigned short, vector unsigned short);
-vector unsigned short);
+vector unsigned short vec_nand (vector unsigned short, vector bool 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 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 vec_orc (vector bool long long, vector unsigned long long);
-vector unsigned long long);
+vector unsigned long long vec_orc (vector unsigned long long, vector bool 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 vec_orc (vector bool unsigned int, vector unsigned int);
-vector unsigned int);
+vector unsigned int vec_orc (vector unsigned int, vector bool 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 vec_orc (vector bool unsigned short, vector unsigned short);
-vector unsigned short);
+vector unsigned short vec_orc (vector unsigned short, vector bool 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 int vec_pack (vector unsigned long long, 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 int vec_packs (vector unsigned long long, vector unsigned long long);
-vector unsigned long long);
+vector unsigned char vec_packsu (vector signed short, vector signed short)
+vector unsigned char vec_packsu (vector unsigned short, vector unsigned short)
+vector unsigned short int vec_packsu (vector signed int, vector signed int);
+vector unsigned short int vec_packsu (vector unsigned int, vector unsigned int);
 vector unsigned int vec_packsu (vector long long, vector long long);
-vector unsigned int vec_packsu (vector unsigned long long,
+vector unsigned int vec_packsu (vector unsigned long long, vector unsigned long long);
-vector unsigned long long);
+vector unsigned int vec_packsu (vector signed long long, vector signed long long);
 vector unsigned char vec_popcnt (vector signed char);
 vector unsigned char vec_popcnt (vector unsigned char);
 vector unsigned short vec_popcnt (vector signed short);
 vector unsigned short vec_popcnt (vector unsigned short);
 vector unsigned int vec_popcnt (vector signed int);
 vector unsigned int vec_popcnt (vector unsigned int);
 vector unsigned long long vec_popcnt (vector signed long long);
 vector unsigned long long vec_popcnt (vector unsigned long long);
-vector long long vec_rl (vector long long,
+vector long long vec_rl (vector long long, vector unsigned long long);
-vector unsigned long long);
+vector long long vec_rl (vector unsigned 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 long long vec_sl (vector unsigned long long, 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_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 char vec_bperm (vector unsigned long long,
+vector unsigned char vec_bperm (vector unsigned long long, vector unsigned char);
-vector unsigned char);
+vector unsigned long long vec_bperm (vector unsigned __int128, 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 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 unsigned long long vec_vminud (vector long long, 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,
 @end smallexample
 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
-(@var{vector __int128_t} and @var{vector __uint128_t}) are available
+(@var{vector __int128} and @var{vector __uint128}) are available
-to hold the @var{__int128_t} and @var{__uint128_t} types to use these
+to hold the @var{__int128} and @var{__uint128} types to use these
 builtins.
 The normal vector extract, and set operations work on
-@var{vector __int128_t} and @var{vector __uint128_t} types,
+@var{vector __int128} and @var{vector __uint128} types,
 but the index value must be 0.
 @smallexample
-vector __int128_t vec_vaddcuq (vector __int128_t, vector __int128_t);
+vector __int128 vec_vaddcuq (vector __int128, vector __int128);
-vector __uint128_t vec_vaddcuq (vector __uint128_t, vector __uint128_t);
+vector __uint128 vec_vaddcuq (vector __uint128, vector __uint128);
-vector __int128_t vec_vadduqm (vector __int128_t, vector __int128_t);
+vector __int128 vec_vadduqm (vector __int128, vector __int128);
-vector __uint128_t vec_vadduqm (vector __uint128_t, vector __uint128_t);
+vector __uint128 vec_vadduqm (vector __uint128, vector __uint128);
-vector __int128_t vec_vaddecuq (vector __int128_t, vector __int128_t,
+vector __int128 vec_vaddecuq (vector __int128, vector __int128,
-vector __int128_t);
+vector __int128);
-vector __uint128_t vec_vaddecuq (vector __uint128_t, vector __uint128_t,
+vector __uint128 vec_vaddecuq (vector __uint128, vector __uint128,
-vector __uint128_t);
+vector __uint128);
-vector __int128_t vec_vaddeuqm (vector __int128_t, vector __int128_t,
+vector __int128 vec_vaddeuqm (vector __int128, vector __int128,
-vector __int128_t);
+vector __int128);
-vector __uint128_t vec_vaddeuqm (vector __uint128_t, vector __uint128_t,
+vector __uint128 vec_vaddeuqm (vector __uint128, vector __uint128,
-vector __uint128_t);
+vector __uint128);
-vector __int128_t vec_vsubecuq (vector __int128_t, vector __int128_t,
+vector __int128 vec_vsubecuq (vector __int128, vector __int128,
-vector __int128_t);
+vector __int128);
-vector __uint128_t vec_vsubecuq (vector __uint128_t, vector __uint128_t,
+vector __uint128 vec_vsubecuq (vector __uint128, vector __uint128,
-vector __uint128_t);
+vector __uint128);
-vector __int128_t vec_vsubeuqm (vector __int128_t, vector __int128_t,
+vector __int128 vec_vsubeuqm (vector __int128, vector __int128,
-vector __int128_t);
+vector __int128);
-vector __uint128_t vec_vsubeuqm (vector __uint128_t, vector __uint128_t,
+vector __uint128 vec_vsubeuqm (vector __uint128, vector __uint128,
-vector __uint128_t);
+vector __uint128);
-vector __int128_t vec_vsubcuq (vector __int128_t, vector __int128_t);
+vector __int128 vec_vsubcuq (vector __int128, vector __int128);
-vector __uint128_t vec_vsubcuq (vector __uint128_t, vector __uint128_t);
+vector __uint128 vec_vsubcuq (vector __uint128, vector __uint128);
-__int128_t vec_vsubuqm (__int128_t, __int128_t);
+__int128 vec_vsubuqm (__int128, __int128);
-__uint128_t vec_vsubuqm (__uint128_t, __uint128_t);
+__uint128 vec_vsubuqm (__uint128, __uint128);
-vector __int128_t __builtin_bcdadd (vector __int128_t, vector__int128_t);
+vector __int128 __builtin_bcdadd (vector __int128, vector __int128, const int);
-int __builtin_bcdadd_lt (vector __int128_t, vector__int128_t);
+int __builtin_bcdadd_lt (vector __int128, vector __int128, const int);
-int __builtin_bcdadd_eq (vector __int128_t, vector__int128_t);
+int __builtin_bcdadd_eq (vector __int128, vector __int128, const int);
-int __builtin_bcdadd_gt (vector __int128_t, vector__int128_t);
+int __builtin_bcdadd_gt (vector __int128, vector __int128, const int);
-int __builtin_bcdadd_ov (vector __int128_t, vector__int128_t);
+int __builtin_bcdadd_ov (vector __int128, vector __int128, const int);
-vector __int128_t bcdsub (vector __int128_t, vector__int128_t);
+vector __int128 __builtin_bcdsub (vector __int128, vector __int128, const int);
-int __builtin_bcdsub_lt (vector __int128_t, vector__int128_t);
+int __builtin_bcdsub_lt (vector __int128, vector __int128, const int);
-int __builtin_bcdsub_eq (vector __int128_t, vector__int128_t);
+int __builtin_bcdsub_eq (vector __int128, vector __int128, const int);
-int __builtin_bcdsub_gt (vector __int128_t, vector__int128_t);
+int __builtin_bcdsub_gt (vector __int128, vector __int128, const int);
-int __builtin_bcdsub_ov (vector __int128_t, vector__int128_t);
+int __builtin_bcdsub_ov (vector __int128, vector __int128, const int);
 @end smallexample
+@node PowerPC AltiVec Built-in Functions Available on ISA 3.0
+@subsubsection PowerPC AltiVec Built-in Functions Available on ISA 3.0
+The following additional built-in functions are also available for the
+PowerPC family of processors, starting with ISA 3.0
+(@option{-mcpu=power9}) or later:
+@smallexample
+unsigned int scalar_extract_exp (double source);
+unsigned long long int scalar_extract_exp (__ieee128 source);
+unsigned long long int scalar_extract_sig (double source);
+unsigned __int128 scalar_extract_sig (__ieee128 source);
+double scalar_insert_exp (unsigned long long int significand,
+unsigned long long int exponent);
+double scalar_insert_exp (double significand, unsigned long long int exponent);
+ieee_128 scalar_insert_exp (unsigned __int128 significand,
+unsigned long long int exponent);
+ieee_128 scalar_insert_exp (ieee_128 significand, unsigned long long int exponent);
+int scalar_cmp_exp_gt (double arg1, double arg2);
+int scalar_cmp_exp_lt (double arg1, double arg2);
+int scalar_cmp_exp_eq (double arg1, double arg2);
+int scalar_cmp_exp_unordered (double arg1, double arg2);
+bool scalar_test_data_class (float source, const int condition);
+bool scalar_test_data_class (double source, const int condition);
+bool scalar_test_data_class (__ieee128 source, const int condition);
+bool scalar_test_neg (float source);
+bool scalar_test_neg (double source);
+bool scalar_test_neg (__ieee128 source);
+@end smallexample
+The @code{scalar_extract_exp} and @code{scalar_extract_sig}
+functions require a 64-bit environment supporting ISA 3.0 or later.
+The @code{scalar_extract_exp} and @code{scalar_extract_sig} built-in
+functions return the significand and the biased exponent value
+respectively of their @code{source} arguments.
+When supplied with a 64-bit @code{source} argument, the
+result returned by @code{scalar_extract_sig} has
+the @code{0x0010000000000000} bit set if the
+function's @code{source} argument is in normalized form.
+Otherwise, this bit is set to 0.
+When supplied with a 128-bit @code{source} argument, the
+@code{0x00010000000000000000000000000000} bit of the result is
+treated similarly.
+Note that the sign of the significand is not represented in the result
+returned from the @code{scalar_extract_sig} function.  Use the
+@code{scalar_test_neg} function to test the sign of its @code{double}
+argument.
+The @code{scalar_insert_exp}
+functions require a 64-bit environment supporting ISA 3.0 or later.
+When supplied with a 64-bit first argument, the
+@code{scalar_insert_exp} built-in function returns a double-precision
+floating point value that is constructed by assembling the values of its
+@code{significand} and @code{exponent} arguments.  The sign of the
+result is copied from the most significant bit of the
+@code{significand} argument.  The significand and exponent components
+of the result are composed of the least significant 11 bits of the
+@code{exponent} argument and the least significant 52 bits of the
+@code{significand} argument respectively.
+When supplied with a 128-bit first argument, the
+@code{scalar_insert_exp} built-in function returns a quad-precision
+ieee floating point value.  The sign bit of the result is copied from
+the most significant bit of the @code{significand} argument.
+The significand and exponent components of the result are composed of
+the least significant 15 bits of the @code{exponent} argument and the
+least significant 112 bits of the @code{significand} argument respectively.
+The @code{scalar_cmp_exp_gt}, @code{scalar_cmp_exp_lt},
+@code{scalar_cmp_exp_eq}, and @code{scalar_cmp_exp_unordered} built-in
+functions return a non-zero value if @code{arg1} is greater than, less
+than, equal to, or not comparable to @code{arg2} respectively.  The
+arguments are not comparable if one or the other equals NaN (not a
+number).
+The @code{scalar_test_data_class} built-in function returns 1
+if any of the condition tests enabled by the value of the
+@code{condition} variable are true, and 0 otherwise.  The
+@code{condition} argument must be a compile-time constant integer with
+value not exceeding 127.  The
+@code{condition} argument is encoded as a bitmask with each bit
+enabling the testing of a different condition, as characterized by the
+following:
+@smallexample
+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
+@end smallexample
+The @code{scalar_test_neg} built-in function returns 1 if its
+@code{source} argument holds a negative value, 0 otherwise.
+The following built-in functions are also available for the PowerPC family
+of processors, starting with ISA 3.0 or later
+(@option{-mcpu=power9}).  These string functions are described
+separately in order to group the descriptions closer to the function
+prototypes:
+@smallexample
+int vec_all_nez (vector signed char, vector signed char);
+int vec_all_nez (vector unsigned char, vector unsigned char);
+int vec_all_nez (vector signed short, vector signed short);
+int vec_all_nez (vector unsigned short, vector unsigned short);
+int vec_all_nez (vector signed int, vector signed int);
+int vec_all_nez (vector unsigned int, vector unsigned int);
+int vec_any_eqz (vector signed char, vector signed char);
+int vec_any_eqz (vector unsigned char, vector unsigned char);
+int vec_any_eqz (vector signed short, vector signed short);
+int vec_any_eqz (vector unsigned short, vector unsigned short);
+int vec_any_eqz (vector signed int, vector signed int);
+int vec_any_eqz (vector unsigned int, vector unsigned int);
+vector bool char vec_cmpnez (vector signed char arg1, vector signed char arg2);
+vector bool char vec_cmpnez (vector unsigned char arg1, vector unsigned char arg2);
+vector bool short vec_cmpnez (vector signed short arg1, vector signed short arg2);
+vector bool short vec_cmpnez (vector unsigned short arg1, vector unsigned short arg2);
+vector bool int vec_cmpnez (vector signed int arg1, vector signed int arg2);
+vector bool int vec_cmpnez (vector unsigned int, vector unsigned int);
+vector signed char vec_cnttz (vector signed char);
+vector unsigned char vec_cnttz (vector unsigned char);
+vector signed short vec_cnttz (vector signed short);
+vector unsigned short vec_cnttz (vector unsigned short);
+vector signed int vec_cnttz (vector signed int);
+vector unsigned int vec_cnttz (vector unsigned int);
+vector signed long long vec_cnttz (vector signed long long);
+vector unsigned long long vec_cnttz (vector unsigned long long);
+signed int vec_cntlz_lsbb (vector signed char);
+signed int vec_cntlz_lsbb (vector unsigned char);
+signed int vec_cnttz_lsbb (vector signed char);
+signed int vec_cnttz_lsbb (vector unsigned char);
+unsigned int vec_first_match_index (vector signed char, vector signed char);
+unsigned int vec_first_match_index (vector unsigned char, vector unsigned char);
+unsigned int vec_first_match_index (vector signed int, vector signed int);
+unsigned int vec_first_match_index (vector unsigned int, vector unsigned int);
+unsigned int vec_first_match_index (vector signed short, vector signed short);
+unsigned int vec_first_match_index (vector unsigned short, vector unsigned short);
+unsigned int vec_first_match_or_eos_index (vector signed char, vector signed char);
+unsigned int vec_first_match_or_eos_index (vector unsigned char, vector unsigned char);
+unsigned int vec_first_match_or_eos_index (vector signed int, vector signed int);
+unsigned int vec_first_match_or_eos_index (vector unsigned int, vector unsigned int);
+unsigned int vec_first_match_or_eos_index (vector signed short, vector signed short);
+unsigned int vec_first_match_or_eos_index (vector unsigned short,
+vector unsigned short);
+unsigned int vec_first_mismatch_index (vector signed char, vector signed char);
+unsigned int vec_first_mismatch_index (vector unsigned char, vector unsigned char);
+unsigned int vec_first_mismatch_index (vector signed int, vector signed int);
+unsigned int vec_first_mismatch_index (vector unsigned int, vector unsigned int);
+unsigned int vec_first_mismatch_index (vector signed short, vector signed short);
+unsigned int vec_first_mismatch_index (vector unsigned short, vector unsigned short);
+unsigned int vec_first_mismatch_or_eos_index (vector signed char, vector signed char);
+unsigned int vec_first_mismatch_or_eos_index (vector unsigned char,
+vector unsigned char);
+unsigned int vec_first_mismatch_or_eos_index (vector signed int, vector signed int);
+unsigned int vec_first_mismatch_or_eos_index (vector unsigned int, vector unsigned int);
+unsigned int vec_first_mismatch_or_eos_index (vector signed short, vector signed short);
+unsigned int vec_first_mismatch_or_eos_index (vector unsigned short,
+vector unsigned short);
+vector unsigned short vec_pack_to_short_fp32 (vector float, vector float);
+vector signed char vec_xl_be (signed long long, signed char *);
+vector unsigned char vec_xl_be (signed long long, unsigned char *);
+vector signed int vec_xl_be (signed long long, signed int *);
+vector unsigned int vec_xl_be (signed long long, unsigned int *);
+vector signed __int128 vec_xl_be (signed long long, signed __int128 *);
+vector unsigned __int128 vec_xl_be (signed long long, unsigned __int128 *);
+vector signed long long vec_xl_be (signed long long, signed long long *);
+vector unsigned long long vec_xl_be (signed long long, unsigned long long *);
+vector signed short vec_xl_be (signed long long, signed short *);
+vector unsigned short vec_xl_be (signed long long, unsigned short *);
+vector double vec_xl_be (signed long long, double *);
+vector float vec_xl_be (signed long long, float *);
+vector signed char vec_xl_len (signed char *addr, size_t len);
+vector unsigned char vec_xl_len (unsigned char *addr, size_t len);
+vector signed int vec_xl_len (signed int *addr, size_t len);
+vector unsigned int vec_xl_len (unsigned int *addr, size_t len);
+vector signed __int128 vec_xl_len (signed __int128 *addr, size_t len);
+vector unsigned __int128 vec_xl_len (unsigned __int128 *addr, size_t len);
+vector signed long long vec_xl_len (signed long long *addr, size_t len);
+vector unsigned long long vec_xl_len (unsigned long long *addr, size_t len);
+vector signed short vec_xl_len (signed short *addr, size_t len);
+vector unsigned short vec_xl_len (unsigned short *addr, size_t len);
+vector double vec_xl_len (double *addr, size_t len);
+vector float vec_xl_len (float *addr, size_t len);
+vector unsigned char vec_xl_len_r (unsigned char *addr, size_t len);
+void vec_xst_len (vector signed char data, signed char *addr, size_t len);
+void vec_xst_len (vector unsigned char data, unsigned char *addr, size_t len);
+void vec_xst_len (vector signed int data, signed int *addr, size_t len);
+void vec_xst_len (vector unsigned int data, unsigned int *addr, size_t len);
+void vec_xst_len (vector unsigned __int128 data, unsigned __int128 *addr, size_t len);
+void vec_xst_len (vector signed long long data, signed long long *addr, size_t len);
+void vec_xst_len (vector unsigned long long data, unsigned long long *addr, size_t len);
+void vec_xst_len (vector signed short data, signed short *addr, size_t len);
+void vec_xst_len (vector unsigned short data, unsigned short *addr, size_t len);
+void vec_xst_len (vector signed __int128 data, signed __int128 *addr, size_t len);
+void vec_xst_len (vector double data, double *addr, size_t len);
+void vec_xst_len (vector float data, float *addr, size_t len);
+void vec_xst_len_r (vector unsigned char data, unsigned char *addr, size_t len);
+signed char vec_xlx (unsigned int index, vector signed char data);
+unsigned char vec_xlx (unsigned int index, vector unsigned char data);
+signed short vec_xlx (unsigned int index, vector signed short data);
+unsigned short vec_xlx (unsigned int index, vector unsigned short data);
+signed int vec_xlx (unsigned int index, vector signed int data);
+unsigned int vec_xlx (unsigned int index, vector unsigned int data);
+float vec_xlx (unsigned int index, vector float data);
+signed char vec_xrx (unsigned int index, vector signed char data);
+unsigned char vec_xrx (unsigned int index, vector unsigned char data);
+signed short vec_xrx (unsigned int index, vector signed short data);
+unsigned short vec_xrx (unsigned int index, vector unsigned short data);
+signed int vec_xrx (unsigned int index, vector signed int data);
+unsigned int vec_xrx (unsigned int index, vector unsigned int data);
+float vec_xrx (unsigned int index, vector float data);
+@end smallexample
+The @code{vec_all_nez}, @code{vec_any_eqz}, and @code{vec_cmpnez}
+perform pairwise comparisons between the elements at the same
+positions within their two vector arguments.
+The @code{vec_all_nez} function returns a
+non-zero value if and only if all pairwise comparisons are not
+equal and no element of either vector argument contains a zero.
+The @code{vec_any_eqz} function returns a
+non-zero value if and only if at least one pairwise comparison is equal
+or if at least one element of either vector argument contains a zero.
+The @code{vec_cmpnez} function returns a vector of the same type as
+its two arguments, within which each element consists of all ones to
+denote that either the corresponding elements of the incoming arguments are
+not equal or that at least one of the corresponding elements contains
+zero.  Otherwise, the element of the returned vector contains all zeros.
+The @code{vec_cntlz_lsbb} function returns the count of the number of
+consecutive leading byte elements (starting from position 0 within the
+supplied vector argument) for which the least-significant bit
+equals zero.  The @code{vec_cnttz_lsbb} function returns the count of
+the number of consecutive trailing byte elements (starting from
+position 15 and counting backwards within the supplied vector
+argument) for which the least-significant bit equals zero.
+The @code{vec_xl_len} and @code{vec_xst_len} functions require a
+64-bit environment supporting ISA 3.0 or later.  The @code{vec_xl_len}
+function loads a variable length vector from memory.  The
+@code{vec_xst_len} function stores a variable length vector to memory.
+With both the @code{vec_xl_len} and @code{vec_xst_len} functions, the
+@code{addr} argument represents the memory address to or from which
+data will be transferred, and the
+@code{len} argument represents the number of bytes to be
+transferred, as computed by the C expression @code{min((len & 0xff), 16)}.
+If this expression's value is not a multiple of the vector element's
+size, the behavior of this function is undefined.
+In the case that the underlying computer is configured to run in
+big-endian mode, the data transfer moves bytes 0 to @code{(len - 1)} of
+the corresponding vector.  In little-endian mode, the data transfer
+moves bytes @code{(16 - len)} to @code{15} of the corresponding
+vector.  For the load function, any bytes of the result vector that
+are not loaded from memory are set to zero.
+The value of the @code{addr} argument need not be aligned on a
+multiple of the vector's element size.
+The @code{vec_xlx} and @code{vec_xrx} functions extract the single
+element selected by the @code{index} argument from the vector
+represented by the @code{data} argument.  The @code{index} argument
+always specifies a byte offset, regardless of the size of the vector
+element.  With @code{vec_xlx}, @code{index} is the offset of the first
+byte of the element to be extracted.  With @code{vec_xrx}, @code{index}
+represents the last byte of the element to be extracted, measured
+from the right end of the vector.  In other words, the last byte of
+the element to be extracted is found at position @code{(15 - index)}.
+There is no requirement that @code{index} be a multiple of the vector
+element size.  However, if the size of the vector element added to
+@code{index} is greater than 15, the content of the returned value is
+undefined.
 If the ISA 3.0 instruction set additions (@option{-mcpu=power9})
 are available:
 @smallexample
-vector unsigned long long vec_bperm (vector unsigned long long,
+vector unsigned long long vec_bperm (vector unsigned long long, vector unsigned char);
-vector unsigned char);
 vector bool char vec_cmpne (vector bool char, vector bool char);
+vector bool char vec_cmpne (vector signed char, vector signed char);
+vector bool char vec_cmpne (vector unsigned char, vector unsigned char);
+vector bool int vec_cmpne (vector bool int, vector bool int);
+vector bool int vec_cmpne (vector signed int, vector signed int);
+vector bool int vec_cmpne (vector unsigned int, vector unsigned int);
+vector bool long long vec_cmpne (vector bool long long, vector bool long long);
+vector bool long long vec_cmpne (vector signed long long, vector signed long long);
+vector bool long long vec_cmpne (vector unsigned long long, vector unsigned long long);
 vector bool short vec_cmpne (vector bool short, vector bool short);
-vector bool int vec_cmpne (vector bool int, vector bool int);
+vector bool short vec_cmpne (vector signed short, vector signed short);
-vector bool long long vec_cmpne (vector bool long long, vector bool long long);
+vector bool short vec_cmpne (vector unsigned short, vector unsigned short);
+vector bool long long vec_cmpne (vector double, vector double);
+vector bool int vec_cmpne (vector float, vector float);
 vector float vec_extract_fp32_from_shorth (vector unsigned short);
 vector float vec_extract_fp32_from_shortl (vector unsigned short);
 vector long long vec_vctz (vector long long);
 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);
+vector unsigned long long vec_extract4b (vector unsigned char, const int);
-long long vec_vextract4b (const vector unsigned char, const int);
+vector unsigned char vec_insert4b (vector signed int, vector unsigned char,
-vector signed char vec_insert4b (vector int, vector signed char, const int);
+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 unsigned int vec_parity_lsbb (vector signed int);
 vector unsigned int vec_parity_lsbb (vector unsigned int);
 vector unsigned __int128 vec_parity_lsbb (vector signed __int128);
 vector unsigned __int128 vec_parity_lsbb (vector unsigned __int128);
 are available:
 @smallexample
 vector long vec_vprtyb (vector long);
 vector unsigned long vec_vprtyb (vector unsigned long);
-vector __int128_t vec_vprtyb (vector __int128_t);
+vector __int128 vec_vprtyb (vector __int128);
-vector __uint128_t vec_vprtyb (vector __uint128_t);
+vector __uint128 vec_vprtyb (vector __uint128);
 vector long vec_vprtybd (vector long);
 vector unsigned long vec_vprtybd (vector unsigned long);
-vector __int128_t vec_vprtybq (vector __int128_t);
+vector __int128 vec_vprtybq (vector __int128);
-vector __uint128_t vec_vprtybd (vector __uint128_t);
+vector __uint128 vec_vprtybd (vector __uint128);
 @end smallexample
 The following built-in vector functions are available for the PowerPC family
 of processors, starting with ISA 3.0 or later (@option{-mcpu=power9}):
 @smallexample
 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 (@option{-mcpu=power9}):
 @smallexample
-__vector unsigned int
+__vector unsigned int vec_extract_exp (__vector float source);
-vec_extract_exp (__vector float source);
+__vector unsigned long long int vec_extract_exp (__vector double 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 unsigned int
-vec_extract_sig (__vector float source);
+__vector float vec_insert_exp (__vector unsigned int significands,
-__vector unsigned long long int
+__vector unsigned int exponents);
-vec_extract_sig (__vector double source);
+__vector float vec_insert_exp (__vector unsigned float significands,
+__vector unsigned int exponents);
-__vector float
+__vector double vec_insert_exp (__vector unsigned long long int significands,
-vec_insert_exp (__vector unsigned int significands,
+__vector unsigned long long int exponents);
-__vector unsigned int exponents);
+__vector double vec_insert_exp (__vector unsigned double significands,
-__vector float
+__vector unsigned long long int exponents);
-vec_insert_exp (__vector unsigned float significands,
-__vector unsigned int exponents);
+__vector bool int vec_test_data_class (__vector float source, const int condition);
-__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);
 @end smallexample
 The @code{vec_extract_sig} and @code{vec_extract_exp} built-in
 On 64-bit targets, if the ISA 3.0 additions (@option{-mcpu=power9})
 are available:
 @smallexample
 vector long vec_revb (vector long);
 vector unsigned long vec_revb (vector unsigned long);
-vector __int128_t vec_revb (vector __int128_t);
+vector __int128 vec_revb (vector __int128);
-vector __uint128_t vec_revb (vector __uint128_t);
+vector __uint128 vec_revb (vector __uint128);
 @end smallexample
 The @code{vec_revb} built-in function reverses the bytes on an element
 by element basis.  A vector of @code{vector unsigned char} or
 @code{vector signed char} reverses the bytes in the whole word.
 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 __builtin_crypto_vncipherlast (vector unsigned long long,
-(vector unsigned long long,
+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 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 __builtin_crypto_vshasigmad (vector unsigned long long,
-(vector unsigned long long, int, int);
+int, int);
-vector unsigned int __builtin_crypto_vshasigmaw (vector unsigned int,
+vector unsigned int __builtin_crypto_vshasigmaw (vector unsigned int, int, int);
-int, int);
 @end smallexample
 The second argument to @var{__builtin_crypto_vshasigmad} and
 @var{__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 (@option{-mcpu=power9}), the following additional
 functions are available for both 32-bit and 64-bit targets.
+@smallexample
 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 *);
 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 *);
+@end smallexample
 @node PowerPC Hardware Transactional Memory Built-in Functions
 @subsection PowerPC Hardware Transactional Memory Built-in Functions
 GCC provides two interfaces for accessing the Hardware Transactional
 Memory (HTM) instructions available on some of the PowerPC family
 of processors (eg, POWER8).  The two interfaces come in a low level
 @smallexample
 void __builtin_ia32_wrpkru (unsigned int)
 unsigned int __builtin_ia32_rdpkru ()
 @end smallexample
-The following built-in functions are available when @option{-mcet} is used.
+The following built-in functions are available when @option{-mcet} or
-They are used to support Intel Control-flow Enforcment Technology (CET).
+@option{-mshstk} option is used.  They support shadow stack
-Each built-in function generates the  machine instruction that is part of the
+machine instructions from Intel Control-flow Enforcement Technology (CET).
-function's name.
+Each built-in function generates the  machine instruction that is part
-@smallexample
+of the function's name.  These are the internal low-level functions.
-unsigned int __builtin_ia32_rdsspd (unsigned int)
+Normally the functions in @ref{x86 control-flow protection intrinsics}
-unsigned long long __builtin_ia32_rdsspq (unsigned long long)
+should be used instead.
+@smallexample
+unsigned int __builtin_ia32_rdsspd (void)
+unsigned long long __builtin_ia32_rdsspq (void)
 void __builtin_ia32_incsspd (unsigned int)
 void __builtin_ia32_incsspq (unsigned long long)
 void __builtin_ia32_saveprevssp(void);
 void __builtin_ia32_rstorssp(void *);
 void __builtin_ia32_wrssd(unsigned int, void *);
 Start a RTM (Restricted Transactional Memory) transaction.
 Returns @code{_XBEGIN_STARTED} when the transaction
 started successfully (note this is not 0, so the constant has to be
 explicitly tested).
-If the transaction aborts, all side-effects
+If the transaction aborts, all side effects
 are undone and an abort code encoded as a bit mask is returned.
 The following macros are defined:
 @table @code
 @item _XABORT_EXPLICIT
 fallback path.
 @end deftypefn
 @deftypefn {RTM Function} {void} _xend ()
 Commit the current transaction. When no transaction is active this faults.
-All memory side-effects of the transaction become visible
+All memory side effects of the transaction become visible
 to other threads in an atomic manner.
 @end deftypefn
 @deftypefn {RTM Function} {int} _xtest ()
 Return a nonzero value if a transaction is currently active, otherwise 0.
 @end smallexample
 @noindent
 Note that, in most cases, the transactional and non-transactional code
 must synchronize together to ensure consistency.
+@node x86 control-flow protection intrinsics
+@subsection x86 Control-Flow Protection Intrinsics
+@deftypefn {CET Function} {ret_type} _get_ssp (void)
+Get the current value of shadow stack pointer if shadow stack support
+from Intel CET is enabled in the hardware or @code{0} otherwise.
+The @code{ret_type} is @code{unsigned long long} for 64-bit targets
+and @code{unsigned int} for 32-bit targets.
+@end deftypefn
+@deftypefn {CET Function} void _inc_ssp (unsigned int)
+Increment the current shadow stack pointer by the size specified by the
+function argument.  The argument is masked to a byte value for security
+reasons, so to increment by more than 255 bytes you must call the function
+multiple times.
+@end deftypefn
+The shadow stack unwind code looks like:
+@smallexample
+#include <immintrin.h>
+/* Unwind the shadow stack for EH.  */
+#define _Unwind_Frames_Extra(x)       \
+do                                  \
+@{                                \
+_Unwind_Word ssp = _get_ssp (); \
+if (ssp != 0)                   \
+@{                            \
+_Unwind_Word tmp = (x);     \
+while (tmp > 255)           \
+@{                        \
+_inc_ssp (tmp);         \
+tmp -= 255;             \
+@}                        \
+_inc_ssp (tmp);             \
+@}                            \
+@}                                \
+while (0)
+@end smallexample
+@noindent
+This code runs unconditionally on all 64-bit processors.  For 32-bit
+processors the code runs on those that support multi-byte NOP instructions.
 @node Target Format Checks
 @section Format Checks Specific to Particular Target Machines
 For some target machines, GCC supports additional options to the
 @table @code
 @item #pragma message @var{string}
 @cindex pragma, diagnostic
 Prints @var{string} as a compiler message on compilation.  The message
-is informational only, and is neither a compilation warning nor an error.
+is informational only, and is neither a compilation warning nor an
+error.  Newlines can be included in the string by using the @samp{\n}
+escape sequence.
 @smallexample
 #pragma message "Compiling " __FILE__ "..."
 @end smallexample
 @end smallexample
 @noindent
 prints @samp{/tmp/file.c:4: note: #pragma message:
 TODO - Remember to fix this}.
+@item #pragma GCC error @var{message}
+@cindex pragma, diagnostic
+Generates an error message.  This pragma @emph{is} considered to
+indicate an error in the compilation, and it will be treated as such.
+Newlines can be included in the string by using the @samp{\n}
+escape sequence.  They will be displayed as newlines even if the
+@option{-fmessage-length} option is set to zero.
+The error is only generated if the pragma is present in the code after
+pre-processing has been completed.  It does not matter however if the
+code containing the pragma is unreachable:
+@smallexample
+#if 0
+#pragma GCC error "this error is not seen"
+#endif
+void foo (void)
+@{
+return;
+#pragma GCC error "this error is seen"
+@}
+@end smallexample
+@item #pragma GCC warning @var{message}
+@cindex pragma, diagnostic
+This is just like @samp{pragma GCC error} except that a warning
+message is issued instead of an error message.  Unless
+@option{-Werror} is in effect, in which case this pragma will generate
+an error as well.
 @end table
 @node Visibility Pragmas
 @subsection Visibility Pragmas
 @xref{Function Attributes}, for more information about the
 @code{target} attribute and the attribute syntax.
 The @code{#pragma GCC target} pragma is presently implemented for
 x86, ARM, AArch64, PowerPC, S/390, and Nios II targets only.
-@end table
-@table @code
 @item #pragma GCC optimize (@var{"string"}...)
 @cindex pragma GCC optimize
 This pragma allows you to set global optimization options for functions
 defined later in the source file.  One or more strings can be
 specified.  Each function that is defined after this point is as
 if @code{attribute((optimize("STRING")))} was specified for that
 function.  The parenthesis around the options is optional.
 @xref{Function Attributes}, for more information about the
 @code{optimize} attribute and the attribute syntax.
-@end table
-@table @code
 @item #pragma GCC push_options
 @itemx #pragma GCC pop_options
 @cindex pragma GCC push_options
 @cindex pragma GCC pop_options
 These pragmas maintain a stack of the current target and optimization
 options.  It is intended for include files where you temporarily want
 to switch to using a different @samp{#pragma GCC target} or
 @samp{#pragma GCC optimize} and then to pop back to the previous
 options.
-@end table
-@table @code
 @item #pragma GCC reset_options
 @cindex pragma GCC reset_options
 This pragma clears the current @code{#pragma GCC target} and
 @code{#pragma GCC optimize} to use the default switches as specified
 on the command line.
 @end table
 @node Loop-Specific Pragmas
 @subsection Loop-Specific Pragmas
 @table @code
 @item #pragma GCC ivdep
 @cindex pragma GCC ivdep
-@end table
 With this pragma, the programmer asserts that there are no loop-carried
 dependencies which would prevent consecutive iterations of
 the following loop from executing concurrently with SIMD
 (single instruction multiple data) instructions.
 for (int i = 0; i < m; i++)
 a[i] = a[i + k] * c;
 @}
 @end smallexample
+@item #pragma GCC unroll @var{n}
+@cindex pragma GCC unroll @var{n}
+You can use this pragma to control how many times a loop should be unrolled.
+It must be placed immediately before a @code{for}, @code{while} or @code{do}
+loop or a @code{#pragma GCC ivdep}, and applies only to the loop that follows.
+@var{n} is an integer constant expression specifying the unrolling factor.
+The values of @math{0} and @math{1} block any unrolling of the loop.
+@end table
 @node Unnamed Fields
 @section Unnamed Structure and Union Fields
 @cindex @code{struct}
 @cindex @code{union}
 the C++ standard is complete, some of those features are superseded by
 superior alternatives.  Using the old features might cause a warning in
 some cases that the feature will be dropped in the future.  In other
 cases, the feature might be gone already.
-While the list below is not exhaustive, it documents some of the options
-that are now deprecated:
-@table @code
-@item -fexternal-templates
-@itemx -falt-external-templates
-These are two of the many ways for G++ to implement template
-instantiation.  @xref{Template Instantiation}.  The C++ standard clearly
-defines how template definitions have to be organized across
-implementation units.  G++ has an implicit instantiation mechanism that
-should work just fine for standard-conforming code.
-@item -fstrict-prototype
-@itemx -fno-strict-prototype
-Previously it was possible to use an empty prototype parameter list to
-indicate an unspecified number of parameters (like C), rather than no
-parameters, as C++ demands.  This feature has been removed, except where
-it is required for backwards compatibility.   @xref{Backwards Compatibility}.
-@end table
 G++ allows a virtual function returning @samp{void *} to be overridden
 by one returning a different pointer type.  This extension to the
 covariant return type rules is now deprecated and will be removed from a
 future version.
-The G++ minimum and maximum operators (@samp{<?} and @samp{>?}) and
-their compound forms (@samp{<?=}) and @samp{>?=}) have been deprecated
-and are now removed from G++.  Code using these operators should be
-modified to use @code{std::min} and @code{std::max} instead.
-The named return value extension has been deprecated, and is now
-removed from G++.
-The use of initializer lists with new expressions has been deprecated,
-and is now removed from G++.
-Floating and complex non-type template parameters have been deprecated,
-and are now removed from G++.
-The implicit typename extension has been deprecated and is now
-removed from G++.
 The use of default arguments in function pointers, function typedefs
 and other places where they are not permitted by the standard is
 deprecated and will be removed from a future version of G++.
 G++ allows static data members of const floating-point type to be declared
 with an initializer in a class definition. The standard only allows
 initializers for static members of const integral types and const
 enumeration types so this extension has been deprecated and will be removed
 from a future version.
+G++ allows attributes to follow a parenthesized direct initializer,
+e.g.@: @samp{ int f (0) __attribute__ ((something)); } This extension
+has been ignored since G++ 3.3 and is deprecated.
+G++ allows anonymous structs and unions to have members that are not
+public non-static data members (i.e.@: fields).  These extensions are
+deprecated.
 @node Backwards Compatibility
 @section Backwards Compatibility
 @cindex Backwards Compatibility
 @cindex ARM [Annotated C++ Reference Manual]
 compatibilities.  @emph{All such backwards compatibility features are
 liable to disappear in future versions of G++.} They should be considered
 deprecated.   @xref{Deprecated Features}.
 @table @code
-@item For scope
-If a variable is declared at for scope, it used to remain in scope until
-the end of the scope that contained the for statement (rather than just
-within the for scope).  G++ retains this, but issues a warning, if such a
-variable is accessed outside the for scope.
 @item Implicit C language
 Old C system header files did not contain an @code{extern "C" @{@dots{}@}}
-scope to set the language.  On such systems, all header files are
+scope to set the language.  On such systems, all system header files are
-implicitly scoped inside a C language scope.  Also, an empty prototype
+implicitly scoped inside a C language scope.  Such headers must
-@code{()} is treated as an unspecified number of arguments, rather
+correctly prototype function argument types, there is no leeway for
-than no arguments, as C++ demands.
+@code{()} to indicate an unspecified set of arguments.
 @end table
 @c  LocalWords:  emph deftypefn builtin ARCv2EM SIMD builtins msimd
 @c  LocalWords:  typedef v4si v8hi DMA dma vdiwr vdowr

Mercurial > hg > CbC > CbC_gcc

comparison gcc/doc/extend.texi @ 131:84e7813d76e9