@c This is part of the GCC manual.
@c For copying conditions, see the file gcc.texi.
-@node C Implementation
-@chapter C Implementation-defined behavior
-@cindex implementation-defined behavior, C language
-
-A conforming implementation of ISO C is required to document its
-choice of behavior in each of the areas that are designated
-``implementation defined.'' The following lists all such areas,
-along with the section number from the ISO/IEC 9899:1999 standard.
-
-@menu
-* Translation implementation::
-* Environment implementation::
-* Identifiers implementation::
-* Characters implementation::
-* Integers implementation::
-* Floating point implementation::
-* Arrays and pointers implementation::
-* Hints implementation::
-* Structures unions enumerations and bit-fields implementation::
-* Qualifiers implementation::
-* Preprocessing directives implementation::
-* Library functions implementation::
-* Architecture implementation::
-* Locale-specific behavior implementation::
-@end menu
-
-@node Translation implementation
-@section Translation
-
-@itemize @bullet
-@item
-@cite{How a diagnostic is identified (3.10, 5.1.1.3).}
-
-Diagnostics consist of all the output sent to stderr by GCC.
-
-@item
-@cite{Whether each nonempty sequence of white-space characters other than
-new-line is retained or replaced by one space character in translation
-phase 3 (5.1.1.2).}
-@end itemize
-
-@node Environment implementation
-@section Environment
-
-The behavior of these points are dependent on the implementation
-of the C library, and are not defined by GCC itself.
-
-@node Identifiers implementation
-@section Identifiers
-
-@itemize @bullet
-@item
-@cite{Which additional multibyte characters may appear in identifiers
-and their correspondence to universal character names (6.4.2).}
-
-@item
-@cite{The number of significant initial characters in an identifier
-(5.2.4.1, 6.4.2).}
-
-For internal names, all characters are significant. For external names,
-the number of significant characters are defined by the linker; for
-almost all targets, all characters are significant.
-
-@end itemize
-
-@node Characters implementation
-@section Characters
-
-@itemize @bullet
-@item
-@cite{The number of bits in a byte (3.6).}
-
-@item
-@cite{The values of the members of the execution character set (5.2.1).}
-
-@item
-@cite{The unique value of the member of the execution character set produced
-for each of the standard alphabetic escape sequences (5.2.2).}
-
-@item
-@cite{The value of a @code{char} object into which has been stored any
-character other than a member of the basic execution character set (6.2.5).}
-
-@item
-@cite{Which of @code{signed char} or @code{unsigned char} has the same range,
-representation, and behavior as ``plain'' @code{char} (6.2.5, 6.3.1.1).}
-
-@item
-@cite{The mapping of members of the source character set (in character
-constants and string literals) to members of the execution character
-set (6.4.4.4, 5.1.1.2).}
-
-@item
-@cite{The value of an integer character constant containing more than one
-character or containing a character or escape sequence that does not map
-to a single-byte execution character (6.4.4.4).}
-
-@item
-@cite{The value of a wide character constant containing more than one
-multibyte character, or containing a multibyte character or escape
-sequence not represented in the extended execution character set (6.4.4.4).}
-
-@item
-@cite{The current locale used to convert a wide character constant consisting
-of a single multibyte character that maps to a member of the extended
-execution character set into a corresponding wide character code (6.4.4.4).}
-
-@item
-@cite{The current locale used to convert a wide string literal into
-corresponding wide character codes (6.4.5).}
-
-@item
-@cite{The value of a string literal containing a multibyte character or escape
-sequence not represented in the execution character set (6.4.5).}
-@end itemize
-
-@node Integers implementation
-@section Integers
-
-@itemize @bullet
-@item
-@cite{Any extended integer types that exist in the implementation (6.2.5).}
-
-@item
-@cite{Whether signed integer types are represented using sign and magnitude,
-two's complement, or one's complement, and whether the extraordinary value
-is a trap representation or an ordinary value (6.2.6.2).}
-
-GCC supports only two's complement integer types, and all bit patterns
-are ordinary values.
-
-@item
-@cite{The rank of any extended integer type relative to another extended
-integer type with the same precision (6.3.1.1).}
-
-@item
-@cite{The result of, or the signal raised by, converting an integer to a
-signed integer type when the value cannot be represented in an object of
-that type (6.3.1.3).}
-
-@item
-@cite{The results of some bitwise operations on signed integers (6.5).}
-@end itemize
-
-@node Floating point implementation
-@section Floating point
-
-@itemize @bullet
-@item
-@cite{The accuracy of the floating-point operations and of the library
-functions in @code{<math.h>} and @code{<complex.h>} that return floating-point
-results (5.2.4.2.2).}
-
-@item
-@cite{The rounding behaviors characterized by non-standard values
-of @code{FLT_ROUNDS} @gol
-(5.2.4.2.2).}
-
-@item
-@cite{The evaluation methods characterized by non-standard negative
-values of @code{FLT_EVAL_METHOD} (5.2.4.2.2).}
-
-@item
-@cite{The direction of rounding when an integer is converted to a
-floating-point number that cannot exactly represent the original
-value (6.3.1.4).}
-
-@item
-@cite{The direction of rounding when a floating-point number is
-converted to a narrower floating-point number (6.3.1.5).}
-
-@item
-@cite{How the nearest representable value or the larger or smaller
-representable value immediately adjacent to the nearest representable
-value is chosen for certain floating constants (6.4.4.2).}
-
-@item
-@cite{Whether and how floating expressions are contracted when not
-disallowed by the @code{FP_CONTRACT} pragma (6.5).}
-
-@item
-@cite{The default state for the @code{FENV_ACCESS} pragma (7.6.1).}
-
-@item
-@cite{Additional floating-point exceptions, rounding modes, environments,
-and classifications, and their macro names (7.6, 7.12).}
-
-@item
-@cite{The default state for the @code{FP_CONTRACT} pragma (7.12.2).}
-
-@item
-@cite{Whether the ``inexact'' floating-point exception can be raised
-when the rounded result actually does equal the mathematical result
-in an IEC 60559 conformant implementation (F.9).}
-
-@item
-@cite{Whether the ``underflow'' (and ``inexact'') floating-point
-exception can be raised when a result is tiny but not inexact in an
-IEC 60559 conformant implementation (F.9).}
-
-@end itemize
-
-@node Arrays and pointers implementation
-@section Arrays and pointers
-
-@itemize @bullet
-@item
-@cite{The result of converting a pointer to an integer or
-vice versa (6.3.2.3).}
-
-A cast from pointer to integer discards most-significant bits if the
-pointer representation is larger than the integer type,
-sign-extends@footnote{Future versions of GCC may zero-extend, or use
-a target-defined @code{ptr_extend} pattern. Do not rely on sign extension.}
-if the pointer representation is smaller than the integer type, otherwise
-the bits are unchanged.
-@c ??? We've always claimed that pointers were unsigned entities.
-@c Shouldn't we therefore be doing zero-extension? If so, the bug
-@c is in convert_to_integer, where we call type_for_size and request
-@c a signed integral type. On the other hand, it might be most useful
-@c for the target if we extend according to POINTERS_EXTEND_UNSIGNED.
-
-A cast from integer to pointer discards most-significant bits if the
-pointer representation is smaller than the integer type, extends according
-to the signedness of the integer type if the pointer representation
-is larger than the integer type, otherwise the bits are unchanged.
-
-When casting from pointer to integer and back again, the resulting
-pointer must reference the same object as the original pointer, otherwise
-the behavior is undefined. That is, one may not use integer arithmetic to
-avoid the undefined behavior of pointer arithmetic as proscribed in 6.5.6/8.
-
-@item
-@cite{The size of the result of subtracting two pointers to elements
-of the same array (6.5.6).}
-
-@end itemize
-
-@node Hints implementation
-@section Hints
-
-@itemize @bullet
-@item
-@cite{The extent to which suggestions made by using the @code{register}
-storage-class specifier are effective (6.7.1).}
-
-The @code{register} specifier affects code generation only in these ways:
-
-@itemize @bullet
-@item
-When used as part of the register variable extension, see
-@ref{Explicit Reg Vars}.
-
-@item
-When @option{-O0} is in use, the compiler allocates distinct stack
-memory for all variables that do not have the @code{register}
-storage-class specifier; if @code{register} is specified, the variable
-may have a shorter lifespan than the code would indicate and may never
-be placed in memory.
-
-@item
-On some rare x86 targets, @code{setjmp} doesn't save the registers in
-all circumstances. In those cases, GCC doesn't allocate any variables
-in registers unless they are marked @code{register}.
-
-@end itemize
-
-@item
-@cite{The extent to which suggestions made by using the inline function
-specifier are effective (6.7.4).}
-
-GCC will not inline any functions if the @option{-fno-inline} option is
-used or if @option{-O0} is used. Otherwise, GCC may still be unable to
-inline a function for many reasons; the @option{-Winline} option may be
-used to determine if a function has not been inlined and why not.
-
-@end itemize
-
-@node Structures unions enumerations and bit-fields implementation
-@section Structures, unions, enumerations, and bit-fields
-
-@itemize @bullet
-@item
-@cite{Whether a ``plain'' int bit-field is treated as a @code{signed int}
-bit-field or as an @code{unsigned int} bit-field (6.7.2, 6.7.2.1).}
-
-@item
-@cite{Allowable bit-field types other than @code{_Bool}, @code{signed int},
-and @code{unsigned int} (6.7.2.1).}
-
-@item
-@cite{Whether a bit-field can straddle a storage-unit boundary (6.7.2.1).}
-
-@item
-@cite{The order of allocation of bit-fields within a unit (6.7.2.1).}
-
-@item
-@cite{The alignment of non-bit-field members of structures (6.7.2.1).}
-
-@item
-@cite{The integer type compatible with each enumerated type (6.7.2.2).}
-
-@end itemize
-
-@node Qualifiers implementation
-@section Qualifiers
-
-@itemize @bullet
-@item
-@cite{What constitutes an access to an object that has volatile-qualified
-type (6.7.3).}
-
-@end itemize
-
-@node Preprocessing directives implementation
-@section Preprocessing directives
-
-@itemize @bullet
-@item
-@cite{How sequences in both forms of header names are mapped to headers
-or external source file names (6.4.7).}
-
-@item
-@cite{Whether the value of a character constant in a constant expression
-that controls conditional inclusion matches the value of the same character
-constant in the execution character set (6.10.1).}
-
-@item
-@cite{Whether the value of a single-character character constant in a
-constant expression that controls conditional inclusion may have a
-negative value (6.10.1).}
-
-@item
-@cite{The places that are searched for an included @samp{<>} delimited
-header, and how the places are specified or the header is
-identified (6.10.2).}
-
-@item
-@cite{How the named source file is searched for in an included @samp{""}
-delimited header (6.10.2).}
-
-@item
-@cite{The method by which preprocessing tokens (possibly resulting from
-macro expansion) in a @code{#include} directive are combined into a header
-name (6.10.2).}
-
-@item
-@cite{The nesting limit for @code{#include} processing (6.10.2).}
-
-GCC imposes a limit of 200 nested @code{#include}s.
-
-@item
-@cite{Whether the @samp{#} operator inserts a @samp{\} character before
-the @samp{\} character that begins a universal character name in a
-character constant or string literal (6.10.3.2).}
-
-@item
-@cite{The behavior on each recognized non-@code{STDC #pragma}
-directive (6.10.6).}
-
-@item
-@cite{The definitions for @code{__DATE__} and @code{__TIME__} when
-respectively, the date and time of translation are not available (6.10.8).}
-
-If the date and time are not available, @code{__DATE__} expands to
-@code{@w{"??? ?? ????"}} and @code{__TIME__} expands to
-@code{"??:??:??"}.
-
-@end itemize
-
-@node Library functions implementation
-@section Library functions
-
-The behavior of these points are dependent on the implementation
-of the C library, and are not defined by GCC itself.
-
-@node Architecture implementation
-@section Architecture
-
-@itemize @bullet
-@item
-@cite{The values or expressions assigned to the macros specified in the
-headers @code{<float.h>}, @code{<limits.h>}, and @code{<stdint.h>}
-(5.2.4.2, 7.18.2, 7.18.3).}
-
-@item
-@cite{The number, order, and encoding of bytes in any object
-(when not explicitly specified in this International Standard) (6.2.6.1).}
-
-@item
-@cite{The value of the result of the sizeof operator (6.5.3.4).}
-
-@end itemize
-
-@node Locale-specific behavior implementation
-@section Locale-specific behavior
-
-The behavior of these points are dependent on the implementation
-of the C library, and are not defined by GCC itself.
-
@node C Extensions
@chapter Extensions to the C Language Family
@cindex extensions, C language
* Offsetof:: Special syntax for implementing @code{offsetof}.
* 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.
* Thread-Local:: Per-thread variables.
@cindex side effects, macro argument
But this definition computes either @var{a} or @var{b} twice, with bad
results if the operand has side effects. In GNU C, if you know the
-type of the operands (here let's assume @code{int}), you can define
+type of the operands (here taken as @code{int}), you can define
the macro safely as follows:
@smallexample
@end smallexample
To see the meaning of the declaration using @code{typeof}, and why it
-might be a useful way to write, let's rewrite it with these macros:
+might be a useful way to write, rewrite it with these macros:
@smallexample
#define pointer(T) typeof(T *)
attribute specification inside double parentheses. The following
attributes are currently defined for functions on all targets:
@code{noreturn}, @code{noinline}, @code{always_inline},
-@code{pure}, @code{const}, @code{nothrow},
+@code{pure}, @code{const}, @code{nothrow}, @code{sentinel},
@code{format}, @code{format_arg}, @code{no_instrument_function},
@code{section}, @code{constructor}, @code{destructor}, @code{used},
@code{unused}, @code{deprecated}, @code{weak}, @code{malloc},
@item dllexport
@cindex @code{__declspec(dllexport)}
-On Microsoft Windows targets the @code{dllexport} attribute causes the
-compiler to provide a global pointer to a pointer in a dll, so that it
-can be referenced with the @code{dllimport} attribute. The pointer name
-is formed by combining @code{_imp__} and the function or variable name.
+On Microsoft Windows targets and Symbian OS targets the
+@code{dllexport} attribute causes the compiler to provide a global
+pointer to a pointer in a DLL, so that it can be referenced with the
+@code{dllimport} attribute. On Microsoft Windows targets, the pointer
+name is formed by combining @code{_imp__} and the function or variable
+name.
+
+You can use @code{__declspec(dllexport)} as a synonym for
+@code{__attribute__ ((dllexport))} for compatibility with other
+compilers.
-Currently, the @code{dllexport}attribute is ignored for inlined
-functions, but export can be forced by using the
-@option{-fkeep-inline-functions} flag. The attribute is also ignored for
-undefined symbols.
+On systems that support the @code{visibility} attribute, this
+attribute also implies ``default'' visibility, unless a
+@code{visibility} attribute is explicitly specified. You should avoid
+the use of @code{dllexport} with ``hidden'' or ``internal''
+visibility; in the future GCC may issue an error for those cases.
+
+Currently, the @code{dllexport} attribute is ignored for inlined
+functions, unless the @option{-fkeep-inline-functions} flag has been
+used. The attribute is also ignored for undefined symbols.
When applied to C++ classes. the attribute marks defined non-inlined
member functions and static data members as exports. Static consts
initialized in-class are not marked unless they are also defined
out-of-class.
-On cygwin, mingw and arm-pe targets, @code{__declspec(dllexport)} is
-recognized as a synonym for @code{__attribute__ ((dllexport))} for
-compatibility with other Microsoft Windows compilers.
-
-Alternative methods for including the symbol in the dll's export table
-are to use a .def file with an @code{EXPORTS} section or, with GNU ld,
-using the @option{--export-all} linker flag.
+For Microsoft Windows targets there are alternative methods for
+including the symbol in the DLL's export table such as using a
+@file{.def} file with an @code{EXPORTS} section or, with GNU ld, using
+the @option{--export-all} linker flag.
@item dllimport
@cindex @code{__declspec(dllimport)}
-On Microsoft Windows targets, the @code{dllimport} attribute causes the
-compiler to reference a function or variable via a global pointer to a
-pointer that is set up by the Microsoft Windows dll library. The pointer
-name is formed by combining @code{_imp__} and the function or variable
-name. The attribute implies @code{extern} storage.
+On Microsoft Windows and Symbian OS targets, the @code{dllimport}
+attribute causes the compiler to reference a function or variable via
+a global pointer to a pointer that is set up by the DLL exporting the
+symbol. The attribute implies @code{extern} storage. On Microsoft
+Windows targets, the pointer name is formed by combining @code{_imp__}
+and the function or variable name.
+
+You can use @code{__declspec(dllimport)} as a synonym for
+@code{__attribute__ ((dllimport))} for compatibility with other
+compilers.
Currently, the attribute is ignored for inlined functions. If the
attribute is applied to a symbol @emph{definition}, an error is reported.
attribute is ignored for virtual methods to allow creation of vtables
using thunks.
-On cygwin, mingw and arm-pe targets, @code{__declspec(dllimport)} is
-recognized as a synonym for @code{__attribute__ ((dllimport))} for
-compatibility with other Microsoft Windows compilers.
-
-The use of the @code{dllimport} attribute on functions is not necessary,
-but provides a small performance benefit by eliminating a thunk in the
-dll. The use of the @code{dllimport} attribute on imported variables was
-required on older versions of GNU ld, but can now be avoided by passing
-the @option{--enable-auto-import} switch to ld. As with functions, using
-the attribute for a variable eliminates a thunk in the dll.
-
-One drawback to using this attribute is that a pointer to a function or
-variable marked as dllimport cannot be used as a constant address. The
-attribute can be disabled for functions by setting the
-@option{-mnop-fun-dllimport} flag.
+On the SH Symbian OS target the @code{dllimport} attribute also has
+another affect - it can cause the vtable and run-time type information
+for a class to be exported. This happens when the class has a
+dllimport'ed constructor or a non-inline, non-pure virtual function
+and, for either of those two conditions, the class also has a inline
+constructor or destructor and has a key function that is defined in
+the current translation unit.
+
+For Microsoft Windows based targets the use of the @code{dllimport}
+attribute on functions is not necessary, but provides a small
+performance benefit by eliminating a thunk in the DLL. The use of the
+@code{dllimport} attribute on imported variables was required on older
+versions of the GNU linker, but can now be avoided by passing the
+@option{--enable-auto-import} switch to the GNU linker. As with
+functions, using the attribute for a variable eliminates a thunk in
+the DLL.
+
+One drawback to using this attribute is that a pointer to a function
+or variable marked as @code{dllimport} cannot be used as a constant
+address. On Microsoft Windows targets, the attribute can be disabled
+for functions by setting the @option{-mnop-fun-dllimport} flag.
@item eightbit_data
@cindex eight bit data on the H8/300, H8/300H, and H8S
are @code{printf_unlocked} and @code{fprintf_unlocked}.
@xref{C Dialect Options,,Options Controlling C Dialect}.
+The target may provide additional types of format checks.
+@xref{Target Format Checks,,Format Checks Specific to Particular
+Target Machines}.
+
@item format_arg (@var{string-index})
@cindex @code{format_arg} function attribute
@opindex Wformat-nonliteral
If you need to map the entire contents of a module to a particular
section, consider using the facilities of the linker instead.
+@item sentinel
+@cindex @code{sentinel} function attribute
+This function attribute ensures that a parameter in a function call is
+an explicit @code{NULL}. The attribute is only valid on variadic
+functions. By default, the sentinel is located at position zero, the
+last parameter of the function call. If an optional integer position
+argument P is supplied to the attribute, the sentinel must be located at
+position P counting backwards from the end of the argument list.
+
+@smallexample
+__attribute__ ((sentinel))
+is equivalent to
+__attribute__ ((sentinel(0)))
+@end smallexample
+
+The attribute is automatically set with a position of 0 for the built-in
+functions @code{execl} and @code{execlp}. The built-in function
+@code{execle} has the attribute set set with a position of 1.
+
+A valid @code{NULL} in this context is defined as zero with any pointer
+type. If your system defines the @code{NULL} macro with an integer type
+then you need to add an explicit cast. GCC replaces @code{stddef.h}
+with a copy that redefines NULL appropriately.
+
+The warnings for missing or incorrect sentinels are enabled with
+@option{-Wformat}.
+
@item short_call
See long_call/short_call.
See the ELF gABI for complete details, but the short story is:
@table @dfn
-@c keep this list of visibilies in alphabetical order.
+@c keep this list of visibilities in alphabetical order.
@item default
Default visibility is the normal case for ELF. This value is
compilers to match the native Microsoft compiler.
@end table
+@subsection Xstormy16 Variable Attributes
+
+One attribute is currently defined for xstormy16 configurations:
+@code{below100}
+
+@table @code
+@item below100
+@cindex @code{below100} attribute
+
+If a variable has the @code{below100} attribute (@code{BELOW100} is
+allowed also), GCC will place the variable in the first 0x100 bytes of
+memory and use special opcodes to access it. Such variables will be
+placed in either the @code{.bss_below100} section or the
+@code{.data_below100} section.
+
+@end table
+
@node Type Attributes
@section Specifying Attributes of Types
@cindex attribute of types
@node PowerPC AltiVec Built-in Functions
@subsection PowerPC AltiVec Built-in Functions
-These built-in functions are available for the PowerPC family
-of computers, depending on the command-line switches used.
+GCC provides an interface for the PowerPC family of processors to access
+the AltiVec operations described in Motorola's AltiVec Programming
+Interface Manual. The interface is made available by including
+@code{<altivec.h>} and using @option{-maltivec} and
+@option{-mabi=altivec}. The interface supports the following vector
+types.
-The following machine modes are available for use with AltiVec built-in
-functions (@pxref{Vector Extensions}): @code{V4SI} for a vector of four
-32-bit integers, @code{V4SF} for a vector of four 32-bit floating point
-numbers, @code{V8HI} for a vector of eight 16-bit integers, and
-@code{V16QI} for a vector of sixteen 8-bit integers.
+@smallexample
+vector unsigned char
+vector signed char
+vector bool char
-The following functions are made available by including
-@code{<altivec.h>} and using @option{-maltivec} and
-@option{-mabi=altivec}. The functions implement the functionality
-described in Motorola's AltiVec Programming Interface Manual.
+vector unsigned short
+vector signed short
+vector bool short
+vector pixel
-There are a few differences from Motorola's documentation and GCC's
-implementation. Vector constants are done with curly braces (not
-parentheses). Vector initializers require no casts if the vector
-constant is of the same type as the variable it is initializing. The
-@code{vector bool} type is deprecated and will be discontinued in
-further revisions. Use @code{vector signed} instead. If @code{signed}
-or @code{unsigned} is omitted, the vector type will default to
-@code{signed}. Lastly, all overloaded functions are implemented with macros
-for the C implementation. So code the following example will not work:
+vector unsigned int
+vector signed int
+vector bool int
+vector float
+@end smallexample
+
+GCC's implementation of the high-level language interface available from
+C and C++ code differs from Motorola's documentation in several ways.
+
+@itemize @bullet
+
+@item
+A vector constant is a list of constant expressions within curly braces.
+
+@item
+A vector initializer requires no cast if the vector constant is of the
+same type as the variable it is initializing.
+
+@item
+If @code{signed} or @code{unsigned} is omitted, the vector type defaults
+to @code{signed} for @code{vector int} or @code{vector short} and to
+@code{unsigned} for @code{vector char}.
+
+@item
+Compiling with @option{-maltivec} adds keywords @code{__vector},
+@code{__pixel}, and @code{__bool}. Macros @option{vector},
+@code{pixel}, and @code{bool} are defined in @code{<altivec.h>} and can
+be undefined.
+
+@item
+GCC allows using a @code{typedef} name as the type specifier for a
+vector type.
+
+@item
+For C, overloaded functions are implemented with macros so the following
+does not work:
@smallexample
vec_add ((vector signed int)@{1, 2, 3, 4@}, foo);
@end smallexample
-Since vec_add is a macro, the vector constant in the above example will
-be treated as four different arguments. Wrap the entire argument in
-parentheses for this to work. The C++ implementation does not use
-macros.
+Since @code{vec_add} is a macro, the vector constant in the example
+is treated as four separate arguments. Wrap the entire argument in
+parentheses for this to work.
+@end itemize
@emph{Note:} Only the @code{<altivec.h>} interface is supported.
Internally, GCC uses built-in functions to achieve the functionality in
the aforementioned header file, but they are not supported and are
subject to change without notice.
-@smallexample
-vector signed char vec_abs (vector signed char, vector signed char);
-vector signed short vec_abs (vector signed short, vector signed short);
-vector signed int vec_abs (vector signed int, vector signed int);
-vector signed float vec_abs (vector signed float, vector signed float);
+The following interfaces are supported for the generic and specific
+AltiVec operations and the AltiVec predicates. In cases where there
+is a direct mapping between generic and specific operations, only the
+generic names are shown here, although the specific operations can also
+be used.
-vector signed char vec_abss (vector signed char, vector signed char);
-vector signed short vec_abss (vector signed short, vector signed short);
+Arguments that are documented as @code{const int} require literal
+integral values within the range required for that operation.
-vector signed char vec_add (vector signed char, vector signed char);
-vector unsigned char vec_add (vector signed char, vector unsigned char);
+@smallexample
+vector signed char vec_abs (vector signed char);
+vector signed short vec_abs (vector signed short);
+vector signed int vec_abs (vector signed int);
+vector float vec_abs (vector float);
-vector unsigned char vec_add (vector unsigned char, vector signed char);
+vector signed char vec_abss (vector signed char);
+vector signed short vec_abss (vector signed short);
+vector signed int vec_abss (vector signed int);
+vector signed char vec_add (vector bool char, vector signed char);
+vector signed char vec_add (vector signed char, vector bool char);
+vector signed char vec_add (vector signed char, vector signed char);
+vector unsigned char vec_add (vector bool char, vector unsigned char);
+vector unsigned char vec_add (vector unsigned char, vector bool char);
vector unsigned char vec_add (vector unsigned char,
vector unsigned char);
+vector signed short vec_add (vector bool short, vector signed short);
+vector signed short vec_add (vector signed short, vector bool short);
vector signed short vec_add (vector signed short, vector signed short);
-vector unsigned short vec_add (vector signed short,
+vector unsigned short vec_add (vector bool short,
vector unsigned short);
vector unsigned short vec_add (vector unsigned short,
- vector signed short);
+ vector bool short);
vector unsigned short vec_add (vector unsigned short,
vector unsigned short);
+vector signed int vec_add (vector bool int, vector signed int);
+vector signed int vec_add (vector signed int, vector bool int);
vector signed int vec_add (vector signed int, vector signed int);
-vector unsigned int vec_add (vector signed int, vector unsigned int);
-vector unsigned int vec_add (vector unsigned int, vector signed int);
+vector unsigned int vec_add (vector bool int, vector unsigned int);
+vector unsigned int vec_add (vector unsigned int, vector bool int);
vector unsigned int vec_add (vector unsigned int, vector unsigned int);
vector float vec_add (vector float, vector float);
+vector float vec_vaddfp (vector float, vector float);
+
+vector signed int vec_vadduwm (vector bool int, vector signed int);
+vector signed int vec_vadduwm (vector signed int, vector bool int);
+vector signed int vec_vadduwm (vector signed int, vector signed int);
+vector unsigned int vec_vadduwm (vector bool int, vector unsigned int);
+vector unsigned int vec_vadduwm (vector unsigned int, vector bool int);
+vector unsigned int vec_vadduwm (vector unsigned int,
+ vector unsigned int);
+
+vector signed short vec_vadduhm (vector bool short,
+ vector signed short);
+vector signed short vec_vadduhm (vector signed short,
+ vector bool short);
+vector signed short vec_vadduhm (vector signed short,
+ vector signed short);
+vector unsigned short vec_vadduhm (vector bool short,
+ vector unsigned short);
+vector unsigned short vec_vadduhm (vector unsigned short,
+ vector bool short);
+vector unsigned short vec_vadduhm (vector unsigned short,
+ vector unsigned short);
+
+vector signed char vec_vaddubm (vector bool char, vector signed char);
+vector signed char vec_vaddubm (vector signed char, vector bool char);
+vector signed char vec_vaddubm (vector signed char, vector signed char);
+vector unsigned char vec_vaddubm (vector bool char,
+ vector unsigned char);
+vector unsigned char vec_vaddubm (vector unsigned char,
+ vector bool char);
+vector unsigned char vec_vaddubm (vector unsigned char,
+ vector unsigned char);
+
vector unsigned int vec_addc (vector unsigned int, vector unsigned int);
-vector unsigned char vec_adds (vector signed char,
- vector unsigned char);
-vector unsigned char vec_adds (vector unsigned char,
- vector signed char);
+vector unsigned char vec_adds (vector bool char, vector unsigned char);
+vector unsigned char vec_adds (vector unsigned char, vector bool char);
vector unsigned char vec_adds (vector unsigned char,
vector unsigned char);
+vector signed char vec_adds (vector bool char, vector signed char);
+vector signed char vec_adds (vector signed char, vector bool char);
vector signed char vec_adds (vector signed char, vector signed char);
-vector unsigned short vec_adds (vector signed short,
+vector unsigned short vec_adds (vector bool short,
vector unsigned short);
vector unsigned short vec_adds (vector unsigned short,
- vector signed short);
+ vector bool short);
vector unsigned short vec_adds (vector unsigned short,
vector unsigned short);
+vector signed short vec_adds (vector bool short, vector signed short);
+vector signed short vec_adds (vector signed short, vector bool short);
vector signed short vec_adds (vector signed short, vector signed short);
-
-vector unsigned int vec_adds (vector signed int, vector unsigned int);
-vector unsigned int vec_adds (vector unsigned int, vector signed int);
+vector unsigned int vec_adds (vector bool int, vector unsigned int);
+vector unsigned int vec_adds (vector unsigned int, vector bool int);
vector unsigned int vec_adds (vector unsigned int, vector unsigned int);
-
+vector signed int vec_adds (vector bool int, vector signed int);
+vector signed int vec_adds (vector signed int, vector bool int);
vector signed int vec_adds (vector signed int, vector signed int);
+vector signed int vec_vaddsws (vector bool int, vector signed int);
+vector signed int vec_vaddsws (vector signed int, vector bool int);
+vector signed int vec_vaddsws (vector signed int, vector signed int);
+
+vector unsigned int vec_vadduws (vector bool int, vector unsigned int);
+vector unsigned int vec_vadduws (vector unsigned int, vector bool int);
+vector unsigned int vec_vadduws (vector unsigned int,
+ vector unsigned int);
+
+vector signed short vec_vaddshs (vector bool short,
+ vector signed short);
+vector signed short vec_vaddshs (vector signed short,
+ vector bool short);
+vector signed short vec_vaddshs (vector signed short,
+ vector signed short);
+
+vector unsigned short vec_vadduhs (vector bool short,
+ vector unsigned short);
+vector unsigned short vec_vadduhs (vector unsigned short,
+ vector bool short);
+vector unsigned short vec_vadduhs (vector unsigned short,
+ vector unsigned short);
+
+vector signed char vec_vaddsbs (vector bool char, vector signed char);
+vector signed char vec_vaddsbs (vector signed char, vector bool char);
+vector signed char vec_vaddsbs (vector signed char, vector signed char);
+
+vector unsigned char vec_vaddubs (vector bool char,
+ vector unsigned char);
+vector unsigned char vec_vaddubs (vector unsigned char,
+ vector bool char);
+vector unsigned char vec_vaddubs (vector unsigned char,
+ vector unsigned char);
+
vector float vec_and (vector float, vector float);
-vector float vec_and (vector float, vector signed int);
-vector float vec_and (vector signed int, vector float);
+vector float vec_and (vector float, vector bool int);
+vector float vec_and (vector bool int, vector float);
+vector bool int vec_and (vector bool int, vector bool int);
+vector signed int vec_and (vector bool int, vector signed int);
+vector signed int vec_and (vector signed int, vector bool int);
vector signed int vec_and (vector signed int, vector signed int);
-vector unsigned int vec_and (vector signed int, vector unsigned int);
-vector unsigned int vec_and (vector unsigned int, vector signed int);
+vector unsigned int vec_and (vector bool int, vector unsigned int);
+vector unsigned int vec_and (vector unsigned int, vector bool int);
vector unsigned int vec_and (vector unsigned int, vector unsigned int);
+vector bool short vec_and (vector bool short, vector bool short);
+vector signed short vec_and (vector bool short, vector signed short);
+vector signed short vec_and (vector signed short, vector bool short);
vector signed short vec_and (vector signed short, vector signed short);
-vector unsigned short vec_and (vector signed short,
+vector unsigned short vec_and (vector bool short,
vector unsigned short);
vector unsigned short vec_and (vector unsigned short,
- vector signed short);
+ vector bool short);
vector unsigned short vec_and (vector unsigned short,
vector unsigned short);
+vector signed char vec_and (vector bool char, vector signed char);
+vector bool char vec_and (vector bool char, vector bool char);
+vector signed char vec_and (vector signed char, vector bool char);
vector signed char vec_and (vector signed char, vector signed char);
-vector unsigned char vec_and (vector signed char, vector unsigned char);
-
-vector unsigned char vec_and (vector unsigned char, vector signed char);
-
+vector unsigned char vec_and (vector bool char, vector unsigned char);
+vector unsigned char vec_and (vector unsigned char, vector bool char);
vector unsigned char vec_and (vector unsigned char,
vector unsigned char);
vector float vec_andc (vector float, vector float);
-vector float vec_andc (vector float, vector signed int);
-vector float vec_andc (vector signed int, vector float);
+vector float vec_andc (vector float, vector bool int);
+vector float vec_andc (vector bool int, vector float);
+vector bool int vec_andc (vector bool int, vector bool int);
+vector signed int vec_andc (vector bool int, vector signed int);
+vector signed int vec_andc (vector signed int, vector bool int);
vector signed int vec_andc (vector signed int, vector signed int);
-vector unsigned int vec_andc (vector signed int, vector unsigned int);
-vector unsigned int vec_andc (vector unsigned int, vector signed int);
+vector unsigned int vec_andc (vector bool int, vector unsigned int);
+vector unsigned int vec_andc (vector unsigned int, vector bool int);
vector unsigned int vec_andc (vector unsigned int, vector unsigned int);
-
+vector bool short vec_andc (vector bool short, vector bool short);
+vector signed short vec_andc (vector bool short, vector signed short);
+vector signed short vec_andc (vector signed short, vector bool short);
vector signed short vec_andc (vector signed short, vector signed short);
-
-vector unsigned short vec_andc (vector signed short,
+vector unsigned short vec_andc (vector bool short,
vector unsigned short);
vector unsigned short vec_andc (vector unsigned short,
- vector signed short);
+ vector bool short);
vector unsigned short vec_andc (vector unsigned short,
vector unsigned short);
+vector signed char vec_andc (vector bool char, vector signed char);
+vector bool char vec_andc (vector bool char, vector bool char);
+vector signed char vec_andc (vector signed char, vector bool char);
vector signed char vec_andc (vector signed char, vector signed char);
-vector unsigned char vec_andc (vector signed char,
- vector unsigned char);
-vector unsigned char vec_andc (vector unsigned char,
- vector signed char);
+vector unsigned char vec_andc (vector bool char, vector unsigned char);
+vector unsigned char vec_andc (vector unsigned char, vector bool char);
vector unsigned char vec_andc (vector unsigned char,
vector unsigned char);
vector unsigned int vec_avg (vector unsigned int, vector unsigned int);
vector signed int vec_avg (vector signed int, vector signed int);
+vector signed int vec_vavgsw (vector signed int, vector signed int);
+
+vector unsigned int vec_vavguw (vector unsigned int,
+ vector unsigned int);
+
+vector signed short vec_vavgsh (vector signed short,
+ vector signed short);
+
+vector unsigned short vec_vavguh (vector unsigned short,
+ vector unsigned short);
+
+vector signed char vec_vavgsb (vector signed char, vector signed char);
+
+vector unsigned char vec_vavgub (vector unsigned char,
+ vector unsigned char);
+
vector float vec_ceil (vector float);
vector signed int vec_cmpb (vector float, vector float);
-vector signed char vec_cmpeq (vector signed char, vector signed char);
-vector signed char vec_cmpeq (vector unsigned char,
- vector unsigned char);
-vector signed short vec_cmpeq (vector signed short,
- vector signed short);
-vector signed short vec_cmpeq (vector unsigned short,
- vector unsigned short);
-vector signed int vec_cmpeq (vector signed int, vector signed int);
-vector signed int vec_cmpeq (vector unsigned int, vector unsigned int);
-vector signed int vec_cmpeq (vector float, vector float);
+vector bool char vec_cmpeq (vector signed char, vector signed char);
+vector bool char vec_cmpeq (vector unsigned char, vector unsigned char);
+vector bool short vec_cmpeq (vector signed short, vector signed short);
+vector bool short vec_cmpeq (vector unsigned short,
+ vector unsigned short);
+vector bool int vec_cmpeq (vector signed int, vector signed int);
+vector bool int vec_cmpeq (vector unsigned int, vector unsigned int);
+vector bool int vec_cmpeq (vector float, vector float);
-vector signed int vec_cmpge (vector float, vector float);
+vector bool int vec_vcmpeqfp (vector float, vector float);
-vector signed char vec_cmpgt (vector unsigned char,
- vector unsigned char);
-vector signed char vec_cmpgt (vector signed char, vector signed char);
-vector signed short vec_cmpgt (vector unsigned short,
- vector unsigned short);
-vector signed short vec_cmpgt (vector signed short,
- vector signed short);
-vector signed int vec_cmpgt (vector unsigned int, vector unsigned int);
-vector signed int vec_cmpgt (vector signed int, vector signed int);
-vector signed int vec_cmpgt (vector float, vector float);
+vector bool int vec_vcmpequw (vector signed int, vector signed int);
+vector bool int vec_vcmpequw (vector unsigned int, vector unsigned int);
-vector signed int vec_cmple (vector float, vector float);
+vector bool short vec_vcmpequh (vector signed short,
+ vector signed short);
+vector bool short vec_vcmpequh (vector unsigned short,
+ vector unsigned short);
-vector signed char vec_cmplt (vector unsigned char,
- vector unsigned char);
-vector signed char vec_cmplt (vector signed char, vector signed char);
-vector signed short vec_cmplt (vector unsigned short,
- vector unsigned short);
-vector signed short vec_cmplt (vector signed short,
- vector signed short);
-vector signed int vec_cmplt (vector unsigned int, vector unsigned int);
-vector signed int vec_cmplt (vector signed int, vector signed int);
-vector signed int vec_cmplt (vector float, vector float);
+vector bool char vec_vcmpequb (vector signed char, vector signed char);
+vector bool char vec_vcmpequb (vector unsigned char,
+ vector unsigned char);
+
+vector bool int vec_cmpge (vector float, vector float);
+
+vector bool char vec_cmpgt (vector unsigned char, vector unsigned char);
+vector bool char vec_cmpgt (vector signed char, vector signed char);
+vector bool short vec_cmpgt (vector unsigned short,
+ vector unsigned short);
+vector bool short vec_cmpgt (vector signed short, vector signed short);
+vector bool int vec_cmpgt (vector unsigned int, vector unsigned int);
+vector bool int vec_cmpgt (vector signed int, vector signed int);
+vector bool int vec_cmpgt (vector float, vector float);
+
+vector 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_ctf (vector unsigned int, const int);
+vector float vec_ctf (vector signed int, const int);
+
+vector float vec_vcfsx (vector signed int, const int);
-vector float vec_ctf (vector unsigned int, const char);
-vector float vec_ctf (vector signed int, const char);
+vector float vec_vcfux (vector unsigned int, const int);
-vector signed int vec_cts (vector float, const char);
+vector signed int vec_cts (vector float, const int);
-vector unsigned int vec_ctu (vector float, const char);
+vector unsigned int vec_ctu (vector float, const int);
-void vec_dss (const char);
+void vec_dss (const int);
void vec_dssall (void);
-void vec_dst (void *, int, const char);
-
-void vec_dstst (void *, int, const char);
-
-void vec_dststt (void *, int, const char);
-
-void vec_dstt (void *, int, const char);
-
-vector float vec_expte (vector float, vector float);
-
-vector float vec_floor (vector float, vector float);
-
-vector float vec_ld (int, vector float *);
-vector float vec_ld (int, float *):
-vector signed int vec_ld (int, int *);
-vector signed int vec_ld (int, vector signed int *);
-vector unsigned int vec_ld (int, vector unsigned int *);
-vector unsigned int vec_ld (int, unsigned int *);
-vector signed short vec_ld (int, short *, vector signed short *);
-vector unsigned short vec_ld (int, unsigned short *,
- vector unsigned short *);
-vector signed char vec_ld (int, signed char *);
-vector signed char vec_ld (int, vector signed char *);
-vector unsigned char vec_ld (int, unsigned char *);
-vector unsigned char vec_ld (int, vector unsigned char *);
-
-vector signed char vec_lde (int, signed char *);
-vector unsigned char vec_lde (int, unsigned char *);
-vector signed short vec_lde (int, short *);
-vector unsigned short vec_lde (int, unsigned short *);
-vector float vec_lde (int, float *);
-vector signed int vec_lde (int, int *);
-vector unsigned int vec_lde (int, unsigned int *);
-
-void float vec_ldl (int, float *);
-void float vec_ldl (int, vector float *);
-void signed int vec_ldl (int, vector signed int *);
-void signed int vec_ldl (int, int *);
-void unsigned int vec_ldl (int, unsigned int *);
-void unsigned int vec_ldl (int, vector unsigned int *);
-void signed short vec_ldl (int, vector signed short *);
-void signed short vec_ldl (int, short *);
-void unsigned short vec_ldl (int, vector unsigned short *);
-void unsigned short vec_ldl (int, unsigned short *);
-void signed char vec_ldl (int, vector signed char *);
-void signed char vec_ldl (int, signed char *);
-void unsigned char vec_ldl (int, vector unsigned char *);
-void unsigned char vec_ldl (int, unsigned char *);
+void vec_dst (const vector unsigned char *, int, const int);
+void vec_dst (const vector signed char *, int, const int);
+void vec_dst (const vector bool char *, int, const int);
+void vec_dst (const vector unsigned short *, int, const int);
+void vec_dst (const vector signed short *, int, const int);
+void vec_dst (const vector bool short *, int, const int);
+void vec_dst (const vector pixel *, int, const int);
+void vec_dst (const vector unsigned int *, int, const int);
+void vec_dst (const vector signed int *, int, const int);
+void vec_dst (const vector bool int *, int, const int);
+void vec_dst (const vector float *, int, const int);
+void vec_dst (const unsigned char *, int, const int);
+void vec_dst (const signed char *, int, const int);
+void vec_dst (const unsigned short *, int, const int);
+void vec_dst (const short *, int, const int);
+void vec_dst (const unsigned int *, int, const int);
+void vec_dst (const int *, int, const int);
+void vec_dst (const unsigned long *, int, const int);
+void vec_dst (const long *, int, const int);
+void vec_dst (const float *, int, const int);
+
+void vec_dstst (const vector unsigned char *, int, const int);
+void vec_dstst (const vector signed char *, int, const int);
+void vec_dstst (const vector bool char *, int, const int);
+void vec_dstst (const vector unsigned short *, int, const int);
+void vec_dstst (const vector signed short *, int, const int);
+void vec_dstst (const vector bool short *, int, const int);
+void vec_dstst (const vector pixel *, int, const int);
+void vec_dstst (const vector unsigned int *, int, const int);
+void vec_dstst (const vector signed int *, int, const int);
+void vec_dstst (const vector bool int *, int, const int);
+void vec_dstst (const vector float *, int, const int);
+void vec_dstst (const unsigned char *, int, const int);
+void vec_dstst (const signed char *, int, const int);
+void vec_dstst (const unsigned short *, int, const int);
+void vec_dstst (const short *, int, const int);
+void vec_dstst (const unsigned int *, int, const int);
+void vec_dstst (const int *, int, const int);
+void vec_dstst (const unsigned long *, int, const int);
+void vec_dstst (const long *, int, const int);
+void vec_dstst (const float *, int, const int);
+
+void vec_dststt (const vector unsigned char *, int, const int);
+void vec_dststt (const vector signed char *, int, const int);
+void vec_dststt (const vector bool char *, int, const int);
+void vec_dststt (const vector unsigned short *, int, const int);
+void vec_dststt (const vector signed short *, int, const int);
+void vec_dststt (const vector bool short *, int, const int);
+void vec_dststt (const vector pixel *, int, const int);
+void vec_dststt (const vector unsigned int *, int, const int);
+void vec_dststt (const vector signed int *, int, const int);
+void vec_dststt (const vector bool int *, int, const int);
+void vec_dststt (const vector float *, int, const int);
+void vec_dststt (const unsigned char *, int, const int);
+void vec_dststt (const signed char *, int, const int);
+void vec_dststt (const unsigned short *, int, const int);
+void vec_dststt (const short *, int, const int);
+void vec_dststt (const unsigned int *, int, const int);
+void vec_dststt (const int *, int, const int);
+void vec_dststt (const unsigned long *, int, const int);
+void vec_dststt (const long *, int, const int);
+void vec_dststt (const float *, int, const int);
+
+void vec_dstt (const vector unsigned char *, int, const int);
+void vec_dstt (const vector signed char *, int, const int);
+void vec_dstt (const vector bool char *, int, const int);
+void vec_dstt (const vector unsigned short *, int, const int);
+void vec_dstt (const vector signed short *, int, const int);
+void vec_dstt (const vector bool short *, int, const int);
+void vec_dstt (const vector pixel *, int, const int);
+void vec_dstt (const vector unsigned int *, int, const int);
+void vec_dstt (const vector signed int *, int, const int);
+void vec_dstt (const vector bool int *, int, const int);
+void vec_dstt (const vector float *, int, const int);
+void vec_dstt (const unsigned char *, int, const int);
+void vec_dstt (const signed char *, int, const int);
+void vec_dstt (const unsigned short *, int, const int);
+void vec_dstt (const short *, int, const int);
+void vec_dstt (const unsigned int *, int, const int);
+void vec_dstt (const int *, int, const int);
+void vec_dstt (const unsigned long *, int, const int);
+void vec_dstt (const long *, int, const int);
+void vec_dstt (const float *, int, const int);
+
+vector float vec_expte (vector float);
+
+vector float vec_floor (vector float);
+
+vector float vec_ld (int, const vector float *);
+vector float vec_ld (int, const float *);
+vector bool int vec_ld (int, const vector bool int *);
+vector signed int vec_ld (int, const vector signed int *);
+vector signed int vec_ld (int, const int *);
+vector signed int vec_ld (int, const long *);
+vector unsigned int vec_ld (int, const vector unsigned int *);
+vector unsigned int vec_ld (int, const unsigned int *);
+vector unsigned int vec_ld (int, const unsigned long *);
+vector bool short vec_ld (int, const vector bool short *);
+vector pixel vec_ld (int, const vector pixel *);
+vector signed short vec_ld (int, const vector signed short *);
+vector signed short vec_ld (int, const short *);
+vector unsigned short vec_ld (int, const vector unsigned short *);
+vector unsigned short vec_ld (int, const unsigned short *);
+vector bool char vec_ld (int, const vector bool char *);
+vector signed char vec_ld (int, const vector signed char *);
+vector signed char vec_ld (int, const signed char *);
+vector unsigned char vec_ld (int, const vector unsigned char *);
+vector unsigned char vec_ld (int, const unsigned char *);
+
+vector signed char vec_lde (int, const signed char *);
+vector unsigned char vec_lde (int, const unsigned char *);
+vector signed short vec_lde (int, const short *);
+vector unsigned short vec_lde (int, const unsigned short *);
+vector float vec_lde (int, const float *);
+vector signed int vec_lde (int, const int *);
+vector unsigned int vec_lde (int, const unsigned int *);
+vector signed int vec_lde (int, const long *);
+vector unsigned int vec_lde (int, const unsigned long *);
+
+vector float vec_lvewx (int, float *);
+vector signed int vec_lvewx (int, int *);
+vector unsigned int vec_lvewx (int, unsigned int *);
+vector signed int vec_lvewx (int, long *);
+vector unsigned int vec_lvewx (int, unsigned long *);
+
+vector signed short vec_lvehx (int, short *);
+vector unsigned short vec_lvehx (int, unsigned short *);
+
+vector signed char vec_lvebx (int, char *);
+vector unsigned char vec_lvebx (int, unsigned char *);
+
+vector float vec_ldl (int, const vector float *);
+vector float vec_ldl (int, const float *);
+vector bool int vec_ldl (int, const vector bool int *);
+vector signed int vec_ldl (int, const vector signed int *);
+vector signed int vec_ldl (int, const int *);
+vector signed int vec_ldl (int, const long *);
+vector unsigned int vec_ldl (int, const vector unsigned int *);
+vector unsigned int vec_ldl (int, const unsigned int *);
+vector unsigned int vec_ldl (int, const unsigned long *);
+vector bool short vec_ldl (int, const vector bool short *);
+vector pixel vec_ldl (int, const vector pixel *);
+vector signed short vec_ldl (int, const vector signed short *);
+vector signed short vec_ldl (int, const short *);
+vector unsigned short vec_ldl (int, const vector unsigned short *);
+vector unsigned short vec_ldl (int, const unsigned short *);
+vector bool char vec_ldl (int, const vector bool char *);
+vector signed char vec_ldl (int, const vector signed char *);
+vector signed char vec_ldl (int, const signed char *);
+vector unsigned char vec_ldl (int, const vector unsigned char *);
+vector unsigned char vec_ldl (int, const unsigned char *);
vector float vec_loge (vector float);
-vector unsigned char vec_lvsl (int, void *, int *);
-
-vector unsigned char vec_lvsr (int, void *, int *);
+vector unsigned char vec_lvsl (int, const volatile unsigned char *);
+vector unsigned char vec_lvsl (int, const volatile signed char *);
+vector unsigned char vec_lvsl (int, const volatile unsigned short *);
+vector unsigned char vec_lvsl (int, const volatile short *);
+vector unsigned char vec_lvsl (int, const volatile unsigned int *);
+vector unsigned char vec_lvsl (int, const volatile int *);
+vector unsigned char vec_lvsl (int, const volatile unsigned long *);
+vector unsigned char vec_lvsl (int, const volatile long *);
+vector unsigned char vec_lvsl (int, const volatile float *);
+
+vector unsigned char vec_lvsr (int, const volatile unsigned char *);
+vector unsigned char vec_lvsr (int, const volatile signed char *);
+vector unsigned char vec_lvsr (int, const volatile unsigned short *);
+vector unsigned char vec_lvsr (int, const volatile short *);
+vector unsigned char vec_lvsr (int, const volatile unsigned int *);
+vector unsigned char vec_lvsr (int, const volatile int *);
+vector unsigned char vec_lvsr (int, const volatile unsigned long *);
+vector unsigned char vec_lvsr (int, const volatile long *);
+vector unsigned char vec_lvsr (int, const volatile float *);
vector float vec_madd (vector float, vector float, vector float);
-vector signed short vec_madds (vector signed short, vector signed short,
+vector signed short vec_madds (vector signed short,
+ vector signed short,
vector signed short);
-vector unsigned char vec_max (vector signed char, vector unsigned char);
-
-vector unsigned char vec_max (vector unsigned char, vector signed char);
-
+vector unsigned char vec_max (vector bool char, vector unsigned char);
+vector unsigned char vec_max (vector unsigned char, vector bool char);
vector unsigned char vec_max (vector unsigned char,
vector unsigned char);
+vector signed char vec_max (vector bool char, vector signed char);
+vector signed char vec_max (vector signed char, vector bool char);
vector signed char vec_max (vector signed char, vector signed char);
-vector unsigned short vec_max (vector signed short,
+vector unsigned short vec_max (vector bool short,
vector unsigned short);
vector unsigned short vec_max (vector unsigned short,
- vector signed short);
+ vector bool short);
vector unsigned short vec_max (vector unsigned short,
vector unsigned short);
+vector signed short vec_max (vector bool short, vector signed short);
+vector signed short vec_max (vector signed short, vector bool short);
vector signed short vec_max (vector signed short, vector signed short);
-vector unsigned int vec_max (vector signed int, vector unsigned int);
-vector unsigned int vec_max (vector unsigned int, vector signed int);
+vector unsigned int vec_max (vector bool int, vector unsigned int);
+vector unsigned int vec_max (vector unsigned int, vector bool int);
vector unsigned int vec_max (vector unsigned int, vector unsigned int);
+vector signed int vec_max (vector bool int, vector signed int);
+vector signed int vec_max (vector signed int, vector bool int);
vector signed int vec_max (vector signed int, vector signed int);
vector float vec_max (vector float, vector float);
+vector float vec_vmaxfp (vector float, vector float);
+
+vector signed int vec_vmaxsw (vector bool int, vector signed int);
+vector signed int vec_vmaxsw (vector signed int, vector bool int);
+vector signed int vec_vmaxsw (vector signed int, vector signed int);
+
+vector unsigned int vec_vmaxuw (vector bool int, vector unsigned int);
+vector unsigned int vec_vmaxuw (vector unsigned int, vector bool int);
+vector unsigned int vec_vmaxuw (vector unsigned int,
+ vector unsigned int);
+
+vector signed short vec_vmaxsh (vector bool short, vector signed short);
+vector signed short vec_vmaxsh (vector signed short, vector bool short);
+vector signed short vec_vmaxsh (vector signed short,
+ vector signed short);
+
+vector unsigned short vec_vmaxuh (vector bool short,
+ vector unsigned short);
+vector unsigned short vec_vmaxuh (vector unsigned short,
+ vector bool short);
+vector unsigned short vec_vmaxuh (vector unsigned short,
+ vector unsigned short);
+
+vector signed char vec_vmaxsb (vector bool char, vector signed char);
+vector signed char vec_vmaxsb (vector signed char, vector bool char);
+vector signed char vec_vmaxsb (vector signed char, vector signed char);
+
+vector unsigned char vec_vmaxub (vector bool char,
+ vector unsigned char);
+vector unsigned char vec_vmaxub (vector unsigned char,
+ vector bool char);
+vector unsigned char vec_vmaxub (vector unsigned char,
+ vector unsigned char);
+
+vector bool char vec_mergeh (vector bool char, vector bool char);
vector signed char vec_mergeh (vector signed char, vector signed char);
vector unsigned char vec_mergeh (vector unsigned char,
vector unsigned char);
+vector bool short vec_mergeh (vector bool short, vector bool short);
+vector pixel vec_mergeh (vector pixel, vector pixel);
vector signed short vec_mergeh (vector signed short,
vector signed short);
vector unsigned short vec_mergeh (vector unsigned short,
vector unsigned short);
vector float vec_mergeh (vector float, vector float);
+vector bool int vec_mergeh (vector bool int, vector bool int);
vector signed int vec_mergeh (vector signed int, vector signed int);
vector unsigned int vec_mergeh (vector unsigned int,
vector unsigned int);
+vector float vec_vmrghw (vector float, vector float);
+vector bool int vec_vmrghw (vector bool int, vector bool int);
+vector signed int vec_vmrghw (vector signed int, vector signed int);
+vector unsigned int vec_vmrghw (vector unsigned int,
+ vector unsigned int);
+
+vector bool short vec_vmrghh (vector bool short, vector bool short);
+vector signed short vec_vmrghh (vector signed short,
+ vector signed short);
+vector unsigned short vec_vmrghh (vector unsigned short,
+ vector unsigned short);
+vector pixel vec_vmrghh (vector pixel, vector pixel);
+
+vector bool char vec_vmrghb (vector bool char, vector bool char);
+vector signed char vec_vmrghb (vector signed char, vector signed char);
+vector unsigned char vec_vmrghb (vector unsigned char,
+ vector unsigned char);
+
+vector bool char vec_mergel (vector bool char, vector bool char);
vector signed char vec_mergel (vector signed char, vector signed char);
vector unsigned char vec_mergel (vector unsigned char,
vector unsigned char);
+vector bool short vec_mergel (vector bool short, vector bool short);
+vector pixel vec_mergel (vector pixel, vector pixel);
vector signed short vec_mergel (vector signed short,
vector signed short);
vector unsigned short vec_mergel (vector unsigned short,
vector unsigned short);
vector float vec_mergel (vector float, vector float);
+vector bool int vec_mergel (vector bool int, vector bool int);
vector signed int vec_mergel (vector signed int, vector signed int);
vector unsigned int vec_mergel (vector unsigned int,
vector unsigned int);
-vector unsigned short vec_mfvscr (void);
+vector float vec_vmrglw (vector float, vector float);
+vector signed int vec_vmrglw (vector signed int, vector signed int);
+vector unsigned int vec_vmrglw (vector unsigned int,
+ vector unsigned int);
+vector bool int vec_vmrglw (vector bool int, vector bool int);
-vector unsigned char vec_min (vector signed 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 bool char vec_vmrglb (vector bool char, vector bool char);
+vector signed char vec_vmrglb (vector signed char, vector signed char);
+vector unsigned char vec_vmrglb (vector unsigned char,
+ vector unsigned char);
-vector unsigned char vec_min (vector unsigned char, vector signed char);
+vector unsigned short vec_mfvscr (void);
+vector unsigned char vec_min (vector bool char, vector unsigned char);
+vector unsigned char vec_min (vector unsigned char, vector bool char);
vector unsigned char vec_min (vector unsigned char,
vector unsigned char);
+vector signed char vec_min (vector bool char, vector signed char);
+vector signed char vec_min (vector signed char, vector bool char);
vector signed char vec_min (vector signed char, vector signed char);
-vector unsigned short vec_min (vector signed short,
+vector unsigned short vec_min (vector bool short,
vector unsigned short);
vector unsigned short vec_min (vector unsigned short,
- vector signed short);
+ vector bool short);
vector unsigned short vec_min (vector unsigned short,
vector unsigned short);
+vector signed short vec_min (vector bool short, vector signed short);
+vector signed short vec_min (vector signed short, vector bool short);
vector signed short vec_min (vector signed short, vector signed short);
-vector unsigned int vec_min (vector signed int, vector unsigned int);
-vector unsigned int vec_min (vector unsigned int, vector signed int);
+vector unsigned int vec_min (vector bool int, vector unsigned int);
+vector unsigned int vec_min (vector unsigned int, vector bool int);
vector unsigned int vec_min (vector unsigned int, vector unsigned int);
+vector signed int vec_min (vector bool int, vector signed int);
+vector signed int vec_min (vector signed int, vector bool int);
vector signed int vec_min (vector signed int, vector signed int);
vector float vec_min (vector float, vector float);
-vector signed short vec_mladd (vector signed short, vector signed short,
+vector float vec_vminfp (vector float, vector float);
+
+vector signed int vec_vminsw (vector bool int, vector signed int);
+vector signed int vec_vminsw (vector signed int, vector bool int);
+vector signed int vec_vminsw (vector signed int, vector signed int);
+
+vector unsigned int vec_vminuw (vector bool int, vector unsigned int);
+vector unsigned int vec_vminuw (vector unsigned int, vector bool int);
+vector unsigned int vec_vminuw (vector unsigned int,
+ vector unsigned int);
+
+vector signed short vec_vminsh (vector bool short, vector signed short);
+vector signed short vec_vminsh (vector signed short, vector bool short);
+vector signed short vec_vminsh (vector signed short,
+ vector signed short);
+
+vector unsigned short vec_vminuh (vector bool short,
+ vector unsigned short);
+vector unsigned short vec_vminuh (vector unsigned short,
+ vector bool short);
+vector unsigned short vec_vminuh (vector unsigned short,
+ vector unsigned short);
+
+vector signed char vec_vminsb (vector bool char, vector signed char);
+vector signed char vec_vminsb (vector signed char, vector bool char);
+vector signed char vec_vminsb (vector signed char, vector signed char);
+
+vector unsigned char vec_vminub (vector bool char,
+ vector unsigned char);
+vector unsigned char vec_vminub (vector unsigned char,
+ vector bool char);
+vector unsigned char vec_vminub (vector unsigned char,
+ vector unsigned char);
+
+vector signed short vec_mladd (vector signed short,
+ vector signed short,
vector signed short);
vector signed short vec_mladd (vector signed short,
vector unsigned short,
vector unsigned int vec_msum (vector unsigned char,
vector unsigned char,
vector unsigned int);
-vector signed int vec_msum (vector signed char, vector unsigned char,
+vector signed int vec_msum (vector signed char,
+ vector unsigned char,
vector signed int);
vector unsigned int vec_msum (vector unsigned short,
vector unsigned short,
vector unsigned int);
-vector signed int vec_msum (vector signed short, vector signed short,
+vector signed int vec_msum (vector signed short,
+ vector signed short,
vector signed int);
+vector signed int vec_vmsumshm (vector signed short,
+ vector signed short,
+ vector signed int);
+
+vector unsigned int vec_vmsumuhm (vector unsigned short,
+ vector unsigned short,
+ vector unsigned int);
+
+vector signed int vec_vmsummbm (vector signed char,
+ vector unsigned char,
+ vector signed int);
+
+vector unsigned int vec_vmsumubm (vector unsigned char,
+ vector unsigned char,
+ vector unsigned int);
+
vector unsigned int vec_msums (vector unsigned short,
vector unsigned short,
vector unsigned int);
-vector signed int vec_msums (vector signed short, vector signed short,
+vector signed int vec_msums (vector signed short,
+ vector signed short,
vector signed int);
+vector signed int vec_vmsumshs (vector signed short,
+ vector signed short,
+ vector signed int);
+
+vector unsigned int vec_vmsumuhs (vector unsigned short,
+ vector unsigned short,
+ vector unsigned int);
+
void vec_mtvscr (vector signed int);
void vec_mtvscr (vector unsigned int);
+void vec_mtvscr (vector bool int);
void vec_mtvscr (vector signed short);
void vec_mtvscr (vector unsigned short);
+void vec_mtvscr (vector bool short);
+void vec_mtvscr (vector pixel);
void vec_mtvscr (vector signed char);
void vec_mtvscr (vector unsigned char);
+void vec_mtvscr (vector bool char);
vector unsigned short vec_mule (vector unsigned char,
vector unsigned char);
-vector signed short vec_mule (vector signed char, vector signed char);
+vector signed short vec_mule (vector signed char,
+ vector signed char);
vector unsigned int vec_mule (vector unsigned short,
vector unsigned short);
vector signed int vec_mule (vector signed short, vector signed short);
+vector signed int vec_vmulesh (vector signed short,
+ vector signed short);
+
+vector unsigned int vec_vmuleuh (vector unsigned short,
+ vector unsigned short);
+
+vector signed short vec_vmulesb (vector signed char,
+ vector signed char);
+
+vector unsigned short vec_vmuleub (vector unsigned char,
+ vector unsigned char);
+
vector unsigned short vec_mulo (vector unsigned char,
vector unsigned char);
vector signed short vec_mulo (vector signed char, vector signed char);
vector unsigned short);
vector signed int vec_mulo (vector signed short, vector signed short);
+vector signed int vec_vmulosh (vector signed short,
+ vector signed short);
+
+vector unsigned int vec_vmulouh (vector unsigned short,
+ vector unsigned short);
+
+vector signed short vec_vmulosb (vector signed char,
+ vector signed char);
+
+vector unsigned short vec_vmuloub (vector unsigned char,
+ vector unsigned char);
+
vector float vec_nmsub (vector float, vector float, vector float);
vector float vec_nor (vector float, vector float);
vector signed int vec_nor (vector signed int, vector signed int);
vector unsigned int vec_nor (vector unsigned int, vector unsigned int);
+vector bool int vec_nor (vector bool int, vector bool int);
vector signed short vec_nor (vector signed short, vector signed short);
vector unsigned short vec_nor (vector unsigned short,
vector unsigned short);
+vector bool short vec_nor (vector bool short, vector bool short);
vector signed char vec_nor (vector signed char, vector signed char);
vector unsigned char vec_nor (vector unsigned char,
vector unsigned char);
+vector bool char vec_nor (vector bool char, vector bool char);
vector float vec_or (vector float, vector float);
-vector float vec_or (vector float, vector signed int);
-vector float vec_or (vector signed int, vector float);
+vector float vec_or (vector float, vector bool int);
+vector float vec_or (vector bool int, vector float);
+vector bool int vec_or (vector bool int, vector bool int);
+vector signed int vec_or (vector bool int, vector signed int);
+vector signed int vec_or (vector signed int, vector bool int);
vector signed int vec_or (vector signed int, vector signed int);
-vector unsigned int vec_or (vector signed int, vector unsigned int);
-vector unsigned int vec_or (vector unsigned int, vector signed int);
+vector unsigned int vec_or (vector bool int, vector unsigned int);
+vector unsigned int vec_or (vector unsigned int, vector bool int);
vector unsigned int vec_or (vector unsigned int, vector unsigned int);
+vector bool short vec_or (vector bool short, vector bool short);
+vector signed short vec_or (vector bool short, vector signed short);
+vector signed short vec_or (vector signed short, vector bool short);
vector signed short vec_or (vector signed short, vector signed short);
-vector unsigned short vec_or (vector signed short,
- vector unsigned short);
-vector unsigned short vec_or (vector unsigned short,
- vector signed short);
+vector unsigned short vec_or (vector bool short, vector unsigned short);
+vector unsigned short vec_or (vector unsigned short, vector bool short);
vector unsigned short vec_or (vector unsigned short,
vector unsigned short);
+vector signed char vec_or (vector bool char, vector signed char);
+vector bool char vec_or (vector bool char, vector bool char);
+vector signed char vec_or (vector signed char, vector bool char);
vector signed char vec_or (vector signed char, vector signed char);
-vector unsigned char vec_or (vector signed char, vector unsigned char);
-vector unsigned char vec_or (vector unsigned char, vector signed char);
+vector unsigned char vec_or (vector bool char, vector unsigned char);
+vector unsigned char vec_or (vector unsigned char, vector bool char);
vector unsigned char vec_or (vector unsigned char,
vector unsigned char);
vector signed char vec_pack (vector signed short, vector signed short);
vector unsigned char vec_pack (vector unsigned short,
vector unsigned short);
+vector bool char vec_pack (vector bool short, vector bool short);
vector signed short vec_pack (vector signed int, vector signed int);
vector unsigned short vec_pack (vector unsigned int,
vector unsigned int);
+vector bool short vec_pack (vector bool int, vector bool int);
-vector signed short vec_packpx (vector unsigned int,
- vector unsigned int);
+vector bool short vec_vpkuwum (vector bool int, vector bool int);
+vector signed short vec_vpkuwum (vector signed int, vector signed int);
+vector unsigned short vec_vpkuwum (vector unsigned int,
+ vector unsigned int);
+
+vector bool char vec_vpkuhum (vector bool short, vector bool short);
+vector signed char vec_vpkuhum (vector signed short,
+ vector signed short);
+vector unsigned char vec_vpkuhum (vector unsigned short,
+ vector unsigned short);
+
+vector pixel vec_packpx (vector unsigned int, vector unsigned int);
vector unsigned char vec_packs (vector unsigned short,
vector unsigned short);
vector signed char vec_packs (vector signed short, vector signed short);
-
vector unsigned short vec_packs (vector unsigned int,
vector unsigned int);
vector signed short vec_packs (vector signed int, vector signed int);
+vector signed short vec_vpkswss (vector signed int, vector signed int);
+
+vector unsigned short vec_vpkuwus (vector unsigned int,
+ vector unsigned int);
+
+vector signed char vec_vpkshss (vector signed short,
+ vector signed short);
+
+vector unsigned char vec_vpkuhus (vector unsigned short,
+ vector unsigned short);
+
vector unsigned char vec_packsu (vector unsigned short,
vector unsigned short);
vector unsigned char vec_packsu (vector signed short,
vector unsigned int);
vector unsigned short vec_packsu (vector signed int, vector signed int);
-vector float vec_perm (vector float, vector float,
+vector unsigned short vec_vpkswus (vector signed int,
+ vector signed int);
+
+vector unsigned char vec_vpkshus (vector signed short,
+ vector signed short);
+
+vector float vec_perm (vector float,
+ vector float,
vector unsigned char);
-vector signed int vec_perm (vector signed int, vector signed int,
+vector signed int vec_perm (vector signed int,
+ vector signed int,
vector unsigned char);
-vector unsigned int vec_perm (vector unsigned int, vector unsigned int,
+vector unsigned int vec_perm (vector unsigned int,
+ vector unsigned int,
vector unsigned char);
-vector signed short vec_perm (vector signed short, vector signed short,
+vector bool int vec_perm (vector bool int,
+ vector bool int,
+ vector unsigned char);
+vector signed short vec_perm (vector signed short,
+ vector signed short,
vector unsigned char);
vector unsigned short vec_perm (vector unsigned short,
vector unsigned short,
vector unsigned char);
-vector signed char vec_perm (vector signed char, vector signed char,
+vector bool short vec_perm (vector bool short,
+ vector bool short,
+ vector unsigned char);
+vector pixel vec_perm (vector pixel,
+ vector pixel,
+ vector unsigned char);
+vector signed char vec_perm (vector signed char,
+ vector signed char,
vector unsigned char);
vector unsigned char vec_perm (vector unsigned char,
vector unsigned char,
vector unsigned char);
+vector bool char vec_perm (vector bool char,
+ vector bool char,
+ vector unsigned char);
vector float vec_re (vector float);
-vector signed char vec_rl (vector signed char, vector unsigned char);
+vector signed char vec_rl (vector signed char,
+ vector unsigned char);
vector unsigned char vec_rl (vector unsigned char,
vector unsigned char);
vector signed short vec_rl (vector signed short, vector unsigned short);
-
vector unsigned short vec_rl (vector unsigned short,
vector unsigned short);
vector signed int vec_rl (vector signed int, vector unsigned int);
vector unsigned int vec_rl (vector unsigned int, vector unsigned int);
+vector signed int vec_vrlw (vector signed int, vector unsigned int);
+vector unsigned int vec_vrlw (vector unsigned int, vector unsigned int);
+
+vector signed short vec_vrlh (vector signed short,
+ vector unsigned short);
+vector unsigned short vec_vrlh (vector unsigned short,
+ vector unsigned short);
+
+vector signed char vec_vrlb (vector signed char, vector unsigned char);
+vector unsigned char vec_vrlb (vector unsigned char,
+ vector unsigned char);
+
vector float vec_round (vector float);
vector float vec_rsqrte (vector float);
-vector float vec_sel (vector float, vector float, vector signed int);
+vector float vec_sel (vector float, vector float, vector bool int);
vector float vec_sel (vector float, vector float, vector unsigned int);
-vector signed int vec_sel (vector signed int, vector signed int,
- vector signed int);
-vector signed int vec_sel (vector signed int, vector signed int,
+vector signed int vec_sel (vector signed int,
+ vector signed int,
+ vector bool int);
+vector signed int vec_sel (vector signed int,
+ vector signed int,
vector unsigned int);
-vector unsigned int vec_sel (vector unsigned int, vector unsigned int,
- vector signed int);
-vector unsigned int vec_sel (vector unsigned int, vector unsigned int,
+vector unsigned int vec_sel (vector unsigned int,
+ vector unsigned int,
+ vector bool int);
+vector unsigned int vec_sel (vector unsigned int,
+ vector unsigned int,
vector unsigned int);
-vector signed short vec_sel (vector signed short, vector signed short,
- vector signed short);
-vector signed short vec_sel (vector signed short, vector signed short,
+vector bool int vec_sel (vector bool int,
+ vector bool int,
+ vector bool int);
+vector bool int vec_sel (vector bool int,
+ vector bool int,
+ vector unsigned int);
+vector signed short vec_sel (vector signed short,
+ vector signed short,
+ vector bool short);
+vector signed short vec_sel (vector signed short,
+ vector signed short,
vector unsigned short);
vector unsigned short vec_sel (vector unsigned short,
vector unsigned short,
- vector signed short);
+ vector bool short);
vector unsigned short vec_sel (vector unsigned short,
vector unsigned short,
vector unsigned short);
-vector signed char vec_sel (vector signed char, vector signed char,
- vector signed char);
-vector signed char vec_sel (vector signed char, vector signed char,
+vector bool short vec_sel (vector bool short,
+ vector bool short,
+ vector bool short);
+vector bool short vec_sel (vector bool short,
+ vector bool short,
+ vector unsigned short);
+vector signed char vec_sel (vector signed char,
+ vector signed char,
+ vector bool char);
+vector signed char vec_sel (vector signed char,
+ vector signed char,
vector unsigned char);
vector unsigned char vec_sel (vector unsigned char,
vector unsigned char,
- vector signed char);
+ vector bool char);
vector unsigned char vec_sel (vector unsigned char,
vector unsigned char,
vector unsigned char);
-
-vector signed char vec_sl (vector signed char, vector unsigned char);
+vector bool char vec_sel (vector bool char,
+ vector bool char,
+ vector bool char);
+vector bool char vec_sel (vector bool char,
+ vector bool char,
+ vector unsigned char);
+
+vector signed char vec_sl (vector signed char,
+ vector unsigned char);
vector unsigned char vec_sl (vector unsigned char,
vector unsigned char);
vector signed short vec_sl (vector signed short, vector unsigned short);
-
vector unsigned short vec_sl (vector unsigned short,
vector unsigned short);
vector signed int vec_sl (vector signed int, vector unsigned int);
vector unsigned int vec_sl (vector unsigned int, vector unsigned int);
-vector float vec_sld (vector float, vector float, const char);
-vector signed int vec_sld (vector signed int, vector signed int,
- const char);
-vector unsigned int vec_sld (vector unsigned int, vector unsigned int,
- const char);
-vector signed short vec_sld (vector signed short, vector signed short,
- const char);
+vector signed int vec_vslw (vector signed int, vector unsigned int);
+vector unsigned int vec_vslw (vector unsigned int, vector unsigned int);
+
+vector signed short vec_vslh (vector signed short,
+ vector unsigned short);
+vector unsigned short vec_vslh (vector unsigned short,
+ vector unsigned short);
+
+vector signed char vec_vslb (vector signed char, vector unsigned char);
+vector unsigned char vec_vslb (vector unsigned char,
+ vector unsigned char);
+
+vector float vec_sld (vector float, vector float, const int);
+vector signed int vec_sld (vector signed int,
+ vector signed int,
+ const int);
+vector unsigned int vec_sld (vector unsigned int,
+ vector unsigned int,
+ const int);
+vector bool int vec_sld (vector bool int,
+ vector bool int,
+ const int);
+vector signed short vec_sld (vector signed short,
+ vector signed short,
+ const int);
vector unsigned short vec_sld (vector unsigned short,
- vector unsigned short, const char);
-vector signed char vec_sld (vector signed char, vector signed char,
- const char);
+ vector unsigned short,
+ const int);
+vector bool short vec_sld (vector bool short,
+ vector bool short,
+ const int);
+vector pixel vec_sld (vector pixel,
+ vector pixel,
+ const int);
+vector signed char vec_sld (vector signed char,
+ vector signed char,
+ const int);
vector unsigned char vec_sld (vector unsigned char,
vector unsigned char,
- const char);
+ const int);
+vector bool char vec_sld (vector bool char,
+ vector bool char,
+ const int);
-vector signed int vec_sll (vector signed int, vector unsigned int);
-vector signed int vec_sll (vector signed int, vector unsigned short);
-vector signed int vec_sll (vector signed int, vector unsigned char);
-vector unsigned int vec_sll (vector unsigned int, vector unsigned int);
+vector signed int vec_sll (vector signed int,
+ vector unsigned int);
+vector signed int vec_sll (vector signed int,
+ vector unsigned short);
+vector signed int vec_sll (vector signed int,
+ vector unsigned char);
+vector unsigned int vec_sll (vector unsigned int,
+ vector unsigned int);
vector unsigned int vec_sll (vector unsigned int,
vector unsigned short);
-vector unsigned int vec_sll (vector unsigned int, vector unsigned char);
-
-vector signed short vec_sll (vector signed short, vector unsigned int);
+vector unsigned int vec_sll (vector unsigned int,
+ vector unsigned char);
+vector bool int vec_sll (vector bool int,
+ vector unsigned int);
+vector bool int vec_sll (vector bool int,
+ vector unsigned short);
+vector bool int vec_sll (vector bool int,
+ vector unsigned char);
+vector signed short vec_sll (vector signed short,
+ vector unsigned int);
vector signed short vec_sll (vector signed short,
vector unsigned short);
-vector signed short vec_sll (vector signed short, vector unsigned char);
-
+vector signed short vec_sll (vector signed short,
+ vector unsigned char);
vector unsigned short vec_sll (vector unsigned short,
vector unsigned int);
vector unsigned short vec_sll (vector unsigned short,
vector unsigned short);
vector unsigned short vec_sll (vector unsigned short,
vector unsigned char);
+vector bool short vec_sll (vector bool short, vector unsigned int);
+vector bool short vec_sll (vector bool short, vector unsigned short);
+vector bool short vec_sll (vector bool short, vector unsigned char);
+vector pixel vec_sll (vector pixel, vector unsigned int);
+vector pixel vec_sll (vector pixel, vector unsigned short);
+vector pixel vec_sll (vector pixel, vector unsigned char);
vector signed char vec_sll (vector signed char, vector unsigned int);
vector signed char vec_sll (vector signed char, vector unsigned short);
vector signed char vec_sll (vector signed char, vector unsigned char);
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 unsigned char);
vector unsigned int vec_slo (vector unsigned int, vector signed char);
vector unsigned int vec_slo (vector unsigned int, vector unsigned char);
-
vector signed short vec_slo (vector signed short, vector signed char);
vector signed short vec_slo (vector signed short, vector unsigned char);
-
vector unsigned short vec_slo (vector unsigned short,
vector signed char);
vector unsigned short vec_slo (vector unsigned short,
vector unsigned char);
+vector pixel vec_slo (vector pixel, vector signed char);
+vector pixel vec_slo (vector pixel, vector unsigned char);
vector signed char vec_slo (vector signed char, vector signed char);
vector signed char vec_slo (vector signed char, vector unsigned char);
vector unsigned char vec_slo (vector unsigned char, vector signed char);
-
vector unsigned char vec_slo (vector unsigned char,
vector unsigned char);
-vector signed char vec_splat (vector signed char, const char);
-vector unsigned char vec_splat (vector unsigned char, const char);
-vector signed short vec_splat (vector signed short, const char);
-vector unsigned short vec_splat (vector unsigned short, const char);
-vector float vec_splat (vector float, const char);
-vector signed int vec_splat (vector signed int, const char);
-vector unsigned int vec_splat (vector unsigned int, const char);
+vector signed char vec_splat (vector signed char, const int);
+vector unsigned char vec_splat (vector unsigned char, const int);
+vector bool char vec_splat (vector bool char, const int);
+vector signed short vec_splat (vector signed short, const int);
+vector unsigned short vec_splat (vector unsigned short, const int);
+vector bool short vec_splat (vector bool short, const int);
+vector pixel vec_splat (vector pixel, const int);
+vector float vec_splat (vector float, const int);
+vector signed int vec_splat (vector signed int, const int);
+vector unsigned int vec_splat (vector unsigned int, const int);
+vector bool int vec_splat (vector bool int, const int);
+
+vector float vec_vspltw (vector float, const int);
+vector signed int vec_vspltw (vector signed int, const int);
+vector unsigned int vec_vspltw (vector unsigned int, const int);
+vector bool int vec_vspltw (vector bool int, const int);
-vector signed char vec_splat_s8 (const char);
+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 short vec_splat_s16 (const char);
+vector signed char vec_vspltb (vector signed char, const int);
+vector unsigned char vec_vspltb (vector unsigned char, const int);
+vector bool char vec_vspltb (vector bool char, const int);
-vector signed int vec_splat_s32 (const char);
+vector signed char vec_splat_s8 (const int);
-vector unsigned char vec_splat_u8 (const char);
+vector signed short vec_splat_s16 (const int);
-vector unsigned short vec_splat_u16 (const char);
+vector signed int vec_splat_s32 (const int);
-vector unsigned int vec_splat_u32 (const char);
+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 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 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 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 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 unsigned char);
vector unsigned int vec_sro (vector unsigned int, vector signed char);
vector unsigned int vec_sro (vector unsigned int, vector unsigned char);
-
vector signed short vec_sro (vector signed short, vector signed char);
vector signed short vec_sro (vector signed short, vector unsigned char);
-
vector unsigned short vec_sro (vector unsigned short,
vector signed char);
vector unsigned short vec_sro (vector unsigned short,
vector unsigned char);
+vector pixel vec_sro (vector pixel, vector signed char);
+vector pixel vec_sro (vector pixel, vector unsigned char);
vector signed char vec_sro (vector signed char, vector signed char);
vector signed char vec_sro (vector signed char, vector unsigned char);
vector unsigned char vec_sro (vector unsigned char, vector signed char);
-
vector unsigned char vec_sro (vector unsigned char,
vector unsigned char);
-void vec_st (vector float, int, float *);
void vec_st (vector float, int, vector float *);
+void vec_st (vector float, int, float *);
+void vec_st (vector signed int, int, vector signed int *);
void vec_st (vector signed int, int, int *);
-void vec_st (vector signed int, int, unsigned int *);
-void vec_st (vector unsigned int, int, unsigned int *);
void vec_st (vector unsigned int, int, vector unsigned int *);
-void vec_st (vector signed short, int, short *);
-void vec_st (vector signed short, int, vector unsigned short *);
+void vec_st (vector unsigned int, int, unsigned int *);
+void vec_st (vector bool int, int, vector bool int *);
+void vec_st (vector bool int, int, unsigned int *);
+void vec_st (vector bool int, int, int *);
void vec_st (vector signed short, int, vector signed short *);
-void vec_st (vector unsigned short, int, unsigned short *);
+void vec_st (vector signed short, int, short *);
void vec_st (vector unsigned short, int, vector unsigned short *);
-void vec_st (vector signed char, int, signed char *);
-void vec_st (vector signed char, int, unsigned char *);
+void vec_st (vector unsigned short, int, unsigned short *);
+void vec_st (vector bool short, int, vector bool short *);
+void vec_st (vector bool short, int, unsigned short *);
+void vec_st (vector pixel, int, vector pixel *);
+void vec_st (vector pixel, int, unsigned short *);
+void vec_st (vector pixel, int, short *);
+void vec_st (vector bool short, int, short *);
void vec_st (vector signed char, int, vector signed char *);
-void vec_st (vector unsigned char, int, unsigned char *);
+void vec_st (vector signed char, int, signed char *);
void vec_st (vector unsigned char, int, vector unsigned char *);
+void vec_st (vector unsigned char, int, unsigned char *);
+void vec_st (vector bool char, int, vector bool char *);
+void vec_st (vector bool char, int, unsigned char *);
+void vec_st (vector bool char, int, signed char *);
-void vec_ste (vector signed char, int, unsigned char *);
void vec_ste (vector signed char, int, signed char *);
void vec_ste (vector unsigned char, int, unsigned char *);
+void vec_ste (vector bool char, int, signed char *);
+void vec_ste (vector bool char, int, unsigned char *);
void vec_ste (vector signed short, int, short *);
-void vec_ste (vector signed short, int, unsigned short *);
-void vec_ste (vector unsigned short, int, void *);
-void vec_ste (vector signed int, int, unsigned int *);
+void vec_ste (vector unsigned short, int, unsigned short *);
+void vec_ste (vector bool short, int, short *);
+void vec_ste (vector bool short, int, unsigned short *);
+void vec_ste (vector pixel, int, short *);
+void vec_ste (vector pixel, int, unsigned short *);
+void vec_ste (vector float, int, float *);
void vec_ste (vector signed int, int, int *);
void vec_ste (vector unsigned int, int, unsigned int *);
-void vec_ste (vector float, int, float *);
+void vec_ste (vector bool int, int, int *);
+void vec_ste (vector bool int, int, unsigned int *);
+
+void vec_stvewx (vector float, int, float *);
+void vec_stvewx (vector signed int, int, int *);
+void vec_stvewx (vector unsigned int, int, unsigned int *);
+void vec_stvewx (vector bool int, int, int *);
+void vec_stvewx (vector bool int, int, unsigned int *);
+
+void vec_stvehx (vector signed short, int, short *);
+void vec_stvehx (vector unsigned short, int, unsigned short *);
+void vec_stvehx (vector bool short, int, short *);
+void vec_stvehx (vector bool short, int, unsigned short *);
+void vec_stvehx (vector pixel, int, short *);
+void vec_stvehx (vector pixel, int, unsigned short *);
+
+void vec_stvebx (vector signed char, int, signed char *);
+void vec_stvebx (vector unsigned char, int, unsigned char *);
+void vec_stvebx (vector bool char, int, signed char *);
+void vec_stvebx (vector bool char, int, unsigned char *);
void vec_stl (vector float, int, vector float *);
void vec_stl (vector float, int, float *);
void vec_stl (vector signed int, int, vector signed int *);
void vec_stl (vector signed int, int, int *);
-void vec_stl (vector signed int, int, unsigned int *);
void vec_stl (vector unsigned int, int, vector unsigned int *);
void vec_stl (vector unsigned int, int, unsigned int *);
-void vec_stl (vector signed short, int, short *);
-void vec_stl (vector signed short, int, unsigned short *);
+void vec_stl (vector bool int, int, vector bool int *);
+void vec_stl (vector bool int, int, unsigned int *);
+void vec_stl (vector bool int, int, int *);
void vec_stl (vector signed short, int, vector signed short *);
+void vec_stl (vector signed short, int, short *);
+void vec_stl (vector unsigned short, int, vector unsigned short *);
void vec_stl (vector unsigned short, int, unsigned short *);
-void vec_stl (vector unsigned short, int, vector signed short *);
-void vec_stl (vector signed char, int, signed char *);
-void vec_stl (vector signed char, int, unsigned char *);
+void vec_stl (vector bool short, int, vector bool short *);
+void vec_stl (vector bool short, int, unsigned short *);
+void vec_stl (vector bool short, int, short *);
+void vec_stl (vector pixel, int, vector pixel *);
+void vec_stl (vector pixel, int, unsigned short *);
+void vec_stl (vector pixel, int, short *);
void vec_stl (vector signed char, int, vector signed char *);
-void vec_stl (vector unsigned char, int, unsigned char *);
+void vec_stl (vector signed char, int, signed char *);
void vec_stl (vector unsigned char, int, vector unsigned char *);
+void vec_stl (vector unsigned char, int, unsigned char *);
+void vec_stl (vector bool char, int, vector bool char *);
+void vec_stl (vector bool char, int, unsigned char *);
+void vec_stl (vector bool char, int, signed char *);
+vector signed char vec_sub (vector bool char, vector signed char);
+vector signed char vec_sub (vector signed char, vector bool char);
vector signed char vec_sub (vector signed char, vector signed char);
-vector unsigned char vec_sub (vector signed char, vector unsigned char);
-
-vector unsigned char vec_sub (vector unsigned char, vector signed char);
-
+vector unsigned char vec_sub (vector bool char, vector unsigned char);
+vector unsigned char vec_sub (vector unsigned char, vector bool char);
vector unsigned char vec_sub (vector unsigned char,
vector unsigned char);
+vector signed short vec_sub (vector bool short, vector signed short);
+vector signed short vec_sub (vector signed short, vector bool short);
vector signed short vec_sub (vector signed short, vector signed short);
-vector unsigned short vec_sub (vector signed short,
+vector unsigned short vec_sub (vector bool short,
vector unsigned short);
vector unsigned short vec_sub (vector unsigned short,
- vector signed short);
+ vector bool short);
vector unsigned short vec_sub (vector unsigned short,
vector unsigned short);
+vector signed int vec_sub (vector bool int, vector signed int);
+vector signed int vec_sub (vector signed int, vector bool int);
vector signed int vec_sub (vector signed int, vector signed int);
-vector unsigned int vec_sub (vector signed int, vector unsigned int);
-vector unsigned int vec_sub (vector unsigned int, vector signed int);
+vector unsigned int vec_sub (vector bool int, vector unsigned int);
+vector unsigned int vec_sub (vector unsigned int, vector bool int);
vector unsigned int vec_sub (vector unsigned int, vector unsigned int);
vector float vec_sub (vector float, vector float);
+vector float vec_vsubfp (vector float, vector float);
+
+vector signed int vec_vsubuwm (vector bool int, vector signed int);
+vector signed int vec_vsubuwm (vector signed int, vector bool int);
+vector signed int vec_vsubuwm (vector signed int, vector signed int);
+vector unsigned int vec_vsubuwm (vector bool int, vector unsigned int);
+vector unsigned int vec_vsubuwm (vector unsigned int, vector bool int);
+vector unsigned int vec_vsubuwm (vector unsigned int,
+ vector unsigned int);
+
+vector signed short vec_vsubuhm (vector bool short,
+ vector signed short);
+vector signed short vec_vsubuhm (vector signed short,
+ vector bool short);
+vector signed short vec_vsubuhm (vector signed short,
+ vector signed short);
+vector unsigned short vec_vsubuhm (vector bool short,
+ vector unsigned short);
+vector unsigned short vec_vsubuhm (vector unsigned short,
+ vector bool short);
+vector unsigned short vec_vsubuhm (vector unsigned short,
+ vector unsigned short);
+
+vector signed char vec_vsububm (vector bool char, vector signed char);
+vector signed char vec_vsububm (vector signed char, vector bool char);
+vector signed char vec_vsububm (vector signed char, vector signed char);
+vector unsigned char vec_vsububm (vector bool char,
+ vector unsigned char);
+vector unsigned char vec_vsububm (vector unsigned char,
+ vector bool char);
+vector unsigned char vec_vsububm (vector unsigned char,
+ vector unsigned char);
+
vector unsigned int vec_subc (vector unsigned int, vector unsigned int);
-vector unsigned char vec_subs (vector signed char,
- vector unsigned char);
-vector unsigned char vec_subs (vector unsigned char,
- vector signed char);
+vector unsigned char vec_subs (vector bool char, vector unsigned char);
+vector unsigned char vec_subs (vector unsigned char, vector bool char);
vector unsigned char vec_subs (vector unsigned char,
vector unsigned char);
+vector signed char vec_subs (vector bool char, vector signed char);
+vector signed char vec_subs (vector signed char, vector bool char);
vector signed char vec_subs (vector signed char, vector signed char);
-vector unsigned short vec_subs (vector signed short,
+vector unsigned short vec_subs (vector bool short,
vector unsigned short);
vector unsigned short vec_subs (vector unsigned short,
- vector signed short);
+ vector bool short);
vector unsigned short vec_subs (vector unsigned short,
vector unsigned short);
+vector signed short vec_subs (vector bool short, vector signed short);
+vector signed short vec_subs (vector signed short, vector bool short);
vector signed short vec_subs (vector signed short, vector signed short);
-
-vector unsigned int vec_subs (vector signed int, vector unsigned int);
-vector unsigned int vec_subs (vector unsigned int, vector signed int);
+vector unsigned int vec_subs (vector bool int, vector unsigned int);
+vector unsigned int vec_subs (vector unsigned int, vector bool int);
vector unsigned int vec_subs (vector unsigned int, vector unsigned int);
-
+vector signed int vec_subs (vector bool int, vector signed int);
+vector signed int vec_subs (vector signed int, vector bool int);
vector signed int vec_subs (vector signed int, vector signed int);
+vector signed int vec_vsubsws (vector bool int, vector signed int);
+vector signed int vec_vsubsws (vector signed int, vector bool int);
+vector signed int vec_vsubsws (vector signed int, vector signed int);
+
+vector unsigned int vec_vsubuws (vector bool int, vector unsigned int);
+vector unsigned int vec_vsubuws (vector unsigned int, vector bool int);
+vector unsigned int vec_vsubuws (vector unsigned int,
+ vector unsigned int);
+
+vector signed short vec_vsubshs (vector bool short,
+ vector signed short);
+vector signed short vec_vsubshs (vector signed short,
+ vector bool short);
+vector signed short vec_vsubshs (vector signed short,
+ vector signed short);
+
+vector unsigned short vec_vsubuhs (vector bool short,
+ vector unsigned short);
+vector unsigned short vec_vsubuhs (vector unsigned short,
+ vector bool short);
+vector unsigned short vec_vsubuhs (vector unsigned short,
+ vector unsigned short);
+
+vector signed char vec_vsubsbs (vector bool char, vector signed char);
+vector signed char vec_vsubsbs (vector signed char, vector bool char);
+vector signed char vec_vsubsbs (vector signed char, vector signed char);
+
+vector unsigned char vec_vsububs (vector bool char,
+ vector unsigned char);
+vector unsigned char vec_vsububs (vector unsigned char,
+ vector bool char);
+vector unsigned char vec_vsububs (vector unsigned char,
+ vector unsigned char);
+
vector unsigned int vec_sum4s (vector unsigned char,
vector unsigned int);
vector signed int vec_sum4s (vector signed char, vector signed int);
vector signed int vec_sum4s (vector signed short, vector signed int);
+vector signed int vec_vsum4shs (vector signed short, vector signed int);
+
+vector signed int vec_vsum4sbs (vector signed char, vector signed int);
+
+vector unsigned int vec_vsum4ubs (vector unsigned char,
+ vector unsigned int);
+
vector signed int vec_sum2s (vector signed int, vector signed int);
vector signed int vec_sums (vector signed int, vector signed int);
vector float vec_trunc (vector float);
vector signed short vec_unpackh (vector signed char);
-vector unsigned int vec_unpackh (vector signed short);
+vector bool short vec_unpackh (vector bool char);
vector signed int vec_unpackh (vector signed short);
+vector bool int vec_unpackh (vector bool short);
+vector unsigned int vec_unpackh (vector pixel);
+
+vector bool int vec_vupkhsh (vector bool short);
+vector signed int vec_vupkhsh (vector signed short);
+
+vector unsigned int vec_vupkhpx (vector pixel);
+
+vector bool short vec_vupkhsb (vector bool char);
+vector signed short vec_vupkhsb (vector signed char);
vector signed short vec_unpackl (vector signed char);
-vector unsigned int vec_unpackl (vector signed short);
+vector bool short vec_unpackl (vector bool char);
+vector unsigned int vec_unpackl (vector pixel);
vector signed int vec_unpackl (vector signed short);
+vector bool int vec_unpackl (vector bool short);
+
+vector unsigned int vec_vupklpx (vector pixel);
+
+vector bool int vec_vupklsh (vector bool short);
+vector signed int vec_vupklsh (vector signed short);
+
+vector bool short vec_vupklsb (vector bool char);
+vector signed short vec_vupklsb (vector signed char);
vector float vec_xor (vector float, vector float);
-vector float vec_xor (vector float, vector signed int);
-vector float vec_xor (vector signed int, vector float);
+vector float vec_xor (vector float, vector bool int);
+vector float vec_xor (vector bool int, vector float);
+vector bool int vec_xor (vector bool int, vector bool int);
+vector signed int vec_xor (vector bool int, vector signed int);
+vector signed int vec_xor (vector signed int, vector bool int);
vector signed int vec_xor (vector signed int, vector signed int);
-vector unsigned int vec_xor (vector signed int, vector unsigned int);
-vector unsigned int vec_xor (vector unsigned int, vector signed int);
+vector unsigned int vec_xor (vector bool int, vector unsigned int);
+vector unsigned int vec_xor (vector unsigned int, vector bool int);
vector unsigned int vec_xor (vector unsigned int, vector unsigned int);
+vector bool short vec_xor (vector bool short, vector bool short);
+vector signed short vec_xor (vector bool short, vector signed short);
+vector signed short vec_xor (vector signed short, vector bool short);
vector signed short vec_xor (vector signed short, vector signed short);
-vector unsigned short vec_xor (vector signed short,
+vector unsigned short vec_xor (vector bool short,
vector unsigned short);
vector unsigned short vec_xor (vector unsigned short,
- vector signed short);
+ vector bool short);
vector unsigned short vec_xor (vector unsigned short,
vector unsigned short);
+vector signed char vec_xor (vector bool char, vector signed char);
+vector bool char vec_xor (vector bool char, vector bool char);
+vector signed char vec_xor (vector signed char, vector bool char);
vector signed char vec_xor (vector signed char, vector signed char);
-vector unsigned char vec_xor (vector signed char, vector unsigned char);
-
-vector unsigned char vec_xor (vector unsigned char, vector signed char);
-
+vector unsigned char vec_xor (vector bool char, vector unsigned char);
+vector unsigned char vec_xor (vector unsigned char, vector bool char);
vector unsigned char vec_xor (vector unsigned char,
vector unsigned char);
-vector signed int vec_all_eq (vector signed char, vector unsigned char);
-
-vector signed int vec_all_eq (vector signed char, vector signed char);
-vector signed int vec_all_eq (vector unsigned char, vector signed char);
-
-vector signed int vec_all_eq (vector unsigned char,
- vector unsigned char);
-vector signed int vec_all_eq (vector signed short,
- vector unsigned short);
-vector signed int vec_all_eq (vector signed short, vector signed short);
-
-vector signed int vec_all_eq (vector unsigned short,
- vector signed short);
-vector signed int vec_all_eq (vector unsigned short,
- vector unsigned short);
-vector signed int vec_all_eq (vector signed int, vector unsigned int);
-vector signed int vec_all_eq (vector signed int, vector signed int);
-vector signed int vec_all_eq (vector unsigned int, vector signed int);
-vector signed int vec_all_eq (vector unsigned int, vector unsigned int);
-
-vector signed int vec_all_eq (vector float, vector float);
-
-vector signed int vec_all_ge (vector signed char, vector unsigned char);
-
-vector signed int vec_all_ge (vector unsigned char, vector signed char);
-
-vector signed int vec_all_ge (vector unsigned char,
- vector unsigned char);
-vector signed int vec_all_ge (vector signed char, vector signed char);
-vector signed int vec_all_ge (vector signed short,
- vector unsigned short);
-vector signed int vec_all_ge (vector unsigned short,
- vector signed short);
-vector signed int vec_all_ge (vector unsigned short,
- vector unsigned short);
-vector signed int vec_all_ge (vector signed short, vector signed short);
-
-vector signed int vec_all_ge (vector signed int, vector unsigned int);
-vector signed int vec_all_ge (vector unsigned int, vector signed int);
-vector signed int vec_all_ge (vector unsigned int, vector unsigned int);
+int vec_all_eq (vector signed char, vector bool char);
+int vec_all_eq (vector signed char, vector signed char);
+int vec_all_eq (vector unsigned char, vector bool char);
+int vec_all_eq (vector unsigned char, vector unsigned char);
+int vec_all_eq (vector bool char, vector bool char);
+int vec_all_eq (vector bool char, vector unsigned char);
+int vec_all_eq (vector bool char, vector signed char);
+int vec_all_eq (vector signed short, vector bool short);
+int vec_all_eq (vector signed short, vector signed short);
+int vec_all_eq (vector unsigned short, vector bool short);
+int vec_all_eq (vector unsigned short, vector unsigned short);
+int vec_all_eq (vector bool short, vector bool short);
+int vec_all_eq (vector bool short, vector unsigned short);
+int vec_all_eq (vector bool short, vector signed short);
+int vec_all_eq (vector pixel, vector pixel);
+int vec_all_eq (vector signed int, vector bool int);
+int vec_all_eq (vector signed int, vector signed int);
+int vec_all_eq (vector unsigned int, vector bool int);
+int vec_all_eq (vector unsigned int, vector unsigned int);
+int vec_all_eq (vector bool int, vector bool int);
+int vec_all_eq (vector bool int, vector unsigned int);
+int vec_all_eq (vector bool int, vector signed int);
+int vec_all_eq (vector float, vector float);
+
+int vec_all_ge (vector bool char, vector unsigned char);
+int vec_all_ge (vector unsigned char, vector bool char);
+int vec_all_ge (vector unsigned char, vector unsigned char);
+int vec_all_ge (vector bool char, vector signed char);
+int vec_all_ge (vector signed char, vector bool char);
+int vec_all_ge (vector signed char, vector signed char);
+int vec_all_ge (vector bool short, vector unsigned short);
+int vec_all_ge (vector unsigned short, vector bool short);
+int vec_all_ge (vector unsigned short, vector unsigned short);
+int vec_all_ge (vector signed short, vector signed short);
+int vec_all_ge (vector bool short, vector signed short);
+int vec_all_ge (vector signed short, vector bool short);
+int vec_all_ge (vector bool int, vector unsigned int);
+int vec_all_ge (vector unsigned int, vector bool int);
+int vec_all_ge (vector unsigned int, vector unsigned int);
+int vec_all_ge (vector bool int, vector signed int);
+int vec_all_ge (vector signed int, vector bool int);
+int vec_all_ge (vector signed int, vector signed int);
+int vec_all_ge (vector float, vector float);
+
+int vec_all_gt (vector bool char, vector unsigned char);
+int vec_all_gt (vector unsigned char, vector bool char);
+int vec_all_gt (vector unsigned char, vector unsigned char);
+int vec_all_gt (vector bool char, vector signed char);
+int vec_all_gt (vector signed char, vector bool char);
+int vec_all_gt (vector signed char, vector signed char);
+int vec_all_gt (vector bool short, vector unsigned short);
+int vec_all_gt (vector unsigned short, vector bool short);
+int vec_all_gt (vector unsigned short, vector unsigned short);
+int vec_all_gt (vector bool short, vector signed short);
+int vec_all_gt (vector signed short, vector bool short);
+int vec_all_gt (vector signed short, vector signed short);
+int vec_all_gt (vector bool int, vector unsigned int);
+int vec_all_gt (vector unsigned int, vector bool int);
+int vec_all_gt (vector unsigned int, vector unsigned int);
+int vec_all_gt (vector bool int, vector signed int);
+int vec_all_gt (vector signed int, vector bool int);
+int vec_all_gt (vector signed int, vector signed int);
+int vec_all_gt (vector float, vector float);
+
+int vec_all_in (vector float, vector float);
+
+int vec_all_le (vector bool char, vector unsigned char);
+int vec_all_le (vector unsigned char, vector bool char);
+int vec_all_le (vector unsigned char, vector unsigned char);
+int vec_all_le (vector bool char, vector signed char);
+int vec_all_le (vector signed char, vector bool char);
+int vec_all_le (vector signed char, vector signed char);
+int vec_all_le (vector bool short, vector unsigned short);
+int vec_all_le (vector unsigned short, vector bool short);
+int vec_all_le (vector unsigned short, vector unsigned short);
+int vec_all_le (vector bool short, vector signed short);
+int vec_all_le (vector signed short, vector bool short);
+int vec_all_le (vector signed short, vector signed short);
+int vec_all_le (vector bool int, vector unsigned int);
+int vec_all_le (vector unsigned int, vector bool int);
+int vec_all_le (vector unsigned int, vector unsigned int);
+int vec_all_le (vector bool int, vector signed int);
+int vec_all_le (vector signed int, vector bool int);
+int vec_all_le (vector signed int, vector signed int);
+int vec_all_le (vector float, vector float);
+
+int vec_all_lt (vector bool char, vector unsigned char);
+int vec_all_lt (vector unsigned char, vector bool char);
+int vec_all_lt (vector unsigned char, vector unsigned char);
+int vec_all_lt (vector bool char, vector signed char);
+int vec_all_lt (vector signed char, vector bool char);
+int vec_all_lt (vector signed char, vector signed char);
+int vec_all_lt (vector bool short, vector unsigned short);
+int vec_all_lt (vector unsigned short, vector bool short);
+int vec_all_lt (vector unsigned short, vector unsigned short);
+int vec_all_lt (vector bool short, vector signed short);
+int vec_all_lt (vector signed short, vector bool short);
+int vec_all_lt (vector signed short, vector signed short);
+int vec_all_lt (vector bool int, vector unsigned int);
+int vec_all_lt (vector unsigned int, vector bool int);
+int vec_all_lt (vector unsigned int, vector unsigned int);
+int vec_all_lt (vector bool int, vector signed int);
+int vec_all_lt (vector signed int, vector bool int);
+int vec_all_lt (vector signed int, vector signed int);
+int vec_all_lt (vector float, vector float);
+
+int vec_all_nan (vector float);
+
+int vec_all_ne (vector signed char, vector bool char);
+int vec_all_ne (vector signed char, vector signed char);
+int vec_all_ne (vector unsigned char, vector bool char);
+int vec_all_ne (vector unsigned char, vector unsigned char);
+int vec_all_ne (vector bool char, vector bool char);
+int vec_all_ne (vector bool char, vector unsigned char);
+int vec_all_ne (vector bool char, vector signed char);
+int vec_all_ne (vector signed short, vector bool short);
+int vec_all_ne (vector signed short, vector signed short);
+int vec_all_ne (vector unsigned short, vector bool short);
+int vec_all_ne (vector unsigned short, vector unsigned short);
+int vec_all_ne (vector bool short, vector bool short);
+int vec_all_ne (vector bool short, vector unsigned short);
+int vec_all_ne (vector bool short, vector signed short);
+int vec_all_ne (vector pixel, vector pixel);
+int vec_all_ne (vector signed int, vector bool int);
+int vec_all_ne (vector signed int, vector signed int);
+int vec_all_ne (vector unsigned int, vector bool int);
+int vec_all_ne (vector unsigned int, vector unsigned int);
+int vec_all_ne (vector bool int, vector bool int);
+int vec_all_ne (vector bool int, vector unsigned int);
+int vec_all_ne (vector bool int, vector signed int);
+int vec_all_ne (vector float, vector float);
+
+int vec_all_nge (vector float, vector float);
+
+int vec_all_ngt (vector float, vector float);
+
+int vec_all_nle (vector float, vector float);
+
+int vec_all_nlt (vector float, vector float);
+
+int vec_all_numeric (vector float);
+
+int vec_any_eq (vector signed char, vector bool char);
+int vec_any_eq (vector signed char, vector signed char);
+int vec_any_eq (vector unsigned char, vector bool char);
+int vec_any_eq (vector unsigned char, vector unsigned char);
+int vec_any_eq (vector bool char, vector bool char);
+int vec_any_eq (vector bool char, vector unsigned char);
+int vec_any_eq (vector bool char, vector signed char);
+int vec_any_eq (vector signed short, vector bool short);
+int vec_any_eq (vector signed short, vector signed short);
+int vec_any_eq (vector unsigned short, vector bool short);
+int vec_any_eq (vector unsigned short, vector unsigned short);
+int vec_any_eq (vector bool short, vector bool short);
+int vec_any_eq (vector bool short, vector unsigned short);
+int vec_any_eq (vector bool short, vector signed short);
+int vec_any_eq (vector pixel, vector pixel);
+int vec_any_eq (vector signed int, vector bool int);
+int vec_any_eq (vector signed int, vector signed int);
+int vec_any_eq (vector unsigned int, vector bool int);
+int vec_any_eq (vector unsigned int, vector unsigned int);
+int vec_any_eq (vector bool int, vector bool int);
+int vec_any_eq (vector bool int, vector unsigned int);
+int vec_any_eq (vector bool int, vector signed int);
+int vec_any_eq (vector float, vector float);
+
+int vec_any_ge (vector signed char, vector bool char);
+int vec_any_ge (vector unsigned char, vector bool char);
+int vec_any_ge (vector unsigned char, vector unsigned char);
+int vec_any_ge (vector signed char, vector signed char);
+int vec_any_ge (vector bool char, vector unsigned char);
+int vec_any_ge (vector bool char, vector signed char);
+int vec_any_ge (vector unsigned short, vector bool short);
+int vec_any_ge (vector unsigned short, vector unsigned short);
+int vec_any_ge (vector signed short, vector signed short);
+int vec_any_ge (vector signed short, vector bool short);
+int vec_any_ge (vector bool short, vector unsigned short);
+int vec_any_ge (vector bool short, vector signed short);
+int vec_any_ge (vector signed int, vector bool int);
+int vec_any_ge (vector unsigned int, vector bool int);
+int vec_any_ge (vector unsigned int, vector unsigned int);
+int vec_any_ge (vector signed int, vector signed int);
+int vec_any_ge (vector bool int, vector unsigned int);
+int vec_any_ge (vector bool int, vector signed int);
+int vec_any_ge (vector float, vector float);
+
+int vec_any_gt (vector bool char, vector unsigned char);
+int vec_any_gt (vector unsigned char, vector bool char);
+int vec_any_gt (vector unsigned char, vector unsigned char);
+int vec_any_gt (vector bool char, vector signed char);
+int vec_any_gt (vector signed char, vector bool char);
+int vec_any_gt (vector signed char, vector signed char);
+int vec_any_gt (vector bool short, vector unsigned short);
+int vec_any_gt (vector unsigned short, vector bool short);
+int vec_any_gt (vector unsigned short, vector unsigned short);
+int vec_any_gt (vector bool short, vector signed short);
+int vec_any_gt (vector signed short, vector bool short);
+int vec_any_gt (vector signed short, vector signed short);
+int vec_any_gt (vector bool int, vector unsigned int);
+int vec_any_gt (vector unsigned int, vector bool int);
+int vec_any_gt (vector unsigned int, vector unsigned int);
+int vec_any_gt (vector bool int, vector signed int);
+int vec_any_gt (vector signed int, vector bool int);
+int vec_any_gt (vector signed int, vector signed int);
+int vec_any_gt (vector float, vector float);
+
+int vec_any_le (vector bool char, vector unsigned char);
+int vec_any_le (vector unsigned char, vector bool char);
+int vec_any_le (vector unsigned char, vector unsigned char);
+int vec_any_le (vector bool char, vector signed char);
+int vec_any_le (vector signed char, vector bool char);
+int vec_any_le (vector signed char, vector signed char);
+int vec_any_le (vector bool short, vector unsigned short);
+int vec_any_le (vector unsigned short, vector bool short);
+int vec_any_le (vector unsigned short, vector unsigned short);
+int vec_any_le (vector bool short, vector signed short);
+int vec_any_le (vector signed short, vector bool short);
+int vec_any_le (vector signed short, vector signed short);
+int vec_any_le (vector bool int, vector unsigned int);
+int vec_any_le (vector unsigned int, vector bool int);
+int vec_any_le (vector unsigned int, vector unsigned int);
+int vec_any_le (vector bool int, vector signed int);
+int vec_any_le (vector signed int, vector bool int);
+int vec_any_le (vector signed int, vector signed int);
+int vec_any_le (vector float, vector float);
+
+int vec_any_lt (vector bool char, vector unsigned char);
+int vec_any_lt (vector unsigned char, vector bool char);
+int vec_any_lt (vector unsigned char, vector unsigned char);
+int vec_any_lt (vector bool char, vector signed char);
+int vec_any_lt (vector signed char, vector bool char);
+int vec_any_lt (vector signed char, vector signed char);
+int vec_any_lt (vector bool short, vector unsigned short);
+int vec_any_lt (vector unsigned short, vector bool short);
+int vec_any_lt (vector unsigned short, vector unsigned short);
+int vec_any_lt (vector bool short, vector signed short);
+int vec_any_lt (vector signed short, vector bool short);
+int vec_any_lt (vector signed short, vector signed short);
+int vec_any_lt (vector bool int, vector unsigned int);
+int vec_any_lt (vector unsigned int, vector bool int);
+int vec_any_lt (vector unsigned int, vector unsigned int);
+int vec_any_lt (vector bool int, vector signed int);
+int vec_any_lt (vector signed int, vector bool int);
+int vec_any_lt (vector signed int, vector signed int);
+int vec_any_lt (vector float, vector float);
+
+int vec_any_nan (vector float);
+
+int vec_any_ne (vector signed char, vector bool char);
+int vec_any_ne (vector signed char, vector signed char);
+int vec_any_ne (vector unsigned char, vector bool char);
+int vec_any_ne (vector unsigned char, vector unsigned char);
+int vec_any_ne (vector bool char, vector bool char);
+int vec_any_ne (vector bool char, vector unsigned char);
+int vec_any_ne (vector bool char, vector signed char);
+int vec_any_ne (vector signed short, vector bool short);
+int vec_any_ne (vector signed short, vector signed short);
+int vec_any_ne (vector unsigned short, vector bool short);
+int vec_any_ne (vector unsigned short, vector unsigned short);
+int vec_any_ne (vector bool short, vector bool short);
+int vec_any_ne (vector bool short, vector unsigned short);
+int vec_any_ne (vector bool short, vector signed short);
+int vec_any_ne (vector pixel, vector pixel);
+int vec_any_ne (vector signed int, vector bool int);
+int vec_any_ne (vector signed int, vector signed int);
+int vec_any_ne (vector unsigned int, vector bool int);
+int vec_any_ne (vector unsigned int, vector unsigned int);
+int vec_any_ne (vector bool int, vector bool int);
+int vec_any_ne (vector bool int, vector unsigned int);
+int vec_any_ne (vector bool int, vector signed int);
+int vec_any_ne (vector float, vector float);
+
+int vec_any_nge (vector float, vector float);
+
+int vec_any_ngt (vector float, vector float);
+
+int vec_any_nle (vector float, vector float);
+
+int vec_any_nlt (vector float, vector float);
+
+int vec_any_numeric (vector float);
+
+int vec_any_out (vector float, vector float);
+@end smallexample
+
+@node Target Format Checks
+@section Format Checks Specific to Particular Target Machines
+
+For some target machines, GCC supports additional options to the
+format attribute
+(@pxref{Function Attributes,,Declaring Attributes of Functions}).
-vector signed int vec_all_ge (vector signed int, vector signed int);
-vector signed int vec_all_ge (vector float, vector float);
-
-vector signed int vec_all_gt (vector signed char, vector unsigned char);
-
-vector signed int vec_all_gt (vector unsigned char, vector signed char);
-
-vector signed int vec_all_gt (vector unsigned char,
- vector unsigned char);
-vector signed int vec_all_gt (vector signed char, vector signed char);
-vector signed int vec_all_gt (vector signed short,
- vector unsigned short);
-vector signed int vec_all_gt (vector unsigned short,
- vector signed short);
-vector signed int vec_all_gt (vector unsigned short,
- vector unsigned short);
-vector signed int vec_all_gt (vector signed short, vector signed short);
-
-vector signed int vec_all_gt (vector signed int, vector unsigned int);
-vector signed int vec_all_gt (vector unsigned int, vector signed int);
-vector signed int vec_all_gt (vector unsigned int, vector unsigned int);
-
-vector signed int vec_all_gt (vector signed int, vector signed int);
-vector signed int vec_all_gt (vector float, vector float);
-
-vector signed int vec_all_in (vector float, vector float);
-
-vector signed int vec_all_le (vector signed char, vector unsigned char);
-
-vector signed int vec_all_le (vector unsigned char, vector signed char);
-
-vector signed int vec_all_le (vector unsigned char,
- vector unsigned char);
-vector signed int vec_all_le (vector signed char, vector signed char);
-vector signed int vec_all_le (vector signed short,
- vector unsigned short);
-vector signed int vec_all_le (vector unsigned short,
- vector signed short);
-vector signed int vec_all_le (vector unsigned short,
- vector unsigned short);
-vector signed int vec_all_le (vector signed short, vector signed short);
-
-vector signed int vec_all_le (vector signed int, vector unsigned int);
-vector signed int vec_all_le (vector unsigned int, vector signed int);
-vector signed int vec_all_le (vector unsigned int, vector unsigned int);
-
-vector signed int vec_all_le (vector signed int, vector signed int);
-vector signed int vec_all_le (vector float, vector float);
-
-vector signed int vec_all_lt (vector signed char, vector unsigned char);
-
-vector signed int vec_all_lt (vector unsigned char, vector signed char);
-
-vector signed int vec_all_lt (vector unsigned char,
- vector unsigned char);
-vector signed int vec_all_lt (vector signed char, vector signed char);
-vector signed int vec_all_lt (vector signed short,
- vector unsigned short);
-vector signed int vec_all_lt (vector unsigned short,
- vector signed short);
-vector signed int vec_all_lt (vector unsigned short,
- vector unsigned short);
-vector signed int vec_all_lt (vector signed short, vector signed short);
-
-vector signed int vec_all_lt (vector signed int, vector unsigned int);
-vector signed int vec_all_lt (vector unsigned int, vector signed int);
-vector signed int vec_all_lt (vector unsigned int, vector unsigned int);
-
-vector signed int vec_all_lt (vector signed int, vector signed int);
-vector signed int vec_all_lt (vector float, vector float);
-
-vector signed int vec_all_nan (vector float);
-
-vector signed int vec_all_ne (vector signed char, vector unsigned char);
-
-vector signed int vec_all_ne (vector signed char, vector signed char);
-vector signed int vec_all_ne (vector unsigned char, vector signed char);
-
-vector signed int vec_all_ne (vector unsigned char,
- vector unsigned char);
-vector signed int vec_all_ne (vector signed short,
- vector unsigned short);
-vector signed int vec_all_ne (vector signed short, vector signed short);
-
-vector signed int vec_all_ne (vector unsigned short,
- vector signed short);
-vector signed int vec_all_ne (vector unsigned short,
- vector unsigned short);
-vector signed int vec_all_ne (vector signed int, vector unsigned int);
-vector signed int vec_all_ne (vector signed int, vector signed int);
-vector signed int vec_all_ne (vector unsigned int, vector signed int);
-vector signed int vec_all_ne (vector unsigned int, vector unsigned int);
-
-vector signed int vec_all_ne (vector float, vector float);
-
-vector signed int vec_all_nge (vector float, vector float);
-
-vector signed int vec_all_ngt (vector float, vector float);
-
-vector signed int vec_all_nle (vector float, vector float);
-
-vector signed int vec_all_nlt (vector float, vector float);
-
-vector signed int vec_all_numeric (vector float);
-
-vector signed int vec_any_eq (vector signed char, vector unsigned char);
-
-vector signed int vec_any_eq (vector signed char, vector signed char);
-vector signed int vec_any_eq (vector unsigned char, vector signed char);
-
-vector signed int vec_any_eq (vector unsigned char,
- vector unsigned char);
-vector signed int vec_any_eq (vector signed short,
- vector unsigned short);
-vector signed int vec_any_eq (vector signed short, vector signed short);
-
-vector signed int vec_any_eq (vector unsigned short,
- vector signed short);
-vector signed int vec_any_eq (vector unsigned short,
- vector unsigned short);
-vector signed int vec_any_eq (vector signed int, vector unsigned int);
-vector signed int vec_any_eq (vector signed int, vector signed int);
-vector signed int vec_any_eq (vector unsigned int, vector signed int);
-vector signed int vec_any_eq (vector unsigned int, vector unsigned int);
-
-vector signed int vec_any_eq (vector float, vector float);
-
-vector signed int vec_any_ge (vector signed char, vector unsigned char);
-
-vector signed int vec_any_ge (vector unsigned char, vector signed char);
-
-vector signed int vec_any_ge (vector unsigned char,
- vector unsigned char);
-vector signed int vec_any_ge (vector signed char, vector signed char);
-vector signed int vec_any_ge (vector signed short,
- vector unsigned short);
-vector signed int vec_any_ge (vector unsigned short,
- vector signed short);
-vector signed int vec_any_ge (vector unsigned short,
- vector unsigned short);
-vector signed int vec_any_ge (vector signed short, vector signed short);
-
-vector signed int vec_any_ge (vector signed int, vector unsigned int);
-vector signed int vec_any_ge (vector unsigned int, vector signed int);
-vector signed int vec_any_ge (vector unsigned int, vector unsigned int);
-
-vector signed int vec_any_ge (vector signed int, vector signed int);
-vector signed int vec_any_ge (vector float, vector float);
-
-vector signed int vec_any_gt (vector signed char, vector unsigned char);
-
-vector signed int vec_any_gt (vector unsigned char, vector signed char);
-
-vector signed int vec_any_gt (vector unsigned char,
- vector unsigned char);
-vector signed int vec_any_gt (vector signed char, vector signed char);
-vector signed int vec_any_gt (vector signed short,
- vector unsigned short);
-vector signed int vec_any_gt (vector unsigned short,
- vector signed short);
-vector signed int vec_any_gt (vector unsigned short,
- vector unsigned short);
-vector signed int vec_any_gt (vector signed short, vector signed short);
-
-vector signed int vec_any_gt (vector signed int, vector unsigned int);
-vector signed int vec_any_gt (vector unsigned int, vector signed int);
-vector signed int vec_any_gt (vector unsigned int, vector unsigned int);
-
-vector signed int vec_any_gt (vector signed int, vector signed int);
-vector signed int vec_any_gt (vector float, vector float);
-
-vector signed int vec_any_le (vector signed char, vector unsigned char);
-
-vector signed int vec_any_le (vector unsigned char, vector signed char);
-
-vector signed int vec_any_le (vector unsigned char,
- vector unsigned char);
-vector signed int vec_any_le (vector signed char, vector signed char);
-vector signed int vec_any_le (vector signed short,
- vector unsigned short);
-vector signed int vec_any_le (vector unsigned short,
- vector signed short);
-vector signed int vec_any_le (vector unsigned short,
- vector unsigned short);
-vector signed int vec_any_le (vector signed short, vector signed short);
-
-vector signed int vec_any_le (vector signed int, vector unsigned int);
-vector signed int vec_any_le (vector unsigned int, vector signed int);
-vector signed int vec_any_le (vector unsigned int, vector unsigned int);
-
-vector signed int vec_any_le (vector signed int, vector signed int);
-vector signed int vec_any_le (vector float, vector float);
-
-vector signed int vec_any_lt (vector signed char, vector unsigned char);
-
-vector signed int vec_any_lt (vector unsigned char, vector signed char);
-
-vector signed int vec_any_lt (vector unsigned char,
- vector unsigned char);
-vector signed int vec_any_lt (vector signed char, vector signed char);
-vector signed int vec_any_lt (vector signed short,
- vector unsigned short);
-vector signed int vec_any_lt (vector unsigned short,
- vector signed short);
-vector signed int vec_any_lt (vector unsigned short,
- vector unsigned short);
-vector signed int vec_any_lt (vector signed short, vector signed short);
-
-vector signed int vec_any_lt (vector signed int, vector unsigned int);
-vector signed int vec_any_lt (vector unsigned int, vector signed int);
-vector signed int vec_any_lt (vector unsigned int, vector unsigned int);
-
-vector signed int vec_any_lt (vector signed int, vector signed int);
-vector signed int vec_any_lt (vector float, vector float);
-
-vector signed int vec_any_nan (vector float);
-
-vector signed int vec_any_ne (vector signed char, vector unsigned char);
-
-vector signed int vec_any_ne (vector signed char, vector signed char);
-vector signed int vec_any_ne (vector unsigned char, vector signed char);
-
-vector signed int vec_any_ne (vector unsigned char,
- vector unsigned char);
-vector signed int vec_any_ne (vector signed short,
- vector unsigned short);
-vector signed int vec_any_ne (vector signed short, vector signed short);
-
-vector signed int vec_any_ne (vector unsigned short,
- vector signed short);
-vector signed int vec_any_ne (vector unsigned short,
- vector unsigned short);
-vector signed int vec_any_ne (vector signed int, vector unsigned int);
-vector signed int vec_any_ne (vector signed int, vector signed int);
-vector signed int vec_any_ne (vector unsigned int, vector signed int);
-vector signed int vec_any_ne (vector unsigned int, vector unsigned int);
-
-vector signed int vec_any_ne (vector float, vector float);
-
-vector signed int vec_any_nge (vector float, vector float);
-
-vector signed int vec_any_ngt (vector float, vector float);
-
-vector signed int vec_any_nle (vector float, vector float);
+@menu
+* Solaris Format Checks::
+@end menu
-vector signed int vec_any_nlt (vector float, vector float);
+@node Solaris Format Checks
+@subsection Solaris Format Checks
-vector signed int vec_any_numeric (vector float);
-
-vector signed int vec_any_out (vector float, vector float);
-@end smallexample
+Solaris targets support the @code{cmn_err} (or @code{__cmn_err__}) format
+check. @code{cmn_err} accepts a subset of the standard @code{printf}
+conversions, and the two-argument @code{%b} conversion for displaying
+bit-fields. See the Solaris man page for @code{cmn_err} for more information.
@node Pragmas
@section Pragmas Accepted by GCC
* ARM Pragmas::
* RS/6000 and PowerPC Pragmas::
* Darwin Pragmas::
+* Solaris Pragmas::
* Symbol-Renaming Pragmas::
+* Structure-Packing Pragmas::
@end menu
@node ARM Pragmas
anywhere within the variables' scopes.
@end table
+@node Solaris Pragmas
+@subsection Solaris Pragmas
+
+The Solaris target supports @code{#pragma redefine_extname}
+(@pxref{Symbol-Renaming Pragmas}). It also supports additional
+@code{#pragma} directives for compatibility with the system compiler.
+
+@table @code
+@item align @var{alignment} (@var{variable} [, @var{variable}]...)
+@cindex pragma, align
+
+Increase the minimum alignment of each @var{variable} to @var{alignment}.
+This is the same as GCC's @code{aligned} attribute @pxref{Variable
+Attributes}).
+
+@item fini (@var{function} [, @var{function}]...)
+@cindex pragma, fini
+
+This pragma causes each listed @var{function} to be called after
+main, or during shared module unloading, by adding a call to the
+@code{.fini} section.
+
+@item init (@var{function} [, @var{function}]...)
+@cindex pragma, init
+
+This pragma causes each listed @var{function} to be called during
+initialization (before @code{main}) or during shared module loading, by
+adding a call to the @code{.init} section.
+
+@end table
+
@node Symbol-Renaming Pragmas
@subsection Symbol-Renaming Pragmas
way of knowing that that happened.)
@end enumerate
+@node Structure-Packing Pragmas
+@subsection Structure-Packing Pragmas
+
+For compatibility with Win32, GCC supports as set of @code{#pragma}
+directives which change the maximum alignment of members of structures,
+unions, and classes subsequently defined. The @var{n} value below always
+is required to be a small power of two and specifies the new alignment
+in bytes.
+
+@enumerate
+@item @code{#pragma pack(@var{n})} simply sets the new alignment.
+@item @code{#pragma pack()} sets the alignment to the one that was in
+effect when compilation started (see also command line option
+@option{-fpack-struct[=<n>]} @pxref{Code Gen Options}).
+@item @code{#pragma pack(push[,@var{n}])} pushes the current alignment
+setting on an internal stack and then optionally sets the new alignment.
+@item @code{#pragma pack(pop)} restores the alignment setting to the one
+saved at the top of the internal stack (and removes that stack entry).
+Note that @code{#pragma pack([@var{n}])} does not influence this internal
+stack; thus it is possible to have @code{#pragma pack(push)} followed by
+multiple @code{#pragma pack(@var{n})} instances and finalized by a single
+@code{#pragma pack(pop)}.
+@end enumerate
+
@node Unnamed Fields
@section Unnamed struct/union fields within structs/unions.
@cindex struct
another way to control placement of these constructs.
@node C++ Interface
-@section Declarations and Definitions in One Header
+@section #pragma interface and implementation
@cindex interface and implementation headers, C++
@cindex C++ interface and implementation headers
-C++ object definitions can be quite complex. In principle, your source
-code will need two kinds of things for each object that you use across
-more than one source file. First, you need an @dfn{interface}
-specification, describing its structure with type declarations and
-function prototypes. Second, you need the @dfn{implementation} itself.
-It can be tedious to maintain a separate interface description in a
-header file, in parallel to the actual implementation. It is also
-dangerous, since separate interface and implementation definitions may
-not remain parallel.
-
@cindex pragmas, interface and implementation
-With GNU C++, you can use a single header file for both purposes.
-@quotation
-@emph{Warning:} The mechanism to specify this is in transition. For the
-nonce, you must use one of two @code{#pragma} commands; in a future
-release of GNU C++, an alternative mechanism will make these
-@code{#pragma} commands unnecessary.
-@end quotation
+@code{#pragma interface} and @code{#pragma implementation} provide the
+user with a way of explicitly directing the compiler to emit entities
+with vague linkage (and debugging information) in a particular
+translation unit.
-The header file contains the full definitions, but is marked with
-@samp{#pragma interface} in the source code. This allows the compiler
-to use the header file only as an interface specification when ordinary
-source files incorporate it with @code{#include}. In the single source
-file where the full implementation belongs, you can use either a naming
-convention or @samp{#pragma implementation} to indicate this alternate
-use of the header file.
+@emph{Note:} As of GCC 2.7.2, these @code{#pragma}s are not useful in
+most cases, because of COMDAT support and the ``key method'' heuristic
+mentioned in @ref{Vague Linkage}. Using them can actually cause your
+program to grow due to unnecesary out-of-line copies of inline
+functions. Currently (3.4) the only benefit of these
+@code{#pragma}s is reduced duplication of debugging information, and
+that should be addressed soon on DWARF 2 targets with the use of
+COMDAT groups.
@table @code
@item #pragma interface
implementation}. This was deemed to be more trouble than it was worth,
however, and disabled.
-If you use an explicit @samp{#pragma implementation}, it must appear in
-your source file @emph{before} you include the affected header files.
-
Use the string argument if you want a single implementation file to
include code from multiple header files. (You must also use
@samp{#include} to include the header file; @samp{#pragma
effect on function inlining.
If you define a class in a header file marked with @samp{#pragma
-interface}, the effect on a function defined in that class is similar to
-an explicit @code{extern} declaration---the compiler emits no code at
-all to define an independent version of the function. Its definition
-is used only for inlining with its callers.
+interface}, the effect on an inline function defined in that class is
+similar to an explicit @code{extern} declaration---the compiler emits
+no code at all to define an independent version of the function. Its
+definition is used only for inlining with its callers.
@opindex fno-implement-inlines
Conversely, when you include the same header file in a main source file
system. Somehow the compiler and linker have to make sure that each
template instance occurs exactly once in the executable if it is needed,
and not at all otherwise. There are two basic approaches to this
-problem, which I will refer to as the Borland model and the Cfront model.
+problem, which are referred to as the Borland model and the Cfront model.
@table @asis
@item Borland model
each translation unit will contain instances of each of the templates it
uses. In a large program, this can lead to an unacceptable amount of code
duplication.
-
-@xref{C++ Interface,,Declarations and Definitions in One Header}, for
-more discussion of these pragmas.
@end enumerate
@node Bound member functions
projects / platform / upstream / gcc.git / blobdiff