-@c Copyright (C) 1988,1989,1992,1993,1994,1996,1998,1999,2000,2001 Free Software Foundation, Inc.
+@c Copyright (C) 1988,1989,1992,1993,1994,1996,1998,1999,2000,2001,2002, 2003
+@c Free Software Foundation, Inc.
@c This is part of the GCC manual.
@c For copying conditions, see the file gcc.texi.
@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
@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
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).}
@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
@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
@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
* Labels as Values:: Getting pointers to labels, and computed gotos.
* Nested Functions:: As in Algol and Pascal, lexical scoping of functions.
* Constructing Calls:: Dispatching a call to another function.
-* Naming Types:: Giving a name to the type of some expression.
* Typeof:: @code{typeof}: referring to the type of an expression.
* Lvalues:: Using @samp{?:}, @samp{,} and casts in lvalues.
* Conditionals:: Omitting the middle operand of a @samp{?:} expression.
* Hex Floats:: Hexadecimal floating-point constants.
* Zero Length:: Zero-length arrays.
* Variable Length:: Arrays whose length is computed at run time.
+* Empty Structures:: Structures with no members.
* Variadic Macros:: Macros with a variable number of arguments.
* Escaped Newlines:: Slightly looser rules for escaped newlines.
* Multi-line Strings:: String literals with embedded newlines.
* Return Address:: Getting the return or frame address of a function.
* Vector Extensions:: Using vector instructions through built-in functions.
* Other Builtins:: Other built-in functions.
+* Target Builtins:: Built-in functions specific to particular targets.
* Pragmas:: Pragmas accepted by GCC.
* Unnamed Fields:: Unnamed struct/union fields within structs/unions.
+* Thread-Local:: Per-thread variables.
@end menu
@node Statement Exprs
@c the above section title wrapped and causes an underfull hbox.. i
@c changed it from "within" to "in". --mew 4feb93
-
A compound statement enclosed in parentheses may appear as an expression
in GNU C@. This allows you to use loops, switches, and local variables
within an expression.
the initial value of a static variable.
If you don't know the type of the operand, you can still do this, but you
-must use @code{typeof} (@pxref{Typeof}) or type naming (@pxref{Naming
-Types}).
+must use @code{typeof} (@pxref{Typeof}).
Statement expressions are not supported fully in G++, and their fate
there is unclear. (It is possible that they will become fully supported
or
@example
-__label__ @var{label1}, @var{label2}, @dots{};
+__label__ @var{label1}, @var{label2}, /* @r{@dots{}} */;
@end example
Local label declarations must come at the beginning of the statement
@example
void *ptr;
-@dots{}
+/* @r{@dots{}} */
ptr = &&foo;
@end example
int access (int *array, int index)
@{ return array[index + offset]; @}
int i;
- @dots{}
+ /* @r{@dots{}} */
for (i = 0; i < size; i++)
- @dots{} access (array, i) @dots{}
+ /* @r{@dots{}} */ access (array, i) /* @r{@dots{}} */
@}
@end group
@end example
called @dfn{trampolines}. A paper describing them is available as
@noindent
-@uref{http://people.debian.org/~karlheg/Usenix88-lexic.pdf}.
+@uref{http://people.debian.org/~aaronl/Usenix88-lexic.pdf}.
A nested function can jump to a label inherited from a containing
function, provided the label was explicitly declared in the containing
return array[index + offset];
@}
int i;
- @dots{}
+ /* @r{@dots{}} */
for (i = 0; i < size; i++)
- @dots{} access (array, i) @dots{}
- @dots{}
+ /* @r{@dots{}} */ access (array, i) /* @r{@dots{}} */
+ /* @r{@dots{}} */
return 0;
/* @r{Control comes here from @code{access}
@{
__label__ failure;
auto int access (int *, int);
- @dots{}
+ /* @r{@dots{}} */
int access (int *array, int index)
@{
if (index > size)
goto failure;
return array[index + offset];
@}
- @dots{}
+ /* @r{@dots{}} */
@}
@end example
returned by @code{__builtin_apply}.
@end deftypefn
-@node Naming Types
-@section Naming an Expression's Type
-@cindex naming types
-
-You can give a name to the type of an expression using a @code{typedef}
-declaration with an initializer. Here is how to define @var{name} as a
-type name for the type of @var{exp}:
-
-@example
-typedef @var{name} = @var{exp};
-@end example
-
-This is useful in conjunction with the statements-within-expressions
-feature. Here is how the two together can be used to define a safe
-``maximum'' macro that operates on any arithmetic type:
-
-@example
-#define max(a,b) \
- (@{typedef _ta = (a), _tb = (b); \
- _ta _a = (a); _tb _b = (b); \
- _a > _b ? _a : _b; @})
-@end example
-
-@cindex underscores in variables in macros
-@cindex @samp{_} in variables in macros
-@cindex local variables in macros
-@cindex variables, local, in macros
-@cindex macros, local variables in
-
-The reason for using names that start with underscores for the local
-variables is to avoid conflicts with variable names that occur within the
-expressions that are substituted for @code{a} and @code{b}. Eventually we
-hope to design a new form of declaration syntax that allows you to declare
-variables whose scopes start only after their initializers; this will be a
-more reliable way to prevent such conflicts.
-
@node Typeof
@section Referring to a Type with @code{typeof}
@findex typeof
used. For example, you can use it in a declaration, in a cast, or inside
of @code{sizeof} or @code{typeof}.
+@code{typeof} is often useful in conjunction with the
+statements-within-expressions feature. Here is how the two together can
+be used to define a safe ``maximum'' macro that operates on any
+arithmetic type and evaluates each of its arguments exactly once:
+
+@example
+#define max(a,b) \
+ (@{ typeof (a) _a = (a); \
+ typeof (b) _b = (b); \
+ _a > _b ? _a : _b; @})
+@end example
+
+@cindex underscores in variables in macros
+@cindex @samp{_} in variables in macros
+@cindex local variables in macros
+@cindex variables, local, in macros
+@cindex macros, local variables in
+
+The reason for using names that start with underscores for the local
+variables is to avoid conflicts with variable names that occur within the
+expressions that are substituted for @code{a} and @code{b}. Eventually we
+hope to design a new form of declaration syntax that allows you to declare
+variables whose scopes start only after their initializers; this will be a
+more reliable way to prevent such conflicts.
+
+@noindent
+Some more examples of the use of @code{typeof}:
+
@itemize @bullet
@item
This declares @code{y} with the type of what @code{x} points to.
pointers to @code{char}.
@end itemize
+@emph{Compatibility Note:} In addition to @code{typeof}, GCC 2 supported
+a more limited extension which permitted one to write
+
+@example
+typedef @var{T} = @var{expr};
+@end example
+
+@noindent
+with the effect of declaring @var{T} to have the type of the expression
+@var{expr}. This extension does not work with GCC 3 (versions between
+3.0 and 3.2 will crash; 3.2.1 and later give an error). Code which
+relies on it should be rewritten to use @code{typeof}:
+
+@example
+typedef typeof(@var{expr}) @var{T};
+@end example
+
+@noindent
+This will work with all versions of GCC@.
+
@node Lvalues
@section Generalized Lvalues
@cindex compound expressions as lvalues
@cindex lvalues, generalized
@cindex extensions, @code{?:}
@cindex @code{?:} extensions
+
Compound expressions, conditional expressions and casts are allowed as
lvalues provided their operands are lvalues. This means that you can take
their addresses or store values into them.
GCC can allocate complex automatic variables in a noncontiguous
fashion; it's even possible for the real part to be in a register while
-the imaginary part is on the stack (or vice-versa). None of the
-supported debugging info formats has a way to represent noncontiguous
-allocation like this, so GCC describes a noncontiguous complex
-variable as if it were two separate variables of noncomplex type.
+the imaginary part is on the stack (or vice-versa). Only the DWARF2
+debug info format can represent this, so use of DWARF2 is recommended.
+If you are using the stabs debug info format, GCC describes a noncontiguous
+complex variable as if it were two separate variables of noncomplex type.
If the variable's actual name is @code{foo}, the two fictitious
variables are named @code{foo$real} and @code{foo$imag}. You can
examine and set these two fictitious variables with your debugger.
-A future version of GDB will know how to recognize such pairs and treat
-them as a single variable with a complex type.
-
@node Hex Floats
@section Hex Floats
@cindex hex floats
thisline->length = this_length;
@end example
-In ISO C89, you would have to give @code{contents} a length of 1, which
+In ISO C90, you would have to give @code{contents} a length of 1, which
means either you waste space or complicate the argument to @code{malloc}.
In ISO C99, you would use a @dfn{flexible array member}, which is
@item
Flexible array members may only appear as the last member of a
@code{struct} that is otherwise non-empty.
+
+@item
+A structure containing a flexible array member, or a union containing
+such a structure (possibly recursively), may not be a member of a
+structure or an element of an array. (However, these uses are
+permitted by GCC as extensions.)
@end itemize
GCC versions before 3.0 allowed zero-length arrays to be statically
struct foo d[1] = @{ @{ 1 @{ 2, 3, 4 @} @} @}; // @r{Invalid.}
@end example
+@node Empty Structures
+@section Structures With No Members
+@cindex empty structures
+@cindex zero-size structures
+
+GCC permits a C structure to have no members:
+
+@example
+struct empty @{
+@};
+@end example
+
+The structure will have size zero. In C++, empty structures are part
+of the language. G++ treats empty structures as if they had a single
+member of type @code{char}.
+
@node Variable Length
@section Arrays of Variable Length
@cindex variable-length arrays
struct entry
tester (int len, char data[len][len])
@{
- @dots{}
+ /* @r{@dots{}} */
@}
@end example
struct entry
tester (int len; char data[len][len], int len)
@{
- @dots{}
+ /* @r{@dots{}} */
@}
@end example
defining the macro is similar to that of a function. Here is an
example:
-@example
+@smallexample
#define debug(format, ...) fprintf (stderr, format, __VA_ARGS__)
-@end example
+@end smallexample
Here @samp{@dots{}} is a @dfn{variable argument}. In the invocation of
such a macro, it represents the zero or more tokens until the closing
To help solve this problem, CPP behaves specially for variable arguments
used with the token paste operator, @samp{##}. If instead you write
-@example
+@smallexample
#define debug(format, ...) fprintf (stderr, format, ## __VA_ARGS__)
-@end example
+@end smallexample
and if the variable arguments are omitted or empty, the @samp{##}
operator causes the preprocessor to remove the comma before it. If you
@cindex escaped newlines
@cindex newlines (escaped)
-Recently, the non-traditional preprocessor has relaxed its treatment of
-escaped newlines. Previously, the newline had to immediately follow a
+Recently, the preprocessor has relaxed its treatment of escaped
+newlines. Previously, the newline had to immediately follow a
backslash. The current implementation allows whitespace in the form of
spaces, horizontal and vertical tabs, and form feeds between the
backslash and the subsequent newline. The preprocessor issues a
foo (float f, float g)
@{
float beat_freqs[2] = @{ f-g, f+g @};
- @dots{}
+ /* @r{@dots{}} */
@}
@end example
subobject corresponding to the closest surrounding brace pair. For
example, with the @samp{struct point} declaration above:
-@example
+@smallexample
struct point ptarray[10] = @{ [2].y = yv2, [2].x = xv2, [0].x = xv0 @};
-@end example
+@end smallexample
@noindent
If the same field is initialized multiple times, it will have value from
@example
union foo u;
-@dots{}
+/* @r{@dots{}} */
u = (union foo) x @equiv{} u.i = x
u = (union foo) y @equiv{} u.d = y
@end example
@example
void hack (union foo);
-@dots{}
+/* @r{@dots{}} */
hack ((union foo) x);
@end example
@example
int i;
-@dots{}
+/* @r{@dots{}} */
i++;
int j = i + 2;
@end example
@cindex @code{volatile} applied to function
@cindex @code{const} applied to function
@cindex functions with @code{printf}, @code{scanf}, @code{strftime} or @code{strfmon} style arguments
+@cindex functions with non-null pointer arguments
@cindex functions that are passed arguments in registers on the 386
@cindex functions that pop the argument stack on the 386
@cindex functions that do not pop the argument stack on the 386
attributes when making a declaration. This keyword is followed by an
attribute specification inside double parentheses. The following
attributes are currently defined for functions on all targets:
-@code{noreturn}, @code{noinline}, @code{pure}, @code{const},
+@code{noreturn}, @code{noinline}, @code{always_inline},
+@code{pure}, @code{const}, @code{nothrow},
@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}, and
-@code{alias}. Several other attributes are defined for functions on
-particular target systems. Other attributes, including @code{section}
-are supported for variables declarations (@pxref{Variable Attributes})
-and for types (@pxref{Type Attributes}).
+@code{unused}, @code{deprecated}, @code{weak}, @code{malloc},
+@code{alias}, and @code{nonnull}. Several other attributes are defined
+for functions on particular target systems. Other attributes, including
+@code{section} are supported for variables declarations
+(@pxref{Variable Attributes}) and for types (@pxref{Type Attributes}).
You may also specify attributes with @samp{__} preceding and following
each keyword. This allows you to use them in header files without
void fatal () __attribute__ ((noreturn));
void
-fatal (@dots{})
+fatal (/* @r{@dots{}} */)
@{
- @dots{} /* @r{Print error message.} */ @dots{}
+ /* @r{@dots{}} */ /* @r{Print error message.} */ /* @r{@dots{}} */
exit (1);
@}
@end group
This function attribute prevents a function from being considered for
inlining.
+@cindex @code{always_inline} function attribute
+@item always_inline
+Generally, functions are not inlined unless optimization is specified.
+For functions declared inline, this attribute inlines the function even
+if no optimization level was specified.
+
@cindex @code{pure} function attribute
@item pure
Many functions have no effects except the return value and their
This approach does not work in GNU C++ from 2.6.0 on, since the language
specifies that the @samp{const} must be attached to the return value.
+@cindex @code{nothrow} function attribute
+@item nothrow
+The @code{nothrow} attribute is used to inform the compiler that a
+function cannot throw an exception. For example, most functions in
+the standard C library can be guaranteed not to throw an exception
+with the notable exceptions of @code{qsort} and @code{bsearch} that
+take function pointer arguments. The @code{nothrow} attribute is not
+implemented in GCC versions earlier than 3.2.
@item format (@var{archetype}, @var{string-index}, @var{first-to-check})
@cindex @code{format} function attribute
@code{vprintf}), specify the third parameter as zero. In this case the
compiler only checks the format string for consistency. For
@code{strftime} formats, the third parameter is required to be zero.
+Since non-static C++ methods have an implicit @code{this} argument, the
+arguments of such methods should be counted from two, not one, when
+giving values for @var{string-index} and @var{first-to-check}.
In the example above, the format string (@code{my_format}) is the second
argument of the function @code{my_print}, and the arguments to check
without the attribute.
The parameter @var{string-index} specifies which argument is the format
-string argument (starting from 1).
+string argument (starting from one). Since non-static C++ methods have
+an implicit @code{this} argument, the arguments of such methods should
+be counted from two.
The @code{format-arg} attribute allows you to identify your own
functions which modify format strings, so that GCC can check the
@option{-ffreestanding} is used. @xref{C Dialect Options,,Options
Controlling C Dialect}.
+@item nonnull (@var{arg-index}, @dots{})
+@cindex @code{nonnull} function attribute
+The @code{nonnull} attribute specifies that some function parameters should
+be non-null pointers. For instance, the declaration:
+
+@smallexample
+extern void *
+my_memcpy (void *dest, const void *src, size_t len)
+ __attribute__((nonnull (1, 2)));
+@end smallexample
+
+@noindent
+causes the compiler to check that, in calls to @code{my_memcpy},
+arguments @var{dest} and @var{src} are non-null. If the compiler
+determines that a null pointer is passed in an argument slot marked
+as non-null, and the @option{-Wnonnull} option is enabled, a warning
+is issued. The compiler may also choose to make optimizations based
+on the knowledge that certain function arguments will not be null.
+
+If no argument index list is given to the @code{nonnull} attribute,
+all pointer arguments are marked as non-null. To illustrate, the
+following declaration is equivalent to the previous example:
+
+@smallexample
+extern void *
+my_memcpy (void *dest, const void *src, size_t len)
+ __attribute__((nonnull));
+@end smallexample
+
@item no_instrument_function
@cindex @code{no_instrument_function} function attribute
@opindex finstrument-functions
alias for another symbol, which must be specified. For instance,
@smallexample
-void __f () @{ /* do something */; @}
+void __f () @{ /* @r{Do something.} */; @}
void f () __attribute__ ((weak, alias ("__f")));
@end smallexample
Not all target machines support this attribute.
+@item visibility ("@var{visibility_type}")
+@cindex @code{visibility} attribute
+The @code{visibility} attribute on ELF targets causes the declaration
+to be emitted with default, hidden, protected or internal visibility.
+
+@smallexample
+void __attribute__ ((visibility ("protected")))
+f () @{ /* @r{Do something.} */; @}
+int i __attribute__ ((visibility ("hidden")));
+@end smallexample
+
+See the ELF gABI for complete details, but the short story is:
+
+@table @dfn
+@item default
+Default visibility is the normal case for ELF. This value is
+available for the visibility attribute to override other options
+that may change the assumed visibility of symbols.
+
+@item hidden
+Hidden visibility indicates that the symbol will not be placed into
+the dynamic symbol table, so no other @dfn{module} (executable or
+shared library) can reference it directly.
+
+@item protected
+Protected visibility indicates that the symbol will be placed in the
+dynamic symbol table, but that references within the defining module
+will bind to the local symbol. That is, the symbol cannot be overridden
+by another module.
+
+@item internal
+Internal visibility is like hidden visibility, but with additional
+processor specific semantics. Unless otherwise specified by the psABI,
+gcc defines internal visibility to mean that the function is @emph{never}
+called from another module. Note that hidden symbols, while then cannot
+be referenced directly by other modules, can be referenced indirectly via
+function pointers. By indicating that a symbol cannot be called from
+outside the module, gcc may for instance omit the load of a PIC register
+since it is known that the calling function loaded the correct value.
+@end table
+
+Not all ELF targets support this attribute.
+
@item regparm (@var{number})
+@cindex @code{regparm} attribute
@cindex functions that are passed arguments in registers on the 386
On the Intel 386, the @code{regparm} attribute causes the compiler to
pass up to @var{number} integer arguments in registers EAX,
variable number of arguments will continue to be passed all of their
arguments on the stack.
+Beware that on some ELF systems this attribute is unsuitable for
+global functions in shared libraries with lazy binding (which is the
+default). Lazy binding will send the first call via resolving code in
+the loader, which might assume EAX, EDX and ECX can be clobbered, as
+per the standard calling conventions. Solaris 8 is affected by this.
+GNU systems with GLIBC 2.1 or higher, and FreeBSD, are believed to be
+safe since the loaders there save all registers. (Lazy binding can be
+disabled with the linker or the loader if desired, to avoid the
+problem.)
+
@item stdcall
@cindex functions that pop the argument stack on the 386
On the Intel 386, the @code{stdcall} attribute causes the compiler to
assume that the called function will pop off the stack space used to
pass arguments, unless it takes a variable number of arguments.
-The PowerPC compiler for Windows NT currently ignores the @code{stdcall}
-attribute.
+@item fastcall
+@cindex functions that pop the argument stack on the 386
+On the Intel 386, the @code{fastcall} attribute causes the compiler to
+pass the first two arguments in the registers ECX and EDX. Subsequent
+arguments are passed on the stack. The called function will pop the
+arguments off the stack. If the number of arguments is variable all
+arguments are pushed on the stack.
@item cdecl
@cindex functions that do pop the argument stack on the 386
pass arguments. This is
useful to override the effects of the @option{-mrtd} switch.
-The PowerPC compiler for Windows NT currently ignores the @code{cdecl}
-attribute.
-
-@item longcall
+@item longcall/shortcall
@cindex functions called via pointer on the RS/6000 and PowerPC
On the RS/6000 and PowerPC, the @code{longcall} attribute causes the
-compiler to always call the function via a pointer, so that functions
-which reside further than 64 megabytes (67,108,864 bytes) from the
-current location can be called.
+compiler to always call this function via a pointer, just as it would if
+the @option{-mlongcall} option had been specified. The @code{shortcall}
+attribute causes the compiler not to do this. These attributes override
+both the @option{-mlongcall} switch and the @code{#pragma longcall}
+setting.
+
+@xref{RS/6000 and PowerPC Options}, for more information on when long
+calls are and are not necessary.
@item long_call/short_call
@cindex indirect calls on ARM
the offset to the function from the call site into the @samp{BL}
instruction directly.
-@item dllimport
-@cindex functions which are imported from a dll on PowerPC Windows NT
-On the PowerPC running Windows NT, the @code{dllimport} attribute causes
-the compiler to call the function via a global pointer to the function
-pointer that is set up by the Windows NT dll library. The pointer name
-is formed by combining @code{__imp_} and the function name.
-
-@item dllexport
-@cindex functions which are exported from a dll on PowerPC Windows NT
-On the PowerPC running Windows NT, the @code{dllexport} attribute causes
-the compiler to provide a global pointer to the function pointer, so
-that it can be called with the @code{dllimport} attribute. The pointer
-name is formed by combining @code{__imp_} and the function name.
-
-@item exception (@var{except-func} [, @var{except-arg}])
-@cindex functions which specify exception handling on PowerPC Windows NT
-On the PowerPC running Windows NT, the @code{exception} attribute causes
-the compiler to modify the structured exception table entry it emits for
-the declared function. The string or identifier @var{except-func} is
-placed in the third entry of the structured exception table. It
-represents a function, which is called by the exception handling
-mechanism if an exception occurs. If it was specified, the string or
-identifier @var{except-arg} is placed in the fourth entry of the
-structured exception table.
-
@item function_vector
@cindex calling functions through the function vector on the H8/300 processors
-Use this option on the H8/300 and H8/300H to indicate that the specified
+Use this attribute on the H8/300 and H8/300H to indicate that the specified
function should be called through the function vector. Calling a
function through the function vector will reduce code size, however;
the function vector has a limited size (maximum 128 entries on the H8/300
and 64 entries on the H8/300H) and shares space with the interrupt vector.
You must use GAS and GLD from GNU binutils version 2.7 or later for
-this option to work correctly.
+this attribute to work correctly.
@item interrupt
@cindex interrupt handler functions
-Use this option on the ARM, AVR and M32R/D ports to indicate that the
-specified function is an interrupt handler. The compiler will generate
-function entry and exit sequences suitable for use in an interrupt
-handler when this attribute is present.
+Use this attribute on the ARM, AVR, C4x, M32R/D and Xstormy16 ports to indicate
+that the specified function is an interrupt handler. The compiler will
+generate function entry and exit sequences suitable for use in an
+interrupt handler when this attribute is present.
Note, interrupt handlers for the H8/300, H8/300H and SH processors can
be specified via the @code{interrupt_handler} attribute.
@item interrupt_handler
@cindex interrupt handler functions on the H8/300 and SH processors
-Use this option on the H8/300, H8/300H and SH to indicate that the
+Use this attribute on the H8/300, H8/300H and SH to indicate that the
specified function is an interrupt handler. The compiler will generate
function entry and exit sequences suitable for use in an interrupt
handler when this attribute is present.
@item sp_switch
-Use this option on the SH to indicate an @code{interrupt_handler}
+Use this attribute on the SH to indicate an @code{interrupt_handler}
function should switch to an alternate stack. It expects a string
argument that names a global variable holding the address of the
alternate stack.
@end smallexample
@item trap_exit
-Use this option on the SH for an @code{interrupt_handle} to return using
+Use this attribute on the SH for an @code{interrupt_handle} to return using
@code{trapa} instead of @code{rte}. This attribute expects an integer
argument specifying the trap number to be used.
@item eightbit_data
@cindex eight bit data on the H8/300 and H8/300H
-Use this option on the H8/300 and H8/300H to indicate that the specified
+Use this attribute on the H8/300 and H8/300H to indicate that the specified
variable should be placed into the eight bit data section.
The compiler will generate more efficient code for certain operations
on data in the eight bit data area. Note the eight bit data area is limited to
256 bytes of data.
You must use GAS and GLD from GNU binutils version 2.7 or later for
-this option to work correctly.
+this attribute to work correctly.
@item tiny_data
@cindex tiny data section on the H8/300H
-Use this option on the H8/300H to indicate that the specified
+Use this attribute on the H8/300H to indicate that the specified
variable should be placed into the tiny data section.
The compiler will generate more efficient code for loads and stores
on data in the tiny data section. Note the tiny data area is limited to
@item signal
@cindex signal handler functions on the AVR processors
-Use this option on the AVR to indicate that the specified
+Use this attribute on the AVR to indicate that the specified
function is an signal handler. The compiler will generate function
entry and exit sequences suitable for use in an signal handler when this
attribute is present. Interrupts will be disabled inside function.
@item naked
@cindex function without a prologue/epilogue code
-Use this option on the ARM or AVR ports to indicate that the specified
-function do not need prologue/epilogue sequences generated by the
-compiler. It is up to the programmer to provide these sequences.
+Use this attribute on the ARM, AVR, C4x and IP2K ports to indicate that the
+specified function do not need prologue/epilogue sequences generated by
+the compiler. It is up to the programmer to provide these sequences.
@item model (@var{model-name})
@cindex function addressability on the M32R/D
and may not be reachable with the @code{bl} instruction (the compiler will
generate the much slower @code{seth/add3/jl} instruction sequence).
+@item far
+@cindex functions which handle memory bank switching
+On 68HC11 and 68HC12 the @code{far} attribute causes the compiler to
+use a calling convention that takes care of switching memory banks when
+entering and leaving a function. This calling convention is also the
+default when using the @option{-mlong-calls} option.
+
+On 68HC12 the compiler will use the @code{call} and @code{rtc} instructions
+to call and return from a function.
+
+On 68HC11 the compiler will generate a sequence of instructions
+to invoke a board-specific routine to switch the memory bank and call the
+real function. The board-specific routine simulates a @code{call}.
+At the end of a function, it will jump to a board-specific routine
+instead of using @code{rts}. The board-specific return routine simulates
+the @code{rtc}.
+
+@item near
+@cindex functions which do not handle memory bank switching on 68HC11/68HC12
+On 68HC11 and 68HC12 the @code{near} attribute causes the compiler to
+use the normal calling convention based on @code{jsr} and @code{rts}.
+This attribute can be used to cancel the effect of the @option{-mlong-calls}
+option.
+
@end table
You can specify multiple attributes in a declaration by separating them
than a function definition. At present, such attribute specifiers apply
to the declared object or function, but in future they may attach to the
outermost adjacent declarator. In simple cases there is no difference,
-but, for example, in
+but, for example, in
@smallexample
void (****f)(void) __attribute__((noreturn));
@var{type-qualifier-and-attribute-specifier-list} @var{Type}'' for
@var{ident}.
-For example,
+For example,
@smallexample
void (__attribute__((noreturn)) ****f) (void);
In GNU C, you may use C++ style comments, which start with @samp{//} and
continue until the end of the line. Many other C implementations allow
-such comments, and they are likely to be in a future C standard.
-However, C++ style comments are not recognized if you specify
-@w{@option{-ansi}}, a @option{-std} option specifying a version of ISO C
-before C99, or @w{@option{-traditional}}, since they are incompatible
-with traditional constructs like @code{dividend//*comment*/divisor}.
+such comments, and they are included in the 1999 C standard. However,
+C++ style comments are not recognized if you specify an @option{-std}
+option specifying a version of ISO C before C99, or @option{-ansi}
+(equivalent to @option{-std=c89}).
@node Dollar Signs
@section Dollar Signs in Identifier Names
data type even at an odd addresses. For these machines, @code{__alignof__}
reports the @emph{recommended} alignment of a type.
-When the operand of @code{__alignof__} is an lvalue rather than a type, the
-value is the largest alignment that the lvalue is known to have. It may
-have this alignment as a result of its data type, or because it is part of
-a structure and inherits alignment from that structure. For example, after
-this declaration:
+If the operand of @code{__alignof__} is an lvalue rather than a type,
+its value is the required alignment for its type, taking into account
+any minimum alignment specified with GCC's @code{__attribute__}
+extension (@pxref{Variable Attributes}). For example, after this
+declaration:
@example
struct foo @{ int x; char y; @} foo1;
@end example
@noindent
-the value of @code{__alignof__ (foo1.y)} is probably 2 or 4, the same as
-@code{__alignof__ (int)}, even though the data type of @code{foo1.y}
-does not itself demand any alignment.
+the value of @code{__alignof__ (foo1.y)} is 1, even though its actual
+alignment is probably 2 or 4, the same as @code{__alignof__ (int)}.
It is an error to ask for the alignment of an incomplete type.
-A related feature which lets you specify the alignment of an object is
-@code{__attribute__ ((aligned (@var{alignment})))}; see the following
-section.
-
@node Variable Attributes
@section Specifying Attributes of Variables
@cindex attribute of variables
The keyword @code{__attribute__} allows you to specify special
attributes of variables or structure fields. This keyword is followed
-by an attribute specification inside double parentheses. Ten
-attributes are currently defined for variables: @code{aligned},
-@code{mode}, @code{nocommon}, @code{packed}, @code{section},
-@code{transparent_union}, @code{unused}, @code{deprecated},
-@code{vector_size}, and @code{weak}. Some other attributes are defined
-for variables on particular target systems. Other attributes are
-available for functions (@pxref{Function Attributes}) and for types
-(@pxref{Type Attributes}). Other front ends might define more
-attributes (@pxref{C++ Extensions,,Extensions to the C++ Language}).
+by an attribute specification inside double parentheses. Some
+attributes are currently defined generically for variables.
+Other attributes are defined for variables on particular target
+systems. Other attributes are available for functions
+(@pxref{Function Attributes}) and for types (@pxref{Type Attributes}).
+Other front ends might define more attributes
+(@pxref{C++ Extensions,,Extensions to the C++ Language}).
You may also specify attributes with @samp{__} preceding and following
each keyword. This allows you to use them in header files without
This is an alternative to creating a union with a @code{double} member
that forces the union to be double-word aligned.
-It is not possible to specify the alignment of functions; the alignment
-of functions is determined by the machine's requirements and cannot be
-changed. You cannot specify alignment for a typedef name because such a
-name is just an alias, not a distinct type.
-
As in the preceding examples, you can explicitly specify the alignment
(in bytes) that you wish the compiler to use for a given variable or
structure field. Alternatively, you can leave out the alignment factor
in an @code{__attribute__} will still only provide you with 8 byte
alignment. See your linker documentation for further information.
+@item cleanup (@var{cleanup_function})
+@cindex @code{cleanup} attribute
+The @code{cleanup} attribute runs a function when the variable goes
+out of scope. This attribute can only be applied to auto function
+scope variables; it may not be applied to parameters or variables
+with static storage duration. The function must take one parameter,
+a pointer to a type compatible with the variable. The return value
+of the function (if any) is ignored.
+
+If @option{-fexceptions} is enabled, then @var{cleanup_function}
+will be run during the stack unwinding that happens during the
+processing of the exception. Note that the @code{cleanup} attribute
+does not allow the exception to be caught, only to perform an action.
+It is undefined what happens if @var{cleanup_function} does not
+return normally.
+
+@item common
+@itemx nocommon
+@cindex @code{common} attribute
+@cindex @code{nocommon} attribute
+@opindex fcommon
+@opindex fno-common
+The @code{common} attribute requests GCC to place a variable in
+``common'' storage. The @code{nocommon} attribute requests the
+opposite -- to allocate space for it directly.
+
+These attributes override the default chosen by the
+@option{-fno-common} and @option{-fcommon} flags respectively.
+
+@item deprecated
+@cindex @code{deprecated} attribute
+The @code{deprecated} attribute results in a warning if the variable
+is used anywhere in the source file. This is useful when identifying
+variables that are expected to be removed in a future version of a
+program. The warning also includes the location of the declaration
+of the deprecated variable, to enable users to easily find further
+information about why the variable is deprecated, or what they should
+do instead. Note that the warnings only occurs for uses:
+
+@smallexample
+extern int old_var __attribute__ ((deprecated));
+extern int old_var;
+int new_fn () @{ return old_var; @}
+@end smallexample
+
+results in a warning on line 3 but not line 2.
+
+The @code{deprecated} attribute can also be used for functions and
+types (@pxref{Function Attributes}, @pxref{Type Attributes}.)
+
@item mode (@var{mode})
@cindex @code{mode} attribute
This attribute specifies the data type for the declaration---whichever
@samp{__word__} for the mode of a one-word integer, and @samp{pointer}
or @samp{__pointer__} for the mode used to represent pointers.
-@item nocommon
-@cindex @code{nocommon} attribute
-@opindex fno-common
-This attribute specifies requests GCC not to place a variable
-``common'' but instead to allocate space for it directly. If you
-specify the @option{-fno-common} flag, GCC will do this for all
-variables.
-
-Specifying the @code{nocommon} attribute for a variable provides an
-initialization of zeros. A variable may only be initialized in one
-source file.
-
@item packed
@cindex @code{packed} attribute
The @code{packed} attribute specifies that a variable or structure field
The @code{shared} attribute is only available on Windows NT@.
+@item tls_model ("@var{tls_model}")
+@cindex @code{tls_model} attribute
+The @code{tls_model} attribute sets thread-local storage model
+(@pxref{Thread-Local}) of a particular @code{__thread} variable,
+overriding @code{-ftls-model=} command line switch on a per-variable
+basis.
+The @var{tls_model} argument should be one of @code{global-dynamic},
+@code{local-dynamic}, @code{initial-exec} or @code{local-exec}.
+
+Not all targets support this attribute.
+
@item transparent_union
This attribute, attached to a function parameter which is a union, means
that the corresponding argument may have the type of any union member,
to be possibly unused. GCC will not produce a warning for this
variable.
-@item deprecated
-The @code{deprecated} attribute results in a warning if the variable
-is used anywhere in the source file. This is useful when identifying
-variables that are expected to be removed in a future version of a
-program. The warning also includes the location of the declaration
-of the deprecated variable, to enable users to easily find further
-information about why the variable is deprecated, or what they should
-do instead. Note that the warnings only occurs for uses:
-
-@smallexample
-extern int old_var __attribute__ ((deprecated));
-extern int old_var;
-int new_fn () @{ return old_var; @}
-@end smallexample
-
-results in a warning on line 3 but not line 2.
-
-The @code{deprecated} attribute can also be used for functions and
-types (@pxref{Function Attributes}, @pxref{Type Attributes}.)
-
@item vector_size (@var{bytes})
This attribute specifies the vector size for the variable, measured in
bytes. For example, the declaration:
@item weak
The @code{weak} attribute is described in @xref{Function Attributes}.
+@end table
+
+@subsection M32R/D Variable Attributes
+
+One attribute is currently defined for the M32R/D.
+@table @code
@item model (@var{model-name})
@cindex variable addressability on the M32R/D
Use this attribute on the M32R/D to set the addressability of an object.
Medium and large model objects may live anywhere in the 32-bit address space
(the compiler will generate @code{seth/add3} instructions to load their
addresses).
-
@end table
-To specify multiple attributes, separate them by commas within the
-double parentheses: for example, @samp{__attribute__ ((aligned (16),
-packed))}.
+@subsection i386 Variable Attributes
+
+Two attributes are currently defined for i386 configurations:
+@code{ms_struct} and @code{gcc_struct}
+
+@table @code
+@item ms_struct
+@itemx gcc_struct
+@cindex @code{ms_struct} attribute
+@cindex @code{gcc_struct} attribute
+
+If @code{packed} is used on a structure, or if bit-fields are used
+it may be that the Microsoft ABI packs them differently
+than GCC would normally pack them. Particularly when moving packed
+data between functions compiled with GCC and the native Microsoft compiler
+(either via function call or as data in a file), it may be necessary to access
+either format.
+
+Currently @option{-m[no-]ms-bitfields} is provided for the Windows X86
+compilers to match the native Microsoft compiler.
+@end table
@node Type Attributes
@section Specifying Attributes of Types
The keyword @code{__attribute__} allows you to specify special
attributes of @code{struct} and @code{union} types when you define such
types. This keyword is followed by an attribute specification inside
-double parentheses. Five attributes are currently defined for types:
+double parentheses. Six attributes are currently defined for types:
@code{aligned}, @code{packed}, @code{transparent_union}, @code{unused},
-and @code{deprecated}. Other attributes are defined for functions
-(@pxref{Function Attributes}) and for variables (@pxref{Variable Attributes}).
+@code{deprecated} and @code{may_alias}. Other attributes are defined for
+functions (@pxref{Function Attributes}) and for variables
+(@pxref{Variable Attributes}).
You may also specify any one of these attributes with @samp{__}
preceding and following its keyword. This allows you to use these
@noindent
force the compiler to insure (as far as it can) that each variable whose
type is @code{struct S} or @code{more_aligned_int} will be allocated and
-aligned @emph{at least} on a 8-byte boundary. On a Sparc, having all
+aligned @emph{at least} on a 8-byte boundary. On a SPARC, having all
variables of type @code{struct S} aligned to 8-byte boundaries allows
the compiler to use the @code{ldd} and @code{std} (doubleword load and
store) instructions when copying one variable of type @code{struct S} to
The @code{deprecated} attribute can also be used for functions and
variables (@pxref{Function Attributes}, @pxref{Variable Attributes}.)
+@item may_alias
+Accesses to objects with types with this attribute are not subjected to
+type-based alias analysis, but are instead assumed to be able to alias
+any other type of objects, just like the @code{char} type. See
+@option{-fstrict-aliasing} for more information on aliasing issues.
+
+Example of use:
+
+@smallexample
+typedef short __attribute__((__may_alias__)) short_a;
+
+int
+main (void)
+@{
+ int a = 0x12345678;
+ short_a *b = (short_a *) &a;
+
+ b[1] = 0;
+
+ if (a == 0x12345678)
+ abort();
+
+ exit(0);
+@}
+@end smallexample
+
+If you replaced @code{short_a} with @code{short} in the variable
+declaration, the above program would abort when compiled with
+@option{-fstrict-aliasing}, which is on by default at @option{-O2} or
+above in recent GCC versions.
+
+@subsection i386 Type Attributes
+
+Two attributes are currently defined for i386 configurations:
+@code{ms_struct} and @code{gcc_struct}
+
+@item ms_struct
+@itemx gcc_struct
+@cindex @code{ms_struct}
+@cindex @code{gcc_struct}
+
+If @code{packed} is used on a structure, or if bit-fields are used
+it may be that the Microsoft ABI packs them differently
+than GCC would normally pack them. Particularly when moving packed
+data between functions compiled with GCC and the native Microsoft compiler
+(either via function call or as data in a file), it may be necessary to access
+either format.
+
+Currently @option{-m[no-]ms-bitfields} is provided for the Windows X86
+compilers to match the native Microsoft compiler.
@end table
To specify multiple attributes, separate them by commas within the
specified, but eventually the default will be @option{-std=gnu99} and
that will implement the C99 semantics, though it does not do so yet.)
-GCC does not inline any functions when not optimizing. It is not
-clear whether it is better to inline or not, in this case, but we found
-that a correct implementation when not optimizing was difficult. So we
-did the easy thing, and turned it off.
+GCC does not inline any functions when not optimizing unless you specify
+the @samp{always_inline} attribute for the function, like this:
+
+@example
+/* Prototype. */
+inline void foo (const char) __attribute__((always_inline));
+@end example
@node Extended Asm
@section Assembler Instructions with C Expression Operands
You may not write a clobber description in a way that overlaps with an
input or output operand. For example, you may not have an operand
describing a register class with one member if you mention that register
-in the clobber list. There is no way for you to specify that an input
+in the clobber list. Variables declared to live in specific registers
+(@pxref{Explicit Reg Vars}), and used as asm input or output operands must
+have no part mentioned in the clobber description.
+There is no way for you to specify that an input
operand is modified without also specifying it as an output
operand. Note that if all the output operands you specify are for this
purpose (and hence unused), you will then also need to specify
func (x, y)
int x, y;
-@dots{}
+/* @r{@dots{}} */
@end example
It is up to you to make sure that the assembler names you choose do not
Global register variables may not have initial values, because an
executable file has no means to supply initial contents for a register.
-On the Sparc, there are reports that g3 @dots{} g7 are suitable
+On the SPARC, there are reports that g3 @dots{} g7 are suitable
registers, but certain library functions, such as @code{getwd}, as well
as the subroutines for division and remainder, modify g3 and g4. g1 and
g2 are local temporaries.
@cindex alternate keywords
@cindex keywords, alternate
-The option @option{-traditional} disables certain keywords;
@option{-ansi} and the various @option{-std} options disable certain
-others. This causes trouble when you want to use GNU C extensions, or
-ISO C features, in a general-purpose header file that should be usable
-by all programs, including ISO C programs and traditional ones. The
-keywords @code{asm}, @code{typeof} and @code{inline} cannot be used
-since they won't work in a program compiled with @option{-ansi}
-(although @code{inline} can be used in a program compiled with
-@option{-std=c99}), while the keywords @code{const}, @code{volatile},
-@code{signed}, @code{typeof} and @code{inline} won't work in a program
-compiled with @option{-traditional}. The ISO C99 keyword
+keywords. This causes trouble when you want to use GNU C extensions, or
+a general-purpose header file that should be usable by all programs,
+including ISO C programs. The keywords @code{asm}, @code{typeof} and
+@code{inline} are not available in programs compiled with
+@option{-ansi} or @option{-std} (although @code{inline} can be used in a
+program compiled with @option{-std=c99}). The ISO C99 keyword
@code{restrict} is only available when @option{-std=gnu99} (which will
eventually be the default) or @option{-std=c99} (or the equivalent
@option{-std=iso9899:1999}) is used.
The way to solve these problems is to put @samp{__} at the beginning and
end of each problematical keyword. For example, use @code{__asm__}
-instead of @code{asm}, @code{__const__} instead of @code{const}, and
-@code{__inline__} instead of @code{inline}.
+instead of @code{asm}, and @code{__inline__} instead of @code{inline}.
Other C compilers won't accept these alternative keywords; if you want to
compile with another compiler, you can define the alternate keywords as
class a @{
public:
- sub (int i)
+ void sub (int i)
@{
printf ("__FUNCTION__ = %s\n", __FUNCTION__);
printf ("__PRETTY_FUNCTION__ = %s\n", __PRETTY_FUNCTION__);
one of its callers. The @var{level} argument is number of frames to
scan up the call stack. A value of @code{0} yields the return address
of the current function, a value of @code{1} yields the return address
-of the caller of the current function, and so forth.
+of the caller of the current function, and so forth. When inlining
+the expected behavior is that the function will return the address of
+the function that will be returned to. To work around this behavior use
+the @code{noinline} function attribute.
The @var{level} argument must be a constant integer.
A floating point value, as wide as a DI mode integer, usually 64 bits.
@end table
-Not all base types or combinations are always valid; which modes can be used
-is determined by the target machine. For example, if targetting the i386 MMX
-extensions, only @code{V8QI}, @code{V4HI} and @code{V2SI} are allowed modes.
+Specifying a combination that is not valid for the current architecture
+will cause gcc to synthesize the instructions using a narrower mode.
+For example, if you specify a variable of type @code{V4SI} and your
+architecture does not allow for this specific SIMD type, gcc will
+produce code that uses 4 @code{SIs}.
+
+The types defined in this manner can be used with a subset of normal C
+operations. Currently, gcc will allow using the following operators on
+these types: @code{+, -, *, /, unary minus}@.
+
+The operations behave like C++ @code{valarrays}. Addition is defined as
+the addition of the corresponding elements of the operands. For
+example, in the code below, each of the 4 elements in @var{a} will be
+added to the corresponding 4 elements in @var{b} and the resulting
+vector will be stored in @var{c}.
-There are no @code{V1xx} vector modes - they would be identical to the
-corresponding base mode.
+@example
+typedef int v4si __attribute__ ((mode(V4SI)));
+
+v4si a, b, c;
+
+c = a + b;
+@end example
+
+Subtraction, multiplication, and division operate in a similar manner.
+Likewise, the result of using the unary minus operator on a vector type
+is a vector whose elements are the negative value of the corresponding
+elements in the operand.
-There is no distinction between signed and unsigned vector modes. This
-distinction is made by the operations that perform on the vectors, not
-by the data type.
+You can declare variables and use them in function calls and returns, as
+well as in assignments and some casts. You can specify a vector type as
+a return type for a function. Vector types can also be used as function
+arguments. It is possible to cast from one vector type to another,
+provided they are of the same size (in fact, you can also cast vectors
+to and from other datatypes of the same size).
-The types defined in this manner are somewhat special, they cannot be
-used with most normal C operations (i.e., a vector addition can @emph{not}
-be represented by a normal addition of two vector type variables). You
-can declare only variables and use them in function calls and returns, as
-well as in assignments and some casts. It is possible to cast from one
-vector type to another, provided they are of the same size (in fact, you
-can also cast vectors to and from other datatypes of the same size).
+You cannot operate between vectors of different lengths or different
+signedness without a cast.
-A port that supports vector operations provides a set of built-in functions
-that can be used to operate on vectors. For example, a function to add two
-vectors and multiply the result by a third could look like this:
+A port that supports hardware vector operations, usually provides a set
+of built-in functions that can be used to operate on vectors. For
+example, a function to add two vectors and multiply the result by a
+third could look like this:
@example
v4si f (v4si a, v4si b, v4si c)
@findex abort
@findex abs
@findex alloca
+@findex atan
+@findex atan2
+@findex atan2f
+@findex atan2l
+@findex atanf
+@findex atanl
@findex bcmp
@findex bzero
+@findex cabs
+@findex cabsf
+@findex cabsl
+@findex calloc
+@findex ceil
+@findex ceilf
+@findex ceill
@findex cimag
@findex cimagf
@findex cimagl
@findex exit
@findex _exit
@findex _Exit
+@findex exp
+@findex expf
+@findex expl
@findex fabs
@findex fabsf
@findex fabsl
@findex ffs
+@findex floor
+@findex floorf
+@findex floorl
+@findex fmod
+@findex fmodf
+@findex fmodl
@findex fprintf
@findex fprintf_unlocked
@findex fputs
@findex index
@findex labs
@findex llabs
+@findex log
+@findex logf
+@findex logl
+@findex malloc
@findex memcmp
@findex memcpy
+@findex mempcpy
@findex memset
+@findex nearbyint
+@findex nearbyintf
+@findex nearbyintl
+@findex pow
+@findex powf
+@findex powl
@findex printf
@findex printf_unlocked
+@findex putchar
+@findex puts
@findex rindex
+@findex round
+@findex roundf
+@findex roundl
+@findex scanf
@findex sin
@findex sinf
@findex sinl
+@findex snprintf
+@findex sprintf
@findex sqrt
@findex sqrtf
@findex sqrtl
+@findex sscanf
+@findex stpcpy
@findex strcat
@findex strchr
@findex strcmp
@findex strcpy
@findex strcspn
+@findex strdup
@findex strlen
@findex strncat
@findex strncmp
@findex strrchr
@findex strspn
@findex strstr
+@findex tan
+@findex tanf
+@findex tanl
+@findex trunc
+@findex truncf
+@findex truncl
+@findex vprintf
+@findex vscanf
+@findex vsnprintf
+@findex vsprintf
+@findex vsscanf
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
@opindex ansi
@opindex std
-The functions @code{abort}, @code{exit}, @code{_Exit} and @code{_exit}
-are recognized and presumed not to return, but otherwise are not built
-in. @code{_exit} is not recognized in strict ISO C mode (@option{-ansi},
-@option{-std=c89} or @option{-std=c99}). @code{_Exit} is not recognized in
-strict C89 mode (@option{-ansi} or @option{-std=c89}).
-
-Outside strict ISO C mode, the functions @code{alloca}, @code{bcmp},
-@code{bzero}, @code{index}, @code{rindex}, @code{ffs}, @code{fputs_unlocked},
-@code{printf_unlocked} and @code{fprintf_unlocked} may be handled as
-built-in functions. All these functions have corresponding versions
+Outside strict ISO C mode (@option{-ansi}, @option{-std=c89} or
+@option{-std=c99}), the functions @code{alloca}, @code{bcmp},
+@code{bzero}, @code{_exit}, @code{ffs}, @code{fprintf_unlocked},
+@code{fputs_unlocked}, @code{index}, @code{mempcpy}, @code{printf_unlocked},
+@code{rindex}, @code{stpcpy} and @code{strdup}
+may be handled as built-in functions.
+All these functions have corresponding versions
prefixed with @code{__builtin_}, which may be used even in strict C89
mode.
-The ISO C99 functions @code{conj}, @code{conjf}, @code{conjl},
-@code{creal}, @code{crealf}, @code{creall}, @code{cimag}, @code{cimagf},
-@code{cimagl}, @code{llabs} and @code{imaxabs} are handled as built-in
-functions except in strict ISO C89 mode. There are also built-in
-versions of the ISO C99 functions @code{cosf}, @code{cosl},
-@code{fabsf}, @code{fabsl}, @code{sinf}, @code{sinl}, @code{sqrtf}, and
-@code{sqrtl}, that are recognized in any mode since ISO C89 reserves
-these names for the purpose to which ISO C99 puts them. All these
-functions have corresponding versions prefixed with @code{__builtin_}.
-
-The ISO C89 functions @code{abs}, @code{cos}, @code{fabs},
-@code{fprintf}, @code{fputs}, @code{labs}, @code{memcmp}, @code{memcpy},
-@code{memset}, @code{printf}, @code{sin}, @code{sqrt}, @code{strcat},
-@code{strchr}, @code{strcmp}, @code{strcpy}, @code{strcspn},
-@code{strlen}, @code{strncat}, @code{strncmp}, @code{strncpy},
-@code{strpbrk}, @code{strrchr}, @code{strspn}, and @code{strstr} are all
-recognized as built-in functions unless @option{-fno-builtin} is
-specified (or @option{-fno-builtin-@var{function}} is specified for an
-individual function). All of these functions have corresponding
-versions prefixed with @code{__builtin_}.
+The ISO C99 functions
+@code{cabs}, @code{cabsf}, @code{cabsl},
+@code{conj}, @code{conjf}, @code{conjl},
+@code{creal}, @code{crealf}, @code{creall},
+@code{cimag}, @code{cimagf}, @code{cimagl},
+@code{_Exit}, @code{imaxabs}, @code{llabs},
+@code{nearbyint}, @code{nearbyintf}, @code{nearbyintl},
+@code{round}, @code{roundf}, @code{roundl}, @code{snprintf},
+@code{trunc}, @code{truncf}, @code{truncl},
+@code{vscanf}, @code{vsnprintf} and @code{vsscanf}
+are handled as built-in functions
+except in strict ISO C90 mode (@option{-ansi} or @option{-std=c89}).
+
+There are also built-in versions of the ISO C99 functions @code{atan2f},
+@code{atan2l}, @code{atanf}, @code{atanl}, @code{ceilf}, @code{ceill},
+@code{cosf}, @code{cosl},
+@code{expf}, @code{expl}, @code{fabsf}, @code{fabsl}, @code{floorf},
+@code{floorl}, @code{fmodf}, @code{fmodl},
+@code{logf}, @code{logl}, @code{powf}, @code{powl},
+@code{sinf}, @code{sinl}, @code{sqrtf}, @code{sqrtl},
+@code{tanf} and @code{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 @code{__builtin_}.
+
+The ISO C90 functions @code{abort}, @code{abs}, @code{atan}, @code{atan2},
+@code{calloc}, @code{ceil}, @code{cos}, @code{exit},
+@code{exp}, @code{fabs}, @code{floor}, @code{fmod},
+@code{fprintf}, @code{fputs}, @code{labs}, @code{log}, @code{malloc},
+@code{memcmp}, @code{memcpy}, @code{memset}, @code{pow}, @code{printf},
+@code{putchar}, @code{puts}, @code{scanf}, @code{sin}, @code{snprintf},
+@code{sprintf}, @code{sqrt}, @code{sscanf},
+@code{strcat}, @code{strchr}, @code{strcmp},
+@code{strcpy}, @code{strcspn}, @code{strlen}, @code{strncat}, @code{strncmp},
+@code{strncpy}, @code{strpbrk}, @code{strrchr}, @code{strspn}, @code{strstr},
+@code{tan}, @code{vprintf} and @code{vsprintf}
+are all recognized as built-in functions unless
+@option{-fno-builtin} is specified (or @option{-fno-builtin-@var{function}}
+is specified for an individual function). All of these functions have
+corresponding versions prefixed with @code{__builtin_}.
GCC provides built-in versions of the ISO C99 floating point comparison
macros that avoid raising exceptions for unordered operands. They have
depending on the arguments' types. For example:
@smallexample
-#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; \
+#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; \
@})
@end smallexample
Example:
@smallexample
-#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), \
- /* @r{The void expression results in a compile-time error} \
- @r{when assigning the result to something.} */ \
+#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), \
+ /* @r{The void expression results in a compile-time error} \
+ @r{when assigning the result to something.} */ \
(void)0))
@end smallexample
@smallexample
static const int table[] = @{
__builtin_constant_p (EXPRESSION) ? (EXPRESSION) : -1,
- /* ... */
+ /* @r{@dots{}} */
@};
@end smallexample
when testing pointer or floating-point values.
@end deftypefn
-@deftypefn {Built-in Function} void __builtin_prefetch (void *@var{addr}, ...)
+@deftypefn {Built-in Function} void __builtin_prefetch (const void *@var{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 @code{__builtin_prefetch} into code for which
a[i] = a[i] + b[i];
__builtin_prefetch (&a[i+j], 1, 1);
__builtin_prefetch (&b[i+j], 0, 1);
- /* ... */
+ /* @r{@dots{}} */
@}
@end smallexample
-Data prefetch does not generate faults if @var{addr} is invalid, but
+Data prefetch does not generate faults if @var{addr} is invalid, but
the address expression itself must be valid. For example, a prefetch
of @code{p->next} will not fault if @code{p->next} is not a valid
address, but evaluation will fault if @code{p} is not a valid address.
and GCC does not issue a warning.
@end deftypefn
-@node Pragmas
-@section Pragmas Accepted by GCC
-@cindex pragmas
-@cindex #pragma
+@deftypefn {Built-in Function} double __builtin_huge_val (void)
+Returns a positive infinity, if supported by the floating-point format,
+else @code{DBL_MAX}. This function is suitable for implementing the
+ISO C macro @code{HUGE_VAL}.
+@end deftypefn
-GCC supports several types of pragmas, primarily in order to compile
-code originally written for other compilers. Note that in general
-we do not recommend the use of pragmas; @xref{Function Attributes},
-for further explanation.
+@deftypefn {Built-in Function} float __builtin_huge_valf (void)
+Similar to @code{__builtin_huge_val}, except the return type is @code{float}.
+@end deftypefn
-@menu
-* ARM Pragmas::
-* Darwin Pragmas::
-@end menu
+@deftypefn {Built-in Function} {long double} __builtin_huge_vall (void)
+Similar to @code{__builtin_huge_val}, except the return
+type is @code{long double}.
+@end deftypefn
-@node ARM Pragmas
-@subsection ARM Pragmas
+@deftypefn {Built-in Function} double __builtin_inf (void)
+Similar to @code{__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 @code{INFINITY}.
+@end deftypefn
-The ARM target defines pragmas for controlling the default addition of
-@code{long_call} and @code{short_call} attributes to functions.
-@xref{Function Attributes}, for information about the effects of these
-attributes.
+@deftypefn {Built-in Function} float __builtin_inff (void)
+Similar to @code{__builtin_inf}, except the return type is @code{float}.
+@end deftypefn
-@table @code
-@item long_calls
-@cindex pragma, long_calls
-Set all subsequent functions to have the @code{long_call} attribute.
+@deftypefn {Built-in Function} {long double} __builtin_infl (void)
+Similar to @code{__builtin_inf}, except the return
+type is @code{long double}.
+@end deftypefn
-@item no_long_calls
-@cindex pragma, no_long_calls
-Set all subsequent functions to have the @code{short_call} attribute.
+@deftypefn {Built-in Function} double __builtin_nan (const char *str)
+This is an implementation of the ISO C99 function @code{nan}.
-@item long_calls_off
-@cindex pragma, long_calls_off
-Do not affect the @code{long_call} or @code{short_call} attributes of
+Since ISO C99 defines this function in terms of @code{strtod}, which we
+do not implement, a description of the parsing is in order. The string
+is parsed as by @code{strtol}; that is, the base is recognized by
+leading @samp{0} or @samp{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.
+@end deftypefn
+
+@deftypefn {Built-in Function} float __builtin_nanf (const char *str)
+Similar to @code{__builtin_nan}, except the return type is @code{float}.
+@end deftypefn
+
+@deftypefn {Built-in Function} {long double} __builtin_nanl (const char *str)
+Similar to @code{__builtin_nan}, except the return type is @code{long double}.
+@end deftypefn
+
+@deftypefn {Built-in Function} double __builtin_nans (const char *str)
+Similar to @code{__builtin_nan}, except the significand is forced
+to be a signaling NaN. The @code{nans} function is proposed by
+@uref{http://std.dkuug.dk/JTC1/SC22/WG14/www/docs/n965.htm,,WG14 N965}.
+@end deftypefn
+
+@deftypefn {Built-in Function} float __builtin_nansf (const char *str)
+Similar to @code{__builtin_nans}, except the return type is @code{float}.
+@end deftypefn
+
+@deftypefn {Built-in Function} {long double} __builtin_nansl (const char *str)
+Similar to @code{__builtin_nans}, except the return type is @code{long double}.
+@end deftypefn
+
+@deftypefn {Built-in Function} int __builtin_ffs (unsigned int x)
+Returns one plus the index of the least significant 1-bit of @var{x}, or
+if @var{x} is zero, returns zero.
+@end deftypefn
+
+@deftypefn {Built-in Function} int __builtin_clz (unsigned int x)
+Returns the number of leading 0-bits in @var{x}, starting at the most
+significant bit position. If @var{x} is 0, the result is undefined.
+@end deftypefn
+
+@deftypefn {Built-in Function} int __builtin_ctz (unsigned int x)
+Returns the number of trailing 0-bits in @var{x}, starting at the least
+significant bit position. If @var{x} is 0, the result is undefined.
+@end deftypefn
+
+@deftypefn {Built-in Function} int __builtin_popcount (unsigned int x)
+Returns the number of 1-bits in @var{x}.
+@end deftypefn
+
+@deftypefn {Built-in Function} int __builtin_parity (unsigned int x)
+Returns the parity of @var{x}, i.@:e. the number of 1-bits in @var{x}
+modulo 2.
+@end deftypefn
+
+@deftypefn {Built-in Function} int __builtin_ffsl (unsigned long)
+Similar to @code{__builtin_ffs}, except the argument type is
+@code{unsigned long}.
+@end deftypefn
+
+@deftypefn {Built-in Function} int __builtin_clzl (unsigned long)
+Similar to @code{__builtin_clz}, except the argument type is
+@code{unsigned long}.
+@end deftypefn
+
+@deftypefn {Built-in Function} int __builtin_ctzl (unsigned long)
+Similar to @code{__builtin_ctz}, except the argument type is
+@code{unsigned long}.
+@end deftypefn
+
+@deftypefn {Built-in Function} int __builtin_popcountl (unsigned long)
+Similar to @code{__builtin_popcount}, except the argument type is
+@code{unsigned long}.
+@end deftypefn
+
+@deftypefn {Built-in Function} int __builtin_parityl (unsigned long)
+Similar to @code{__builtin_parity}, except the argument type is
+@code{unsigned long}.
+@end deftypefn
+
+@deftypefn {Built-in Function} int __builtin_ffsll (unsigned long long)
+Similar to @code{__builtin_ffs}, except the argument type is
+@code{unsigned long long}.
+@end deftypefn
+
+@deftypefn {Built-in Function} int __builtin_clzll (unsigned long long)
+Similar to @code{__builtin_clz}, except the argument type is
+@code{unsigned long long}.
+@end deftypefn
+
+@deftypefn {Built-in Function} int __builtin_ctzll (unsigned long long)
+Similar to @code{__builtin_ctz}, except the argument type is
+@code{unsigned long long}.
+@end deftypefn
+
+@deftypefn {Built-in Function} int __builtin_popcountll (unsigned long long)
+Similar to @code{__builtin_popcount}, except the argument type is
+@code{unsigned long long}.
+@end deftypefn
+
+@deftypefn {Built-in Function} int __builtin_parityll (unsigned long long)
+Similar to @code{__builtin_parity}, except the argument type is
+@code{unsigned long long}.
+@end deftypefn
+
+
+@node Target Builtins
+@section 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::
+@end menu
+
+@node Alpha Built-in Functions
+@subsection 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.
+
+@example
+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)
+@end example
+
+The following built-in functions are always with @option{-mmax}
+or @option{-mcpu=@var{cpu}} where @var{cpu} is @code{pca56} or
+later. They all generate the machine instruction that is part
+of the name.
+
+@example
+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)
+@end example
+
+The following built-in functions are always with @option{-mcix}
+or @option{-mcpu=@var{cpu}} where @var{cpu} is @code{ev67} or
+later. They all generate the machine instruction that is part
+of the name.
+
+@example
+long __builtin_alpha_cttz (long)
+long __builtin_alpha_ctlz (long)
+long __builtin_alpha_ctpop (long)
+@end example
+
+The following builtins are available on systems that use the OSF/1
+PALcode. Normally they invoke the @code{rduniq} and @code{wruniq}
+PAL calls, but when invoked with @option{-mtls-kernel}, they invoke
+@code{rdval} and @code{wrval}.
+
+@example
+void *__builtin_thread_pointer (void)
+void __builtin_set_thread_pointer (void *)
+@end example
+
+@node ARM Built-in Functions
+@subsection ARM Built-in Functions
+
+These built-in functions are available for the ARM family of
+processors, when the @option{-mcpu=iwmmxt} switch is used:
+
+@example
+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)
+@end example
+
+@node X86 Built-in Functions
+@subsection 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
+(@pxref{Vector Extensions}): @code{V2SI} for a vector of two 32-bit integers,
+@code{V4HI} for a vector of four 16-bit integers, and @code{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 @code{DI} as their mode.
+
+If 3Dnow extensions are enabled, @code{V2SF} is used as a mode for a vector
+of two 32-bit floating point values.
+
+If SSE extensions are enabled, @code{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 @code{V4SI}. Finally, some instructions operate on an
+entire vector register, interpreting it as a 128-bit integer, these use mode
+@code{TI}.
+
+The following built-in functions are made available by @option{-mmmx}.
+All of them generate the machine instruction that is part of the name.
+
+@example
+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)
+@end example
+
+The following built-in functions are made available either with
+@option{-msse}, or with a combination of @option{-m3dnow} and
+@option{-march=athlon}. All of them generate the machine
+instruction that is part of the name.
+
+@example
+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)
+@end example
+
+The following built-in functions are available when @option{-msse} is used.
+All of them generate the machine instruction that is part of the name.
+
+@example
+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)
+@end example
+
+The following built-in functions are available when @option{-msse} is used.
+
+@table @code
+@item v4sf __builtin_ia32_loadaps (float *)
+Generates the @code{movaps} machine instruction as a load from memory.
+@item void __builtin_ia32_storeaps (float *, v4sf)
+Generates the @code{movaps} machine instruction as a store to memory.
+@item v4sf __builtin_ia32_loadups (float *)
+Generates the @code{movups} machine instruction as a load from memory.
+@item void __builtin_ia32_storeups (float *, v4sf)
+Generates the @code{movups} machine instruction as a store to memory.
+@item v4sf __builtin_ia32_loadsss (float *)
+Generates the @code{movss} machine instruction as a load from memory.
+@item void __builtin_ia32_storess (float *, v4sf)
+Generates the @code{movss} machine instruction as a store to memory.
+@item v4sf __builtin_ia32_loadhps (v4sf, v2si *)
+Generates the @code{movhps} machine instruction as a load from memory.
+@item v4sf __builtin_ia32_loadlps (v4sf, v2si *)
+Generates the @code{movlps} machine instruction as a load from memory
+@item void __builtin_ia32_storehps (v4sf, v2si *)
+Generates the @code{movhps} machine instruction as a store to memory.
+@item void __builtin_ia32_storelps (v4sf, v2si *)
+Generates the @code{movlps} machine instruction as a store to memory.
+@end table
+
+The following built-in functions are available when @option{-m3dnow} is used.
+All of them generate the machine instruction that is part of the name.
+
+@example
+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)
+@end example
+
+The following built-in functions are available when both @option{-m3dnow}
+and @option{-march=athlon} are used. All of them generate the machine
+instruction that is part of the name.
+
+@example
+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)
+@end example
+
+@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.
+
+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.
+
+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.
+
+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:
+
+@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.
+
+@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);
+
+vector signed char vec_abss (vector signed char, vector signed char);
+vector signed short vec_abss (vector signed short, vector signed short);
+
+vector signed char vec_add (vector signed char, vector signed char);
+vector unsigned char vec_add (vector signed char, vector unsigned char);
+
+vector unsigned char vec_add (vector unsigned char, vector signed char);
+
+vector unsigned char vec_add (vector unsigned char,
+ vector unsigned char);
+vector signed short vec_add (vector signed short, vector signed short);
+vector unsigned short vec_add (vector signed short,
+ vector unsigned short);
+vector unsigned short vec_add (vector unsigned short,
+ vector signed short);
+vector unsigned short vec_add (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_add (vector signed int, vector signed int);
+vector unsigned int vec_add (vector signed int, vector unsigned int);
+vector unsigned int vec_add (vector unsigned int, vector signed int);
+vector unsigned int vec_add (vector unsigned int, vector unsigned int);
+vector float vec_add (vector float, vector float);
+
+vector unsigned int vec_addc (vector unsigned int, vector unsigned int);
+
+vector unsigned char vec_adds (vector signed char,
+ vector unsigned char);
+vector unsigned char vec_adds (vector unsigned char,
+ vector signed char);
+vector unsigned char vec_adds (vector unsigned char,
+ vector unsigned char);
+vector signed char vec_adds (vector signed char, vector signed char);
+vector unsigned short vec_adds (vector signed short,
+ vector unsigned short);
+vector unsigned short vec_adds (vector unsigned short,
+ vector signed short);
+vector unsigned short vec_adds (vector unsigned short,
+ vector unsigned short);
+vector signed short vec_adds (vector signed short, vector signed short);
+
+vector unsigned int vec_adds (vector signed int, vector unsigned int);
+vector unsigned int vec_adds (vector unsigned int, vector signed int);
+vector unsigned int vec_adds (vector unsigned int, vector unsigned int);
+
+vector signed int vec_adds (vector signed int, vector signed int);
+
+vector float vec_and (vector float, vector float);
+vector float vec_and (vector float, vector signed int);
+vector float vec_and (vector signed int, vector float);
+vector signed int vec_and (vector signed int, vector signed int);
+vector unsigned int vec_and (vector signed int, vector unsigned int);
+vector unsigned int vec_and (vector unsigned int, vector signed int);
+vector unsigned int vec_and (vector unsigned int, vector unsigned int);
+vector signed short vec_and (vector signed short, vector signed short);
+vector unsigned short vec_and (vector signed short,
+ vector unsigned short);
+vector unsigned short vec_and (vector unsigned short,
+ vector signed short);
+vector unsigned short vec_and (vector unsigned short,
+ vector unsigned short);
+vector signed char vec_and (vector signed char, vector signed char);
+vector unsigned char vec_and (vector signed char, vector unsigned char);
+
+vector unsigned char vec_and (vector unsigned char, vector signed char);
+
+vector unsigned char vec_and (vector unsigned char,
+ vector unsigned char);
+
+vector float vec_andc (vector float, vector float);
+vector float vec_andc (vector float, vector signed int);
+vector float vec_andc (vector signed int, vector float);
+vector signed int vec_andc (vector signed int, vector signed int);
+vector unsigned int vec_andc (vector signed int, vector unsigned int);
+vector unsigned int vec_andc (vector unsigned int, vector signed int);
+vector unsigned int vec_andc (vector unsigned int, vector unsigned int);
+
+vector signed short vec_andc (vector signed short, vector signed short);
+
+vector unsigned short vec_andc (vector signed short,
+ vector unsigned short);
+vector unsigned short vec_andc (vector unsigned short,
+ vector signed short);
+vector unsigned short vec_andc (vector unsigned short,
+ vector unsigned short);
+vector signed char vec_andc (vector signed char, vector signed char);
+vector unsigned char vec_andc (vector signed char,
+ vector unsigned char);
+vector unsigned char vec_andc (vector unsigned char,
+ vector signed char);
+vector unsigned char vec_andc (vector unsigned char,
+ vector unsigned char);
+
+vector unsigned char vec_avg (vector unsigned char,
+ vector unsigned char);
+vector signed char vec_avg (vector signed char, vector signed char);
+vector unsigned short vec_avg (vector unsigned short,
+ vector unsigned short);
+vector signed short vec_avg (vector signed short, vector signed short);
+vector unsigned int vec_avg (vector unsigned int, vector unsigned int);
+vector signed int vec_avg (vector signed int, vector signed int);
+
+vector float vec_ceil (vector float);
+
+vector signed int vec_cmpb (vector float, vector float);
+
+vector signed char vec_cmpeq (vector signed char, vector signed char);
+vector signed char vec_cmpeq (vector unsigned char,
+ vector unsigned char);
+vector signed short vec_cmpeq (vector signed short,
+ vector signed short);
+vector signed short vec_cmpeq (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_cmpeq (vector signed int, vector signed int);
+vector signed int vec_cmpeq (vector unsigned int, vector unsigned int);
+vector signed int vec_cmpeq (vector float, vector float);
+
+vector signed int vec_cmpge (vector float, vector float);
+
+vector signed char vec_cmpgt (vector unsigned char,
+ vector unsigned char);
+vector signed char vec_cmpgt (vector signed char, vector signed char);
+vector signed short vec_cmpgt (vector unsigned short,
+ vector unsigned short);
+vector signed short vec_cmpgt (vector signed short,
+ vector signed short);
+vector signed int vec_cmpgt (vector unsigned int, vector unsigned int);
+vector signed int vec_cmpgt (vector signed int, vector signed int);
+vector signed int vec_cmpgt (vector float, vector float);
+
+vector signed int vec_cmple (vector float, vector float);
+
+vector signed char vec_cmplt (vector unsigned char,
+ vector unsigned char);
+vector signed char vec_cmplt (vector signed char, vector signed char);
+vector signed short vec_cmplt (vector unsigned short,
+ vector unsigned short);
+vector signed short vec_cmplt (vector signed short,
+ vector signed short);
+vector signed int vec_cmplt (vector unsigned int, vector unsigned int);
+vector signed int vec_cmplt (vector signed int, vector signed int);
+vector signed int vec_cmplt (vector float, vector float);
+
+vector float vec_ctf (vector unsigned int, const char);
+vector float vec_ctf (vector signed int, const char);
+
+vector signed int vec_cts (vector float, const char);
+
+vector unsigned int vec_ctu (vector float, const char);
+
+void vec_dss (const char);
+
+void vec_dssall (void);
+
+void vec_dst (void *, int, const char);
+
+void vec_dstst (void *, int, const char);
+
+void vec_dststt (void *, int, const char);
+
+void vec_dstt (void *, int, const char);
+
+vector float vec_expte (vector float, vector float);
+
+vector float vec_floor (vector float, vector float);
+
+vector float vec_ld (int, vector float *);
+vector float vec_ld (int, float *):
+vector signed int vec_ld (int, int *);
+vector signed int vec_ld (int, vector signed int *);
+vector unsigned int vec_ld (int, vector unsigned int *);
+vector unsigned int vec_ld (int, unsigned int *);
+vector signed short vec_ld (int, short *, vector signed short *);
+vector unsigned short vec_ld (int, unsigned short *,
+ vector unsigned short *);
+vector signed char vec_ld (int, signed char *);
+vector signed char vec_ld (int, vector signed char *);
+vector unsigned char vec_ld (int, unsigned char *);
+vector unsigned char vec_ld (int, vector unsigned char *);
+
+vector signed char vec_lde (int, signed char *);
+vector unsigned char vec_lde (int, unsigned char *);
+vector signed short vec_lde (int, short *);
+vector unsigned short vec_lde (int, unsigned short *);
+vector float vec_lde (int, float *);
+vector signed int vec_lde (int, int *);
+vector unsigned int vec_lde (int, unsigned int *);
+
+void float vec_ldl (int, float *);
+void float vec_ldl (int, vector float *);
+void signed int vec_ldl (int, vector signed int *);
+void signed int vec_ldl (int, int *);
+void unsigned int vec_ldl (int, unsigned int *);
+void unsigned int vec_ldl (int, vector unsigned int *);
+void signed short vec_ldl (int, vector signed short *);
+void signed short vec_ldl (int, short *);
+void unsigned short vec_ldl (int, vector unsigned short *);
+void unsigned short vec_ldl (int, unsigned short *);
+void signed char vec_ldl (int, vector signed char *);
+void signed char vec_ldl (int, signed char *);
+void unsigned char vec_ldl (int, vector unsigned char *);
+void unsigned char vec_ldl (int, unsigned char *);
+
+vector float vec_loge (vector float);
+
+vector unsigned char vec_lvsl (int, void *, int *);
+
+vector unsigned char vec_lvsr (int, void *, int *);
+
+vector float vec_madd (vector float, vector float, vector float);
+
+vector signed short vec_madds (vector signed short, vector signed short,
+ vector signed short);
+
+vector unsigned char vec_max (vector signed char, vector unsigned char);
+
+vector unsigned char vec_max (vector unsigned char, vector signed char);
+
+vector unsigned char vec_max (vector unsigned char,
+ vector unsigned char);
+vector signed char vec_max (vector signed char, vector signed char);
+vector unsigned short vec_max (vector signed short,
+ vector unsigned short);
+vector unsigned short vec_max (vector unsigned short,
+ vector signed short);
+vector unsigned short vec_max (vector unsigned short,
+ vector unsigned short);
+vector signed short vec_max (vector signed short, vector signed short);
+vector unsigned int vec_max (vector signed int, vector unsigned int);
+vector unsigned int vec_max (vector unsigned int, vector signed int);
+vector unsigned int vec_max (vector unsigned int, vector unsigned int);
+vector signed int vec_max (vector signed int, vector signed int);
+vector float vec_max (vector float, vector float);
+
+vector signed char vec_mergeh (vector signed char, vector signed char);
+vector unsigned char vec_mergeh (vector unsigned char,
+ vector unsigned char);
+vector signed short vec_mergeh (vector signed short,
+ vector signed short);
+vector unsigned short vec_mergeh (vector unsigned short,
+ vector unsigned short);
+vector float vec_mergeh (vector float, vector float);
+vector signed int vec_mergeh (vector signed int, vector signed int);
+vector unsigned int vec_mergeh (vector unsigned int,
+ vector unsigned int);
+
+vector signed char vec_mergel (vector signed char, vector signed char);
+vector unsigned char vec_mergel (vector unsigned char,
+ vector unsigned char);
+vector signed short vec_mergel (vector signed short,
+ vector signed short);
+vector unsigned short vec_mergel (vector unsigned short,
+ vector unsigned short);
+vector float vec_mergel (vector float, vector float);
+vector signed int vec_mergel (vector signed int, vector signed int);
+vector unsigned int vec_mergel (vector unsigned int,
+ vector unsigned int);
+
+vector unsigned short vec_mfvscr (void);
+
+vector unsigned char vec_min (vector signed char, vector unsigned char);
+
+vector unsigned char vec_min (vector unsigned char, vector signed char);
+
+vector unsigned char vec_min (vector unsigned char,
+ vector unsigned char);
+vector signed char vec_min (vector signed char, vector signed char);
+vector unsigned short vec_min (vector signed short,
+ vector unsigned short);
+vector unsigned short vec_min (vector unsigned short,
+ vector signed short);
+vector unsigned short vec_min (vector unsigned short,
+ vector unsigned short);
+vector signed short vec_min (vector signed short, vector signed short);
+vector unsigned int vec_min (vector signed int, vector unsigned int);
+vector unsigned int vec_min (vector unsigned int, vector signed int);
+vector unsigned int vec_min (vector unsigned int, vector unsigned int);
+vector signed int vec_min (vector signed int, vector signed int);
+vector float vec_min (vector float, vector float);
+
+vector signed short vec_mladd (vector signed short, vector signed short,
+ vector signed short);
+vector signed short vec_mladd (vector signed short,
+ vector unsigned short,
+ vector unsigned short);
+vector signed short vec_mladd (vector unsigned short,
+ vector signed short,
+ vector signed short);
+vector unsigned short vec_mladd (vector unsigned short,
+ vector unsigned short,
+ vector unsigned short);
+
+vector signed short vec_mradds (vector signed short,
+ vector signed short,
+ vector signed short);
+
+vector unsigned int vec_msum (vector unsigned char,
+ vector unsigned char,
+ vector unsigned int);
+vector signed int vec_msum (vector signed char, vector unsigned char,
+ vector signed int);
+vector unsigned int vec_msum (vector unsigned short,
+ vector unsigned short,
+ vector unsigned int);
+vector signed int vec_msum (vector signed short, vector signed short,
+ vector signed int);
+
+vector unsigned int vec_msums (vector unsigned short,
+ vector unsigned short,
+ vector unsigned int);
+vector signed int vec_msums (vector signed short, vector signed short,
+ vector signed int);
+
+void vec_mtvscr (vector signed int);
+void vec_mtvscr (vector unsigned int);
+void vec_mtvscr (vector signed short);
+void vec_mtvscr (vector unsigned short);
+void vec_mtvscr (vector signed char);
+void vec_mtvscr (vector unsigned char);
+
+vector unsigned short vec_mule (vector unsigned char,
+ vector unsigned char);
+vector signed short vec_mule (vector signed char, vector signed char);
+vector unsigned int vec_mule (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_mule (vector signed short, vector signed short);
+
+vector unsigned short vec_mulo (vector unsigned char,
+ vector unsigned char);
+vector signed short vec_mulo (vector signed char, vector signed char);
+vector unsigned int vec_mulo (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_mulo (vector signed short, vector signed short);
+
+vector float vec_nmsub (vector float, vector float, vector float);
+
+vector float vec_nor (vector float, vector float);
+vector signed int vec_nor (vector signed int, vector signed int);
+vector unsigned int vec_nor (vector unsigned int, vector unsigned int);
+vector signed short vec_nor (vector signed short, vector signed short);
+vector unsigned short vec_nor (vector unsigned short,
+ vector unsigned short);
+vector signed char vec_nor (vector signed char, vector signed char);
+vector unsigned char vec_nor (vector unsigned char,
+ vector unsigned char);
+
+vector float vec_or (vector float, vector float);
+vector float vec_or (vector float, vector signed int);
+vector float vec_or (vector signed int, vector float);
+vector signed int vec_or (vector signed int, vector signed int);
+vector unsigned int vec_or (vector signed int, vector unsigned int);
+vector unsigned int vec_or (vector unsigned int, vector signed int);
+vector unsigned int vec_or (vector unsigned int, vector unsigned int);
+vector signed short vec_or (vector signed short, vector signed short);
+vector unsigned short vec_or (vector signed short,
+ vector unsigned short);
+vector unsigned short vec_or (vector unsigned short,
+ vector signed short);
+vector unsigned short vec_or (vector unsigned short,
+ vector unsigned short);
+vector signed char vec_or (vector signed char, vector signed char);
+vector unsigned char vec_or (vector signed char, vector unsigned char);
+vector unsigned char vec_or (vector unsigned char, vector signed char);
+vector unsigned char vec_or (vector unsigned char,
+ vector unsigned char);
+
+vector signed char vec_pack (vector signed short, vector signed short);
+vector unsigned char vec_pack (vector unsigned short,
+ vector unsigned short);
+vector signed short vec_pack (vector signed int, vector signed int);
+vector unsigned short vec_pack (vector unsigned int,
+ vector unsigned int);
+
+vector signed short vec_packpx (vector unsigned int,
+ vector unsigned int);
+
+vector unsigned char vec_packs (vector unsigned short,
+ vector unsigned short);
+vector signed char vec_packs (vector signed short, vector signed short);
+
+vector unsigned short vec_packs (vector unsigned int,
+ vector unsigned int);
+vector signed short vec_packs (vector signed int, vector signed int);
+
+vector unsigned char vec_packsu (vector unsigned short,
+ vector unsigned short);
+vector unsigned char vec_packsu (vector signed short,
+ vector signed short);
+vector unsigned short vec_packsu (vector unsigned int,
+ vector unsigned int);
+vector unsigned short vec_packsu (vector signed int, vector signed int);
+
+vector float vec_perm (vector float, vector float,
+ vector unsigned char);
+vector signed int vec_perm (vector signed int, vector signed int,
+ vector unsigned char);
+vector unsigned int vec_perm (vector unsigned int, vector unsigned int,
+ vector unsigned char);
+vector signed short vec_perm (vector signed short, vector signed short,
+ vector unsigned char);
+vector unsigned short vec_perm (vector unsigned short,
+ vector unsigned short,
+ vector unsigned char);
+vector signed char vec_perm (vector signed char, vector signed char,
+ vector unsigned char);
+vector unsigned char vec_perm (vector unsigned char,
+ vector unsigned char,
+ vector unsigned char);
+
+vector float vec_re (vector float);
+
+vector signed char vec_rl (vector signed char, vector unsigned char);
+vector unsigned char vec_rl (vector unsigned char,
+ vector unsigned char);
+vector signed short vec_rl (vector signed short, vector unsigned short);
+
+vector unsigned short vec_rl (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_rl (vector signed int, vector unsigned int);
+vector unsigned int vec_rl (vector unsigned int, vector unsigned int);
+
+vector float vec_round (vector float);
+
+vector float vec_rsqrte (vector float);
+
+vector float vec_sel (vector float, vector float, vector signed int);
+vector float vec_sel (vector float, vector float, vector unsigned int);
+vector signed int vec_sel (vector signed int, vector signed int,
+ vector signed int);
+vector signed int vec_sel (vector signed int, vector signed int,
+ vector unsigned int);
+vector unsigned int vec_sel (vector unsigned int, vector unsigned int,
+ vector signed int);
+vector unsigned int vec_sel (vector unsigned int, vector unsigned int,
+ vector unsigned int);
+vector signed short vec_sel (vector signed short, vector signed short,
+ vector signed short);
+vector signed short vec_sel (vector signed short, vector signed short,
+ vector unsigned short);
+vector unsigned short vec_sel (vector unsigned short,
+ vector unsigned short,
+ vector signed short);
+vector unsigned short vec_sel (vector unsigned short,
+ vector unsigned short,
+ vector unsigned short);
+vector signed char vec_sel (vector signed char, vector signed char,
+ vector signed char);
+vector signed char vec_sel (vector signed char, vector signed char,
+ vector unsigned char);
+vector unsigned char vec_sel (vector unsigned char,
+ vector unsigned char,
+ vector signed char);
+vector unsigned char vec_sel (vector unsigned char,
+ vector unsigned char,
+ vector unsigned char);
+
+vector signed char vec_sl (vector signed char, vector unsigned char);
+vector unsigned char vec_sl (vector unsigned char,
+ vector unsigned char);
+vector signed short vec_sl (vector signed short, vector unsigned short);
+
+vector unsigned short vec_sl (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_sl (vector signed int, vector unsigned int);
+vector unsigned int vec_sl (vector unsigned int, vector unsigned int);
+
+vector float vec_sld (vector float, vector float, const char);
+vector signed int vec_sld (vector signed int, vector signed int,
+ const char);
+vector unsigned int vec_sld (vector unsigned int, vector unsigned int,
+ const char);
+vector signed short vec_sld (vector signed short, vector signed short,
+ const char);
+vector unsigned short vec_sld (vector unsigned short,
+ vector unsigned short, const char);
+vector signed char vec_sld (vector signed char, vector signed char,
+ const char);
+vector unsigned char vec_sld (vector unsigned char,
+ vector unsigned char,
+ const char);
+
+vector signed int vec_sll (vector signed int, vector unsigned int);
+vector signed int vec_sll (vector signed int, vector unsigned short);
+vector signed int vec_sll (vector signed int, vector unsigned char);
+vector unsigned int vec_sll (vector unsigned int, vector unsigned int);
+vector unsigned int vec_sll (vector unsigned int,
+ vector unsigned short);
+vector unsigned int vec_sll (vector unsigned int, vector unsigned char);
+
+vector signed short vec_sll (vector signed short, vector unsigned int);
+vector signed short vec_sll (vector signed short,
+ vector unsigned short);
+vector signed short vec_sll (vector signed short, vector unsigned char);
+
+vector unsigned short vec_sll (vector unsigned short,
+ vector unsigned int);
+vector unsigned short vec_sll (vector unsigned short,
+ vector unsigned short);
+vector unsigned short vec_sll (vector unsigned short,
+ vector unsigned char);
+vector signed char vec_sll (vector signed char, vector unsigned int);
+vector signed char vec_sll (vector signed char, vector unsigned short);
+vector signed char vec_sll (vector signed char, vector unsigned char);
+vector unsigned char vec_sll (vector unsigned char,
+ vector unsigned int);
+vector unsigned char vec_sll (vector unsigned char,
+ vector unsigned short);
+vector unsigned char vec_sll (vector unsigned char,
+ vector unsigned char);
+
+vector float vec_slo (vector float, vector signed char);
+vector float vec_slo (vector float, vector unsigned char);
+vector signed int vec_slo (vector signed int, vector signed char);
+vector signed int vec_slo (vector signed int, vector unsigned char);
+vector unsigned int vec_slo (vector unsigned int, vector signed char);
+vector unsigned int vec_slo (vector unsigned int, vector unsigned char);
+
+vector signed short vec_slo (vector signed short, vector signed char);
+vector signed short vec_slo (vector signed short, vector unsigned char);
+
+vector unsigned short vec_slo (vector unsigned short,
+ vector signed char);
+vector unsigned short vec_slo (vector unsigned short,
+ vector unsigned char);
+vector signed char vec_slo (vector signed char, vector signed char);
+vector signed char vec_slo (vector signed char, vector unsigned char);
+vector unsigned char vec_slo (vector unsigned char, vector signed char);
+
+vector unsigned char vec_slo (vector unsigned char,
+ vector unsigned char);
+
+vector signed char vec_splat (vector signed char, const char);
+vector unsigned char vec_splat (vector unsigned char, const char);
+vector signed short vec_splat (vector signed short, const char);
+vector unsigned short vec_splat (vector unsigned short, const char);
+vector float vec_splat (vector float, const char);
+vector signed int vec_splat (vector signed int, const char);
+vector unsigned int vec_splat (vector unsigned int, const char);
+
+vector signed char vec_splat_s8 (const char);
+
+vector signed short vec_splat_s16 (const char);
+
+vector signed int vec_splat_s32 (const char);
+
+vector unsigned char vec_splat_u8 (const char);
+
+vector unsigned short vec_splat_u16 (const char);
+
+vector unsigned int vec_splat_u32 (const char);
+
+vector signed char vec_sr (vector signed char, vector unsigned char);
+vector unsigned char vec_sr (vector unsigned char,
+ vector unsigned char);
+vector signed short vec_sr (vector signed short, vector unsigned short);
+
+vector unsigned short vec_sr (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_sr (vector signed int, vector unsigned int);
+vector unsigned int vec_sr (vector unsigned int, vector unsigned int);
+
+vector signed char vec_sra (vector signed char, vector unsigned char);
+vector unsigned char vec_sra (vector unsigned char,
+ vector unsigned char);
+vector signed short vec_sra (vector signed short,
+ vector unsigned short);
+vector unsigned short vec_sra (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_sra (vector signed int, vector unsigned int);
+vector unsigned int vec_sra (vector unsigned int, vector unsigned int);
+
+vector signed int vec_srl (vector signed int, vector unsigned int);
+vector signed int vec_srl (vector signed int, vector unsigned short);
+vector signed int vec_srl (vector signed int, vector unsigned char);
+vector unsigned int vec_srl (vector unsigned int, vector unsigned int);
+vector unsigned int vec_srl (vector unsigned int,
+ vector unsigned short);
+vector unsigned int vec_srl (vector unsigned int, vector unsigned char);
+
+vector signed short vec_srl (vector signed short, vector unsigned int);
+vector signed short vec_srl (vector signed short,
+ vector unsigned short);
+vector signed short vec_srl (vector signed short, vector unsigned char);
+
+vector unsigned short vec_srl (vector unsigned short,
+ vector unsigned int);
+vector unsigned short vec_srl (vector unsigned short,
+ vector unsigned short);
+vector unsigned short vec_srl (vector unsigned short,
+ vector unsigned char);
+vector signed char vec_srl (vector signed char, vector unsigned int);
+vector signed char vec_srl (vector signed char, vector unsigned short);
+vector signed char vec_srl (vector signed char, vector unsigned char);
+vector unsigned char vec_srl (vector unsigned char,
+ vector unsigned int);
+vector unsigned char vec_srl (vector unsigned char,
+ vector unsigned short);
+vector unsigned char vec_srl (vector unsigned char,
+ vector unsigned char);
+
+vector float vec_sro (vector float, vector signed char);
+vector float vec_sro (vector float, vector unsigned char);
+vector signed int vec_sro (vector signed int, vector signed char);
+vector signed int vec_sro (vector signed int, vector unsigned char);
+vector unsigned int vec_sro (vector unsigned int, vector signed char);
+vector unsigned int vec_sro (vector unsigned int, vector unsigned char);
+
+vector signed short vec_sro (vector signed short, vector signed char);
+vector signed short vec_sro (vector signed short, vector unsigned char);
+
+vector unsigned short vec_sro (vector unsigned short,
+ vector signed char);
+vector unsigned short vec_sro (vector unsigned short,
+ vector unsigned char);
+vector signed char vec_sro (vector signed char, vector signed char);
+vector signed char vec_sro (vector signed char, vector unsigned char);
+vector unsigned char vec_sro (vector unsigned char, vector signed char);
+
+vector unsigned char vec_sro (vector unsigned char,
+ vector unsigned char);
+
+void vec_st (vector float, int, float *);
+void vec_st (vector float, int, vector float *);
+void vec_st (vector signed int, int, int *);
+void vec_st (vector signed int, int, unsigned int *);
+void vec_st (vector unsigned int, int, unsigned int *);
+void vec_st (vector unsigned int, int, vector unsigned int *);
+void vec_st (vector signed short, int, short *);
+void vec_st (vector signed short, int, vector unsigned short *);
+void vec_st (vector signed short, int, vector signed short *);
+void vec_st (vector unsigned short, int, unsigned short *);
+void vec_st (vector unsigned short, int, vector unsigned short *);
+void vec_st (vector signed char, int, signed char *);
+void vec_st (vector signed char, int, unsigned char *);
+void vec_st (vector signed char, int, vector signed char *);
+void vec_st (vector unsigned char, int, unsigned char *);
+void vec_st (vector unsigned char, int, vector unsigned char *);
+
+void vec_ste (vector signed char, int, unsigned char *);
+void vec_ste (vector signed char, int, signed char *);
+void vec_ste (vector unsigned char, int, unsigned char *);
+void vec_ste (vector signed short, int, short *);
+void vec_ste (vector signed short, int, unsigned short *);
+void vec_ste (vector unsigned short, int, void *);
+void vec_ste (vector signed int, int, unsigned int *);
+void vec_ste (vector signed int, int, int *);
+void vec_ste (vector unsigned int, int, unsigned int *);
+void vec_ste (vector float, int, float *);
+
+void vec_stl (vector float, int, vector float *);
+void vec_stl (vector float, int, float *);
+void vec_stl (vector signed int, int, vector signed int *);
+void vec_stl (vector signed int, int, int *);
+void vec_stl (vector signed int, int, unsigned int *);
+void vec_stl (vector unsigned int, int, vector unsigned int *);
+void vec_stl (vector unsigned int, int, unsigned int *);
+void vec_stl (vector signed short, int, short *);
+void vec_stl (vector signed short, int, unsigned short *);
+void vec_stl (vector signed short, int, vector signed short *);
+void vec_stl (vector unsigned short, int, unsigned short *);
+void vec_stl (vector unsigned short, int, vector signed short *);
+void vec_stl (vector signed char, int, signed char *);
+void vec_stl (vector signed char, int, unsigned char *);
+void vec_stl (vector signed char, int, vector signed char *);
+void vec_stl (vector unsigned char, int, unsigned char *);
+void vec_stl (vector unsigned char, int, vector unsigned char *);
+
+vector signed char vec_sub (vector signed char, vector signed char);
+vector unsigned char vec_sub (vector signed char, vector unsigned char);
+
+vector unsigned char vec_sub (vector unsigned char, vector signed char);
+
+vector unsigned char vec_sub (vector unsigned char,
+ vector unsigned char);
+vector signed short vec_sub (vector signed short, vector signed short);
+vector unsigned short vec_sub (vector signed short,
+ vector unsigned short);
+vector unsigned short vec_sub (vector unsigned short,
+ vector signed short);
+vector unsigned short vec_sub (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_sub (vector signed int, vector signed int);
+vector unsigned int vec_sub (vector signed int, vector unsigned int);
+vector unsigned int vec_sub (vector unsigned int, vector signed int);
+vector unsigned int vec_sub (vector unsigned int, vector unsigned int);
+vector float vec_sub (vector float, vector float);
+
+vector unsigned int vec_subc (vector unsigned int, vector unsigned int);
+
+vector unsigned char vec_subs (vector signed char,
+ vector unsigned char);
+vector unsigned char vec_subs (vector unsigned char,
+ vector signed char);
+vector unsigned char vec_subs (vector unsigned char,
+ vector unsigned char);
+vector signed char vec_subs (vector signed char, vector signed char);
+vector unsigned short vec_subs (vector signed short,
+ vector unsigned short);
+vector unsigned short vec_subs (vector unsigned short,
+ vector signed short);
+vector unsigned short vec_subs (vector unsigned short,
+ vector unsigned short);
+vector signed short vec_subs (vector signed short, vector signed short);
+
+vector unsigned int vec_subs (vector signed int, vector unsigned int);
+vector unsigned int vec_subs (vector unsigned int, vector signed int);
+vector unsigned int vec_subs (vector unsigned int, vector unsigned int);
+
+vector signed int vec_subs (vector signed int, vector signed int);
+
+vector unsigned int vec_sum4s (vector unsigned char,
+ vector unsigned int);
+vector signed int vec_sum4s (vector signed char, vector signed int);
+vector signed int vec_sum4s (vector signed short, vector signed int);
+
+vector signed int vec_sum2s (vector signed int, vector signed int);
+
+vector signed int vec_sums (vector signed int, vector signed int);
+
+vector float vec_trunc (vector float);
+
+vector signed short vec_unpackh (vector signed char);
+vector unsigned int vec_unpackh (vector signed short);
+vector signed int vec_unpackh (vector signed short);
+
+vector signed short vec_unpackl (vector signed char);
+vector unsigned int vec_unpackl (vector signed short);
+vector signed int vec_unpackl (vector signed short);
+
+vector float vec_xor (vector float, vector float);
+vector float vec_xor (vector float, vector signed int);
+vector float vec_xor (vector signed int, vector float);
+vector signed int vec_xor (vector signed int, vector signed int);
+vector unsigned int vec_xor (vector signed int, vector unsigned int);
+vector unsigned int vec_xor (vector unsigned int, vector signed int);
+vector unsigned int vec_xor (vector unsigned int, vector unsigned int);
+vector signed short vec_xor (vector signed short, vector signed short);
+vector unsigned short vec_xor (vector signed short,
+ vector unsigned short);
+vector unsigned short vec_xor (vector unsigned short,
+ vector signed short);
+vector unsigned short vec_xor (vector unsigned short,
+ vector unsigned short);
+vector signed char vec_xor (vector signed char, vector signed char);
+vector unsigned char vec_xor (vector signed char, vector unsigned char);
+
+vector unsigned char vec_xor (vector unsigned char, vector signed char);
+
+vector unsigned char vec_xor (vector unsigned char,
+ vector unsigned char);
+
+vector signed int vec_all_eq (vector signed char, vector unsigned char);
+
+vector signed int vec_all_eq (vector signed char, vector signed char);
+vector signed int vec_all_eq (vector unsigned char, vector signed char);
+
+vector signed int vec_all_eq (vector unsigned char,
+ vector unsigned char);
+vector signed int vec_all_eq (vector signed short,
+ vector unsigned short);
+vector signed int vec_all_eq (vector signed short, vector signed short);
+
+vector signed int vec_all_eq (vector unsigned short,
+ vector signed short);
+vector signed int vec_all_eq (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_all_eq (vector signed int, vector unsigned int);
+vector signed int vec_all_eq (vector signed int, vector signed int);
+vector signed int vec_all_eq (vector unsigned int, vector signed int);
+vector signed int vec_all_eq (vector unsigned int, vector unsigned int);
+
+vector signed int vec_all_eq (vector float, vector float);
+
+vector signed int vec_all_ge (vector signed char, vector unsigned char);
+
+vector signed int vec_all_ge (vector unsigned char, vector signed char);
+
+vector signed int vec_all_ge (vector unsigned char,
+ vector unsigned char);
+vector signed int vec_all_ge (vector signed char, vector signed char);
+vector signed int vec_all_ge (vector signed short,
+ vector unsigned short);
+vector signed int vec_all_ge (vector unsigned short,
+ vector signed short);
+vector signed int vec_all_ge (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_all_ge (vector signed short, vector signed short);
+
+vector signed int vec_all_ge (vector signed int, vector unsigned int);
+vector signed int vec_all_ge (vector unsigned int, vector signed int);
+vector signed int vec_all_ge (vector unsigned int, vector unsigned int);
+
+vector signed int vec_all_ge (vector signed int, vector signed int);
+vector signed int vec_all_ge (vector float, vector float);
+
+vector signed int vec_all_gt (vector signed char, vector unsigned char);
+
+vector signed int vec_all_gt (vector unsigned char, vector signed char);
+
+vector signed int vec_all_gt (vector unsigned char,
+ vector unsigned char);
+vector signed int vec_all_gt (vector signed char, vector signed char);
+vector signed int vec_all_gt (vector signed short,
+ vector unsigned short);
+vector signed int vec_all_gt (vector unsigned short,
+ vector signed short);
+vector signed int vec_all_gt (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_all_gt (vector signed short, vector signed short);
+
+vector signed int vec_all_gt (vector signed int, vector unsigned int);
+vector signed int vec_all_gt (vector unsigned int, vector signed int);
+vector signed int vec_all_gt (vector unsigned int, vector unsigned int);
+
+vector signed int vec_all_gt (vector signed int, vector signed int);
+vector signed int vec_all_gt (vector float, vector float);
+
+vector signed int vec_all_in (vector float, vector float);
+
+vector signed int vec_all_le (vector signed char, vector unsigned char);
+
+vector signed int vec_all_le (vector unsigned char, vector signed char);
+
+vector signed int vec_all_le (vector unsigned char,
+ vector unsigned char);
+vector signed int vec_all_le (vector signed char, vector signed char);
+vector signed int vec_all_le (vector signed short,
+ vector unsigned short);
+vector signed int vec_all_le (vector unsigned short,
+ vector signed short);
+vector signed int vec_all_le (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_all_le (vector signed short, vector signed short);
+
+vector signed int vec_all_le (vector signed int, vector unsigned int);
+vector signed int vec_all_le (vector unsigned int, vector signed int);
+vector signed int vec_all_le (vector unsigned int, vector unsigned int);
+
+vector signed int vec_all_le (vector signed int, vector signed int);
+vector signed int vec_all_le (vector float, vector float);
+
+vector signed int vec_all_lt (vector signed char, vector unsigned char);
+
+vector signed int vec_all_lt (vector unsigned char, vector signed char);
+
+vector signed int vec_all_lt (vector unsigned char,
+ vector unsigned char);
+vector signed int vec_all_lt (vector signed char, vector signed char);
+vector signed int vec_all_lt (vector signed short,
+ vector unsigned short);
+vector signed int vec_all_lt (vector unsigned short,
+ vector signed short);
+vector signed int vec_all_lt (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_all_lt (vector signed short, vector signed short);
+
+vector signed int vec_all_lt (vector signed int, vector unsigned int);
+vector signed int vec_all_lt (vector unsigned int, vector signed int);
+vector signed int vec_all_lt (vector unsigned int, vector unsigned int);
+
+vector signed int vec_all_lt (vector signed int, vector signed int);
+vector signed int vec_all_lt (vector float, vector float);
+
+vector signed int vec_all_nan (vector float);
+
+vector signed int vec_all_ne (vector signed char, vector unsigned char);
+
+vector signed int vec_all_ne (vector signed char, vector signed char);
+vector signed int vec_all_ne (vector unsigned char, vector signed char);
+
+vector signed int vec_all_ne (vector unsigned char,
+ vector unsigned char);
+vector signed int vec_all_ne (vector signed short,
+ vector unsigned short);
+vector signed int vec_all_ne (vector signed short, vector signed short);
+
+vector signed int vec_all_ne (vector unsigned short,
+ vector signed short);
+vector signed int vec_all_ne (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_all_ne (vector signed int, vector unsigned int);
+vector signed int vec_all_ne (vector signed int, vector signed int);
+vector signed int vec_all_ne (vector unsigned int, vector signed int);
+vector signed int vec_all_ne (vector unsigned int, vector unsigned int);
+
+vector signed int vec_all_ne (vector float, vector float);
+
+vector signed int vec_all_nge (vector float, vector float);
+
+vector signed int vec_all_ngt (vector float, vector float);
+
+vector signed int vec_all_nle (vector float, vector float);
+
+vector signed int vec_all_nlt (vector float, vector float);
+
+vector signed int vec_all_numeric (vector float);
+
+vector signed int vec_any_eq (vector signed char, vector unsigned char);
+
+vector signed int vec_any_eq (vector signed char, vector signed char);
+vector signed int vec_any_eq (vector unsigned char, vector signed char);
+
+vector signed int vec_any_eq (vector unsigned char,
+ vector unsigned char);
+vector signed int vec_any_eq (vector signed short,
+ vector unsigned short);
+vector signed int vec_any_eq (vector signed short, vector signed short);
+
+vector signed int vec_any_eq (vector unsigned short,
+ vector signed short);
+vector signed int vec_any_eq (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_any_eq (vector signed int, vector unsigned int);
+vector signed int vec_any_eq (vector signed int, vector signed int);
+vector signed int vec_any_eq (vector unsigned int, vector signed int);
+vector signed int vec_any_eq (vector unsigned int, vector unsigned int);
+
+vector signed int vec_any_eq (vector float, vector float);
+
+vector signed int vec_any_ge (vector signed char, vector unsigned char);
+
+vector signed int vec_any_ge (vector unsigned char, vector signed char);
+
+vector signed int vec_any_ge (vector unsigned char,
+ vector unsigned char);
+vector signed int vec_any_ge (vector signed char, vector signed char);
+vector signed int vec_any_ge (vector signed short,
+ vector unsigned short);
+vector signed int vec_any_ge (vector unsigned short,
+ vector signed short);
+vector signed int vec_any_ge (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_any_ge (vector signed short, vector signed short);
+
+vector signed int vec_any_ge (vector signed int, vector unsigned int);
+vector signed int vec_any_ge (vector unsigned int, vector signed int);
+vector signed int vec_any_ge (vector unsigned int, vector unsigned int);
+
+vector signed int vec_any_ge (vector signed int, vector signed int);
+vector signed int vec_any_ge (vector float, vector float);
+
+vector signed int vec_any_gt (vector signed char, vector unsigned char);
+
+vector signed int vec_any_gt (vector unsigned char, vector signed char);
+
+vector signed int vec_any_gt (vector unsigned char,
+ vector unsigned char);
+vector signed int vec_any_gt (vector signed char, vector signed char);
+vector signed int vec_any_gt (vector signed short,
+ vector unsigned short);
+vector signed int vec_any_gt (vector unsigned short,
+ vector signed short);
+vector signed int vec_any_gt (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_any_gt (vector signed short, vector signed short);
+
+vector signed int vec_any_gt (vector signed int, vector unsigned int);
+vector signed int vec_any_gt (vector unsigned int, vector signed int);
+vector signed int vec_any_gt (vector unsigned int, vector unsigned int);
+
+vector signed int vec_any_gt (vector signed int, vector signed int);
+vector signed int vec_any_gt (vector float, vector float);
+
+vector signed int vec_any_le (vector signed char, vector unsigned char);
+
+vector signed int vec_any_le (vector unsigned char, vector signed char);
+
+vector signed int vec_any_le (vector unsigned char,
+ vector unsigned char);
+vector signed int vec_any_le (vector signed char, vector signed char);
+vector signed int vec_any_le (vector signed short,
+ vector unsigned short);
+vector signed int vec_any_le (vector unsigned short,
+ vector signed short);
+vector signed int vec_any_le (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_any_le (vector signed short, vector signed short);
+
+vector signed int vec_any_le (vector signed int, vector unsigned int);
+vector signed int vec_any_le (vector unsigned int, vector signed int);
+vector signed int vec_any_le (vector unsigned int, vector unsigned int);
+
+vector signed int vec_any_le (vector signed int, vector signed int);
+vector signed int vec_any_le (vector float, vector float);
+
+vector signed int vec_any_lt (vector signed char, vector unsigned char);
+
+vector signed int vec_any_lt (vector unsigned char, vector signed char);
+
+vector signed int vec_any_lt (vector unsigned char,
+ vector unsigned char);
+vector signed int vec_any_lt (vector signed char, vector signed char);
+vector signed int vec_any_lt (vector signed short,
+ vector unsigned short);
+vector signed int vec_any_lt (vector unsigned short,
+ vector signed short);
+vector signed int vec_any_lt (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_any_lt (vector signed short, vector signed short);
+
+vector signed int vec_any_lt (vector signed int, vector unsigned int);
+vector signed int vec_any_lt (vector unsigned int, vector signed int);
+vector signed int vec_any_lt (vector unsigned int, vector unsigned int);
+
+vector signed int vec_any_lt (vector signed int, vector signed int);
+vector signed int vec_any_lt (vector float, vector float);
+
+vector signed int vec_any_nan (vector float);
+
+vector signed int vec_any_ne (vector signed char, vector unsigned char);
+
+vector signed int vec_any_ne (vector signed char, vector signed char);
+vector signed int vec_any_ne (vector unsigned char, vector signed char);
+
+vector signed int vec_any_ne (vector unsigned char,
+ vector unsigned char);
+vector signed int vec_any_ne (vector signed short,
+ vector unsigned short);
+vector signed int vec_any_ne (vector signed short, vector signed short);
+
+vector signed int vec_any_ne (vector unsigned short,
+ vector signed short);
+vector signed int vec_any_ne (vector unsigned short,
+ vector unsigned short);
+vector signed int vec_any_ne (vector signed int, vector unsigned int);
+vector signed int vec_any_ne (vector signed int, vector signed int);
+vector signed int vec_any_ne (vector unsigned int, vector signed int);
+vector signed int vec_any_ne (vector unsigned int, vector unsigned int);
+
+vector signed int vec_any_ne (vector float, vector float);
+
+vector signed int vec_any_nge (vector float, vector float);
+
+vector signed int vec_any_ngt (vector float, vector float);
+
+vector signed int vec_any_nle (vector float, vector float);
+
+vector signed int vec_any_nlt (vector float, vector float);
+
+vector signed int vec_any_numeric (vector float);
+
+vector signed int vec_any_out (vector float, vector float);
+@end smallexample
+
+@node Pragmas
+@section Pragmas Accepted by GCC
+@cindex pragmas
+@cindex #pragma
+
+GCC supports several types of pragmas, primarily in order to compile
+code originally written for other compilers. Note that in general
+we do not recommend the use of pragmas; @xref{Function Attributes},
+for further explanation.
+
+@menu
+* ARM Pragmas::
+* RS/6000 and PowerPC Pragmas::
+* Darwin Pragmas::
+* Solaris Pragmas::
+* Tru64 Pragmas::
+@end menu
+
+@node ARM Pragmas
+@subsection ARM Pragmas
+
+The ARM target defines pragmas for controlling the default addition of
+@code{long_call} and @code{short_call} attributes to functions.
+@xref{Function Attributes}, for information about the effects of these
+attributes.
+
+@table @code
+@item long_calls
+@cindex pragma, long_calls
+Set all subsequent functions to have the @code{long_call} attribute.
+
+@item no_long_calls
+@cindex pragma, no_long_calls
+Set all subsequent functions to have the @code{short_call} attribute.
+
+@item long_calls_off
+@cindex pragma, long_calls_off
+Do not affect the @code{long_call} or @code{short_call} attributes of
subsequent functions.
@end table
+@node RS/6000 and PowerPC Pragmas
+@subsection RS/6000 and PowerPC Pragmas
+
+The RS/6000 and PowerPC targets define one pragma for controlling
+whether or not the @code{longcall} attribute is added to function
+declarations by default. This pragma overrides the @option{-mlongcall}
+option, but not the @code{longcall} and @code{shortcall} attributes.
+@xref{RS/6000 and PowerPC Options}, for more information about when long
+calls are and are not necessary.
+
+@table @code
+@item longcall (1)
+@cindex pragma, longcall
+Apply the @code{longcall} attribute to all subsequent function
+declarations.
+
+@item longcall (0)
+Do not apply the @code{longcall} attribute to subsequent function
+declarations.
+@end table
+
@c Describe c4x pragmas here.
@c Describe h8300 pragmas here.
@c Describe i370 pragmas here.
The following pragmas are available for all architectures running the
Darwin operating system. These are useful for compatibility with other
-MacOS compilers.
+Mac OS compilers.
@table @code
@item mark @var{tokens}@dots{}
anywhere within the variables' scopes.
@end table
+@node Solaris Pragmas
+@subsection Solaris Pragmas
+
+For compatibility with the SunPRO compiler, the following pragma
+is supported.
+
+@table @code
+@item redefine_extname @var{oldname} @var{newname}
+@cindex pragma, redefine_extname
+
+This pragma gives the C function @var{oldname} the assembler label
+@var{newname}. The pragma must appear before the function declaration.
+This pragma is equivalent to the asm labels extension (@pxref{Asm
+Labels}). The preprocessor defines @code{__PRAGMA_REDEFINE_EXTNAME}
+if the pragma is available.
+@end table
+
+@node Tru64 Pragmas
+@subsection Tru64 Pragmas
+
+For compatibility with the Compaq C compiler, the following pragma
+is supported.
+
+@table @code
+@item extern_prefix @var{string}
+@cindex pragma, extern_prefix
+
+This pragma renames all subsequent function and variable declarations
+such that @var{string} is prepended to the name. This effect may be
+terminated by using another @code{extern_prefix} pragma with the
+empty string.
+
+This pragma is similar in intent to to the asm labels extension
+(@pxref{Asm Labels}) in that the system programmer wants to change
+the assembly-level ABI without changing the source-level API. The
+preprocessor defines @code{__PRAGMA_EXTERN_PREFIX} if the pragma is
+available.
+@end table
+
@node Unnamed Fields
@section Unnamed struct/union fields within structs/unions.
@cindex struct
Such constructs are not supported and must be avoided. In the future,
such constructs may be detected and treated as compilation errors.
+@node Thread-Local
+@section Thread-Local Storage
+@cindex Thread-Local Storage
+@cindex @acronym{TLS}
+@cindex __thread
+
+Thread-local storage (@acronym{TLS}) is a mechanism by which variables
+are allocated such that there is one instance of the variable per extant
+thread. The run-time model GCC uses to implement this originates
+in the IA-64 processor-specific ABI, but has since been migrated
+to other processors as well. It requires significant support from
+the linker (@command{ld}), dynamic linker (@command{ld.so}), and
+system libraries (@file{libc.so} and @file{libpthread.so}), so it
+is not available everywhere.
+
+At the user level, the extension is visible with a new storage
+class keyword: @code{__thread}. For example:
+
+@example
+__thread int i;
+extern __thread struct state s;
+static __thread char *p;
+@end example
+
+The @code{__thread} specifier may be used alone, with the @code{extern}
+or @code{static} specifiers, but with no other storage class specifier.
+When used with @code{extern} or @code{static}, @code{__thread} must appear
+immediately after the other storage class specifier.
+
+The @code{__thread} specifier may be applied to any global, file-scoped
+static, function-scoped static, or static data member of a class. It may
+not be applied to block-scoped automatic or non-static data member.
+
+When the address-of operator is applied to a thread-local variable, it is
+evaluated at run-time and returns the address of the current thread's
+instance of that variable. An address so obtained may be used by any
+thread. When a thread terminates, any pointers to thread-local variables
+in that thread become invalid.
+
+No static initialization may refer to the address of a thread-local variable.
+
+In C++, if an initializer is present for a thread-local variable, it must
+be a @var{constant-expression}, as defined in 5.19.2 of the ANSI/ISO C++
+standard.
+
+See @uref{http://people.redhat.com/drepper/tls.pdf,
+ELF Handling For Thread-Local Storage} for a detailed explanation of
+the four thread-local storage addressing models, and how the run-time
+is expected to function.
+
+@menu
+* C99 Thread-Local Edits::
+* C++98 Thread-Local Edits::
+@end menu
+
+@node C99 Thread-Local Edits
+@subsection ISO/IEC 9899:1999 Edits for Thread-Local Storage
+
+The following are a set of changes to ISO/IEC 9899:1999 (aka C99)
+that document the exact semantics of the language extension.
+
+@itemize @bullet
+@item
+@cite{5.1.2 Execution environments}
+
+Add new text after paragraph 1
+
+@quotation
+Within either execution environment, a @dfn{thread} is a flow of
+control within a program. It is implementation defined whether
+or not there may be more than one thread associated with a program.
+It is implementation defined how threads beyond the first are
+created, the name and type of the function called at thread
+startup, and how threads may be terminated. However, objects
+with thread storage duration shall be initialized before thread
+startup.
+@end quotation
+
+@item
+@cite{6.2.4 Storage durations of objects}
+
+Add new text before paragraph 3
+
+@quotation
+An object whose identifier is declared with the storage-class
+specifier @w{@code{__thread}} has @dfn{thread storage duration}.
+Its lifetime is the entire execution of the thread, and its
+stored value is initialized only once, prior to thread startup.
+@end quotation
+
+@item
+@cite{6.4.1 Keywords}
+
+Add @code{__thread}.
+
+@item
+@cite{6.7.1 Storage-class specifiers}
+
+Add @code{__thread} to the list of storage class specifiers in
+paragraph 1.
+
+Change paragraph 2 to
+
+@quotation
+With the exception of @code{__thread}, at most one storage-class
+specifier may be given [@dots{}]. The @code{__thread} specifier may
+be used alone, or immediately following @code{extern} or
+@code{static}.
+@end quotation
+
+Add new text after paragraph 6
+
+@quotation
+The declaration of an identifier for a variable that has
+block scope that specifies @code{__thread} shall also
+specify either @code{extern} or @code{static}.
+
+The @code{__thread} specifier shall be used only with
+variables.
+@end quotation
+@end itemize
+
+@node C++98 Thread-Local Edits
+@subsection ISO/IEC 14882:1998 Edits for Thread-Local Storage
+
+The following are a set of changes to ISO/IEC 14882:1998 (aka C++98)
+that document the exact semantics of the language extension.
+
+@itemize @bullet
+@item
+@b{[intro.execution]}
+
+New text after paragraph 4
+
+@quotation
+A @dfn{thread} is a flow of control within the abstract machine.
+It is implementation defined whether or not there may be more than
+one thread.
+@end quotation
+
+New text after paragraph 7
+
+@quotation
+It is unspecified whether additional action must be taken to
+ensure when and whether side effects are visible to other threads.
+@end quotation
+
+@item
+@b{[lex.key]}
+
+Add @code{__thread}.
+
+@item
+@b{[basic.start.main]}
+
+Add after paragraph 5
+
+@quotation
+The thread that begins execution at the @code{main} function is called
+the @dfn{main thread}. It is implementation defined how functions
+beginning threads other than the main thread are designated or typed.
+A function so designated, as well as the @code{main} function, is called
+a @dfn{thread startup function}. It is implementation defined what
+happens if a thread startup function returns. It is implementation
+defined what happens to other threads when any thread calls @code{exit}.
+@end quotation
+
+@item
+@b{[basic.start.init]}
+
+Add after paragraph 4
+
+@quotation
+The storage for an object of thread storage duration shall be
+statically initialized before the first statement of the thread startup
+function. An object of thread storage duration shall not require
+dynamic initialization.
+@end quotation
+
+@item
+@b{[basic.start.term]}
+
+Add after paragraph 3
+
+@quotation
+The type of an object with thread storage duration shall not have a
+non-trivial destructor, nor shall it be an array type whose elements
+(directly or indirectly) have non-trivial destructors.
+@end quotation
+
+@item
+@b{[basic.stc]}
+
+Add ``thread storage duration'' to the list in paragraph 1.
+
+Change paragraph 2
+
+@quotation
+Thread, static, and automatic storage durations are associated with
+objects introduced by declarations [@dots{}].
+@end quotation
+
+Add @code{__thread} to the list of specifiers in paragraph 3.
+
+@item
+@b{[basic.stc.thread]}
+
+New section before @b{[basic.stc.static]}
+
+@quotation
+The keyword @code{__thread} applied to an non-local object gives the
+object thread storage duration.
+
+A local variable or class data member declared both @code{static}
+and @code{__thread} gives the variable or member thread storage
+duration.
+@end quotation
+
+@item
+@b{[basic.stc.static]}
+
+Change paragraph 1
+
+@quotation
+All objects which have neither thread storage duration, dynamic
+storage duration nor are local [@dots{}].
+@end quotation
+
+@item
+@b{[dcl.stc]}
+
+Add @code{__thread} to the list in paragraph 1.
+
+Change paragraph 1
+
+@quotation
+With the exception of @code{__thread}, at most one
+@var{storage-class-specifier} shall appear in a given
+@var{decl-specifier-seq}. The @code{__thread} specifier may
+be used alone, or immediately following the @code{extern} or
+@code{static} specifiers. [@dots{}]
+@end quotation
+
+Add after paragraph 5
+
+@quotation
+The @code{__thread} specifier can be applied only to the names of objects
+and to anonymous unions.
+@end quotation
+
+@item
+@b{[class.mem]}
+
+Add after paragraph 6
+
+@quotation
+Non-@code{static} members shall not be @code{__thread}.
+@end quotation
+@end itemize
+
@node C++ Extensions
@chapter Extensions to the C++ Language
@cindex extensions, C++ language
However, side effects in @code{X} or @code{Y} may cause unintended
behavior. For example, @code{MIN (i++, j++)} will fail, incrementing
-the smaller counter twice. A GNU C extension allows you to write safe
-macros that avoid this kind of problem (@pxref{Naming Types,,Naming an
-Expression's Type}). However, writing @code{MIN} and @code{MAX} as
-macros also forces you to use function-call notation for a
-fundamental arithmetic operation. Using GNU C++ extensions, you can
-write @w{@samp{int min = i <? j;}} instead.
+the smaller counter twice. The GNU C @code{typeof} extension allows you
+to write safe macros that avoid this kind of problem (@pxref{Typeof}).
+However, writing @code{MIN} and @code{MAX} as macros also forces you to
+use function-call notation for a fundamental arithmetic operation.
+Using GNU C++ extensions, you can write @w{@samp{int min = i <? j;}}
+instead.
Since @code{<?} and @code{>?} are built into the compiler, they properly
handle expressions with side-effects; @w{@samp{int min = i++ <? j++;}}
@example
void fn (int *__restrict__ rptr, int &__restrict__ rref)
@{
- @dots{}
+ /* @r{@dots{}} */
@}
@end example
@example
void T::fn () __restrict__
@{
- @dots{}
+ /* @r{@dots{}} */
@}
@end example
@node Template Instantiation
@section Where's the Template?
-
@cindex template instantiation
C++ templates are the first language feature to require more
instances required by your explicit instantiations (but not by any
other files) without having to specify them as well.
-g++ has extended the template instantiation syntax outlined in the
-Working Paper to allow forward declaration of explicit instantiations
+g++ has extended the template instantiation syntax given in the ISO
+standard to allow forward declaration of explicit instantiations
(with @code{extern}), instantiation of the compiler support data for a
template class (i.e.@: the vtable) without instantiating any of its
members (with @code{inline}), and instantiation of only the static data
uses. In a large program, this can lead to an unacceptable amount of code
duplication.
-@item
-@opindex fexternal-templates
-Add @samp{#pragma interface} to all files containing template
-definitions. For each of these files, add @samp{#pragma implementation
-"@var{filename}"} to the top of some @samp{.C} file which
-@samp{#include}s it. Then compile everything with
-@option{-fexternal-templates}. The templates will then only be expanded
-in the translation unit which implements them (i.e.@: has a @samp{#pragma
-implementation} line for the file where they live); all other files will
-use external references. If you're lucky, everything should work
-properly. If you get undefined symbol errors, you need to make sure
-that each template instance which is used in the program is used in the
-file which implements that template. If you don't have any use for a
-particular instance in that file, you can just instantiate it
-explicitly, using the syntax from the latest C++ working paper:
-
-@example
-template class A<int>;
-template ostream& operator << (ostream&, const A<int>&);
-@end example
-
-This strategy will work with code written for either model. If you are
-using code written for the Cfront model, the file containing a class
-template and the file containing its member templates should be
-implemented in the same translation unit.
-
-@item
-@opindex falt-external-templates
-A slight variation on this approach is to use the flag
-@option{-falt-external-templates} instead. This flag causes template
-instances to be emitted in the translation unit that implements the
-header where they are first instantiated, rather than the one which
-implements the file where the templates are defined. This header must
-be the same in all translation units, or things are likely to break.
-
@xref{C++ Interface,,Declarations and Definitions in One Header}, for
more discussion of these pragmas.
@end enumerate
@node Bound member functions
@section Extracting the function pointer from a bound pointer to member function
-
@cindex pmf
@cindex pointer to member function
@cindex bound pointer to member function
In the following example, @code{A} would normally be created before
@code{B}, but the @code{init_priority} attribute has reversed that order:
-@example
+@smallexample
Some_Class A __attribute__ ((init_priority (2000)));
Some_Class B __attribute__ ((init_priority (543)));
-@end example
+@end smallexample
@noindent
Note that the particular values of @var{priority} do not matter; only their
when Java exceptions are thrown through it, GCC will guess incorrectly.
Sample problematic code is:
-@example
+@smallexample
struct S @{ ~S(); @};
extern void bar(); // is written in Java, and may throw exceptions
void foo()
S s;
bar();
@}
-@end example
+@end smallexample
@noindent
The usual effect of an incorrect guess is a link failure, complaining of
and are now removed from g++.
The implicit typename extension has been deprecated and will be removed
-from g++ at some point. In some cases g++ determines that a dependant
+from g++ at some point. In some cases g++ determines that a dependent
type such as @code{TPL<T>::X} is a type without needing a
@code{typename} keyword, contrary to the standard.
OSDN Git Service
