6.30 Declaring Attributes of Functions
======================================
In GNU C, you declare certain things about functions called in your
program which help the compiler optimize function calls and check your
code more carefully.
The keyword `__attribute__' allows you to specify special 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: `aligned',
`alloc_size', `alloc_align', `assume_aligned', `noreturn',
`returns_twice', `noinline', `noclone', `always_inline', `flatten',
`pure', `const', `nothrow', `sentinel', `format', `format_arg',
`no_instrument_function', `no_split_stack', `section', `constructor',
`destructor', `used', `unused', `deprecated', `weak', `malloc',
`alias', `ifunc', `warn_unused_result', `nonnull', `returns_nonnull',
`gnu_inline', `externally_visible', `hot', `cold', `artificial',
`no_sanitize_address', `no_address_safety_analysis',
`no_sanitize_undefined', `no_reorder', `error' and `warning'. Several
other attributes are defined for functions on particular target
systems. Other attributes, including `section' are supported for
variables declarations (*note Variable Attributes::), labels (*note
Label Attributes::) and for types (*note Type Attributes::).
GCC plugins may provide their own attributes.
You may also specify attributes with `__' preceding and following each
keyword. This allows you to use them in header files without being
concerned about a possible macro of the same name. For example, you
may use `__noreturn__' instead of `noreturn'.
*Note Attribute Syntax::, for details of the exact syntax for using
attributes.
...
`optimize'
The `optimize' attribute is used to specify that a function is to
be compiled with different optimization options than specified on
the command line. Arguments can either be numbers or strings.
Numbers are assumed to be an optimization level. Strings that
begin with `O' are assumed to be an optimization option, while
other options are assumed to be used with a `-f' prefix. You can
also use the `#pragma GCC optimize' pragma to set the optimization
options that affect more than one function. *Note Function
Specific Option Pragmas::, for details about the `#pragma GCC
optimize' pragma.
This can be used for instance to have frequently-executed functions
compiled with more aggressive optimization options that produce
faster and larger code, while other functions can be compiled with
less aggressive options.
....
6.32 Attribute Syntax
=====================
This section describes the syntax with which `__attribute__' may be
used, and the constructs to which attribute specifiers bind, for the C
language. Some details may vary for C++ and Objective-C. Because of
infelicities in the grammar for attributes, some forms described here
may not be successfully parsed in all cases.
There are some problems with the semantics of attributes in C++. For
example, there are no manglings for attributes, although they may affect
code generation, so problems may arise when attributed types are used in
conjunction with templates or overloading. Similarly, `typeid' does
not distinguish between types with different attributes. Support for
attributes in C++ may be restricted in future to attributes on
declarations only, but not on nested declarators.
*Note Function Attributes::, for details of the semantics of attributes
applying to functions. *Note Variable Attributes::, for details of the
semantics of attributes applying to variables. *Note Type Attributes::,
for details of the semantics of attributes applying to structure, union
and enumerated types. *Note Label Attributes::, for details of the
semantics of attributes applying to labels.
An "attribute specifier" is of the form `__attribute__
((ATTRIBUTE-LIST))'. An "attribute list" is a possibly empty
comma-separated sequence of "attributes", where each attribute is one
of the following:
* Empty. Empty attributes are ignored.
* A word (which may be an identifier such as `unused', or a reserved
word such as `const').
* A word, followed by, in parentheses, parameters for the attribute.
These parameters take one of the following forms:
* An identifier. For example, `mode' attributes use this form.
* An identifier followed by a comma and a non-empty
comma-separated list of expressions. For example, `format'
attributes use this form.
* A possibly empty comma-separated list of expressions. For
example, `format_arg' attributes use this form with the list
being a single integer constant expression, and `alias'
attributes use this form with the list being a single string
constant.
An "attribute specifier list" is a sequence of one or more attribute
specifiers, not separated by any other tokens.
....
6.57.13 Function Specific Option Pragmas
----------------------------------------
`#pragma GCC target ("STRING"...)'
This pragma allows you to set target specific options for functions
defined later in the source file. One or more strings can be
specified. Each function that is defined after this point is as
if `attribute((target("STRING")))' was specified for that
function. The parenthesis around the options is optional. *Note
Function Attributes::, for more information about the `target'
attribute and the attribute syntax.
The `#pragma GCC target' pragma is presently implemented for
i386/x86_64, PowerPC, and Nios II targets only.
`#pragma GCC optimize ("STRING"...)'
This pragma allows you to set global optimization options for
functions defined later in the source file. One or more strings
can be specified. Each function that is defined after this point
is as if `attribute((optimize("STRING")))' was specified for that
function. The parenthesis around the options is optional. *Note
Function Attributes::, for more information about the `optimize'
attribute and the attribute syntax.
The `#pragma GCC optimize' pragma is not implemented in GCC
versions earlier than 4.4.
`#pragma GCC push_options'
`#pragma GCC pop_options'
These pragmas maintain a stack of the current target and
optimization options. It is intended for include files where you
temporarily want to switch to using a different `#pragma GCC
target' or `#pragma GCC optimize' and then to pop back to the
previous options.
The `#pragma GCC push_options' and `#pragma GCC pop_options'
pragmas are not implemented in GCC versions earlier than 4.4.
`#pragma GCC reset_options'
This pragma clears the current `#pragma GCC target' and `#pragma
GCC optimize' to use the default switches as specified on the
command line.
The `#pragma GCC reset_options' pragma is not implemented in GCC
versions earlier than 4.4.
I thought it might not be right anyway, though it did work but i was thinking it might need to be atomic.