-@c Copyright (C) 1988,1989,1992,1993,1994,1996,1998,1999,2000,2001,2002,2003,2004
+@c Copyright (C) 1988,1989,1992,1993,1994,1996,1998,1999,2000,2001,2002,2003,2004,2005
@c Free Software Foundation, Inc.
@c This is part of the GCC manual.
@c For copying conditions, see the file gcc.texi.
In G++, the result value of a statement expression undergoes array and
function pointer decay, and is returned by value to the enclosing
-expression. For instance, if @code{A} is a class, then
+expression. For instance, if @code{A} is a class, then
@smallexample
A a;
header files using statement-expression that lead to precisely this
bug.)
+Jumping into a statement expression with @code{goto} or using a
+@code{switch} statement outside the statement expression with a
+@code{case} or @code{default} label inside the statement expression is
+not permitted. Jumping into a statement expression with a computed
+@code{goto} (@pxref{Labels as Values}) yields undefined behavior.
+Jumping out of a statement expression is permitted, but if the
+statement expression is part of a larger expression then it is
+unspecified which other subexpressions of that expression have been
+evaluated except where the language definition requires certain
+subexpressions to be evaluated before or after the statement
+expression. In any case, as with a function call the evaluation of a
+statement expression is not interleaved with the evaluation of other
+parts of the containing expression. For example,
+
+@smallexample
+ foo (), ((@{ bar1 (); goto a; 0; @}) + bar2 ()), baz();
+@end smallexample
+
+@noindent
+will call @code{foo} and @code{bar1} and will not call @code{baz} but
+may or may not call @code{bar2}. If @code{bar2} is called, it will be
+called after @code{foo} and before @code{bar1}
+
@node Local Labels
@section Locally Declared Labels
@cindex local labels
@cindex macros, local labels
GCC allows you to declare @dfn{local labels} in any nested block
-scope. A local label is just like an ordinary label, but you can
+scope. A local label is just like an ordinary label, but you can
only reference it (with a @code{goto} statement, or by taking its
address) within the block in which it was declared.
@end smallexample
Nested function definitions are permitted within functions in the places
-where variable definitions are allowed; that is, in any block, before
-the first statement in the block.
+where variable definitions are allowed; that is, in any block, mixed
+with the other declarations and statements in the block.
It is possible to call the nested function from outside the scope of its
name by storing its address or passing the address to another function:
@end group
@end smallexample
-A nested function always has internal linkage. Declaring one with
-@code{extern} is erroneous. If you need to declare the nested function
+A nested function always has no linkage. Declaring one with
+@code{extern} or @code{static} is erroneous. If you need to declare the nested function
before its definition, use @code{auto} (which is otherwise meaningless
for function declarations).
@cindex function attributes
@cindex declaring attributes of functions
@cindex functions that never return
+@cindex functions that return more than once
@cindex functions that have no side effects
@cindex functions in arbitrary sections
@cindex functions that behave like malloc
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{always_inline},
+@code{noreturn}, @code{returns_twice}, @code{noinline}, @code{always_inline},
@code{pure}, @code{const}, @code{nothrow}, @code{sentinel},
@code{format}, @code{format_arg}, @code{no_instrument_function},
@code{section}, @code{constructor}, @code{destructor}, @code{used},
attributes.
@table @code
-@c Keep this table alphabetized by attribute name. Treat _ as space.
+@c Keep this table alphabetized by attribute name. Treat _ as space.
@item alias ("@var{target}")
@cindex @code{alias} attribute
@end smallexample
declares @samp{f} to be a weak alias for @samp{__f}. In C++, the
-mangled name for the target must be used.
+mangled name for the target must be used. It is an error if @samp{__f}
+is not defined in the same translation unit.
Not all target machines support this attribute.
@cindex @code{const} function attribute
Many functions do not examine any values except their arguments, and
have no effects except the return value. Basically this is just slightly
-more strict class than the @code{pure} attribute above, since function is not
+more strict class than the @code{pure} attribute below, since function is not
allowed to read global memory.
@cindex pointer arguments
functions, unless the @option{-fkeep-inline-functions} flag has been
used. The attribute is also ignored for undefined symbols.
-When applied to C++ classes. the attribute marks defined non-inlined
-member functions and static data members as exports. Static consts
+When applied to C++ classes, the attribute marks defined non-inlined
+member functions and static data members as exports. Static consts
initialized in-class are not marked unless they are also defined
out-of-class.
On Microsoft Windows and Symbian OS targets, the @code{dllimport}
attribute causes the compiler to reference a function or variable via
a global pointer to a pointer that is set up by the DLL exporting the
-symbol. The attribute implies @code{extern} storage. On Microsoft
+symbol. The attribute implies @code{extern} storage. On Microsoft
Windows targets, the pointer name is formed by combining @code{_imp__}
and the function or variable name.
@code{__attribute__ ((dllimport))} for compatibility with other
compilers.
-Currently, the attribute is ignored for inlined functions. If the
+Currently, the attribute is ignored for inlined functions. If the
attribute is applied to a symbol @emph{definition}, an error is reported.
If a symbol previously declared @code{dllimport} is later defined, the
attribute is ignored in subsequent references, and a warning is emitted.
For Microsoft Windows based targets the use of the @code{dllimport}
attribute on functions is not necessary, but provides a small
-performance benefit by eliminating a thunk in the DLL. The use of the
+performance benefit by eliminating a thunk in the DLL@. The use of the
@code{dllimport} attribute on imported variables was required on older
versions of the GNU linker, but can now be avoided by passing the
-@option{--enable-auto-import} switch to the GNU linker. As with
+@option{--enable-auto-import} switch to the GNU linker. As with
functions, using the attribute for a variable eliminates a thunk in
-the DLL.
+the DLL@.
One drawback to using this attribute is that a pointer to a function
or variable marked as @code{dllimport} cannot be used as a constant
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}.
+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
+instead of using @code{rts}. The board-specific return routine simulates
the @code{rtc}.
@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
+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 format (@var{archetype}, @var{string-index}, @var{first-to-check})
volatile voidfn fatal;
@end smallexample
+This approach does not work in GNU C++.
+
@item nothrow
@cindex @code{nothrow} function attribute
The @code{nothrow} attribute is used to inform the compiler that a
disabled with the linker or the loader if desired, to avoid the
problem.)
+@item returns_twice
+@cindex @code{returns_twice} attribute
+The @code{returns_twice} attribute tells the compiler that a function may
+return more than one time. The compiler will ensure that all registers
+are dead before calling such a function and will emit a warning about
+the variables that may be clobbered after the second return from the
+function. Examples of such functions are @code{setjmp} and @code{vfork}.
+The @code{longjmp}-like counterpart of such function, if any, might need
+to be marked with the @code{noreturn} attribute.
+
@item saveall
@cindex save all registers on the H8/300, H8/300H, and H8S
Use this attribute on the H8/300, H8/300H, and H8S to indicate that
@c keep this list of visibilities in alphabetical order.
@item default
-Default visibility is the normal case for ELF. This value is
+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.
that may be unused but which is compiled with @option{-Wall}. It would
not normally be appropriate to use in it human-written code, though it
could be useful in cases where the code that jumps to the label is
-contained within an @code{#ifdef} conditional. GNU C++ does not permit
+contained within an @code{#ifdef} conditional. GNU C++ does not permit
such placement of attribute lists, as it is permissible for a
declaration, which could begin with an attribute list, to be labelled in
-C++. Declarations cannot be labelled in C90 or C99, so the ambiguity
+C++. Declarations cannot be labelled in C90 or C99, so the ambiguity
does not arise there.
An attribute specifier list may appear as part of a @code{struct},
/* @r{Old-style function definition.} */
int
-isroot (x) /* ??? lossage here ??? */
+isroot (x) /* @r{??? lossage here ???} */
uid_t x;
@{
return x == 0;
main()
@{
- /* Initialize stack pointer */
+ /* @r{Initialize stack pointer} */
init_sp (stack + sizeof (stack));
- /* Initialize initialized data */
+ /* @r{Initialize initialized data} */
memcpy (&init_data, &data, &edata - &data);
- /* Turn on the serial ports */
+ /* @r{Turn on the serial ports} */
init_duart (&a);
init_duart (&b);
@}
int
main()
@{
- /* Read and write foo. All running
- copies see the same value. */
+ /* @r{Read and write foo. All running
+ copies see the same value.} */
return 0;
@}
@end smallexample
@subsection M32R/D Variable Attributes
-One attribute is currently defined for the M32R/D.
+One attribute is currently defined for the M32R/D@.
@table @code
@item model (@var{model-name})
@item packed
This attribute, attached to @code{struct} or @code{union} type
definition, specifies that each member of the structure or union is
-placed to minimize the memory required. When attached to an @code{enum}
+placed to minimize the memory required. When attached to an @code{enum}
definition, it indicates that the smallest integral type should be used.
@opindex fshort-enums
On those ARM targets that support @code{dllimport} (such as Symbian
OS), you can use the @code{notshared} attribute to indicate that the
virtual table and other similar data for a class should not be
-exported from a DLL. For example:
+exported from a DLL@. For example:
@smallexample
class __declspec(notshared) C @{
the @samp{always_inline} attribute for the function, like this:
@smallexample
-/* Prototype. */
+/* @r{Prototype.} */
inline void foo (const char) __attribute__((always_inline));
@end smallexample
output operand from the first input, if any. Commas separate the
operands within each group. The total number of operands is currently
limited to 30; this limitation may be lifted in some future version of
-GCC.
+GCC@.
If there are no output operands but there are input operands, you must
place two consecutive colons surrounding the place where the output
@smallexample
asm volatile ("movc3 %0,%1,%2"
- : /* no outputs */
+ : /* @r{no outputs} */
: "g" (from), "g" (to), "g" (count)
: "r0", "r1", "r2", "r3", "r4", "r5");
@end smallexample
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. When inlining
+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.
On some machines it may be impossible to determine the return address of
any function other than the current one; in such cases, or when the top
of the stack has been reached, this function will return @code{0} or a
-random value. In addition, @code{__builtin_frame_address} may be used
+random value. In addition, @code{__builtin_frame_address} may be used
to determine if the top of the stack has been reached.
This function should only be used with a nonzero argument for debugging
@findex __builtin_islessequal
@findex __builtin_islessgreater
@findex __builtin_isunordered
+@findex __builtin_powi
+@findex __builtin_powif
+@findex __builtin_powil
@findex _Exit
@findex _exit
@findex abort
GCC includes built-in versions of many of the functions in the standard
C library. The versions prefixed with @code{__builtin_} will always be
treated as having the same meaning as the C library function even if you
-specify the @option{-fno-builtin} option. (@pxref{C Dialect Options})
+specify the @option{-fno-builtin} option. (@pxref{C Dialect Options})
Many of these functions are only optimized in certain cases; if they are
not optimized in a particular case, a call to the library function will
be emitted.
@})
@end smallexample
-@emph{Note:} This construct is only available for C.
+@emph{Note:} This construct is only available for C@.
@end deftypefn
(void)0))
@end smallexample
-@emph{Note:} This construct is only available for C. Furthermore, the
+@emph{Note:} This construct is only available for C@. Furthermore, the
unused expression (@var{exp1} or @var{exp2} depending on the value of
@var{const_exp}) may still generate syntax errors. This may change in
future revisions.
@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
@deftypefn {Built-in Function} float __builtin_inff (void)
Similar to @code{__builtin_inf}, except the return type is @code{float}.
+This function is suitable for implementing the ISO C99 macro @code{INFINITY}.
@end deftypefn
@deftypefn {Built-in Function} {long double} __builtin_infl (void)
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.
+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.
@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
+to be a signaling NaN@. The @code{nans} function is proposed by
@uref{http://www.open-std.org/jtc1/sc22/wg14/www/docs/n965.htm,,WG14 N965}.
@end deftypefn
@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}
+Returns the parity of @var{x}, i.e.@: the number of 1-bits in @var{x}
modulo 2.
@end deftypefn
@code{unsigned long long}.
@end deftypefn
+@deftypefn {Built-in Function} double __builtin_powi (double, int)
+Returns the first argument raised to the power of the second. Unlike the
+@code{pow} function no guarantees about precision and rounding are made.
+@end deftypefn
+
+@deftypefn {Built-in Function} float __builtin_powif (float, int)
+Similar to @code{__builtin_powi}, except the argument and return types
+are @code{float}.
+@end deftypefn
+
+@deftypefn {Built-in Function} {long double} __builtin_powil (long double, int)
+Similar to @code{__builtin_powi}, except the argument and return types
+are @code{long double}.
+@end deftypefn
+
@node Target Builtins
@section Built-in Functions Specific to Particular Target Machines
* X86 Built-in Functions::
* MIPS Paired-Single Support::
* PowerPC AltiVec Built-in Functions::
+* SPARC VIS Built-in Functions::
@end menu
@node Alpha Built-in Functions
same type as the variable it is initializing.
@item
-If @code{signed} or @code{unsigned} is omitted, the vector type defaults
-to @code{signed} for @code{vector int} or @code{vector short} and to
-@code{unsigned} for @code{vector char}.
+If @code{signed} or @code{unsigned} is omitted, the signedness of the
+vector type is the default signedness of the base type. The default
+varies depending on the operating system, so a portable program should
+always specify the signedness.
@item
Compiling with @option{-maltivec} adds keywords @code{__vector},
int vec_any_out (vector float, vector float);
@end smallexample
+@node SPARC VIS Built-in Functions
+@subsection SPARC VIS Built-in Functions
+
+GCC supports SIMD operations on the SPARC using both the generic vector
+extensions (@pxref{Vector Extensions}) as well as built-in functions for
+the SPARC Visual Instruction Set (VIS). When you use the @option{-mvis}
+switch, the VIS extension is exposed as the following built-in functions:
+
+@smallexample
+typedef int v2si __attribute__ ((vector_size (8)));
+typedef short v4hi __attribute__ ((vector_size (8)));
+typedef short v2hi __attribute__ ((vector_size (4)));
+typedef char v8qi __attribute__ ((vector_size (8)));
+typedef char v4qi __attribute__ ((vector_size (4)));
+
+void * __builtin_vis_alignaddr (void *, long);
+int64_t __builtin_vis_faligndatadi (int64_t, int64_t);
+v2si __builtin_vis_faligndatav2si (v2si, v2si);
+v4hi __builtin_vis_faligndatav4hi (v4si, v4si);
+v8qi __builtin_vis_faligndatav8qi (v8qi, v8qi);
+
+v4hi __builtin_vis_fexpand (v4qi);
+
+v4hi __builtin_vis_fmul8x16 (v4qi, v4hi);
+v4hi __builtin_vis_fmul8x16au (v4qi, v4hi);
+v4hi __builtin_vis_fmul8x16al (v4qi, v4hi);
+v4hi __builtin_vis_fmul8sux16 (v8qi, v4hi);
+v4hi __builtin_vis_fmul8ulx16 (v8qi, v4hi);
+v2si __builtin_vis_fmuld8sux16 (v4qi, v2hi);
+v2si __builtin_vis_fmuld8ulx16 (v4qi, v2hi);
+
+v4qi __builtin_vis_fpack16 (v4hi);
+v8qi __builtin_vis_fpack32 (v2si, v2si);
+v2hi __builtin_vis_fpackfix (v2si);
+v8qi __builtin_vis_fpmerge (v4qi, v4qi);
+
+int64_t __builtin_vis_pdist (v8qi, v8qi, int64_t);
+@end smallexample
+
@node Target Format Checks
@section Format Checks Specific to Particular Target Machines
* Solaris Pragmas::
* Symbol-Renaming Pragmas::
* Structure-Packing Pragmas::
+* Weak Pragmas::
@end menu
@node ARM Pragmas
Increase the minimum alignment of each @var{variable} to @var{alignment}.
This is the same as GCC's @code{aligned} attribute @pxref{Variable
-Attributes}).
+Attributes}). Macro expansion occurs on the arguments to this pragma
+when compiling C and Objective-C. It does not currently occur when
+compiling C++, but this is a bug which may be fixed in a future
+release.
@item fini (@var{function} [, @var{function}]...)
@cindex pragma, fini
This effect may be terminated with another @code{extern_prefix} pragma
whose argument is an empty string. The preprocessor macro
@code{__PRAGMA_EXTERN_PREFIX} will be defined if this pragma is
-available (currently only on Tru64 UNIX).
+available (currently only on Tru64 UNIX)@.
@end table
These pragmas and the asm labels extension interact in a complicated
@node Structure-Packing Pragmas
@subsection Structure-Packing Pragmas
-For compatibility with Win32, GCC supports as set of @code{#pragma}
+For compatibility with Win32, GCC supports a set of @code{#pragma}
directives which change the maximum alignment of members of structures,
unions, and classes subsequently defined. The @var{n} value below always
is required to be a small power of two and specifies the new alignment
@code{#pragma pack(pop)}.
@end enumerate
+@node Weak Pragmas
+@subsection Weak Pragmas
+
+For compatibility with SVR4, GCC supports a set of @code{#pragma}
+directives for declaring symbols to be weak, and defining weak
+aliases.
+
+@table @code
+@item #pragma weak @var{symbol}
+@cindex pragma, weak
+This pragma declares @var{symbol} to be weak, as if the declaration
+had the attribute of the same name. The pragma may appear before
+or after the declaration of @var{symbol}, but must appear before
+either its first use or its definition. It is not an error for
+@var{symbol} to never be defined at all.
+
+@item #pragma weak @var{symbol1} = @var{symbol2}
+This pragma declares @var{symbol1} to be a weak alias of @var{symbol2}.
+It is an error if @var{symbol2} is not defined in the current
+translation unit.
+@end table
+
@node Unnamed Fields
@section Unnamed struct/union fields within structs/unions
@cindex struct
Predefined Macros,cpp,The GNU C Preprocessor}).
@menu
-* Min and Max:: C++ Minimum and maximum operators.
* Volatiles:: What constitutes an access to a volatile object.
* Restricted Pointers:: C99 restricted pointers and references.
* Vague Linkage:: Where G++ puts inlines, vtables and such.
* Backwards Compatibility:: Compatibilities with earlier definitions of C++.
@end menu
-@node Min and Max
-@section Minimum and Maximum Operators in C++
-
-It is very convenient to have operators which return the ``minimum'' or the
-``maximum'' of two arguments. In GNU C++ (but not in GNU C),
-
-@table @code
-@item @var{a} <? @var{b}
-@findex <?
-@cindex minimum operator
-is the @dfn{minimum}, returning the smaller of the numeric values
-@var{a} and @var{b};
-
-@item @var{a} >? @var{b}
-@findex >?
-@cindex maximum operator
-is the @dfn{maximum}, returning the larger of the numeric values @var{a}
-and @var{b}.
-@end table
-
-These operations are not primitive in ordinary C++, since you can
-use a macro to return the minimum of two things in C++, as in the
-following example.
-
-@smallexample
-#define MIN(X,Y) ((X) < (Y) ? : (X) : (Y))
-@end smallexample
-
-@noindent
-You might then use @w{@samp{int min = MIN (i, j);}} to set @var{min} to
-the minimum value of variables @var{i} and @var{j}.
-
-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. 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++;}}
-works correctly.
-
@node Volatiles
@section When is a Volatile Object Accessed?
@cindex accessing volatiles
covariant return type rules is now deprecated and will be removed from a
future version.
+The G++ minimum and maximum operators (@samp{<?} and @samp{>?}) and
+their compound forms (@samp{<?=}) and @samp{>?=}) have been deprecated
+and will be removed in a future version. Code using these operators
+should be modified to use @code{std::min} and @code{std::max} instead.
+
The named return value extension has been deprecated, and is now
removed from G++.
and other places where they are not permitted by the standard is
deprecated and will be removed from a future version of G++.
+G++ allows floating-point literals to appear in integral constant expressions,
+e.g. @samp{ enum E @{ e = int(2.2 * 3.7) @} }
+This extension is deprecated and will be removed from a future version.
+
+G++ allows static data members of const floating-point type to be declared
+with an initializer in a class definition. The standard only allows
+initializers for static members of const integral types and const
+enumeration types so this extension has been deprecated and will be removed
+from a future version.
+
@node Backwards Compatibility
@section Backwards Compatibility
@cindex Backwards Compatibility
projects / gcc.git / blobdiff