This is
/es/build/frv-050408/1/frv550-uclinux/X-tools-build/gcc/doc/gcc.info,
produced by makeinfo version 4.0 from
/es/build/frv-050408/1/frv550-uclinux/sources/tools-src/gcc/doc/gcc.texi.

START-INFO-DIR-ENTRY
* usegcc: (usegcc).			Using the GNU C compiler.
END-INFO-DIR-ENTRY

Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.

   Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.2 or
any later version published by the Free Software Foundation; with the
Invariant Sections being "GNU General Public License" and "Funding Free
Software", the Front-Cover texts being (a) (see below), and with the
Back-Cover Texts being (b) (see below).  A copy of the license is
included in the section entitled "GNU Free Documentation License".

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

   A GNU Manual

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

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

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

File: gcc.info,  Node: Other Builtins,  Next: Redefining Typedefs,  Prev: Vector Extensions,  Up: C Extensions

Other built-in functions provided by GCC
========================================

   GCC provides a large number of built-in functions other than the ones
mentioned above.  Some of these are for internal use in the processing
of exceptions or variable-length argument lists and will not be
documented here because they may change from time to time; we do not
recommend general use of these functions.

   The remaining functions are provided for optimization purposes.

   GCC includes built-in versions of many of the functions in the
standard C library.  The versions prefixed with `__builtin_' will
always be treated as having the same meaning as the C library function
even if you specify the `-fno-builtin' option. (*note C Dialect
Options::) Many of these functions are only optimized in certain cases;
if they are not optimized in a particular case, a call to the library
function will be emitted.

   Outside strict ISO C mode (`-ansi', `-std=c89' or `-std=c99'), the
functions `_exit', `alloca', `bcmp', `bzero', `dcgettext', `dgettext',
`dremf', `dreml', `drem', `exp10f', `exp10l', `exp10', `ffsll', `ffsl',
`ffs', `fprintf_unlocked', `fputs_unlocked', `gammaf', `gammal',
`gamma', `gettext', `index', `j0f', `j0l', `j0', `j1f', `j1l', `j1',
`jnf', `jnl', `jn', `mempcpy', `pow10f', `pow10l', `pow10',
`printf_unlocked', `rindex', `scalbf', `scalbl', `scalb',
`significandf', `significandl', `significand', `sincosf', `sincosl',
`sincos', `stpcpy', `strdup', `strfmon', `y0f', `y0l', `y0', `y1f',
`y1l', `y1', `ynf', `ynl' and `yn' may be handled as built-in functions.
All these functions have corresponding versions prefixed with
`__builtin_', which may be used even in strict C89 mode.

   The ISO C99 functions `_Exit', `acoshf', `acoshl', `acosh', `asinhf',
`asinhl', `asinh', `atanhf', `atanhl', `atanh', `cabsf', `cabsl',
`cabs', `cacosf', `cacoshf', `cacoshl', `cacosh', `cacosl', `cacos',
`cargf', `cargl', `carg', `casinf', `casinhf', `casinhl', `casinh',
`casinl', `casin', `catanf', `catanhf', `catanhl', `catanh', `catanl',
`catan', `cbrtf', `cbrtl', `cbrt', `ccosf', `ccoshf', `ccoshl',
`ccosh', `ccosl', `ccos', `cexpf', `cexpl', `cexp', `cimagf', `cimagl',
`cimag', `conjf', `conjl', `conj', `copysignf', `copysignl',
`copysign', `cpowf', `cpowl', `cpow', `cprojf', `cprojl', `cproj',
`crealf', `creall', `creal', `csinf', `csinhf', `csinhl', `csinh',
`csinl', `csin', `csqrtf', `csqrtl', `csqrt', `ctanf', `ctanhf',
`ctanhl', `ctanh', `ctanl', `ctan', `erfcf', `erfcl', `erfc', `erff',
`erfl', `erf', `exp2f', `exp2l', `exp2', `expm1f', `expm1l', `expm1',
`fdimf', `fdiml', `fdim', `fmaf', `fmal', `fmaxf', `fmaxl', `fmax',
`fma', `fminf', `fminl', `fmin', `hypotf', `hypotl', `hypot', `ilogbf',
`ilogbl', `ilogb', `imaxabs', `lgammaf', `lgammal', `lgamma', `llabs',
`llrintf', `llrintl', `llrint', `llroundf', `llroundl', `llround',
`log1pf', `log1pl', `log1p', `log2f', `log2l', `log2', `logbf', `logbl',
`logb', `lrintf', `lrintl', `lrint', `lroundf', `lroundl', `lround',
`nearbyintf', `nearbyintl', `nearbyint', `nextafterf', `nextafterl',
`nextafter', `nexttowardf', `nexttowardl', `nexttoward', `remainderf',
`remainderl', `remainder', `remquof', `remquol', `remquo', `rintf',
`rintl', `rint', `roundf', `roundl', `round', `scalblnf', `scalblnl',
`scalbln', `scalbnf', `scalbnl', `scalbn', `snprintf', `tgammaf',
`tgammal', `tgamma', `truncf', `truncl', `trunc', `vfscanf', `vscanf',
`vsnprintf' and `vsscanf' are handled as built-in functions except in
strict ISO C90 mode (`-ansi' or `-std=c89').

   There are also built-in versions of the ISO C99 functions `acosf',
`acosl', `asinf', `asinl', `atan2f', `atan2l', `atanf', `atanl',
`ceilf', `ceill', `cosf', `coshf', `coshl', `cosl', `expf', `expl',
`fabsf', `fabsl', `floorf', `floorl', `fmodf', `fmodl', `frexpf',
`frexpl', `ldexpf', `ldexpl', `log10f', `log10l', `logf', `logl',
`modfl', `modf', `powf', `powl', `sinf', `sinhf', `sinhl', `sinl',
`sqrtf', `sqrtl', `tanf', `tanhf', `tanhl' and `tanl' that are
recognized in any mode since ISO C90 reserves these names for the
purpose to which ISO C99 puts them.  All these functions have
corresponding versions prefixed with `__builtin_'.

   The ISO C90 functions `abort', `abs', `acos', `asin', `atan2',
`atan', `calloc', `ceil', `cosh', `cos', `exit', `exp', `fabs',
`floor', `fmod', `fprintf', `fputs', `frexp', `fscanf', `labs',
`ldexp', `log10', `log', `malloc', `memcmp', `memcpy', `memset',
`modf', `pow', `printf', `putchar', `puts', `scanf', `sinh', `sin',
`snprintf', `sprintf', `sqrt', `sscanf', `strcat', `strchr', `strcmp',
`strcpy', `strcspn', `strlen', `strncat', `strncmp', `strncpy',
`strpbrk', `strrchr', `strspn', `strstr', `tanh', `tan', `vfprintf',
`vprintf' and `vsprintf' are all recognized as built-in functions unless
`-fno-builtin' is specified (or `-fno-builtin-FUNCTION' is specified
for an individual function).  All of these functions have corresponding
versions prefixed with `__builtin_'.

   GCC provides built-in versions of the ISO C99 floating point
comparison macros that avoid raising exceptions for unordered operands.
They have the same names as the standard macros ( `isgreater',
`isgreaterequal', `isless', `islessequal', `islessgreater', and
`isunordered') , with `__builtin_' prefixed.  We intend for a library
implementor to be able to simply `#define' each standard macro to its
built-in equivalent.

 - Built-in Function: int __builtin_types_compatible_p (TYPE1, TYPE2)
     You can use the built-in function `__builtin_types_compatible_p' to
     determine whether two types are the same.

     This built-in function returns 1 if the unqualified versions of the
     types TYPE1 and TYPE2 (which are types, not expressions) are
     compatible, 0 otherwise.  The result of this built-in function can
     be used in integer constant expressions.

     This built-in function ignores top level qualifiers (e.g., `const',
     `volatile').  For example, `int' is equivalent to `const int'.

     The type `int[]' and `int[5]' are compatible.  On the other hand,
     `int' and `char *' are not compatible, even if the size of their
     types, on the particular architecture are the same.  Also, the
     amount of pointer indirection is taken into account when
     determining similarity.  Consequently, `short *' is not similar to
     `short **'.  Furthermore, two types that are typedefed are
     considered compatible if their underlying types are compatible.

     An `enum' type is considered to be compatible with another `enum'
     type.  For example, `enum {foo, bar}' is similar to `enum {hot,
     dog}'.

     You would typically use this function in code whose execution
     varies depending on the arguments' types.  For example:

          #define foo(x)                                                  \
            ({                                                           \
              typeof (x) tmp;                                             \
              if (__builtin_types_compatible_p (typeof (x), long double)) \
                tmp = foo_long_double (tmp);                              \
              else if (__builtin_types_compatible_p (typeof (x), double)) \
                tmp = foo_double (tmp);                                   \
              else if (__builtin_types_compatible_p (typeof (x), float))  \
                tmp = foo_float (tmp);                                    \
              else                                                        \
                abort ();                                                 \
              tmp;                                                        \
            })

     _Note:_ This construct is only available for C.


 - Built-in Function: TYPE __builtin_choose_expr (CONST_EXP, EXP1, EXP2)
     You can use the built-in function `__builtin_choose_expr' to
     evaluate code depending on the value of a constant expression.
     This built-in function returns EXP1 if CONST_EXP, which is a
     constant expression that must be able to be determined at compile
     time, is nonzero.  Otherwise it returns 0.

     This built-in function is analogous to the `? :' operator in C,
     except that the expression returned has its type unaltered by
     promotion rules.  Also, the built-in function does not evaluate
     the expression that was not chosen.  For example, if CONST_EXP
     evaluates to true, EXP2 is not evaluated even if it has
     side-effects.

     This built-in function can return an lvalue if the chosen argument
     is an lvalue.

     If EXP1 is returned, the return type is the same as EXP1's type.
     Similarly, if EXP2 is returned, its return type is the same as
     EXP2.

     Example:

          #define foo(x)                                                    \
            __builtin_choose_expr (                                         \
              __builtin_types_compatible_p (typeof (x), double),            \
              foo_double (x),                                               \
              __builtin_choose_expr (                                       \
                __builtin_types_compatible_p (typeof (x), float),           \
                foo_float (x),                                              \
                /* The void expression results in a compile-time error  \
                   when assigning the result to something.  */          \
                (void)0))

     _Note:_ This construct is only available for C.  Furthermore, the
     unused expression (EXP1 or EXP2 depending on the value of
     CONST_EXP) may still generate syntax errors.  This may change in
     future revisions.


 - Built-in Function: int __builtin_constant_p (EXP)
     You can use the built-in function `__builtin_constant_p' to
     determine if a value is known to be constant at compile-time and
     hence that GCC can perform constant-folding on expressions
     involving that value.  The argument of the function is the value
     to test.  The function returns the integer 1 if the argument is
     known to be a compile-time constant and 0 if it is not known to be
     a compile-time constant.  A return of 0 does not indicate that the
     value is _not_ a constant, but merely that GCC cannot prove it is
     a constant with the specified value of the `-O' option.

     You would typically use this function in an embedded application
     where memory was a critical resource.  If you have some complex
     calculation, you may want it to be folded if it involves
     constants, but need to call a function if it does not.  For
     example:

          #define Scale_Value(X)      \
            (__builtin_constant_p (X) \
            ? ((X) * SCALE + OFFSET) : Scale (X))

     You may use this built-in function in either a macro or an inline
     function.  However, if you use it in an inlined function and pass
     an argument of the function as the argument to the built-in, GCC
     will never return 1 when you call the inline function with a
     string constant or compound literal (*note Compound Literals::)
     and will not return 1 when you pass a constant numeric value to
     the inline function unless you specify the `-O' option.

     You may also use `__builtin_constant_p' in initializers for static
     data.  For instance, you can write

          static const int table[] = {
             __builtin_constant_p (EXPRESSION) ? (EXPRESSION) : -1,
             /* ... */
          };

     This is an acceptable initializer even if EXPRESSION is not a
     constant expression.  GCC must be more conservative about
     evaluating the built-in in this case, because it has no
     opportunity to perform optimization.

     Previous versions of GCC did not accept this built-in in data
     initializers.  The earliest version where it is completely safe is
     3.0.1.

 - Built-in Function: long __builtin_expect (long EXP, long C)
     You may use `__builtin_expect' to provide the compiler with branch
     prediction information.  In general, you should prefer to use
     actual profile feedback for this (`-fprofile-arcs'), as
     programmers are notoriously bad at predicting how their programs
     actually perform.  However, there are applications in which this
     data is hard to collect.

     The return value is the value of EXP, which should be an integral
     expression.  The value of C must be a compile-time constant.  The
     semantics of the built-in are that it is expected that EXP == C.
     For example:

          if (__builtin_expect (x, 0))
            foo ();

     would indicate that we do not expect to call `foo', since we
     expect `x' to be zero.  Since you are limited to integral
     expressions for EXP, you should use constructions such as

          if (__builtin_expect (ptr != NULL, 1))
            error ();

     when testing pointer or floating-point values.

 - Built-in Function: void __builtin_prefetch (const void *ADDR, ...)
     This function is used to minimize cache-miss latency by moving
     data into a cache before it is accessed.  You can insert calls to
     `__builtin_prefetch' into code for which you know addresses of
     data in memory that is likely to be accessed soon.  If the target
     supports them, data prefetch instructions will be generated.  If
     the prefetch is done early enough before the access then the data
     will be in the cache by the time it is accessed.

     The value of ADDR is the address of the memory to prefetch.  There
     are two optional arguments, RW and LOCALITY.  The value of RW is a
     compile-time constant one or zero; one means that the prefetch is
     preparing for a write to the memory address and zero, the default,
     means that the prefetch is preparing for a read.  The value
     LOCALITY must be a compile-time constant integer between zero and
     three.  A value of zero means that the data has no temporal
     locality, so it need not be left in the cache after the access.  A
     value of three means that the data has a high degree of temporal
     locality and should be left in all levels of cache possible.
     Values of one and two mean, respectively, a low or moderate degree
     of temporal locality.  The default is three.

          for (i = 0; i < n; i++)
            {
              a[i] = a[i] + b[i];
              __builtin_prefetch (&a[i+j], 1, 1);
              __builtin_prefetch (&b[i+j], 0, 1);
              /* ... */
            }

     Data prefetch does not generate faults if ADDR is invalid, but the
     address expression itself must be valid.  For example, a prefetch
     of `p->next' will not fault if `p->next' is not a valid address,
     but evaluation will fault if `p' is not a valid address.

     If the target does not support data prefetch, the address
     expression is evaluated if it includes side effects but no other
     code is generated and GCC does not issue a warning.

 - Built-in Function: double __builtin_huge_val (void)
     Returns a positive infinity, if supported by the floating-point
     format, else `DBL_MAX'.  This function is suitable for
     implementing the ISO C macro `HUGE_VAL'.

 - Built-in Function: float __builtin_huge_valf (void)
     Similar to `__builtin_huge_val', except the return type is `float'.

 - Built-in Function: long double __builtin_huge_vall (void)
     Similar to `__builtin_huge_val', except the return type is `long
     double'.

 - Built-in Function: double __builtin_inf (void)
     Similar to `__builtin_huge_val', except a warning is generated if
     the target floating-point format does not support infinities.
     This function is suitable for implementing the ISO C99 macro
     `INFINITY'.

 - Built-in Function: float __builtin_inff (void)
     Similar to `__builtin_inf', except the return type is `float'.

 - Built-in Function: long double __builtin_infl (void)
     Similar to `__builtin_inf', except the return type is `long
     double'.

 - Built-in Function: double __builtin_nan (const char *str)
     This is an implementation of the ISO C99 function `nan'.

     Since ISO C99 defines this function in terms of `strtod', which we
     do not implement, a description of the parsing is in order.  The
     string is parsed as by `strtol'; that is, the base is recognized by
     leading `0' or `0x' prefixes.  The number parsed is placed in the
     significand such that the least significant bit of the number is
     at the least significant bit of the significand.  The number is
     truncated to fit the significand field provided.  The significand
     is forced to be a quiet NaN.

     This function, if given a string literal, is evaluated early enough
     that it is considered a compile-time constant.

 - Built-in Function: float __builtin_nanf (const char *str)
     Similar to `__builtin_nan', except the return type is `float'.

 - Built-in Function: long double __builtin_nanl (const char *str)
     Similar to `__builtin_nan', except the return type is `long
     double'.

 - Built-in Function: double __builtin_nans (const char *str)
     Similar to `__builtin_nan', except the significand is forced to be
     a signaling NaN.  The `nans' function is proposed by WG14 N965.

 - Built-in Function: float __builtin_nansf (const char *str)
     Similar to `__builtin_nans', except the return type is `float'.

 - Built-in Function: long double __builtin_nansl (const char *str)
     Similar to `__builtin_nans', except the return type is `long
     double'.

 - Built-in Function: int __builtin_ffs (unsigned int x)
     Returns one plus the index of the least significant 1-bit of X, or
     if X is zero, returns zero.

 - Built-in Function: int __builtin_clz (unsigned int x)
     Returns the number of leading 0-bits in X, starting at the most
     significant bit position.  If X is 0, the result is undefined.

 - Built-in Function: int __builtin_ctz (unsigned int x)
     Returns the number of trailing 0-bits in X, starting at the least
     significant bit position.  If X is 0, the result is undefined.

 - Built-in Function: int __builtin_popcount (unsigned int x)
     Returns the number of 1-bits in X.

 - Built-in Function: int __builtin_parity (unsigned int x)
     Returns the parity of X, i.e. the number of 1-bits in X modulo 2.

 - Built-in Function: int __builtin_ffsl (unsigned long)
     Similar to `__builtin_ffs', except the argument type is `unsigned
     long'.

 - Built-in Function: int __builtin_clzl (unsigned long)
     Similar to `__builtin_clz', except the argument type is `unsigned
     long'.

 - Built-in Function: int __builtin_ctzl (unsigned long)
     Similar to `__builtin_ctz', except the argument type is `unsigned
     long'.

 - Built-in Function: int __builtin_popcountl (unsigned long)
     Similar to `__builtin_popcount', except the argument type is
     `unsigned long'.

 - Built-in Function: int __builtin_parityl (unsigned long)
     Similar to `__builtin_parity', except the argument type is
     `unsigned long'.

 - Built-in Function: int __builtin_ffsll (unsigned long long)
     Similar to `__builtin_ffs', except the argument type is `unsigned
     long long'.

 - Built-in Function: int __builtin_clzll (unsigned long long)
     Similar to `__builtin_clz', except the argument type is `unsigned
     long long'.

 - Built-in Function: int __builtin_ctzll (unsigned long long)
     Similar to `__builtin_ctz', except the argument type is `unsigned
     long long'.

 - Built-in Function: int __builtin_popcountll (unsigned long long)
     Similar to `__builtin_popcount', except the argument type is
     `unsigned long long'.

 - Built-in Function: int __builtin_parityll (unsigned long long)
     Similar to `__builtin_parity', except the argument type is
     `unsigned long long'.


File: gcc.info,  Node: Redefining Typedefs,  Next: Target Builtins,  Prev: Other Builtins,  Up: C Extensions

Redefining typedef names
========================

   GCC allows you to redefine a typedef name, as long as the previous
type and the new type are the same.  ISO C does not allow typedefs to
be redefined.


File: gcc.info,  Node: Target Builtins,  Next: Pragmas,  Prev: Redefining Typedefs,  Up: C Extensions

Built-in Functions Specific to Particular Target Machines
=========================================================

   On some target machines, GCC supports many built-in functions
specific to those machines.  Generally these generate calls to specific
machine instructions, but allow the compiler to schedule those calls.

* Menu:

* Alpha Built-in Functions::
* ARM Built-in Functions::
* X86 Built-in Functions::
* PowerPC AltiVec Built-in Functions::


File: gcc.info,  Node: Alpha Built-in Functions,  Next: ARM Built-in Functions,  Up: Target Builtins

Alpha Built-in Functions
------------------------

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

   The following built-in functions are always available.  They all
generate the machine instruction that is part of the name.

     long __builtin_alpha_implver (void)
     long __builtin_alpha_rpcc (void)
     long __builtin_alpha_amask (long)
     long __builtin_alpha_cmpbge (long, long)
     long __builtin_alpha_extbl (long, long)
     long __builtin_alpha_extwl (long, long)
     long __builtin_alpha_extll (long, long)
     long __builtin_alpha_extql (long, long)
     long __builtin_alpha_extwh (long, long)
     long __builtin_alpha_extlh (long, long)
     long __builtin_alpha_extqh (long, long)
     long __builtin_alpha_insbl (long, long)
     long __builtin_alpha_inswl (long, long)
     long __builtin_alpha_insll (long, long)
     long __builtin_alpha_insql (long, long)
     long __builtin_alpha_inswh (long, long)
     long __builtin_alpha_inslh (long, long)
     long __builtin_alpha_insqh (long, long)
     long __builtin_alpha_mskbl (long, long)
     long __builtin_alpha_mskwl (long, long)
     long __builtin_alpha_mskll (long, long)
     long __builtin_alpha_mskql (long, long)
     long __builtin_alpha_mskwh (long, long)
     long __builtin_alpha_msklh (long, long)
     long __builtin_alpha_mskqh (long, long)
     long __builtin_alpha_umulh (long, long)
     long __builtin_alpha_zap (long, long)
     long __builtin_alpha_zapnot (long, long)

   The following built-in functions are always with `-mmax' or
`-mcpu=CPU' where CPU is `pca56' or later.  They all generate the
machine instruction that is part of the name.

     long __builtin_alpha_pklb (long)
     long __builtin_alpha_pkwb (long)
     long __builtin_alpha_unpkbl (long)
     long __builtin_alpha_unpkbw (long)
     long __builtin_alpha_minub8 (long, long)
     long __builtin_alpha_minsb8 (long, long)
     long __builtin_alpha_minuw4 (long, long)
     long __builtin_alpha_minsw4 (long, long)
     long __builtin_alpha_maxub8 (long, long)
     long __builtin_alpha_maxsb8 (long, long)
     long __builtin_alpha_maxuw4 (long, long)
     long __builtin_alpha_maxsw4 (long, long)
     long __builtin_alpha_perr (long, long)

   The following built-in functions are always with `-mcix' or
`-mcpu=CPU' where CPU is `ev67' or later.  They all generate the
machine instruction that is part of the name.

     long __builtin_alpha_cttz (long)
     long __builtin_alpha_ctlz (long)
     long __builtin_alpha_ctpop (long)

   The following builtins are available on systems that use the OSF/1
PALcode.  Normally they invoke the `rduniq' and `wruniq' PAL calls, but
when invoked with `-mtls-kernel', they invoke `rdval' and `wrval'.

     void *__builtin_thread_pointer (void)
     void __builtin_set_thread_pointer (void *)


File: gcc.info,  Node: ARM Built-in Functions,  Next: X86 Built-in Functions,  Prev: Alpha Built-in Functions,  Up: Target Builtins

ARM Built-in Functions
----------------------

   These built-in functions are available for the ARM family of
processors, when the `-mcpu=iwmmxt' switch is used:

     typedef int __v2si __attribute__ ((__mode__ (__V2SI__)))
     
     v2si __builtin_arm_waddw (v2si, v2si)
     v2si __builtin_arm_waddw (v2si, v2si)
     v2si __builtin_arm_wsubw (v2si, v2si)
     v2si __builtin_arm_wsubw (v2si, v2si)
     v2si __builtin_arm_waddwss (v2si, v2si)
     v2si __builtin_arm_wsubwss (v2si, v2si)
     v2si __builtin_arm_wsubwss (v2si, v2si)
     v2si __builtin_arm_wsubwss (v2si, v2si)
     v2si __builtin_arm_wsubwss (v2si, v2si)
     v2si __builtin_arm_waddwus (v2si, v2si)
     v2si __builtin_arm_wsubwus (v2si, v2si)
     v2si __builtin_arm_wsubwus (v2si, v2si)
     v2si __builtin_arm_wmaxuw (v2si, v2si)
     v2si __builtin_arm_wmaxsw (v2si, v2si)
     v2si __builtin_arm_wavg2br (v2si, v2si)
     v2si __builtin_arm_wavg2hr (v2si, v2si)
     v2si __builtin_arm_wavg2b (v2si, v2si)
     v2si __builtin_arm_wavg2h (v2si, v2si)
     v2si __builtin_arm_waccb (v2si)
     v2si __builtin_arm_wacch (v2si)
     v2si __builtin_arm_waccw (v2si)
     v2si __builtin_arm_wmacs (v2si, v2si, v2si)
     v2si __builtin_arm_wmacsz (v2si, v2si, v2si)
     v2si __builtin_arm_wmacu (v2si, v2si, v2si)
     v2si __builtin_arm_wmacuz (v2si, v2si)
     v2si __builtin_arm_wsadb (v2si, v2si)
     v2si __builtin_arm_wsadbz (v2si, v2si)
     v2si __builtin_arm_wsadh (v2si, v2si)
     v2si __builtin_arm_wsadhz (v2si, v2si)
     v2si __builtin_arm_walign (v2si, v2si)
     v2si __builtin_arm_tmia (v2si, int, int)
     v2si __builtin_arm_tmiaph (v2si, int, int)
     v2si __builtin_arm_tmiabb (v2si, int, int)
     v2si __builtin_arm_tmiabt (v2si, int, int)
     v2si __builtin_arm_tmiatb (v2si, int, int)
     v2si __builtin_arm_tmiatt (v2si, int, int)
     int  __builtin_arm_tmovmskb (v2si)
     int  __builtin_arm_tmovmskh (v2si)
     int  __builtin_arm_tmovmskw (v2si)
     v2si __builtin_arm_wmadds (v2si, v2si)
     v2si __builtin_arm_wmaddu (v2si, v2si)
     v2si __builtin_arm_wpackhss (v2si, v2si)
     v2si __builtin_arm_wpackwss (v2si, v2si)
     v2si __builtin_arm_wpackdss (v2si, v2si)
     v2si __builtin_arm_wpackhus (v2si, v2si)
     v2si __builtin_arm_wpackwus (v2si, v2si)
     v2si __builtin_arm_wpackdus (v2si, v2si)
     v2si __builtin_arm_waddb (v2si, v2si)
     v2si __builtin_arm_waddh (v2si, v2si)
     v2si __builtin_arm_waddw (v2si, v2si)
     v2si __builtin_arm_waddbss (v2si, v2si)
     v2si __builtin_arm_waddhss (v2si, v2si)
     v2si __builtin_arm_waddwss (v2si, v2si)
     v2si __builtin_arm_waddbus (v2si, v2si)
     v2si __builtin_arm_waddhus (v2si, v2si)
     v2si __builtin_arm_waddwus (v2si, v2si)
     v2si __builtin_arm_wsubb (v2si, v2si)
     v2si __builtin_arm_wsubh (v2si, v2si)
     v2si __builtin_arm_wsubw (v2si, v2si)
     v2si __builtin_arm_wsubbss (v2si, v2si)
     v2si __builtin_arm_wsubhss (v2si, v2si)
     v2si __builtin_arm_wsubwss (v2si, v2si)
     v2si __builtin_arm_wsubbus (v2si, v2si)
     v2si __builtin_arm_wsubhus (v2si, v2si)
     v2si __builtin_arm_wsubwus (v2si, v2si)
     v2si __builtin_arm_wand (v2si, v2si)
     v2si __builtin_arm_wandn (v2si, v2si)
     v2si __builtin_arm_wor (v2si, v2si)
     v2si __builtin_arm_wxor (v2si, v2si)
     v2si __builtin_arm_wcmpeqb (v2si, v2si)
     v2si __builtin_arm_wcmpeqh (v2si, v2si)
     v2si __builtin_arm_wcmpeqw (v2si, v2si)
     v2si __builtin_arm_wcmpgtub (v2si, v2si)
     v2si __builtin_arm_wcmpgtuh (v2si, v2si)
     v2si __builtin_arm_wcmpgtuw (v2si, v2si)
     v2si __builtin_arm_wcmpgtsb (v2si, v2si)
     v2si __builtin_arm_wcmpgtsh (v2si, v2si)
     v2si __builtin_arm_wcmpgtsw (v2si, v2si)
     int  __builtin_arm_textrmsb (v2si, int)
     int  __builtin_arm_textrmsh (v2si, int)
     int  __builtin_arm_textrmsw (v2si, int)
     int  __builtin_arm_textrmub (v2si, int)
     int  __builtin_arm_textrmuh (v2si, int)
     int  __builtin_arm_textrmuw (v2si, int)
     v2si __builtin_arm_tinsrb (v2si, int, int)
     v2si __builtin_arm_tinsrh (v2si, int, int)
     v2si __builtin_arm_tinsrw (v2si, int, int)
     v2si __builtin_arm_wmaxsw (v2si, v2si)
     v2si __builtin_arm_wmaxsh (v2si, v2si)
     v2si __builtin_arm_wmaxsb (v2si, v2si)
     v2si __builtin_arm_wmaxuw (v2si, v2si)
     v2si __builtin_arm_wmaxuh (v2si, v2si)
     v2si __builtin_arm_wmaxub (v2si, v2si)
     v2si __builtin_arm_wminsw (v2si, v2si)
     v2si __builtin_arm_wminsh (v2si, v2si)
     v2si __builtin_arm_wminsb (v2si, v2si)
     v2si __builtin_arm_wminuw (v2si, v2si)
     v2si __builtin_arm_wminuh (v2si, v2si)
     v2si __builtin_arm_wminub (v2si, v2si)
     v2si __builtin_arm_wmuluh (v2si, v2si)
     v2si __builtin_arm_wmulsh (v2si, v2si)
     v2si __builtin_arm_wmulul (v2si, v2si)
     v2si __builtin_arm_wshufh (v2si, int)
     v2si __builtin_arm_wsllh (v2si, v2si)
     v2si __builtin_arm_wsllw (v2si, v2si)
     v2si __builtin_arm_wslld (v2si, v2si)
     v2si __builtin_arm_wsrah (v2si, v2si)
     v2si __builtin_arm_wsraw (v2si, v2si)
     v2si __builtin_arm_wsrad (v2si, v2si)
     v2si __builtin_arm_wsrlh (v2si, v2si)
     v2si __builtin_arm_wsrlw (v2si, v2si)
     v2si __builtin_arm_wsrld (v2si, v2si)
     v2si __builtin_arm_wrorh (v2si, v2si)
     v2si __builtin_arm_wrorw (v2si, v2si)
     v2si __builtin_arm_wrord (v2si, v2si)
     v2si __builtin_arm_wsllhi (v2si, int)
     v2si __builtin_arm_wsllwi (v2si, int)
     v2si __builtin_arm_wslldi (v2si, v2si)
     v2si __builtin_arm_wsrahi (v2si, int)
     v2si __builtin_arm_wsrawi (v2si, int)
     v2si __builtin_arm_wsradi (v2si, v2si)
     v2si __builtin_arm_wsrlwi (v2si, int)
     v2si __builtin_arm_wsrldi (v2si, int)
     v2si __builtin_arm_wrorhi (v2si, int)
     v2si __builtin_arm_wrorwi (v2si, int)
     v2si __builtin_arm_wrordi (v2si, int)
     v2si __builtin_arm_wunpckihb (v2si, v2si)
     v2si __builtin_arm_wunpckihh (v2si, v2si)
     v2si __builtin_arm_wunpckihw (v2si, v2si)
     v2si __builtin_arm_wunpckilb (v2si, v2si)
     v2si __builtin_arm_wunpckilh (v2si, v2si)
     v2si __builtin_arm_wunpckilw (v2si, v2si)
     v2si __builtin_arm_wunpckehsb (v2si)
     v2si __builtin_arm_wunpckehsh (v2si)
     v2si __builtin_arm_wunpckehsw (v2si)
     v2si __builtin_arm_wunpckehub (v2si)
     v2si __builtin_arm_wunpckehuh (v2si)
     v2si __builtin_arm_wunpckehuw (v2si)
     v2si __builtin_arm_wunpckelsb (v2si)
     v2si __builtin_arm_wunpckelsh (v2si)
     v2si __builtin_arm_wunpckelsw (v2si)
     v2si __builtin_arm_wunpckelub (v2si)
     v2si __builtin_arm_wunpckeluh (v2si)
     v2si __builtin_arm_wunpckeluw (v2si)
     v2si __builtin_arm_wsubwss (v2si, v2si)
     v2si __builtin_arm_wsraw (v2si, v2si)
     v2si __builtin_arm_wsrad (v2si, v2si)


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

X86 Built-in Functions
----------------------

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

   The following machine modes are available for use with MMX built-in
functions (*note Vector Extensions::): `V2SI' for a vector of two
32-bit integers, `V4HI' for a vector of four 16-bit integers, and
`V8QI' for a vector of eight 8-bit integers.  Some of the built-in
functions operate on MMX registers as a whole 64-bit entity, these use
`DI' as their mode.

   If 3Dnow extensions are enabled, `V2SF' is used as a mode for a
vector of two 32-bit floating point values.

   If SSE extensions are enabled, `V4SF' is used for a vector of four
32-bit floating point values.  Some instructions use a vector of four
32-bit integers, these use `V4SI'.  Finally, some instructions operate
on an entire vector register, interpreting it as a 128-bit integer,
these use mode `TI'.

   The following built-in functions are made available by `-mmmx'.  All
of them generate the machine instruction that is part of the name.

     v8qi __builtin_ia32_paddb (v8qi, v8qi)
     v4hi __builtin_ia32_paddw (v4hi, v4hi)
     v2si __builtin_ia32_paddd (v2si, v2si)
     v8qi __builtin_ia32_psubb (v8qi, v8qi)
     v4hi __builtin_ia32_psubw (v4hi, v4hi)
     v2si __builtin_ia32_psubd (v2si, v2si)
     v8qi __builtin_ia32_paddsb (v8qi, v8qi)
     v4hi __builtin_ia32_paddsw (v4hi, v4hi)
     v8qi __builtin_ia32_psubsb (v8qi, v8qi)
     v4hi __builtin_ia32_psubsw (v4hi, v4hi)
     v8qi __builtin_ia32_paddusb (v8qi, v8qi)
     v4hi __builtin_ia32_paddusw (v4hi, v4hi)
     v8qi __builtin_ia32_psubusb (v8qi, v8qi)
     v4hi __builtin_ia32_psubusw (v4hi, v4hi)
     v4hi __builtin_ia32_pmullw (v4hi, v4hi)
     v4hi __builtin_ia32_pmulhw (v4hi, v4hi)
     di __builtin_ia32_pand (di, di)
     di __builtin_ia32_pandn (di,di)
     di __builtin_ia32_por (di, di)
     di __builtin_ia32_pxor (di, di)
     v8qi __builtin_ia32_pcmpeqb (v8qi, v8qi)
     v4hi __builtin_ia32_pcmpeqw (v4hi, v4hi)
     v2si __builtin_ia32_pcmpeqd (v2si, v2si)
     v8qi __builtin_ia32_pcmpgtb (v8qi, v8qi)
     v4hi __builtin_ia32_pcmpgtw (v4hi, v4hi)
     v2si __builtin_ia32_pcmpgtd (v2si, v2si)
     v8qi __builtin_ia32_punpckhbw (v8qi, v8qi)
     v4hi __builtin_ia32_punpckhwd (v4hi, v4hi)
     v2si __builtin_ia32_punpckhdq (v2si, v2si)
     v8qi __builtin_ia32_punpcklbw (v8qi, v8qi)
     v4hi __builtin_ia32_punpcklwd (v4hi, v4hi)
     v2si __builtin_ia32_punpckldq (v2si, v2si)
     v8qi __builtin_ia32_packsswb (v4hi, v4hi)
     v4hi __builtin_ia32_packssdw (v2si, v2si)
     v8qi __builtin_ia32_packuswb (v4hi, v4hi)

   The following built-in functions are made available either with
`-msse', or with a combination of `-m3dnow' and `-march=athlon'.  All
of them generate the machine instruction that is part of the name.

     v4hi __builtin_ia32_pmulhuw (v4hi, v4hi)
     v8qi __builtin_ia32_pavgb (v8qi, v8qi)
     v4hi __builtin_ia32_pavgw (v4hi, v4hi)
     v4hi __builtin_ia32_psadbw (v8qi, v8qi)
     v8qi __builtin_ia32_pmaxub (v8qi, v8qi)
     v4hi __builtin_ia32_pmaxsw (v4hi, v4hi)
     v8qi __builtin_ia32_pminub (v8qi, v8qi)
     v4hi __builtin_ia32_pminsw (v4hi, v4hi)
     int __builtin_ia32_pextrw (v4hi, int)
     v4hi __builtin_ia32_pinsrw (v4hi, int, int)
     int __builtin_ia32_pmovmskb (v8qi)
     void __builtin_ia32_maskmovq (v8qi, v8qi, char *)
     void __builtin_ia32_movntq (di *, di)
     void __builtin_ia32_sfence (void)

   The following built-in functions are available when `-msse' is used.
All of them generate the machine instruction that is part of the name.

     int __builtin_ia32_comieq (v4sf, v4sf)
     int __builtin_ia32_comineq (v4sf, v4sf)
     int __builtin_ia32_comilt (v4sf, v4sf)
     int __builtin_ia32_comile (v4sf, v4sf)
     int __builtin_ia32_comigt (v4sf, v4sf)
     int __builtin_ia32_comige (v4sf, v4sf)
     int __builtin_ia32_ucomieq (v4sf, v4sf)
     int __builtin_ia32_ucomineq (v4sf, v4sf)
     int __builtin_ia32_ucomilt (v4sf, v4sf)
     int __builtin_ia32_ucomile (v4sf, v4sf)
     int __builtin_ia32_ucomigt (v4sf, v4sf)
     int __builtin_ia32_ucomige (v4sf, v4sf)
     v4sf __builtin_ia32_addps (v4sf, v4sf)
     v4sf __builtin_ia32_subps (v4sf, v4sf)
     v4sf __builtin_ia32_mulps (v4sf, v4sf)
     v4sf __builtin_ia32_divps (v4sf, v4sf)
     v4sf __builtin_ia32_addss (v4sf, v4sf)
     v4sf __builtin_ia32_subss (v4sf, v4sf)
     v4sf __builtin_ia32_mulss (v4sf, v4sf)
     v4sf __builtin_ia32_divss (v4sf, v4sf)
     v4si __builtin_ia32_cmpeqps (v4sf, v4sf)
     v4si __builtin_ia32_cmpltps (v4sf, v4sf)
     v4si __builtin_ia32_cmpleps (v4sf, v4sf)
     v4si __builtin_ia32_cmpgtps (v4sf, v4sf)
     v4si __builtin_ia32_cmpgeps (v4sf, v4sf)
     v4si __builtin_ia32_cmpunordps (v4sf, v4sf)
     v4si __builtin_ia32_cmpneqps (v4sf, v4sf)
     v4si __builtin_ia32_cmpnltps (v4sf, v4sf)
     v4si __builtin_ia32_cmpnleps (v4sf, v4sf)
     v4si __builtin_ia32_cmpngtps (v4sf, v4sf)
     v4si __builtin_ia32_cmpngeps (v4sf, v4sf)
     v4si __builtin_ia32_cmpordps (v4sf, v4sf)
     v4si __builtin_ia32_cmpeqss (v4sf, v4sf)
     v4si __builtin_ia32_cmpltss (v4sf, v4sf)
     v4si __builtin_ia32_cmpless (v4sf, v4sf)
     v4si __builtin_ia32_cmpunordss (v4sf, v4sf)
     v4si __builtin_ia32_cmpneqss (v4sf, v4sf)
     v4si __builtin_ia32_cmpnlts (v4sf, v4sf)
     v4si __builtin_ia32_cmpnless (v4sf, v4sf)
     v4si __builtin_ia32_cmpordss (v4sf, v4sf)
     v4sf __builtin_ia32_maxps (v4sf, v4sf)
     v4sf __builtin_ia32_maxss (v4sf, v4sf)
     v4sf __builtin_ia32_minps (v4sf, v4sf)
     v4sf __builtin_ia32_minss (v4sf, v4sf)
     v4sf __builtin_ia32_andps (v4sf, v4sf)
     v4sf __builtin_ia32_andnps (v4sf, v4sf)
     v4sf __builtin_ia32_orps (v4sf, v4sf)
     v4sf __builtin_ia32_xorps (v4sf, v4sf)
     v4sf __builtin_ia32_movss (v4sf, v4sf)
     v4sf __builtin_ia32_movhlps (v4sf, v4sf)
     v4sf __builtin_ia32_movlhps (v4sf, v4sf)
     v4sf __builtin_ia32_unpckhps (v4sf, v4sf)
     v4sf __builtin_ia32_unpcklps (v4sf, v4sf)
     v4sf __builtin_ia32_cvtpi2ps (v4sf, v2si)
     v4sf __builtin_ia32_cvtsi2ss (v4sf, int)
     v2si __builtin_ia32_cvtps2pi (v4sf)
     int __builtin_ia32_cvtss2si (v4sf)
     v2si __builtin_ia32_cvttps2pi (v4sf)
     int __builtin_ia32_cvttss2si (v4sf)
     v4sf __builtin_ia32_rcpps (v4sf)
     v4sf __builtin_ia32_rsqrtps (v4sf)
     v4sf __builtin_ia32_sqrtps (v4sf)
     v4sf __builtin_ia32_rcpss (v4sf)
     v4sf __builtin_ia32_rsqrtss (v4sf)
     v4sf __builtin_ia32_sqrtss (v4sf)
     v4sf __builtin_ia32_shufps (v4sf, v4sf, int)
     void __builtin_ia32_movntps (float *, v4sf)
     int __builtin_ia32_movmskps (v4sf)

   The following built-in functions are available when `-msse' is used.

`v4sf __builtin_ia32_loadaps (float *)'
     Generates the `movaps' machine instruction as a load from memory.

`void __builtin_ia32_storeaps (float *, v4sf)'
     Generates the `movaps' machine instruction as a store to memory.

`v4sf __builtin_ia32_loadups (float *)'
     Generates the `movups' machine instruction as a load from memory.

`void __builtin_ia32_storeups (float *, v4sf)'
     Generates the `movups' machine instruction as a store to memory.

`v4sf __builtin_ia32_loadsss (float *)'
     Generates the `movss' machine instruction as a load from memory.

`void __builtin_ia32_storess (float *, v4sf)'
     Generates the `movss' machine instruction as a store to memory.

`v4sf __builtin_ia32_loadhps (v4sf, v2si *)'
     Generates the `movhps' machine instruction as a load from memory.

`v4sf __builtin_ia32_loadlps (v4sf, v2si *)'
     Generates the `movlps' machine instruction as a load from memory

`void __builtin_ia32_storehps (v4sf, v2si *)'
     Generates the `movhps' machine instruction as a store to memory.

`void __builtin_ia32_storelps (v4sf, v2si *)'
     Generates the `movlps' machine instruction as a store to memory.

   The following built-in functions are available when `-mpni' is used.
All of them generate the machine instruction that is part of the name.

     v2df __builtin_ia32_addsubpd (v2df, v2df)
     v2df __builtin_ia32_addsubps (v2df, v2df)
     v2df __builtin_ia32_haddpd (v2df, v2df)
     v2df __builtin_ia32_haddps (v2df, v2df)
     v2df __builtin_ia32_hsubpd (v2df, v2df)
     v2df __builtin_ia32_hsubps (v2df, v2df)
     v16qi __builtin_ia32_lddqu (char const *)
     void __builtin_ia32_monitor (void *, unsigned int, unsigned int)
     v2df __builtin_ia32_movddup (v2df)
     v4sf __builtin_ia32_movshdup (v4sf)
     v4sf __builtin_ia32_movsldup (v4sf)
     void __builtin_ia32_mwait (unsigned int, unsigned int)

   The following built-in functions are available when `-mpni' is used.

`v2df __builtin_ia32_loadddup (double const *)'
     Generates the `movddup' machine instruction as a load from memory.

   The following built-in functions are available when `-m3dnow' is
used.  All of them generate the machine instruction that is part of the
name.

     void __builtin_ia32_femms (void)
     v8qi __builtin_ia32_pavgusb (v8qi, v8qi)
     v2si __builtin_ia32_pf2id (v2sf)
     v2sf __builtin_ia32_pfacc (v2sf, v2sf)
     v2sf __builtin_ia32_pfadd (v2sf, v2sf)
     v2si __builtin_ia32_pfcmpeq (v2sf, v2sf)
     v2si __builtin_ia32_pfcmpge (v2sf, v2sf)
     v2si __builtin_ia32_pfcmpgt (v2sf, v2sf)
     v2sf __builtin_ia32_pfmax (v2sf, v2sf)
     v2sf __builtin_ia32_pfmin (v2sf, v2sf)
     v2sf __builtin_ia32_pfmul (v2sf, v2sf)
     v2sf __builtin_ia32_pfrcp (v2sf)
     v2sf __builtin_ia32_pfrcpit1 (v2sf, v2sf)
     v2sf __builtin_ia32_pfrcpit2 (v2sf, v2sf)
     v2sf __builtin_ia32_pfrsqrt (v2sf)
     v2sf __builtin_ia32_pfrsqrtit1 (v2sf, v2sf)
     v2sf __builtin_ia32_pfsub (v2sf, v2sf)
     v2sf __builtin_ia32_pfsubr (v2sf, v2sf)
     v2sf __builtin_ia32_pi2fd (v2si)
     v4hi __builtin_ia32_pmulhrw (v4hi, v4hi)

   The following built-in functions are available when both `-m3dnow'
and `-march=athlon' are used.  All of them generate the machine
instruction that is part of the name.

     v2si __builtin_ia32_pf2iw (v2sf)
     v2sf __builtin_ia32_pfnacc (v2sf, v2sf)
     v2sf __builtin_ia32_pfpnacc (v2sf, v2sf)
     v2sf __builtin_ia32_pi2fw (v2si)
     v2sf __builtin_ia32_pswapdsf (v2sf)
     v2si __builtin_ia32_pswapdsi (v2si)

