@c Every entry should start with a sentence that says where the attribute
@c may appear.
-@cindex @code{access} function attribute
+@atindex @code{access}
+@cindex functions that restrict access to pointer arguments
@item access (@var{access-mode}, @var{ref-index})
@itemx access (@var{access-mode}, @var{ref-index}, @var{size-index})
This attribute applies to functions.
documented later in this section, for more information and
caveats.
-@cindex @code{alias} attribute
+@atindex @code{alias}
@item alias ("@var{target}")
This attribute applies to variables and functions.
This attribute requires assembler and object file support,
and may not be available on all targets.
-@cindex @code{aligned} attribute
+@atindex @code{aligned}
+@cindex alignment of functions and data
@item aligned
@itemx aligned (@var{alignment})
This attribute applies to functions, variables, typedefs, structs, and
Stack variables are not affected by linker restrictions; GCC can properly
align them on any target.
-@cindex @code{alloc_align} function attribute
+@atindex @code{alloc_align}
+@cindex alignment of allocated data
@item alloc_align (@var{position})
The @code{alloc_align} attribute may be applied to a function that
returns a pointer and takes at least one argument of an integer or
declares that @code{my_memalign} returns memory with minimum alignment
given by parameter 1.
-@cindex @code{alloc_size} attribute
+@atindex @code{alloc_size}
+@cindex size of objects
@item alloc_size (@var{position})
@itemx alloc_size (@var{position-1}, @var{position-2})
The @code{alloc_size} attribute may be applied to a function that
is a pointer to a function that returns an object whose size is
given by argument 1 to the function.
-@cindex @code{always_inline} function attribute
+@atindex @code{always_inline}
+@cindex inlining
+@cindex function inlining
@item always_inline
The @code{always_inline} attribute applies to functions.
functions across translation units, but only if an optimization level
that normally enables inlining is additionally specified.
-@cindex @code{artificial} function attribute
+@atindex @code{artificial}
@item artificial
This attribute applies to functions.
or using the caller location for all instructions within the inlined
body.
-@cindex @code{assume} statement attribute
+@atindex @code{assume}
@item assume
This is a statement attribute that can appear only as an
attribute declaration.
@code{y} is not actually incremented and the compiler can but does not
have to optimize it to just @code{return 42 + 42;}.
-@cindex @code{assume_aligned} function attribute
+@atindex @code{assume_aligned}
+@cindex alignment of data
@item assume_aligned (@var{alignment})
@itemx assume_aligned (@var{alignment}, @var{offset})
The @code{assume_aligned} attribute may be applied to a function that
that @code{my_alloc2} returns a pointer whose value modulo 32 is equal
to 8.
-@cindex @code{btf_decl_tag} attribute
+@atindex @code{btf_decl_tag}
@item btf_decl_tag
This attribute can be applied to functions, variables, struct or union member
declarations, and function parameter declarations.
associating the string @samp{__percpu} with the @code{BTF_KIND_VAR}
record for the variable @code{foo}.
-@cindex @code{btf_type_tag} type attribute
+@atindex @code{btf_type_tag}
@item btf_type_tag (@var{argument})
This attribute applies to types.
tags associated with pointer types. Type tags on non-pointer types
may be silently skipped when generating BTF.
-@cindex @code{cleanup} variable attribute
+@atindex @code{cleanup}
+@cindex cleanup functions
@item cleanup (@var{cleanup_function})
This attribute applies to variables.
It is undefined what happens if @var{cleanup_function} does not
return normally.
-@cindex @code{cold} attribute
-@cindex @code{hot} attribute
+@atindex @code{cold}
+@atindex @code{hot}
+@cindex cold functions and code regions
+@cindex hot functions and code regions
@item cold
@itemx hot
is used in cases where @code{__builtin_expect} cannot be used, for instance
with computed goto or @code{asm goto}.
-@cindex @code{common} variable attribute
-@cindex @code{nocommon} variable attribute
+@atindex @code{common}
+@atindex @code{nocommon}
+@cindex common storage
@opindex fcommon
@opindex fno-common
@item common
These attributes override the default chosen by the
@option{-fno-common} and @option{-fcommon} flags respectively.
-@cindex @code{const} function attribute
+@atindex @code{const}
@cindex functions that have no side effects
@item const
This attribute applies to functions.
in C++, reference arguments. Likewise, a function that calls a non-const
function usually must not be const itself.
-@cindex @code{constructor} function attribute
-@cindex @code{destructor} function attribute
+@atindex @code{constructor}
+@atindex @code{destructor}
+@cindex functions that are called on program startup or exit
@item constructor
@itemx destructor
@itemx constructor (@var{priority})
those not using ELF object format, or the GNU linker) reject this
usage.
-@cindex @code{copy} attribute
+@atindex @code{copy}
@item copy
@itemx copy (@var{name})
The @code{copy} attribute can appear on function, variable, and type
struct __attribute__ ((copy ( (struct A *)0)) B @{ /* @r{@dots{}} */ @};
@end smallexample
-@cindex @code{counted_by} variable attribute
+@atindex @code{counted_by}
+@cindex flexible array members
@item counted_by (@var{count})
The @code{counted_by} attribute may be attached to a C99 flexible array
member or a pointer field of a structure.
Note, however, the above feature is not valid for the pointer field.
-@cindex @code{deprecated} attribute
+@atindex @code{deprecated}
+@cindex deprecated entities
@item deprecated
@itemx deprecated (@var{msg})
This attribute can appear on function, variable, type, or enumerator
escape sequences, and if the @option{-fmessage-length} option is set
to 0 (its default value) then any newline characters are ignored.
-@cindex @code{designated_init} type attribute
+@atindex @code{designated_init}
@item designated_init
This attribute may only be applied to structure types.
GCC emits warnings based on this attribute by default; use
@option{-Wno-designated-init} to suppress them.
-@cindex @code{error} function attribute
-@cindex @code{warning} function attribute
+@atindex @code{error}
+@atindex @code{warning}
+@cindex functions that are supposed to be optimized away
@item error ("@var{message}")
@itemx warning ("@var{message}")
This attribute applies to functions.
earlier and with exact location of the call even in presence of inline
functions or when not emitting debugging information.
-@cindex @code{expected_throw} function attribute
+@atindex @code{expected_throw}
+@cindex functions that are expected to throw exceptions
@item expected_throw
This attribute applies to functions.
@samp{-fharden-control-flow-redundancy} is enabled, and
@samp{-fhardcfr-check-noreturn-calls=not-always} is not overridden.
-@cindex @code{externally_visible} attribute
+@atindex @code{externally_visible}
@item externally_visible
This attribute applies to global variables and functions.
For other linkers that cannot generate resolution file,
explicit @code{externally_visible} attributes are still necessary.
-@cindex @code{fallthrough} statement attribute
+@atindex @code{fallthrough}
+@cindex fallthrough in switch statements
+@cindex switch statement fallthrough
@item fallthrough
This statement attribute can appear only as an attribute declaration.
@}
@end smallexample
-@cindex @code{fd_arg} function attribute
-@cindex @code{fd_arg_read} function attribute
-@cindex @code{fd_arg_write} function attribute
+@atindex @code{fd_arg}
+@atindex @code{fd_arg_read}
+@atindex @code{fd_arg_write}
+@cindex functions that take file descriptor arguments
@item fd_arg (@var{N})
@itemx fd_arg_read (@var{N})
@itemx fd_arg_write (@var{N})
should not warn about a @code{case} that corresponds to a bitwise
combination of enumerators.
-@cindex @code{flatten} function attribute
+@atindex @code{flatten}
+@cindex inlining
+@cindex function inlining
@item flatten
This attribute applies to functions.
inlined. Whether the function itself is considered for inlining depends
on its size and the current inlining parameters.
-@cindex @code{format} function attribute
+@atindex @code{format}
@cindex functions with @code{printf}, @code{scanf}, @code{strftime} or @code{strfmon} style arguments
+@cindex functions that have format string arguments
@opindex Wformat
@item format (@var{archetype}, @var{string-index}, @var{first-to-check})
The @code{format} attribute applies to functions.
are @code{printf_unlocked} and @code{fprintf_unlocked}.
@xref{C Dialect Options,,Options Controlling C Dialect}.
-@cindex @code{format_arg} function attribute
+@atindex @code{format_arg}
+@cindex functions that have format string arguments
@opindex Wformat-nonliteral
@item format_arg (@var{string-index})
The @code{format_arg} attribute applies to functions.
@code{CFStringRefs} and associated functions.
-@cindex @code{gnu_inline} function attribute
+@atindex @code{gnu_inline}
+@cindex inlining
+@cindex function inlining
@item gnu_inline
This attribute applies to functions.
but it still requires the @code{inline} keyword to enable its special
behavior.
-@cindex @code{hardbool} type attribute
+@atindex @code{hardbool}
+@cindex hardened boolean types
@item hardbool
@itemx hardbool (@var{false_value})
@itemx hardbool (@var{false_value}, @var{true_value})
clauses, and with enumerations or other languages' integral types that
correspond to C's chosen integral type.
-@cindex @code{ifunc} function attribute
+@atindex @code{ifunc}
@cindex indirect functions
@cindex functions that are dynamically resolved
@item ifunc ("@var{resolver}")
Indirect functions cannot be weak. Binutils version 2.20.1 or higher
and GNU C Library version 2.11.1 are required to use this feature.
-@cindex @code{interrupt_handler} function attribute
-@cindex @code{interrupt} function attribute
+@atindex @code{interrupt_handler}
+@atindex @code{interrupt}
+@cindex interrupt handlers
+@cindex functions that handle interrupts
@item interrupt
@itemx interrupt_handler
These attributes apply to functions.
functions. The exact syntax and behavior are target-specific;
refer to the following subsections for details.
-@cindex @code{leaf} function attribute
+@atindex @code{leaf}
@item leaf
This attribute applies to functions.
this reason the attribute is not allowed on types to annotate indirect
calls.
-@cindex @code{malloc} function attribute
+@atindex @code{malloc}
@cindex functions that behave like malloc
@item malloc
@item malloc (@var{deallocator})
a @option{-Wanalyzer-possible-null-argument} diagnostic for code paths
in which the deallocator is called with null.
-@cindex @code{may_alias} type attribute
+@atindex @code{may_alias}
+@cindex pointer aliasing
@item may_alias
The @code{may_alias} attribute applies to pointer type declarations.
@option{-fstrict-aliasing}, which is on by default at @option{-O2} or
above.
-@cindex @code{mode} attribute
+@atindex @code{mode}
@item mode (@var{mode})
This attribute can apply to a variable or type declaration.
@code{__word__} for the mode of a one-word integer, and @code{pointer}
or @code{__pointer__} for the mode used to represent pointers.
-@cindex @code{musttail} statement attribute
+@atindex @code{musttail}
+@cindex tail recursion
+@cindex functions that return via tail call
@item musttail
This attribute can be applied to a @code{return} statement
with a return-value expression that is a function call.
variable is a function argument, because those are in scope
for the whole function.
-@cindex @code{naked} function attribute
+@atindex @code{naked}
+@cindex naked functions
+@cindex functions that do not have prologue/epilogue code
@item naked
This attribute applies to functions.
Not all targets support this attribute. Those that do include ARC, ARM,
AVR, BPF, C-SKY, MCORE, MSP430, NDS32, RISC-V, RL78, RX, and x86.
-@cindex @code{no_icf} attribute
+@atindex @code{no_icf}
@item no_icf
This attribute can be applied to functions or variables.
It prevents the entity from being
merged with another semantically equivalent function or variable.
-@cindex @code{no_instrument_function} function attribute
+@atindex @code{no_instrument_function}
+@cindex functions that should not be instrumented
+@cindex function instrumentation
@opindex finstrument-functions
@opindex p
@opindex pg
the compiler that it should not process any code instrumentation
for profile-feedback-based optimization code instrumentation.
-@cindex @code{no_reorder} attribute
+@atindex @code{no_reorder}
@item no_reorder
This attribute applies to functions or variables.
marked symbols.
@cindex @code{no_sanitize} function attribute
+@cindex functions that should not be sanitized
@item no_sanitize ("@var{sanitize_option}")
This attribute applies to functions.
g () @{ /* @r{Do something.} */; @}
@end smallexample
-@cindex @code{no_sanitize_address} function attribute
+@atindex @code{no_sanitize_address}
+@cindex functions that should not be sanitized
@item no_sanitize_address
@itemx no_address_safety_analysis
This attribute applies to functions.
@code{no_sanitize_address}.
@cindex @code{no_sanitize_coverage} function attribute
+@cindex functions that should not be sanitized
@item no_sanitize_coverage
This attribute applies to functions.
informs the compiler that it should not do coverage-guided
fuzzing code instrumentation (@option{-fsanitize-coverage}).
-@cindex @code{no_sanitize_thread} function attribute
+@atindex @code{no_sanitize_thread}
+@cindex functions that should not be sanitized
@item no_sanitize_thread
This attribute applies to functions.
informs the compiler that it should not instrument memory accesses
in the function when compiling with the @option{-fsanitize=thread} option.
-@cindex @code{no_sanitize_undefined} function attribute
+@atindex @code{no_sanitize_undefined}
+@cindex functions that should not be sanitized
@item no_sanitize_undefined
This attribute applies to functions.
informs the compiler that it should not check for undefined behavior
in the function when compiling with the @option{-fsanitize=undefined} option.
-@cindex @code{no_split_stack} function attribute
+@atindex @code{no_split_stack}
@opindex fsplit-stack
@item no_split_stack
This attribute applies to functions.
@code{no_split_stack} attribute do not have that prologue, and thus
may run with only a small amount of stack space available.
-@cindex @code{no_stack_limit} function attribute
+@atindex @code{no_stack_limit}
+@cindex stack protection
+@cindex functions that should not have stack limit checking
@item no_stack_limit
This attribute applies to functions.
and @option{-fstack-limit-symbol} command-line options; it has the effect
of disabling stack limit checking in the function it applies to.
-@cindex @code{no_stack_protector} function attribute
+@atindex @code{no_stack_protector}
+@cindex stack protection
+@cindex functions that should not have stack protection
@item no_stack_protector
This attribute applies to functions.
It prevents GCC from generating stack protection code for the function.
-@cindex @code{noclone} function attribute
+@atindex @code{noclone}
@item noclone
This attribute applies to functions.
and which is (currently) performed by interprocedural constant
propagation.
-@cindex @code{noinit} variable attribute
+@atindex @code{noinit}
+@cindex variables that should not be initialized
@item noinit
This attribute applies to variables.
script to place sections with the @code{.noinit} prefix in the right
location.
-@cindex @code{noinline} function attribute
+@atindex @code{noinline}
+@cindex inlining, suppressing
+@cindex function inlining, suppressing
+@cindex suppressing inlining
@item noinline
This attribute applies to functions.
(@pxref{Extended Asm}) in the called function, to serve as a special
side effect.
-@cindex @code{noipa} function attribute
+@atindex @code{noipa}
@item noipa
This attribute applies to functions.
including those that do not have an attribute suitable for disabling
them individually.
-@cindex @code{nonnull} function attribute
-@cindex functions with non-null pointer arguments
+@atindex @code{nonnull}
+@cindex functions that have non-null pointer arguments
@item nonnull
@itemx nonnull (@var{arg-index}, @dots{})
The @code{nonnull} attribute may be applied to a function that takes at
__attribute__((nonnull));
@end smallexample
-@cindex @code{nonnull_if_nonzero} function attribute
+@atindex @code{nonnull_if_nonzero}
+@cindex functions that have non-null pointer arguments
@item nonnull_if_nonzero (@var{arg-index}, @var{arg2-index})
@itemx nonnull_if_nonzero (@var{arg-index}, @var{arg2-index}, @var{arg3-index})
This attribute may be applied to a function that takes at
used on declarations which have e.g.@: an exception for zero sizes,
in which case null may be passed.
-@cindex @code{nonstring} variable attribute
+@atindex @code{nonstring}
+@cindex nonstring character arrays
+@cindex character arrays, non-null-terminated
@item nonstring
This attribute applies to variables or members of a struct, union, or class
that have type array of @code{char}, @code{signed char}, or
@}
@end smallexample
-@cindex @code{noplt} function attribute
+@atindex @code{noplt}
@item noplt
This attribute applies to functions.
In position-dependent code, a few targets also convert calls to
functions that are marked to not use the PLT to use the GOT instead.
-@cindex @code{noreturn} function attribute
+@atindex @code{noreturn}
@cindex functions that never return
@item noreturn
This attribute applies to functions.
It does not make sense for a @code{noreturn} function to have a return
type other than @code{void}.
-@cindex @code{nothrow} function attribute
+@atindex @code{nothrow}
+@cindex functions that do not throw exceptions
@item nothrow
This attribute applies to functions.
with the notable exceptions of @code{qsort} and @code{bsearch} that
take function pointer arguments.
-@cindex @code{null_terminated_string_arg} function attribute
+@atindex @code{null_terminated_string_arg}
+@cindex character arrays, null-terminated
@item null_terminated_string_arg
@itemx null_terminated_string_arg (@var{N})
The @code{null_terminated_string_arg} attribute may be applied to a
be validly null-terminated, or validly readable up to the size specified by
the second parameter.
-@cindex @code{objc_nullability} variable attribute
+@atindex @code{objc_nullability}
@item objc_nullability (@var{nullability kind}) @r{(Objective-C and Objective-C++ only)}
This attribute applies to pointer variables only.
property to be reset in some manner to a default) but for which the property
getter will never validly return @code{nil}.
-@cindex @code{objc_root_class} type attribute
+@atindex @code{objc_root_class}
@item objc_root_class @r{(Objective-C and Objective-C++ only)}
This attribute applies to Objective-C and Objective-C++ classes.
the compiler to elide any warnings about a missing superclass and to
make additional checks for mandatory methods as needed.
-@cindex @code{optimize} function attribute
+@atindex @code{optimize}
+@cindex optimization, per-function
+@cindex functions that are compiled with specific optimizations
@item optimize (@var{level}, @dots{})
@item optimize (@var{string}, @dots{})
This attribute applies to functions.
The @code{optimize} attribute should be used for debugging purposes only.
It is not suitable in production code.
-@cindex @code{packed} attribute
+@atindex @code{packed}
+@cindex packed data
+@cindex alignment of structure fields
@item packed
This attribute can be attached to a @code{struct}, @code{union}, or
C++ @code{class} definition, to a member of one, or to an @code{enum}
@end smallexample
@opindex fshort-enums
-When attached to an @code{enum} definition, the @code{packed} attribute
+When attached to an @code{enum}
indicates that the smallest integral type should be used to represent the type.
Specifying the @option{-fshort-enums} flag on the command line
is equivalent to specifying the @code{packed}
not on a @code{typedef} that does not also define the enumerated type,
structure, union, or class.
-@cindex @code{patchable_function_entry} function attribute
+@atindex @code{patchable_function_entry}
@cindex extra NOP instructions at the function entry point
+@cindex functions that have patchable entries
@item patchable_function_entry
This attribute applies to functions.
framework with the attribute @code{patchable_function_entry (0)}
to prevent recursion.
-@cindex @code{persistent} variable attribute
+@atindex @code{persistent}
+@cindex persistent data
@item persistent
This attribute applies to variables.
right location. Specifically, some type of non-volatile, writable
memory is required.
-@cindex @code{pure} function attribute
+@atindex @code{pure}
@cindex functions that have no side effects
@item pure
This attribute applies to functions.
effects it does not make sense for such a function to return @code{void}.
Declaring such a function is diagnosed.
-@cindex @code{reproducible} function type attribute
+@atindex @code{reproducible}
@cindex functions that have no side effects
@item reproducible
This attribute applies to function types.
additional results through those pointers or references or references to
pointers.
-@cindex @code{retain} attribute
+@atindex @code{retain}
+@cindex linker garbage collection
@item retain
This attribute applies to functions and variables.
This additional functionality requires Binutils version 2.36 or later.
-@cindex @code{returns_nonnull} function attribute
+@atindex @code{returns_nonnull}
@item returns_nonnull
This attribute applies to functions returning a pointer type.
lets the compiler optimize callers based on the knowledge
that the return value will never be null.
-@cindex @code{returns_twice} function attribute
+@atindex @code{returns_twice}
@cindex functions that return more than once
@item returns_twice
This attribute applies to functions.
The @code{longjmp}-like counterpart of such function, if any, might need
to be marked with the @code{noreturn} attribute.
-@cindex @code{scalar_storage_order} type attribute
+@atindex @code{scalar_storage_order}
+@cindex endianness
+@cindex byte order
@item scalar_storage_order ("@var{endianness}")
This attribute applies to a @code{union} or @code{struct}.
through distinct types that assign a different storage order to it, then the
behavior is undefined.
-@cindex @code{section} attribute
+@atindex @code{section}
@cindex functions in arbitrary sections
@cindex variables in arbitrary sections
+@cindex program sections
@item section ("@var{section-name}")
This attribute applies to functions and variables.
If you need to map the entire contents of a module to a particular
section, consider using the facilities of the linker instead.
-@cindex @code{sentinel} function attribute
+@atindex @code{sentinel}
+@cindex variadic function sentinel
+@cindex functions that have a null-terminated argument list
@item sentinel
@itemx sentinel (@var{position})
This attribute applies to functions.
The warnings for missing or incorrect sentinels are enabled with
@option{-Wformat}.
-@cindex @code{simd} function attribute
+@atindex @code{simd}
+@cindex SIMD function cloning
+@cindex functions that have SIMD clones
@item simd
@itemx simd("@var{mask}")
This attribute applies to functions.
present on a declaration and the @option{-fopenmp} or @option{-fopenmp-simd}
switch is specified, then the attribute is ignored.
-@cindex @code{stack_protect} function attribute
+@atindex @code{stack_protect}
+@cindex stack protection
+@cindex functions that should have stack protection
@item stack_protect
This attribute applies to functions.
flags @option{-fstack-protector}, @option{-fstack-protector-strong}
or @option{-fstack-protector-explicit} are set.
-@cindex @code{strict_flex_array} variable attribute
+@atindex @code{strict_flex_array}
+@cindex flexible array members
@item strict_flex_array (@var{level})
The @code{strict_flex_array} attribute can be attached to the trailing
array field of a structure.
@option{-Wstrict-flex-arrays} option. @xref{Warning Options}, for more
information.
-@cindex @code{strub} type attribute
+@atindex @code{strub}
+@cindex stack scrubbing
@item strub
This attribute applies to types, and may also appear in variable and function
declarations.
inline __attribute__ ((noclone, always_inline)) void flip (void) @{@}
@end smallexample
-@cindex @code{symver} function attribute
+@atindex @code{symver}
+@cindex symbol versioning
@item symver ("@var{name2}@@@var{nodename}")
This attribute applies to functions.
@code{"@var{name2}@@@var{nodename}"} was used) the version is also used
to resolve @var{name2} by the linker.
-@cindex @code{tainted_args} function attribute
+@atindex @code{tainted_args}
+@cindex tainted arguments
+@cindex functions that have tainted arguments
@item tainted_args
This attribute applies to functions.
@option{-Wanalyzer-tainted-offset},
and @option{-Wanalyzer-tainted-size}.
-@cindex @code{target} function attribute
+@atindex @code{target}
+@cindex target-specific code generation attributes
@item target (@var{string}, @dots{})
This attribute applies to functions.
@xref{Function Multiversioning} for more details.
-@cindex @code{target_version} function attribute
+@atindex @code{target_version}
+@cindex function multiversioning
@item target_version (@var{option})
This attribute applies to functions.
@xref{Function Multiversioning} for more details.
-@cindex @code{target_clones} function attribute
+@atindex @code{target_clones}
+@cindex function multiversioning
@item target_clones (@var{options})
This attribute applies to functions.
@xref{Function Multiversioning} for more details.
-@cindex @code{tls_model} variable attribute
+@atindex @code{tls_model}
@item tls_model ("@var{tls_model}")
This attribute applies to variables.
Not all targets support this attribute.
-@cindex @code{transparent_union} type attribute
+@atindex @code{transparent_union}
+@cindex transparent unions
@item transparent_union
This attribute applies to @code{union} type definitions.
@}
@end smallexample
-@cindex @code{unavailable} attribute
+@atindex @code{unavailable}
@item unavailable
@itemx unavailable (@var{msg})
The @code{unavailable} attribute can apply to functions, variables, types,
@code{unavailable} attribute behaves in the same manner as
@code{deprecated}.
-@cindex @code{uninitialized} variable attribute
+@atindex @code{uninitialized}
@item uninitialized
This variable applies to variables with automatic storage.
This attribute has no effect when the option @code{-ftrivial-auto-var-init}
is not present.
-@cindex @code{unsequenced} function type attribute
+@atindex @code{unsequenced}
@cindex functions that have no side effects
@item unsequenced
This type attribute can appear on both function declarations and declarations
precedence over @code{unsequenced} which has precedence over
@code{reproducible}.
-@cindex @code{unused} attribute
+@atindex @code{unused}
+@cindex unused entities
@item unused
This attribute can be attached to a function, variable, structure field,
type declaration, or label.
could be useful in cases where the code that jumps to the label is
contained within an @code{#ifdef} conditional.
-@cindex @code{used} attribute
+@atindex @code{used}
+@cindex used entities
@item used
The @code{used} attribute applies to functions and variables.
attribute also means that the member is instantiated if the
class itself is instantiated.
-@cindex @code{vector_size} attribute
+@atindex @code{vector_size}
+@cindex vector types
@item vector_size (@var{bytes})
The @code{vector_size} attribute can be attached to type, variable,
and function declarations.
@xref{Vector Extensions}, for details of manipulating objects of vector types.
-@cindex @code{visibility} attribute
+@atindex @code{visibility}
+@cindex visibility of symbols
+@cindex linker visibility
@item visibility ("@var{visibility_type}")
This attribute can be applied to functions, variables, and types.
typeinfo node and exception handling will break.
@cindex @code{warn_if_not_aligned} attribute
+@cindex alignment of structure fields
@item warn_if_not_aligned (@var{alignment})
This attribute applies to structure fields.
This warning can be disabled by @option{-Wno-if-not-aligned}.
-@cindex @code{warn_unused_result} function attribute
+@atindex @code{warn_unused_result}
+@cindex unused function result
+@cindex functions whose return value must be used
@item warn_unused_result
This attribute applies to functions.
@noindent
results in warning on line 5.
-@cindex @code{weak} attribute
+@atindex @code{weak}
+@cindex weak symbols
@item weak
This attribute applies to function and variable declarations.
the weak symbol. Weak symbols are supported for ELF targets, and also
for a.out targets when using the GNU assembler and linker.
-@cindex @code{weakref} attribute
+@atindex @code{weakref}
+@cindex weak symbols
@item weakref
@itemx weakref ("@var{target}")
This attribute applies to function or variable declarations.
A declaration to which @code{weakref} is attached and that is associated
with a named @code{target} must be @code{static}.
-@cindex @code{zero_call_used_regs} function attribute
+@atindex @code{zero_call_used_regs}
@item zero_call_used_regs ("@var{choice}")
This attribute applies to functions.
@table @code
-@cindex @code{target} function attribute, AArch64
+@atindex @code{target}, AArch64
+@cindex AArch64 code generation attributes
@item target (@var{options})
This attribute applies to functions.
These are the permitted options:
@table @samp
-@cindex @code{target("general-regs-only")} function attribute, AArch64
+@atindex @code{target("general-regs-only")}, AArch64
@item general-regs-only
Indicates that no floating-point or Advanced SIMD registers should be
used when generating code for this function. If the function explicitly
the same behavior as that of the command-line option
@option{-mgeneral-regs-only}.
-@cindex @code{target("fix-cortex-a53-835769")} function attribute, AArch64
+@atindex @code{target("fix-cortex-a53-835769")}, AArch64
@item fix-cortex-a53-835769
Indicates that the workaround for the Cortex-A53 erratum 835769 should be
applied to this function. To explicitly disable the workaround for this
This corresponds to the behavior of the command-line options
@option{-mfix-cortex-a53-835769} and @option{-mno-fix-cortex-a53-835769}.
-@cindex @code{target("cmodel=")} function attribute, AArch64
+@atindex @code{target("cmodel=")}, AArch64
@item cmodel=
Indicates that code should be generated for a particular code model for
this function. The behavior and permissible arguments are the same as
for the command-line option @option{-mcmodel=}.
-@cindex @code{target("strict-align")} function attribute, AArch64
+@atindex @code{target("strict-align")}, AArch64
@item strict-align
@itemx no-strict-align
@code{strict-align} indicates that the compiler should not assume that unaligned
@code{no-strict-align} can be specified. The behavior is same as for the
command-line option @option{-mstrict-align} and @option{-mno-strict-align}.
-@cindex @code{target("omit-leaf-frame-pointer")} function attribute, AArch64
+@atindex @code{target("omit-leaf-frame-pointer")}, AArch64
@item omit-leaf-frame-pointer
Indicates that the frame pointer should be omitted for a leaf function call.
To keep the frame pointer, the inverse attribute
the same behavior as the command-line options @option{-momit-leaf-frame-pointer}
and @option{-mno-omit-leaf-frame-pointer}.
-@cindex @code{target("tls-dialect=")} function attribute, AArch64
+@atindex @code{target("tls-dialect=")}, AArch64
@item tls-dialect=
Specifies the TLS dialect to use for this function. The behavior and
permissible arguments are the same as for the command-line option
@option{-mtls-dialect=}.
-@cindex @code{target("arch=")} function attribute, AArch64
+@atindex @code{target("arch=")}, AArch64
@item arch=
Specifies the architecture version and architectural extensions to use
for this function. The behavior and permissible arguments are the same as
for the @option{-march=} command-line option.
-@cindex @code{target("tune=")} function attribute, AArch64
+@atindex @code{target("tune=")}, AArch64
@item tune=
Specifies the core for which to tune the performance of this function.
The behavior and permissible arguments are the same as for the @option{-mtune=}
command-line option.
-@cindex @code{target("cpu=")} function attribute, AArch64
+@atindex @code{target("cpu=")}, AArch64
@item cpu=
Specifies the core for which to tune the performance of this function and also
whose architectural features to use. The behavior and valid arguments are the
same as for the @option{-mcpu=} command-line option.
-@cindex @code{target("sign-return-address")} function attribute, AArch64
+@atindex @code{target("sign-return-address")}, AArch64
@item sign-return-address
Select the function scope on which return address signing will be applied. The
behavior and permissible arguments are the same as for the command-line option
attribute is deprecated. The @code{branch-protection} attribute should
be used instead.
-@cindex @code{target("branch-protection")} function attribute, AArch64
+@atindex @code{target("branch-protection")}, AArch64
@item branch-protection
Select the function scope on which branch protection will be applied. The
behavior and permissible arguments are the same as for the command-line option
@option{-mbranch-protection=}. The default value is @code{none}.
-@cindex @code{target("outline-atomics")} function attribute, AArch64
+@atindex @code{target("outline-atomics")}, AArch64
@item outline-atomics
@itemx no-outline-atomics
Enable or disable calls to out-of-line helpers to implement atomic operations.
This corresponds to the behavior of the command-line options
@option{-moutline-atomics} and @option{-mno-outline-atomics}.
-@cindex @code{target("max-vectorization")} function attribute, AArch64
+@atindex @code{target("max-vectorization")}, AArch64
@item max-vectorization
@itemx no-max-vectorization
@code{max-vectorization} tells GCC's vectorizer to treat all vector
This corresponds to the behavior of the command-line options
@option{-mmax-vectorization} and @option{-mno-max-vectorization}.
-@cindex @code{target("indirect_return")} function attribute, AArch64
+@atindex @code{target("indirect_return")}, AArch64
@item indirect_return
The @code{indirect_return} attribute can be applied to a function type
to indicate that the function may return via an indirect branch instead
adds a @code{BTI J} instruction when BTI is enabled e.g. via
@option{-mbranch-protection}.
-@cindex @code{target("preserve_none")} function attribute, AArch64
+@atindex @code{target("preserve_none")}, AArch64
@item preserve_none
Use this attribute to change the procedure call standard of the specified
function to the preserve-none variant.
These attributes are supported by the AMD GCN back end:
@table @code
-@cindex @code{amdgpu_hsa_kernel} function attribute, AMD GCN
+@atindex @code{amdgpu_hsa_kernel}, AMD GCN
@item amdgpu_hsa_kernel
This attribute applies to functions.
These attributes are supported by the ARC back end:
@table @code
-@cindex @code{interrupt} function attribute, ARC
+@atindex @code{interrupt}, ARC
@item interrupt
This attribute applies to functions.
@w{@code{ilink2}} for ARCv1 architecture, and @w{@code{ilink}} and
@w{@code{firq}} for ARCv2 architecture.
-@cindex @code{long_call} function attribute, ARC
-@cindex @code{medium_call} function attribute, ARC
-@cindex @code{short_call} function attribute, ARC
+@atindex @code{long_call}, ARC
+@atindex @code{medium_call}, ARC
+@atindex @code{short_call}, ARC
@cindex indirect calls, ARC
@item long_call
@itemx medium_call
branch-and-link instruction, which has a 21-bit offset from
the call site.
-@cindex @code{jli_always} function attribute, ARC
+@atindex @code{jli_always}, ARC
@item jli_always
This attribute applies to functions.
into @code{.jlitab} section, which holds the location of the functions
which are addressed using this instruction.
-@cindex @code{jli_fixed} function attribute, ARC
+@atindex @code{jli_fixed}, ARC
@item jli_fixed
This attribute applies to functions.
Identical to @code{jli_always} above, but the location of the function in the
@code{jli} table is known and given as an attribute parameter.
-@cindex @code{secure_call} function attribute, ARC
+@atindex @code{secure_call}, ARC
@item secure_call
This attribute applies to functions.
callable from normal mode. The location of the secure call function
into the @code{sjli} table needs to be passed as argument.
-@cindex @code{aux} variable attribute, ARC
+@atindex @code{aux}, ARC
@item aux
This attribute applies to variables.
given via attribute argument.
@item uncached
-@cindex @code{uncached} type attribute, ARC
+@atindex @code{uncached}, ARC
This attribute applies to types.
Declaring objects with the @code{uncached} type attribute
@table @code
-@cindex @code{general-regs-only} function attribute, ARM
+@atindex @code{general-regs-only}, ARM
@item general-regs-only
This attribute applies to functions.
the same behavior as that of the command-line option
@option{-mgeneral-regs-only}.
-@cindex @code{interrupt} function attribute, ARM
+@atindex @code{interrupt}, ARM
@item interrupt
This attribute applies to functions.
On ARMv7-M the interrupt type is ignored, and the attribute means the function
may be called with a word-aligned stack pointer.
-@cindex @code{isr} function attribute, ARM
+@atindex @code{isr}, ARM
@item isr
This attribute applies to functions.
Use this attribute on ARM to write Interrupt Service Routines. This is an
alias to the @code{interrupt} attribute above.
-@cindex @code{long_call} function attribute, ARM
-@cindex @code{short_call} function attribute, ARM
+@atindex @code{long_call}, ARM
+@atindex @code{short_call}, ARM
@cindex indirect calls, ARM
@item long_call
@itemx short_call
the offset to the function from the call site into the @samp{BL}
instruction directly.
-@cindex @code{pcs} function attribute, ARM
+@atindex @code{pcs}, ARM
@item pcs
This attribute applies to functions.
Variadic functions always use the @code{"aapcs"} calling convention and
the compiler rejects attempts to specify an alternative.
-@cindex @code{target} function attribute
+@atindex @code{target}, ARM
@item target (@var{options})
This attribute applies to functions.
On ARM, the following options are allowed:
@table @samp
-@cindex @code{target("thumb")} function attribute, ARM
+@atindex @code{target("thumb")}, ARM
@item thumb
Force code generation in the Thumb (T16/T32) ISA, depending on the
architecture level.
-@cindex @code{target("arm")} function attribute, ARM
+@atindex @code{target("arm")}, ARM
@item arm
Force code generation in the ARM (A32) ISA.
Functions from different modes can be inlined in the caller's mode.
-@cindex @code{target("fpu=")} function attribute, ARM
+@atindex @code{target("fpu=")}, ARM
@item fpu=
Specifies the fpu for which to tune the performance of this function.
The behavior and permissible arguments are the same as for the @option{-mfpu=}
command-line option.
-@cindex @code{arch=} function attribute, ARM
+@atindex @code{arch=}, ARM
@item arch=
Specifies the architecture version and architectural extensions to use
for this function. The behavior and permissible arguments are the same as
@end table
-@cindex @code{notshared} type attribute, ARM
+@atindex @code{notshared}, ARM
@item notshared
This attributes applies to class types.
These attributes are supported by the AVR back end:
@table @code
-@cindex @code{signal} function attribute, AVR
-@cindex @code{interrupt} function attribute, AVR
+@atindex @code{signal}, AVR
+@atindex @code{interrupt}, AVR
@item signal
@itemx interrupt
These attributes apply to functions.
When both @code{signal} and @code{interrupt} are specified for the same
function, then @code{signal} is silently ignored.
-@cindex @code{signal(@var{num})} function attribute, AVR
-@cindex @code{interrupt(@var{num})} function attribute, AVR
+@atindex @code{signal(@var{num})}, AVR
+@atindex @code{interrupt(@var{num})}, AVR
@item signal(@var{num})
@itemx interrupt(@var{num})
These attributes apply to functions.
without the overhead introduced by @code{ISR_ALIASOF}.
-@cindex @code{noblock} function attribute, AVR
+@atindex @code{noblock}, AVR
@item noblock
This attribute applies to functions.
attribute. Using the @code{noblock} attribute without @code{signal} has no
effect.
-@cindex @code{no_gccisr} function attribute, AVR
+@atindex @code{no_gccisr}, AVR
@item no_gccisr
This attribute applies to functions.
To disable @code{__gcc_isr} generation for the whole compilation unit,
use option @option{-mno-gas-isr-prologues}, @pxref{AVR Options}.
-@cindex @code{OS_main} function attribute, AVR
-@cindex @code{OS_task} function attribute, AVR
+@atindex @code{OS_main}, AVR
+@atindex @code{OS_task}, AVR
@item OS_main
@itemx OS_task
This attribute applies to functions.
as needed.
@end itemize
-@cindex @code{progmem} variable attribute, AVR
+@atindex @code{progmem}, AVR
@item progmem
This attribute applies to variables.
@end table
-@cindex @code{io} variable attribute, AVR
+@atindex @code{io}, AVR
@item io
@itemx io (@var{addr})
This attribute applies to variables.
extern volatile int porta __attribute__((io));
@end smallexample
-@cindex @code{io_low} variable attribute, AVR
+@atindex @code{io_low}, AVR
@item io_low
@itemx io_low (@var{addr})
The @code{io_low} attribute applies to variables.
allowing the use of @code{cbi}, @code{sbi}, @code{sbic} and @code{sbis}
instructions.
-@cindex @code{address} variable attribute, AVR
+@atindex @code{address}, AVR
@item address (@var{addr})
This attribute applies to variables.
a_symbol = 1234
@end smallexample
-@cindex @code{absdata} variable attribute, AVR
+@atindex @code{absdata}, AVR
@item absdata
This attribute applies to variables.
@table @code
-@cindex @code{exception_handler} function attribute
+@atindex @code{exception_handler}, Blackfin
@cindex exception handler functions, Blackfin
@item exception_handler
This attribute applies to functions.
exit sequences suitable for use in an exception handler when this
attribute is present.
-@cindex @code{interrupt_handler} function attribute, Blackfin
+@atindex @code{interrupt_handler}, Blackfin
@item interrupt_handler
This attribute applies to functions.
generates function entry and exit sequences suitable for use in an
interrupt handler when this attribute is present.
-@cindex @code{kspisusp} function attribute, Blackfin
+@atindex @code{kspisusp}, Blackfin
@cindex User stack pointer in interrupts on the Blackfin
@item kspisusp
This attribute applies to functions.
or @code{nmi_handler}, code is generated to load the stack pointer
from the USP register in the function prologue.
-@cindex @code{l1_text} function attribute, Blackfin
+@atindex @code{l1_text}, Blackfin
@item l1_text
This attribute applies to functions.
With @option{-mfdpic}, function calls with a such function as the callee
or caller uses inlined PLT.
-@cindex @code{l2} attribute, Blackfin
+@atindex @code{l2}, Blackfin
@item l2
This attribute applies to functions and variables.
named @code{.l2.data}.
@cindex indirect calls, Blackfin
-@cindex @code{longcall} function attribute, Blackfin
-@cindex @code{shortcall} function attribute, Blackfin
+@atindex @code{longcall}, Blackfin
+@atindex @code{shortcall}, Blackfin
@item longcall
@itemx shortcall
This attribute applies to functions.
enough for the shorter calling sequence to be used. These attributes
override the @option{-mlongcall} switch.
-@cindex @code{nesting} function attribute, Blackfin
+@atindex @code{nesting}, Blackfin
@cindex Allow nesting in an interrupt handler on the Blackfin processor
@item nesting
This attribute applies to functions.
@code{exception_handler} or @code{nmi_handler} to indicate that the function
entry code should enable nested interrupts or exceptions.
-@cindex @code{nmi_handler} function attribute, Blackfin
+@atindex @code{nmi_handler}, Blackfin
@cindex NMI handler functions on the Blackfin processor
@item nmi_handler
This attribute applies to functions.
exit sequences suitable for use in an NMI handler when this
attribute is present.
-@cindex @code{saveall} function attribute, Blackfin
+@atindex @code{saveall}, Blackfin
@cindex save all registers on the Blackfin
@item saveall
This attribute applies to functions.
all registers except the stack pointer should be saved in the prologue
regardless of whether they are used or not.
-@cindex @code{l1_data} variable attribute, Blackfin
-@cindex @code{l1_data_A} variable attribute, Blackfin
-@cindex @code{l1_data_B} variable attribute, Blackfin
+@atindex @code{l1_data}, Blackfin
+@atindex @code{l1_data_A}, Blackfin
+@atindex @code{l1_data_B}, Blackfin
@item l1_data
@itemx l1_data_A
@itemx l1_data_B
These attributes are supported by the BPF back end:
@table @code
-@cindex @code{kernel helper}, function attribute, BPF
+@atindex @code{kernel helper}, BPF
@item kernel_helper
This attribute applies to functions.
__attribute__ ((kernel_helper (4)));
@end smallexample
-@cindex @code{preserve_access_index} type attribute, BPF
+@atindex @code{preserve_access_index}, BPF
@item preserve_access_index
This attribute applies to types.
These attributes are supported by the C-SKY back end:
@table @code
-@cindex @code{interrupt} function attribute, C-SKY
-@cindex @code{isr} function attribute, C-SKY
+@atindex @code{interrupt}, C-SKY
+@atindex @code{isr}, C-SKY
@item interrupt
@itemx isr
These attributes apply to functions.
These attributes are supported by the Epiphany back end:
@table @code
-@cindex @code{disinterrupt} function attribute, Epiphany
+@atindex @code{disinterrupt}, Epiphany
@item disinterrupt
This attribute applies to functions.
instructions to disable interrupts for the duration of the given
function.
-@cindex @code{forwarder_section} function attribute, Epiphany
+@atindex @code{forwarder_section}, Epiphany
@item forwarder_section
This attribute applies to functions.
to transfer control. The single parameter identifies the section where
the trampoline is placed.
-@cindex @code{interrupt} function attribute, Epiphany
+@atindex @code{interrupt}, Epiphany
@item interrupt
This attribute applies to functions.
external_dma_handler ();
@end smallexample
-@cindex @code{long_call} function attribute, Epiphany
-@cindex @code{short_call} function attribute, Epiphany
+@atindex @code{long_call}, Epiphany
+@atindex @code{short_call}, Epiphany
@cindex indirect calls, Epiphany
@item long_call
@itemx short_call
These attributes are available for H8/300 targets:
@table @code
-@cindex @code{function_vector} function attribute, H8/300
+@atindex @code{function_vector}, H8/300
@item function_vector
This attribute applies to functions.
and 64 entries on the H8/300H and H8S)
and shares space with the interrupt vector.
-@cindex @code{interrupt_handler} function attribute, H8/300
+@atindex @code{interrupt_handler}, H8/300
@item interrupt_handler
This attribute applies to functions.
generates function entry and exit sequences suitable for use in an
interrupt handler when this attribute is present.
-@cindex @code{saveall} function attribute, H8/300
+@atindex @code{saveall}, H8/300
@cindex save all registers on the H8/300, H8/300H, and H8S
@item saveall
This attribute applies to functions.
all registers except the stack pointer should be saved in the prologue
regardless of whether they are used or not.
-@cindex @code{monitor} function attribute, H8/300
+@atindex @code{monitor}, H8/300
@item monitor
This attribute applies to functions.
to generate entry and exit sequences that disable interrupts during
execution of the function.
-@cindex @code{OS_Task} function attribute, H8/300
+@atindex @code{OS_Task}, H8/300
@item OS_Task
This attribute applies to functions.
restore sequences on function entry and exit. The function epilogue
generated by GCC includes only a return instruction.
-@cindex @code{eightbit_data} variable attribute, H8/300
+@atindex @code{eightbit_data}, H8/300
@cindex eight-bit data on the H8/300, H8/300H, and H8S
@item eightbit_data
This attribute applies to variable declarations.
on data in the eight-bit data area. Note the eight-bit data area is limited to
256 bytes of data.
-@cindex @code{tiny_data} variable attribute, H8/300
+@atindex @code{tiny_data}, H8/300
@cindex tiny data section on the H8/300H and H8S
@item tiny_data
This attribute applies to variable declarations.
These attributes are supported on IA-64 targets:
@table @code
-@cindex @code{syscall_linkage} function attribute, IA-64
+@atindex @code{syscall_linkage}, IA-64
@item syscall_linkage
This attribute applies to functions.
the input registers. This also prevents kernel data from leaking into
application code.
-@cindex @code{version_id} attribute, IA-64
+@atindex @code{version_id}, IA-64
@item version_id
This attribute applies to global variables or functions.
@noindent
Calls to @code{foo} are mapped to calls to @code{foo@{20040821@}}.
-@cindex @code{model} variable attribute, IA-64
+@atindex @code{model}, IA-64
@item model (@var{model-name})
This attribute applies to variables.
@table @code
-@cindex @code{target (option,...)} loongarch function attribute target
-@item target (option,...)
-@cindex @code{target} LoongArch function attribute
+@atindex @code{target}, LoongArch
@item target (@var{options})
This attribute applies to functions.
These are the permitted options:
@table @samp
-@cindex @code{target("strict-align")} function attribute, LoongArch
+@atindex @code{target("strict-align")}, LoongArch
@item strict-align
@itemx no-strict-align
@code{strict-align} indicates that the compiler should not assume that unaligned
@code{no-strict-align} can be specified. The behavior is same as for the
command-line option @option{-mstrict-align} and @option{-mno-strict-align}.
-@cindex @code{target("cmodel=")} function attribute, LoongArch
+@atindex @code{target("cmodel=")}, LoongArch
@item cmodel=
Indicates that code should be generated for a particular code model for
this function. The behavior and permissible arguments are the same as
for the command-line option @option{-mcmodel=}.
-@cindex @code{target("arch=")} function attribute, LoongArch
+@atindex @code{target("arch=")}, LoongArch
@item arch=
Specifies the architecture version and architectural extensions to use
for this function. The behavior and permissible arguments are the same as
for the @option{-march=} command-line option.
-@cindex @code{target("tune=")} function attribute, LoongArch
+@atindex @code{target("tune=")}, LoongArch
@item tune=
Specifies the core for which to tune the performance of this function.
The behavior and permissible arguments are the same as for the @option{-mtune=}
command-line option.
-@cindex @code{target("lsx")} function attribute, LoongArch
+@atindex @code{target("lsx")}, LoongArch
@item lsx
@itemx no-lsx
@code{lsx} indicates that vector instruction generation is allowed
The behavior is same as for the command-line option
@option{-mlsx} and @option{-mno-lsx}.
-@cindex @code{target("lasx")} function attribute, LoongArch
+@atindex @code{target("lasx")}, LoongArch
@item lasx
@itemx no-lasx
@code{lasx} indicates that lasx instruction generation is allowed (not allowed)
$ gcc test.c -o test.s -O2 -mlasx -mno-lasx
@end smallexample
-@cindex @code{target("recipe")} function attribute, LoongArch
+@atindex @code{target("recipe")}, LoongArch
@item recipe
@itemx no-recipe
@code{recipe} indicates that frecipe.@{s/d@} and frsqrt.@{s/d@}
The behavior is same as for the command-line options
@option{-mrecipe} and @option{-mno-recipe}.
-@cindex @code{target("div32")} function attribute, LoongArch
+@atindex @code{target("div32")}, LoongArch
@item div32
@itemx no-div32
@code{div32} determines whether div.w[u] and mod.w[u] instructions on
The behavior is same as for the command-line options
@option{-mdiv32} and @option{-mno-div32}.
-@cindex @code{target("lam-bh")} function attribute, LoongArch
+@atindex @code{target("lam-bh")}, LoongArch
@item lam-bh
@itemx no-lam-bh
@code{lam-bh} indicates that am@{swap/add@}[_db].@{b/h@} instruction generation
The behavior is same as for the command-line options
@option{-mlam-bh} and @option{-mno-lam-bh}.
-@cindex @code{target("lamcas")} function attribute, LoongArch
+@atindex @code{target("lamcas")}, LoongArch
@item lamcas
@itemx no-lamcas
@code{lamcas} indicates that amcas[_db].@{b/h/w/d@} instruction generation
The behavior is same as for the command-line options
@option{-mlamcas} and @option{-mno-lamcas}.
-@cindex @code{target("scq")} function attribute, LoongArch
+@atindex @code{target("scq")}, LoongArch
@item scq
@itemx no-scq
@code{scq} indicates that sc.q instruction generation is allowed (not allowed)
The behavior is same as for the command-line options
@option{-mscq} and @option{-mno-scq}.
-@cindex @code{target("ld-seq-sa")} function attribute, LoongArch
+@atindex @code{target("ld-seq-sa")}, LoongArch
@item ld-seq-sa
@itemx no-ld-seq-sa
@code{ld-seq-sa} indicates that same-address load-load barriers (dbar 0x700)
it is not inlined if the code model of the caller function is different
from the code model of the callee function.
-@cindex @code{target_clones (string,...)} LoongArch function attribute
+@atindex @code{target_clones}, LoongArch
@item target_clones (@var{options})
This attribute applies to functions.
Note that the option values on the GCC command line are not considered when
calculating the priority.
-@cindex @code{target_version} LoongArch function attribute
+@atindex @code{target_version}, LoongArch
@item target_version (@var{option})
This attribute applies to functions.
@}
@end smallexample
-@cindex @code{model} variable attribute, LoongArch
+@atindex @code{model}, LoongArch
@item model("@var{name}")
This attribute applies to variables.
These attributes are supported by the M32C back end:
@table @code
-@cindex @code{bank_switch} function attribute, M32C
+@atindex @code{bank_switch}, M32C
@item bank_switch
This attribute applies to functions.
prologue and epilogue to use bank switching to preserve the registers
rather than saving them on the stack.
-@cindex @code{fast_interrupt} function attribute, M32C
+@atindex @code{fast_interrupt}, M32C
@item fast_interrupt
This attribute applies to functions.
@code{interrupt} attribute, except that @code{freit} is used to return
instead of @code{reit}.
-@cindex @code{function_vector} function attribute, M16C/M32C
+@atindex @code{function_vector}, M16C/M32C
@item function_vector
This attribute applies to functions.
This attribute is ignored for R8C target.
-@cindex @code{interrupt} function attribute, M32C
+@atindex @code{interrupt}, M32C
@item interrupt
This attribute applies to functions.
These attributes are supported by the M32R/D back end:
@table @code
-@cindex @code{interrupt} function attribute, M32R/D
+@atindex @code{interrupt}, M32R/D
@item interrupt
This attribute applies to functions.
function entry and exit sequences suitable for use in an interrupt handler
when this attribute is present.
-@cindex @code{model} attribute, M32R/D
+@atindex @code{model}, M32R/D
@cindex function addressability on the M32R/D
@cindex variable addressability on the M32R/D
@item model (@var{model-name})
These attributes are supported by the m68k back end:
@table @code
-@cindex @code{interrupt} function attribute, m68k
-@cindex @code{interrupt_handler} function attribute, m68k
+@atindex @code{interrupt}, m68k
+@atindex @code{interrupt_handler}, m68k
@item interrupt
@itemx interrupt_handler
These attributes apply to functions.
generates function entry and exit sequences suitable for use in an
interrupt handler when this attribute is present. Either name may be used.
-@cindex @code{interrupt_thread} function attribute, fido
+@atindex @code{interrupt_thread}, fido
@item interrupt_thread
This attribute applies to functions.
These attributes are supported on MicroBlaze targets:
@table @code
-@cindex @code{save_volatiles} function attribute, MicroBlaze
+@atindex @code{save_volatiles}, MicroBlaze
@item save_volatiles
This attribute applies to functions.
function, only volatiles used by the function are saved. A normal function
return is generated instead of a return from interrupt.
-@cindex @code{break_handler} function attribute, MicroBlaze
+@atindex @code{break_handler}, MicroBlaze
@cindex break handler functions
@item break_handler
This attribute applies to functions.
void f () __attribute__ ((break_handler));
@end smallexample
-@cindex @code{interrupt_handler} function attribute, MicroBlaze
-@cindex @code{fast_interrupt} function attribute, MicroBlaze
+@atindex @code{interrupt_handler}, MicroBlaze
+@atindex @code{fast_interrupt}, MicroBlaze
@item interrupt_handler
@itemx fast_interrupt
These attributes apply to functions.
@node Microsoft Windows Attributes
@subsubsection Microsoft Windows Attributes
-The following attributes are available on Microsoft Windows and Symbian OS
-targets.
+@cindex @code{__declspec}
+On Microsoft Windows and Symbian OS targets, GCC supports the
+@code{__declspec} keyword in addition to @code{__attribute__} and
+the standard C or C++ attribute syntax, for compatibility with other
+compilers. The @code{__declspec} syntax
+supported by GCC is limited and should only be used as explicitly
+documented in this section.
+
+The following attributes are available on Microsoft Windows and Symbian OS:
@table @code
-@cindex @code{dllexport} attribute
-@cindex @code{__declspec(dllexport)}
+@atindex @code{dllexport}, Microsoft Windows
@item dllexport
This attribute can be applied to functions, variables, and C++ classes.
@file{.def} file with an @code{EXPORTS} section or, with GNU ld, using
the @option{--export-all} linker flag.
-@cindex @code{dllimport} attribute
-@cindex @code{__declspec(dllimport)}
+@atindex @code{dllimport}, Microsoft Windows
@item dllimport
This attribute applies to functions, variables, and C++ classes.
referenced. On Microsoft Windows targets, the attribute can be disabled
for functions by setting the @option{-mnop-fun-dllimport} flag.
-@cindex @code{selectany} variable attribute
+@atindex @code{selectany}, Microsoft Windows
@item selectany
This attribute applies to variables.
@code{__attribute__ ((selectany))} for compatibility with other
compilers.
-@cindex @code{shared} variable attribute
+@atindex @code{shared}, Microsoft Windows
@item shared
This attribute applies to variables.
These attributes are supported by the MIPS back end:
@table @code
-@cindex @code{interrupt} function attribute, MIPS
+@atindex @code{interrupt}, MIPS
@item interrupt
This attribute applies to functions.
You can use the following attributes to modify the behavior
of an interrupt handler:
@table @code
-@cindex @code{use_shadow_register_set} function attribute, MIPS
+@atindex @code{use_shadow_register_set}, MIPS
@item use_shadow_register_set
Assume that the handler uses a shadow register set, instead of
the main general-purpose registers. An optional argument @code{intstack} is
supported to indicate that the shadow register set contains a valid stack
pointer.
-@cindex @code{keep_interrupts_masked} function attribute, MIPS
+@atindex @code{keep_interrupts_masked}, MIPS
@item keep_interrupts_masked
This attribute applies to functions.
Without this attribute,
GCC tries to reenable interrupts for as much of the function as it can.
-@cindex @code{use_debug_exception_return} function attribute, MIPS
+@atindex @code{use_debug_exception_return}, MIPS
@item use_debug_exception_return
This attribute applies to functions.
@end smallexample
@cindex indirect calls, MIPS
-@cindex @code{long_call} function attribute, MIPS
-@cindex @code{short_call} function attribute, MIPS
-@cindex @code{near} function attribute, MIPS
-@cindex @code{far} function attribute, MIPS
+@atindex @code{long_call}, MIPS
+@atindex @code{short_call}, MIPS
+@atindex @code{near}, MIPS
+@atindex @code{far}, MIPS
@item long_call
@itemx short_call
@itemx near
effect; they specify that non-PIC calls should be made using the more
efficient @code{jal} instruction.
-@cindex @code{mips16} function attribute, MIPS
-@cindex @code{nomips16} function attribute, MIPS
+@atindex @code{mips16}, MIPS
+@atindex @code{nomips16}, MIPS
@item mips16
@itemx nomips16
may interact badly with some GCC extensions such as @code{__builtin_apply}
(@pxref{Constructing Calls}).
-@cindex @code{micromips} function attribute
-@cindex @code{nomicromips} function attribute
+@atindex @code{micromips}, MIPS
+@atindex @code{nomicromips}, MIPS
@item micromips, MIPS
@itemx nomicromips, MIPS
This attribute applies to functions.
may interact badly with some GCC extensions such as @code{__builtin_apply}
(@pxref{Constructing Calls}).
-@cindex @code{nocompression} function attribute, MIPS
+@atindex @code{nocompression}, MIPS
@item nocompression
This attribute applies to functions.
overrides the @option{-mips16} and @option{-mmicromips} options on the
command line (@pxref{MIPS Options}).
-@cindex @code{use_hazard_barrier_return} function attribute, MIPS
+@atindex @code{use_hazard_barrier_return}, MIPS
@item use_hazard_barrier_return
This attribute applies to functions.
instead of generating a normal return instruction.
@item code_readable
-@cindex @code{code_readable} function attribute, MIPS
+@atindex @code{code_readable}, MIPS
This attribute applies to functions.
For MIPS targets that support PC-relative addressing modes, this attribute
These attributes are supported by the MSP430 back end:
@table @code
-@cindex @code{critical} function attribute, MSP430
+@atindex @code{critical}, MSP430
@item critical
This attribute applies to functions.
on exit. The @code{critical} attribute is therefore redundant on
@code{interrupt} functions.
-@cindex @code{interrupt} function attribute, MSP430
+@atindex @code{interrupt}, MSP430
@item interrupt
This attribute applies to functions.
the names @code{watchdog} for vector 26, @code{nmi} for vector 30 and
@code{reset} for vector 31 are recognized.
-@cindex @code{reentrant} function attribute, MSP430
+@atindex @code{reentrant}, MSP430
@item reentrant
This attribute applies to functions.
or @code{critical} attributes. They can have the @code{interrupt}
attribute.
-@cindex @code{wakeup} function attribute, MSP430
+@atindex @code{wakeup}, MSP430
@item wakeup
This attribute only applies to interrupt functions. It is silently
ignored if applied to a non-interrupt function.
function rouses the processor from any low-power state that it
might be in when the function exits.
-@cindex @code{lower} attribute, MSP430
-@cindex @code{upper} attribute, MSP430
-@cindex @code{either} attribute, MSP430
+@atindex @code{lower}, MSP430
+@atindex @code{upper}, MSP430
+@atindex @code{either}, MSP430
@item lower
@itemx upper
@itemx either
These attributes are supported by the NDS32 back end:
@table @code
-@cindex @code{exception} function attribute
+@atindex @code{exception}, NDS32
@cindex exception handler functions, NDS32
@item exception
This attribute applies to functions.
is an exception handler. The compiler will generate corresponding sections
for use in an exception handler.
-@cindex @code{interrupt} function attribute, NDS32
+@atindex @code{interrupt}, NDS32
@item interrupt
This attribute applies to functions.
for use in an interrupt handler. You can use the following attributes
to modify the behavior:
@table @code
-@cindex @code{nested} function attribute, NDS32
+@atindex @code{nested}, NDS32
@item nested
This interrupt service routine is interruptible.
-@cindex @code{not_nested} function attribute, NDS32
+@atindex @code{not_nested}, NDS32
@item not_nested
This interrupt service routine is not interruptible.
-@cindex @code{nested_ready} function attribute, NDS32
+@atindex @code{nested_ready}, NDS32
@item nested_ready
This interrupt service routine is interruptible after @code{PSW.GIE}
(global interrupt enable) is set. This allows interrupt service routine to
finish some short critical code before enabling interrupts.
-@cindex @code{save_all} function attribute, NDS32
+@atindex @code{save_all}, NDS32
@item save_all
The system will help save all registers into stack before entering
interrupt handler.
-@cindex @code{partial_save} function attribute, NDS32
+@atindex @code{partial_save}, NDS32
@item partial_save
The system will help save caller registers into stack before entering
interrupt handler.
@end table
-@cindex @code{reset} function attribute, NDS32
+@atindex @code{reset}, NDS32
@cindex reset handler functions
@item reset
This attribute applies to functions.
for use in a reset handler. You can use the following attributes
to provide extra exception handling:
@table @code
-@cindex @code{nmi} function attribute, NDS32
+@atindex @code{nmi}, NDS32
@item nmi
Provide a user-defined function to handle NMI exception.
-@cindex @code{warm} function attribute, NDS32
+@atindex @code{warm}, NDS32
@item warm
Provide a user-defined function to handle warm reset exception.
@end table
These attributes are supported by the Nvidia PTX back end:
@table @code
-@cindex @code{kernel} function attribute, Nvidia PTX
+@atindex @code{kernel}, Nvidia PTX
@item kernel
This attribute applies to functions.
Kernel functions must have @code{void} return type.
-@cindex @code{shared} variable attribute, Nvidia PTX
+@atindex @code{shared}, Nvidia PTX
@item shared
This attribute applies to variables.
@table @code
@cindex indirect calls, PowerPC
-@cindex @code{longcall} function attribute, PowerPC
-@cindex @code{shortcall} function attribute, PowerPC
+@atindex @code{longcall}, PowerPC
+@atindex @code{shortcall}, PowerPC
@item longcall
@itemx shortcall
These attributes apply to functions.
@xref{RS/6000 and PowerPC Options}, for more information on whether long
calls are necessary.
-@cindex @code{target} function attribute
+@atindex @code{target}, PowerPC
@item target (@var{options})
This attribute applies to functions.
On the PowerPC, the following options are allowed:
@table @samp
-@cindex @code{target("altivec")} function attribute, PowerPC
+@atindex @code{target("altivec")}, PowerPC
@item altivec
@itemx no-altivec
Generate code that uses (does not use) AltiVec instructions. In
32-bit code, you cannot enable AltiVec instructions unless
@option{-mabi=altivec} is used on the command line.
-@cindex @code{target("cmpb")} function attribute, PowerPC
+@atindex @code{target("cmpb")}, PowerPC
@item cmpb
@itemx no-cmpb
Generate code that uses (does not use) the compare bytes instruction
implemented on the POWER6 processor and other processors that support
the PowerPC V2.05 architecture.
-@cindex @code{target("dlmzb")} function attribute, PowerPC
+@atindex @code{target("dlmzb")}, PowerPC
@item dlmzb
@itemx no-dlmzb
Generate code that uses (does not use) the string-search @samp{dlmzb}
instruction on the IBM 405, 440, 464 and 476 processors. This instruction is
generated by default when targeting those processors.
-@cindex @code{target("fprnd")} function attribute, PowerPC
+@atindex @code{target("fprnd")}, PowerPC
@item fprnd
@itemx no-fprnd
Generate code that uses (does not use) the FP round to integer
instructions implemented on the POWER5+ processor and other processors
that support the PowerPC V2.03 architecture.
-@cindex @code{target("hard-dfp")} function attribute, PowerPC
+@atindex @code{target("hard-dfp")}, PowerPC
@item hard-dfp
@itemx no-hard-dfp
Generate code that uses (does not use) the decimal floating-point
instructions implemented on some POWER processors.
-@cindex @code{target("isel")} function attribute, PowerPC
+@atindex @code{target("isel")}, PowerPC
@item isel
@itemx no-isel
Generate code that uses (does not use) ISEL instruction.
-@cindex @code{target("mfcrf")} function attribute, PowerPC
+@atindex @code{target("mfcrf")}, PowerPC
@item mfcrf
@itemx no-mfcrf
Generate code that uses (does not use) the move from condition
register field instruction implemented on the POWER4 processor and
other processors that support the PowerPC V2.01 architecture.
-@cindex @code{target("mulhw")} function attribute, PowerPC
+@atindex @code{target("mulhw")}, PowerPC
@item mulhw
@itemx no-mulhw
Generate code that uses (does not use) the half-word multiply and
These instructions are generated by default when targeting those
processors.
-@cindex @code{target("multiple")} function attribute, PowerPC
+@atindex @code{target("multiple")}, PowerPC
@item multiple
@itemx no-multiple
Generate code that uses (does not use) the load multiple word
instructions and the store multiple word instructions.
-@cindex @code{target("update")} function attribute, PowerPC
+@atindex @code{target("update")}, PowerPC
@item update
@itemx no-update
Generate code that uses (does not use) the load or store instructions
that update the base register to the address of the calculated memory
location.
-@cindex @code{target("popcntb")} function attribute, PowerPC
+@atindex @code{target("popcntb")}, PowerPC
@item popcntb
@itemx no-popcntb
Generate code that uses (does not use) the popcount and double-precision
processor and other processors that support the PowerPC V2.02
architecture.
-@cindex @code{target("popcntd")} function attribute, PowerPC
+@atindex @code{target("popcntd")}, PowerPC
@item popcntd
@itemx no-popcntd
Generate code that uses (does not use) the popcount instruction
implemented on the POWER7 processor and other processors that support
the PowerPC V2.06 architecture.
-@cindex @code{target("powerpc-gfxopt")} function attribute, PowerPC
+@atindex @code{target("powerpc-gfxopt")}, PowerPC
@item powerpc-gfxopt
@itemx no-powerpc-gfxopt
Generate code that uses (does not use) the optional PowerPC
architecture instructions in the Graphics group, including
floating-point select.
-@cindex @code{target("powerpc-gpopt")} function attribute, PowerPC
+@atindex @code{target("powerpc-gpopt")}, PowerPC
@item powerpc-gpopt
@itemx no-powerpc-gpopt
Generate code that uses (does not use) the optional PowerPC
architecture instructions in the General Purpose group, including
floating-point square root.
-@cindex @code{target("recip-precision")} function attribute, PowerPC
+@atindex @code{target("recip-precision")}, PowerPC
@item recip-precision
@itemx no-recip-precision
Assume (do not assume) that the reciprocal estimate instructions
provide higher-precision estimates than is mandated by the PowerPC
ABI.
-@cindex @code{target("string")} function attribute, PowerPC
+@atindex @code{target("string")}, PowerPC
@item string
@itemx no-string
Generate code that uses (does not use) the load string instructions
and the store string word instructions to save multiple registers and
do small block moves.
-@cindex @code{target("vsx")} function attribute, PowerPC
+@atindex @code{target("vsx")}, PowerPC
@item vsx
@itemx no-vsx
Generate code that uses (does not use) vector/scalar (VSX)
cannot enable VSX or AltiVec instructions unless
@option{-mabi=altivec} is used on the command line.
-@cindex @code{target("friz")} function attribute, PowerPC
+@atindex @code{target("friz")}, PowerPC
@item friz
@itemx no-friz
Generate (do not generate) the @code{friz} instruction when the
point. The @code{friz} instruction does not return the same value if
the floating-point number is too large to fit in an integer.
-@cindex @code{target("avoid-indexed-addresses")} function attribute, PowerPC
+@atindex @code{target("avoid-indexed-addresses")}, PowerPC
@item avoid-indexed-addresses
@itemx no-avoid-indexed-addresses
Generate code that tries to avoid (not avoid) the use of indexed load
or store instructions.
-@cindex @code{target("paired")} function attribute, PowerPC
+@atindex @code{target("paired")}, PowerPC
@item paired
@itemx no-paired
Generate code that uses (does not use) the generation of PAIRED simd
instructions.
-@cindex @code{target("longcall")} function attribute, PowerPC
+@atindex @code{target("longcall")}, PowerPC
@item longcall
@itemx no-longcall
Generate code that assumes (does not assume) that all calls are far
away so that a longer more expensive calling sequence is required.
-@cindex @code{target("cpu=@var{CPU}")} function attribute, PowerPC
+@atindex @code{target("cpu=@var{CPU}")}, PowerPC
@item cpu=@var{CPU}
Specify the architecture to generate code for when compiling the
function. If you select the @code{target("cpu=power7")} attribute when
generating 32-bit code, VSX and AltiVec instructions are not generated
unless you use the @option{-mabi=altivec} option on the command line.
-@cindex @code{target("tune=@var{TUNE}")} function attribute, PowerPC
+@atindex @code{target("tune=@var{TUNE}")}, PowerPC
@item tune=@var{TUNE}
Specify the architecture to tune for when compiling the function. If
you do not specify the @code{target("tune=@var{TUNE}")} attribute and
function that has different target options than the caller, unless the
callee has a subset of the target options of the caller.
-@cindex @code{ms_struct} attribute, PowerPC
-@cindex @code{gcc_struct} attribute, PowerPC
+@atindex @code{ms_struct}, PowerPC
+@atindex @code{gcc_struct}, PowerPC
@item ms_struct
@itemx gcc_struct
These attributes can be applied to variables and struct declarations.
For full documentation of the struct attributes please see the
documentation in @ref{x86 Attributes}.
-@cindex @code{altivec} attribute, PowerPC
+@atindex @code{altivec}, PowerPC
@item altivec
The @code{altivec} attribute applies to variables and types.
These attributes are supported by the RISC-V back end:
@table @code
-@cindex @code{interrupt} function attribute, RISC-V
+@atindex @code{interrupt}, RISC-V
@item interrupt
This attribute applies to functions.
@code{machine}, and @code{rnmi}. If there is no parameter, then it
defaults to @code{machine}.
-@cindex @code{riscv_vector_cc} function attribute, RISC-V
+@atindex @code{riscv_vector_cc}, RISC-V
@item riscv_vector_cc
This attribute applies to functions.
[[riscv::vector_cc]] void foo(); // For C++11 and C23
@end smallexample
-@cindex @code{target} function attribute
+@atindex @code{target}, RISC-V
@item target (@var{options})
This attribute applies to functions.
per-function basis.
@table @samp
-@cindex @code{target("arch=")} function attribute, RISC-V
+@atindex @code{target("arch=")}, RISC-V
@item arch=
Specifies the architecture version and architectural extensions to use
for this function. The behavior and permissible arguments are the same as
Multiple extension can be enabled by separating them with a comma. For example:
@code{arch=+zba,+zbb}.
-@cindex @code{target("tune=")} function attribute, RISC-V
+@atindex @code{target("tune=")}, RISC-V
@item tune=
Specifies the core for which to tune the performance of this function.
The behavior and permissible arguments are the same as for the @option{-mtune=}
command-line option.
-@cindex @code{target("cpu=")} function attribute, RISC-V
+@atindex @code{target("cpu=")}, RISC-V
@item cpu=
Specifies the core for which to tune the performance of this function and also
whose architectural features to use. The behavior and valid arguments are the
same as for the @option{-mcpu=} command-line option.
-@cindex @code{target("max-vectorization")} function attribute, RISC-V
+@atindex @code{target("max-vectorization")}, RISC-V
@item max-vectorization
@itemx no-max-vectorization
@code{max-vectorization} tells GCC's vectorizer to treat all vector
These attributes are supported by the RL78 back end:
@table @code
-@cindex @code{interrupt} function attribute, RL78
-@cindex @code{brk_interrupt} function attribute, RL78
+@atindex @code{interrupt}, RL78
+@atindex @code{brk_interrupt}, RL78
@item interrupt
@itemx brk_interrupt
These attributes apply to functions.
handlers intended to be used with the @code{BRK} opcode (i.e.@: those
that must end with @code{RETB} instead of @code{RETI}).
-@cindex @code{saddr} variable attribute, RL78
+@atindex @code{saddr}, RL78
@item saddr
This attribute applies to variables.
These attributes are supported by the RX back end:
@table @code
-@cindex @code{fast_interrupt} function attribute, RX
+@atindex @code{fast_interrupt}, RX
@item fast_interrupt
This attribute applies to functions.
@code{interrupt} attribute, except that @code{freit} is used to return
instead of @code{reit}.
-@cindex @code{interrupt} function attribute, RX
+@atindex @code{interrupt}, RX
@item interrupt
This attribute applies to functions.
txd1_handler ();
@end smallexample
-@cindex @code{vector} function attribute, RX
+@atindex @code{vector}, RX
@item vector
This attribute applies to functions.
These attributes are supported on the S/390:
@table @code
-@cindex @code{hotpatch} function attribute, S/390
+@atindex @code{hotpatch}, S/390
@item hotpatch (@var{halfwords-before-function-label},@var{halfwords-after-function-label})
This attribute applies to functions.
If both arguments are zero, hotpatching is disabled.
-@cindex @code{target} function attribute
+@atindex @code{target}, S/390
@item target (@var{options})
This attribute applies to functions.
These attributes are supported on the SH family of processors:
@table @code
-@cindex @code{function_vector} function attribute, SH
+@atindex @code{function_vector}, SH
@cindex calling functions through the function vector on SH2A
@item function_vector
This attribute applies to functions.
made to the same function, it saves 2 bytes of code per each of these
calls.
-@cindex @code{interrupt_handler} function attribute, SH
+@atindex @code{interrupt_handler}, SH
@item interrupt_handler
This attribute applies to functions.
generates function entry and exit sequences suitable for use in an
interrupt handler when this attribute is present.
-@cindex @code{nosave_low_regs} function attribute, SH
+@atindex @code{nosave_low_regs}, SH
@item nosave_low_regs
This attribute applies to functions.
and SH4* targets that have a second R0..R7 register bank for non-reentrant
interrupt handlers.
-@cindex @code{renesas} function attribute, SH
+@atindex @code{renesas}, SH
@item renesas
This attribute applies to functions.
On SH targets this attribute specifies that the function or struct follows the
Renesas ABI.
-@cindex @code{resbank} function attribute, SH
+@atindex @code{resbank}, SH
@item resbank
This attribute applies to functions.
banks are stacked in first-in last-out (FILO) sequence. Restoration
from the bank is executed by issuing a RESBANK instruction.
-@cindex @code{sp_switch} function attribute, SH
+@atindex @code{sp_switch}, SH
@item sp_switch
This attribute applies to functions.
sp_switch ("alt_stack")));
@end smallexample
-@cindex @code{trap_exit} function attribute, SH
+@atindex @code{trap_exit}, SH
@item trap_exit
This attribute applies to functions.
@code{trapa} instead of @code{rte}. This attribute expects an integer
argument specifying the trap number to be used.
-@cindex @code{trapa_handler} function attribute, SH
+@atindex @code{trapa_handler}, SH
@item trapa_handler
This attribute applies to functions.
The V850 back end supports these attributes:
@table @code
-@cindex @code{interrupt} function attribute, V850
-@cindex @code{interrupt_handler} function attribute, V850
+@atindex @code{interrupt}, V850
+@atindex @code{interrupt_handler}, V850
@item interrupt
@itemx interrupt_handler
This attribute applies to functions.
function entry and exit sequences suitable for use in an interrupt handler
when either attribute is present.
-@cindex @code{sda} variable attribute, V850
+@atindex @code{sda}, V850
@item sda
This attribute applies to variables.
Use it to explicitly place a variable in the small data area,
which can hold up to 64 kilobytes.
-@cindex @code{tda} variable attribute, V850
+@atindex @code{tda}, V850
@item tda
This attribute applies to variables.
Use it to explicitly place a variable in the tiny data area,
which can hold up to 256 bytes in total.
-@cindex @code{zda} variable attribute, V850
+@atindex @code{zda}, V850
@item zda
This attribute applies to variables.
These attributes are supported by the Visium back end:
@table @code
-@cindex @code{interrupt} function attribute, Visium
+@atindex @code{interrupt}, Visium
@item interrupt
This attribute applies to functions.
These attributes are supported by the x86 back end:
@table @code
-@cindex @code{cdecl} function attribute, x86-32
+@atindex @code{cdecl}, x86-32
@cindex functions that pop the argument stack on x86-32
@opindex mrtd
@item cdecl
pass arguments. This is
useful to override the effects of the @option{-mrtd} switch.
-@cindex @code{fastcall} function attribute, x86-32
+@atindex @code{fastcall}, x86-32
@cindex functions that pop the argument stack on x86-32
@item fastcall
This attribute applies to functions.
pops the arguments off the stack. If the number of arguments is variable all
arguments are pushed on the stack.
-@cindex @code{thiscall} function attribute, x86-32
+@atindex @code{thiscall}, x86-32
@cindex functions that pop the argument stack on x86-32
@item thiscall
This attribute applies to functions.
As a GCC extension, this calling convention can be used for C functions
and for static member methods.
-@cindex @code{ms_abi} function attribute, x86
-@cindex @code{sysv_abi} function attribute, x86
+@atindex @code{ms_abi}, x86
+@atindex @code{sysv_abi}, x86
@item ms_abi
@itemx sysv_abi
These attributes apply to functions.
Note, the @code{ms_abi} attribute for Microsoft Windows 64-bit targets currently
requires the @option{-maccumulate-outgoing-args} option.
-@cindex @code{callee_pop_aggregate_return} function attribute, x86
+@atindex @code{callee_pop_aggregate_return}, x86
@item callee_pop_aggregate_return (@var{number})
This attribute applies to functions.
the compiler assumes that the
caller pops the stack for hidden pointer.
-@cindex @code{ms_hook_prologue} function attribute, x86
+@atindex @code{ms_hook_prologue}, x86
@item ms_hook_prologue
This attribute applies to functions.
prologue used in Win32 API functions in Microsoft Windows XP Service Pack 2
and newer.
-@cindex @code{regparm} function attribute, x86
+@atindex @code{regparm}, x86
@cindex functions that are passed arguments in registers on x86-32
@item regparm (@var{number})
This attribute applies to functions.
disabled with the linker or the loader if desired, to avoid the
problem.)
-@cindex @code{sseregparm} function attribute, x86
+@atindex @code{sseregparm}, x86
@item sseregparm
This attribute applies to functions.
variable number of arguments continue to pass all of their
floating-point arguments on the stack.
-@cindex @code{force_align_arg_pointer} function attribute, x86
+@atindex @code{force_align_arg_pointer}, x86
@item force_align_arg_pointer
This attribute applies to functions.
This supports mixing legacy codes that run with a 4-byte aligned stack
with modern codes that keep a 16-byte stack for SSE compatibility.
-@cindex @code{stdcall} function attribute, x86-32
+@atindex @code{stdcall}, x86-32
@cindex functions that pop the argument stack on x86-32
@item stdcall
This attribute applies to functions.
assume that the called function pops off the stack space used to
pass arguments, unless it takes a variable number of arguments.
-@cindex @code{no_callee_saved_registers} function attribute, x86
+@atindex @code{no_callee_saved_registers}, x86
@item no_callee_saved_registers
This attribute applies to functions.
assembly stub which will preserve all registers and return from
interrupt.
-@cindex @code{preserve_none} function attribute, x86
+@atindex @code{preserve_none}, x86
@item preserve_none
This attribute applies to functions.
integer parameter passing and this calling convention is subject to
change.
-@cindex @code{no_caller_saved_registers} function attribute, x86
+@atindex @code{no_caller_saved_registers}, x86
@item no_caller_saved_registers
This attribute applies to functions.
with AVX enabled. Note that MMX and x87 registers aren't preserved by
@code{no_caller_saved_registers} attribute.
-@cindex @code{interrupt} function attribute, x86
+@atindex @code{interrupt}, x86
@item interrupt
This attribute applies to functions.
code; you should use an interrupt handler in other cases. The system
will crash if the wrong kind of handler is used.
-@cindex @code{target} function attribute
+@atindex @code{target}, x86
@item target (@var{options})
This attribute applies to functions.
On the x86, the following options are allowed:
@table @samp
-@cindex @code{target("3dnow")} function attribute, x86
+@atindex @code{target("3dnow")}, x86
@item 3dnow
@itemx no-3dnow
Enable/disable the generation of the 3DNow!@: instructions.
-@cindex @code{target("3dnowa")} function attribute, x86
+@atindex @code{target("3dnowa")}, x86
@item 3dnowa
@itemx no-3dnowa
Enable/disable the generation of the enhanced 3DNow!@: instructions.
-@cindex @code{target("abm")} function attribute, x86
+@atindex @code{target("abm")}, x86
@item abm
@itemx no-abm
Enable/disable the generation of the advanced bit instructions.
-@cindex @code{target("adx")} function attribute, x86
+@atindex @code{target("adx")}, x86
@item adx
@itemx no-adx
Enable/disable the generation of the ADX instructions.
-@cindex @code{target("aes")} function attribute, x86
+@atindex @code{target("aes")}, x86
@item aes
@itemx no-aes
Enable/disable the generation of the AES instructions.
-@cindex @code{target("avx")} function attribute, x86
+@atindex @code{target("avx")}, x86
@item avx
@itemx no-avx
Enable/disable the generation of the AVX instructions.
-@cindex @code{target("avx2")} function attribute, x86
+@atindex @code{target("avx2")}, x86
@item avx2
@itemx no-avx2
Enable/disable the generation of the AVX2 instructions.
-@cindex @code{target("avx512bitalg")} function attribute, x86
+@atindex @code{target("avx512bitalg")}, x86
@item avx512bitalg
@itemx no-avx512bitalg
Enable/disable the generation of the AVX512BITALG instructions.
-@cindex @code{target("avx512bw")} function attribute, x86
+@atindex @code{target("avx512bw")}, x86
@item avx512bw
@itemx no-avx512bw
Enable/disable the generation of the AVX512BW instructions.
-@cindex @code{target("avx512cd")} function attribute, x86
+@atindex @code{target("avx512cd")}, x86
@item avx512cd
@itemx no-avx512cd
Enable/disable the generation of the AVX512CD instructions.
-@cindex @code{target("avx512dq")} function attribute, x86
+@atindex @code{target("avx512dq")}, x86
@item avx512dq
@itemx no-avx512dq
Enable/disable the generation of the AVX512DQ instructions.
-@cindex @code{target("avx512er")} function attribute, x86
+@atindex @code{target("avx512er")}, x86
@item avx512er
@itemx no-avx512er
Enable/disable the generation of the AVX512ER instructions.
-@cindex @code{target("avx512f")} function attribute, x86
+@atindex @code{target("avx512f")}, x86
@item avx512f
@itemx no-avx512f
Enable/disable the generation of the AVX512F instructions.
-@cindex @code{target("avx512ifma")} function attribute, x86
+@atindex @code{target("avx512ifma")}, x86
@item avx512ifma
@itemx no-avx512ifma
Enable/disable the generation of the AVX512IFMA instructions.
-@cindex @code{target("avx512vbmi")} function attribute, x86
+@atindex @code{target("avx512vbmi")}, x86
@item avx512vbmi
@itemx no-avx512vbmi
Enable/disable the generation of the AVX512VBMI instructions.
-@cindex @code{target("avx512vbmi2")} function attribute, x86
+@atindex @code{target("avx512vbmi2")}, x86
@item avx512vbmi2
@itemx no-avx512vbmi2
Enable/disable the generation of the AVX512VBMI2 instructions.
-@cindex @code{target("avx512vl")} function attribute, x86
+@atindex @code{target("avx512vl")}, x86
@item avx512vl
@itemx no-avx512vl
Enable/disable the generation of the AVX512VL instructions.
-@cindex @code{target("avx512vnni")} function attribute, x86
+@atindex @code{target("avx512vnni")}, x86
@item avx512vnni
@itemx no-avx512vnni
Enable/disable the generation of the AVX512VNNI instructions.
-@cindex @code{target("avx512vpopcntdq")} function attribute, x86
+@atindex @code{target("avx512vpopcntdq")}, x86
@item avx512vpopcntdq
@itemx no-avx512vpopcntdq
Enable/disable the generation of the AVX512VPOPCNTDQ instructions.
-@cindex @code{target("bmi")} function attribute, x86
+@atindex @code{target("bmi")}, x86
@item bmi
@itemx no-bmi
Enable/disable the generation of the BMI instructions.
-@cindex @code{target("bmi2")} function attribute, x86
+@atindex @code{target("bmi2")}, x86
@item bmi2
@itemx no-bmi2
Enable/disable the generation of the BMI2 instructions.
-@cindex @code{target("cldemote")} function attribute, x86
+@atindex @code{target("cldemote")}, x86
@item cldemote
@itemx no-cldemote
Enable/disable the generation of the CLDEMOTE instructions.
-@cindex @code{target("clflushopt")} function attribute, x86
+@atindex @code{target("clflushopt")}, x86
@item clflushopt
@itemx no-clflushopt
Enable/disable the generation of the CLFLUSHOPT instructions.
-@cindex @code{target("clwb")} function attribute, x86
+@atindex @code{target("clwb")}, x86
@item clwb
@itemx no-clwb
Enable/disable the generation of the CLWB instructions.
-@cindex @code{target("clzero")} function attribute, x86
+@atindex @code{target("clzero")}, x86
@item clzero
@itemx no-clzero
Enable/disable the generation of the CLZERO instructions.
-@cindex @code{target("crc32")} function attribute, x86
+@atindex @code{target("crc32")}, x86
@item crc32
@itemx no-crc32
Enable/disable the generation of the CRC32 instructions.
-@cindex @code{target("cx16")} function attribute, x86
+@atindex @code{target("cx16")}, x86
@item cx16
@itemx no-cx16
Enable/disable the generation of the CMPXCHG16B instructions.
-@cindex @code{target("default")} function attribute, x86
+@atindex @code{target("default")}, x86
@item default
@xref{Function Multiversioning}, where it is used to specify the
default function version.
-@cindex @code{target("f16c")} function attribute, x86
+@atindex @code{target("f16c")}, x86
@item f16c
@itemx no-f16c
Enable/disable the generation of the F16C instructions.
-@cindex @code{target("fma")} function attribute, x86
+@atindex @code{target("fma")}, x86
@item fma
@itemx no-fma
Enable/disable the generation of the FMA instructions.
-@cindex @code{target("fma4")} function attribute, x86
+@atindex @code{target("fma4")}, x86
@item fma4
@itemx no-fma4
Enable/disable the generation of the FMA4 instructions.
-@cindex @code{target("fsgsbase")} function attribute, x86
+@atindex @code{target("fsgsbase")}, x86
@item fsgsbase
@itemx no-fsgsbase
Enable/disable the generation of the FSGSBASE instructions.
-@cindex @code{target("fxsr")} function attribute, x86
+@atindex @code{target("fxsr")}, x86
@item fxsr
@itemx no-fxsr
Enable/disable the generation of the FXSR instructions.
-@cindex @code{target("gfni")} function attribute, x86
+@atindex @code{target("gfni")}, x86
@item gfni
@itemx no-gfni
Enable/disable the generation of the GFNI instructions.
-@cindex @code{target("hle")} function attribute, x86
+@atindex @code{target("hle")}, x86
@item hle
@itemx no-hle
Enable/disable the generation of the HLE instruction prefixes.
-@cindex @code{target("lwp")} function attribute, x86
+@atindex @code{target("lwp")}, x86
@item lwp
@itemx no-lwp
Enable/disable the generation of the LWP instructions.
-@cindex @code{target("lzcnt")} function attribute, x86
+@atindex @code{target("lzcnt")}, x86
@item lzcnt
@itemx no-lzcnt
Enable/disable the generation of the LZCNT instructions.
-@cindex @code{target("mmx")} function attribute, x86
+@atindex @code{target("mmx")}, x86
@item mmx
@itemx no-mmx
Enable/disable the generation of the MMX instructions.
-@cindex @code{target("movbe")} function attribute, x86
+@atindex @code{target("movbe")}, x86
@item movbe
@itemx no-movbe
Enable/disable the generation of the MOVBE instructions.
-@cindex @code{target("movdir64b")} function attribute, x86
+@atindex @code{target("movdir64b")}, x86
@item movdir64b
@itemx no-movdir64b
Enable/disable the generation of the MOVDIR64B instructions.
-@cindex @code{target("movdiri")} function attribute, x86
+@atindex @code{target("movdiri")}, x86
@item movdiri
@itemx no-movdiri
Enable/disable the generation of the MOVDIRI instructions.
-@cindex @code{target("mwait")} function attribute, x86
+@atindex @code{target("mwait")}, x86
@item mwait
@itemx no-mwait
Enable/disable the generation of the MWAIT and MONITOR instructions.
-@cindex @code{target("mwaitx")} function attribute, x86
+@atindex @code{target("mwaitx")}, x86
@item mwaitx
@itemx no-mwaitx
Enable/disable the generation of the MWAITX instructions.
-@cindex @code{target("pclmul")} function attribute, x86
+@atindex @code{target("pclmul")}, x86
@item pclmul
@itemx no-pclmul
Enable/disable the generation of the PCLMUL instructions.
-@cindex @code{target("pconfig")} function attribute, x86
+@atindex @code{target("pconfig")}, x86
@item pconfig
@itemx no-pconfig
Enable/disable the generation of the PCONFIG instructions.
-@cindex @code{target("pku")} function attribute, x86
+@atindex @code{target("pku")}, x86
@item pku
@itemx no-pku
Enable/disable the generation of the PKU instructions.
-@cindex @code{target("popcnt")} function attribute, x86
+@atindex @code{target("popcnt")}, x86
@item popcnt
@itemx no-popcnt
Enable/disable the generation of the POPCNT instruction.
-@cindex @code{target("prfchw")} function attribute, x86
+@atindex @code{target("prfchw")}, x86
@item prfchw
@itemx no-prfchw
Enable/disable the generation of the PREFETCHW instruction.
-@cindex @code{target("ptwrite")} function attribute, x86
+@atindex @code{target("ptwrite")}, x86
@item ptwrite
@itemx no-ptwrite
Enable/disable the generation of the PTWRITE instructions.
-@cindex @code{target("rdpid")} function attribute, x86
+@atindex @code{target("rdpid")}, x86
@item rdpid
@itemx no-rdpid
Enable/disable the generation of the RDPID instructions.
-@cindex @code{target("rdrnd")} function attribute, x86
+@atindex @code{target("rdrnd")}, x86
@item rdrnd
@itemx no-rdrnd
Enable/disable the generation of the RDRND instructions.
-@cindex @code{target("rdseed")} function attribute, x86
+@atindex @code{target("rdseed")}, x86
@item rdseed
@itemx no-rdseed
Enable/disable the generation of the RDSEED instructions.
-@cindex @code{target("rtm")} function attribute, x86
+@atindex @code{target("rtm")}, x86
@item rtm
@itemx no-rtm
Enable/disable the generation of the RTM instructions.
-@cindex @code{target("sahf")} function attribute, x86
+@atindex @code{target("sahf")}, x86
@item sahf
@itemx no-sahf
Enable/disable the generation of the SAHF instructions.
-@cindex @code{target("sgx")} function attribute, x86
+@atindex @code{target("sgx")}, x86
@item sgx
@itemx no-sgx
Enable/disable the generation of the SGX instructions.
-@cindex @code{target("sha")} function attribute, x86
+@atindex @code{target("sha")}, x86
@item sha
@itemx no-sha
Enable/disable the generation of the SHA instructions.
-@cindex @code{target("shstk")} function attribute, x86
+@atindex @code{target("shstk")}, x86
@item shstk
@itemx no-shstk
Enable/disable the shadow stack built-in functions from CET.
-@cindex @code{target("sse")} function attribute, x86
+@atindex @code{target("sse")}, x86
@item sse
@itemx no-sse
Enable/disable the generation of the SSE instructions.
-@cindex @code{target("sse2")} function attribute, x86
+@atindex @code{target("sse2")}, x86
@item sse2
@itemx no-sse2
Enable/disable the generation of the SSE2 instructions.
-@cindex @code{target("sse3")} function attribute, x86
+@atindex @code{target("sse3")}, x86
@item sse3
@itemx no-sse3
Enable/disable the generation of the SSE3 instructions.
-@cindex @code{target("sse4")} function attribute, x86
+@atindex @code{target("sse4")}, x86
@item sse4
@itemx no-sse4
Enable/disable the generation of the SSE4 instructions (both SSE4.1
and SSE4.2).
-@cindex @code{target("sse4.1")} function attribute, x86
+@atindex @code{target("sse4.1")}, x86
@item sse4.1
@itemx no-sse4.1
Enable/disable the generation of the SSE4.1 instructions.
-@cindex @code{target("sse4.2")} function attribute, x86
+@atindex @code{target("sse4.2")}, x86
@item sse4.2
@itemx no-sse4.2
Enable/disable the generation of the SSE4.2 instructions.
-@cindex @code{target("sse4a")} function attribute, x86
+@atindex @code{target("sse4a")}, x86
@item sse4a
@itemx no-sse4a
Enable/disable the generation of the SSE4A instructions.
-@cindex @code{target("ssse3")} function attribute, x86
+@atindex @code{target("ssse3")}, x86
@item ssse3
@itemx no-ssse3
Enable/disable the generation of the SSSE3 instructions.
-@cindex @code{target("tbm")} function attribute, x86
+@atindex @code{target("tbm")}, x86
@item tbm
@itemx no-tbm
Enable/disable the generation of the TBM instructions.
-@cindex @code{target("vaes")} function attribute, x86
+@atindex @code{target("vaes")}, x86
@item vaes
@itemx no-vaes
Enable/disable the generation of the VAES instructions.
-@cindex @code{target("vpclmulqdq")} function attribute, x86
+@atindex @code{target("vpclmulqdq")}, x86
@item vpclmulqdq
@itemx no-vpclmulqdq
Enable/disable the generation of the VPCLMULQDQ instructions.
-@cindex @code{target("waitpkg")} function attribute, x86
+@atindex @code{target("waitpkg")}, x86
@item waitpkg
@itemx no-waitpkg
Enable/disable the generation of the WAITPKG instructions.
-@cindex @code{target("wbnoinvd")} function attribute, x86
+@atindex @code{target("wbnoinvd")}, x86
@item wbnoinvd
@itemx no-wbnoinvd
Enable/disable the generation of the WBNOINVD instructions.
-@cindex @code{target("xop")} function attribute, x86
+@atindex @code{target("xop")}, x86
@item xop
@itemx no-xop
Enable/disable the generation of the XOP instructions.
-@cindex @code{target("xsave")} function attribute, x86
+@atindex @code{target("xsave")}, x86
@item xsave
@itemx no-xsave
Enable/disable the generation of the XSAVE instructions.
-@cindex @code{target("xsavec")} function attribute, x86
+@atindex @code{target("xsavec")}, x86
@item xsavec
@itemx no-xsavec
Enable/disable the generation of the XSAVEC instructions.
-@cindex @code{target("xsaveopt")} function attribute, x86
+@atindex @code{target("xsaveopt")}, x86
@item xsaveopt
@itemx no-xsaveopt
Enable/disable the generation of the XSAVEOPT instructions.
-@cindex @code{target("xsaves")} function attribute, x86
+@atindex @code{target("xsaves")}, x86
@item xsaves
@itemx no-xsaves
Enable/disable the generation of the XSAVES instructions.
-@cindex @code{target("amx-tile")} function attribute, x86
+@atindex @code{target("amx-tile")}, x86
@item amx-tile
@itemx no-amx-tile
Enable/disable the generation of the AMX-TILE instructions.
-@cindex @code{target("amx-int8")} function attribute, x86
+@atindex @code{target("amx-int8")}, x86
@item amx-int8
@itemx no-amx-int8
Enable/disable the generation of the AMX-INT8 instructions.
-@cindex @code{target("amx-bf16")} function attribute, x86
+@atindex @code{target("amx-bf16")}, x86
@item amx-bf16
@itemx no-amx-bf16
Enable/disable the generation of the AMX-BF16 instructions.
-@cindex @code{target("uintr")} function attribute, x86
+@atindex @code{target("uintr")}, x86
@item uintr
@itemx no-uintr
Enable/disable the generation of the UINTR instructions.
-@cindex @code{target("hreset")} function attribute, x86
+@atindex @code{target("hreset")}, x86
@item hreset
@itemx no-hreset
Enable/disable the generation of the HRESET instruction.
-@cindex @code{target("kl")} function attribute, x86
+@atindex @code{target("kl")}, x86
@item kl
@itemx no-kl
Enable/disable the generation of the KEYLOCKER instructions.
-@cindex @code{target("widekl")} function attribute, x86
+@atindex @code{target("widekl")}, x86
@item widekl
@itemx no-widekl
Enable/disable the generation of the WIDEKL instructions.
-@cindex @code{target("avxvnni")} function attribute, x86
+@atindex @code{target("avxvnni")}, x86
@item avxvnni
@itemx no-avxvnni
Enable/disable the generation of the AVXVNNI instructions.
-@cindex @code{target("avxifma")} function attribute, x86
+@atindex @code{target("avxifma")}, x86
@item avxifma
@itemx no-avxifma
Enable/disable the generation of the AVXIFMA instructions.
-@cindex @code{target("avxvnniint8")} function attribute, x86
+@atindex @code{target("avxvnniint8")}, x86
@item avxvnniint8
@itemx no-avxvnniint8
Enable/disable the generation of the AVXVNNIINT8 instructions.
-@cindex @code{target("avxneconvert")} function attribute, x86
+@atindex @code{target("avxneconvert")}, x86
@item avxneconvert
@itemx no-avxneconvert
Enable/disable the generation of the AVXNECONVERT instructions.
-@cindex @code{target("cmpccxadd")} function attribute, x86
+@atindex @code{target("cmpccxadd")}, x86
@item cmpccxadd
@itemx no-cmpccxadd
Enable/disable the generation of the CMPccXADD instructions.
-@cindex @code{target("amx-fp16")} function attribute, x86
+@atindex @code{target("amx-fp16")}, x86
@item amx-fp16
@itemx no-amx-fp16
Enable/disable the generation of the AMX-FP16 instructions.
-@cindex @code{target("prefetchi")} function attribute, x86
+@atindex @code{target("prefetchi")}, x86
@item prefetchi
@itemx no-prefetchi
Enable/disable the generation of the PREFETCHI instructions.
-@cindex @code{target("raoint")} function attribute, x86
+@atindex @code{target("raoint")}, x86
@item raoint
@itemx no-raoint
Enable/disable the generation of the RAOINT instructions.
-@cindex @code{target("amx-complex")} function attribute, x86
+@atindex @code{target("amx-complex")}, x86
@item amx-complex
@itemx no-amx-complex
Enable/disable the generation of the AMX-COMPLEX instructions.
-@cindex @code{target("avxvnniint16")} function attribute, x86
+@atindex @code{target("avxvnniint16")}, x86
@item avxvnniint16
@itemx no-avxvnniint16
Enable/disable the generation of the AVXVNNIINT16 instructions.
-@cindex @code{target("sm3")} function attribute, x86
+@atindex @code{target("sm3")}, x86
@item sm3
@itemx no-sm3
Enable/disable the generation of the SM3 instructions.
-@cindex @code{target("sha512")} function attribute, x86
+@atindex @code{target("sha512")}, x86
@item sha512
@itemx no-sha512
Enable/disable the generation of the SHA512 instructions.
-@cindex @code{target("sm4")} function attribute, x86
+@atindex @code{target("sm4")}, x86
@item sm4
@itemx no-sm4
Enable/disable the generation of the SM4 instructions.
-@cindex @code{target("usermsr")} function attribute, x86
+@atindex @code{target("usermsr")}, x86
@item usermsr
@itemx no-usermsr
Enable/disable the generation of the USER_MSR instructions.
-@cindex @code{target("apxf")} function attribute, x86
+@atindex @code{target("apxf")}, x86
@item apxf
@itemx no-apxf
Enable/disable the generation of the APX features, including
EGPR, PUSH2POP2, NDD and PPX.
-@cindex @code{target("avx10.1")} function attribute, x86
+@atindex @code{target("avx10.1")}, x86
@item avx10.1
@itemx no-avx10.1
Enable/Disable the generation of the AVX10.1 instructions.
-@cindex @code{target("avx10.2")} function attribute, x86
+@atindex @code{target("avx10.2")}, x86
@item avx10.2
@itemx no-avx10.2
Enable/Disable the generation of the AVX10.2 instructions.
-@cindex @code{target("amx-avx512")} function attribute, x86
+@atindex @code{target("amx-avx512")}, x86
@item amx-avx512
@itemx no-amx-avx512
Enable/disable the generation of the AMX-AVX512 instructions.
-@cindex @code{target("amx-tf32")} function attribute, x86
+@atindex @code{target("amx-tf32")}, x86
@item amx-tf32
@itemx no-amx-tf32
Enable/disable the generation of the AMX-TF32 instructions.
-@cindex @code{target("amx-fp8")} function attribute, x86
+@atindex @code{target("amx-fp8")}, x86
@item amx-fp8
@itemx no-amx-fp8
Enable/disable the generation of the AMX-FP8 instructions.
-@cindex @code{target("movrs")} function attribute, x86
+@atindex @code{target("movrs")}, x86
@item movrs
@itemx no-movrs
Enable/disable the generation of the MOVRS instructions.
-@cindex @code{target("amx-movrs")} function attribute, x86
+@atindex @code{target("amx-movrs")}, x86
@item amx-movrs
@itemx no-amx-movrs
Enable/disable the generation of the AMX-MOVRS instructions.
-@cindex @code{target("cld")} function attribute, x86
+@atindex @code{target("cld")}, x86
@item cld
@itemx no-cld
Enable/disable the generation of the CLD before string moves.
-@cindex @code{target("fancy-math-387")} function attribute, x86
+@atindex @code{target("fancy-math-387")}, x86
@item fancy-math-387
@itemx no-fancy-math-387
Enable/disable the generation of the @code{sin}, @code{cos}, and
@code{sqrt} instructions on the 387 floating-point unit.
-@cindex @code{target("ieee-fp")} function attribute, x86
+@atindex @code{target("ieee-fp")}, x86
@item ieee-fp
@itemx no-ieee-fp
Enable/disable the generation of floating point that depends on IEEE arithmetic.
-@cindex @code{target("inline-all-stringops")} function attribute, x86
+@atindex @code{target("inline-all-stringops")}, x86
@item inline-all-stringops
@itemx no-inline-all-stringops
Enable/disable inlining of string operations.
-@cindex @code{target("inline-stringops-dynamically")} function attribute, x86
+@atindex @code{target("inline-stringops-dynamically")}, x86
@item inline-stringops-dynamically
@itemx no-inline-stringops-dynamically
Enable/disable the generation of the inline code to do small string
operations and calling the library routines for large operations.
-@cindex @code{target("align-stringops")} function attribute, x86
+@atindex @code{target("align-stringops")}, x86
@item align-stringops
@itemx no-align-stringops
Do/do not align destination of inlined string operations.
-@cindex @code{target("recip")} function attribute, x86
+@atindex @code{target("recip")}, x86
@item recip
@itemx no-recip
Enable/disable the generation of RCPSS, RCPPS, RSQRTSS and RSQRTPS
instructions followed an additional Newton-Raphson step instead of
doing a floating-point division.
-@cindex @code{target("80387")} function attribute, x86
+@atindex @code{target("80387")}, x86
@item 80387
@itemx no-80387
Generate code containing 80387 instructions for floating point.
-@cindex @code{target("general-regs-only")} function attribute, x86
+@atindex @code{target("general-regs-only")}, x86
@item general-regs-only
Generate code which uses only the general registers.
-@cindex @code{target("arch=@var{ARCH}")} function attribute, x86
+@atindex @code{target("arch=@var{ARCH}")}, x86
@item arch=@var{ARCH}
Specify the architecture to generate code for in compiling the function.
-@cindex @code{target("tune=@var{TUNE}")} function attribute, x86
+@atindex @code{target("tune=@var{TUNE}")}, x86
@item tune=@var{TUNE}
Specify the architecture to tune for in compiling the function.
-@cindex @code{target("fpmath=@var{FPMATH}")} function attribute, x86
+@atindex @code{target("fpmath=@var{FPMATH}")}, x86
@item fpmath=@var{FPMATH}
Specify which floating-point unit to use. You must specify the
@code{target("fpmath=sse,387")} option as
@code{target("fpmath=sse+387")} because the comma would separate
different options.
-@cindex @code{prefer-vector-width} function attribute, x86
+@atindex @code{prefer-vector-width}, x86
@item prefer-vector-width=@var{OPT}
On x86 targets, the @code{prefer-vector-width} attribute informs the
compiler to use @var{OPT}-bit vector width in instructions
of ISA features and marked with always_inline.
@end table
-@cindex @code{indirect_branch} function attribute, x86
+@atindex @code{indirect_branch}, x86
@item indirect_branch("@var{choice}")
This attribute applies to functions.
@samp{thunk-extern} converts indirect call and jump to external call
and return thunk provided in a separate object file.
-@cindex @code{function_return} function attribute, x86
+@atindex @code{function_return}, x86
@item function_return("@var{choice}")
This attribute applies to functions.
call and return thunk. @samp{thunk-extern} converts function return to
external call and return thunk provided in a separate object file.
-@cindex @code{nocf_check} function attribute
+@atindex @code{nocf_check}, x86
@item nocf_check
This attribute applies to functions and function types.
@}
@end smallexample
-@cindex @code{cf_check} function attribute, x86
+@atindex @code{cf_check}, x86
@item cf_check
This attribute applies to functions.
compiler that ENDBR instruction should be placed at the function
entry when @option{-fcf-protection=branch} is enabled.
-@cindex @code{indirect_return} function attribute, x86
+@atindex @code{indirect_return}, x86
@item indirect_return
This attribute applies to functions.
as well as variable or type of function pointer to inform the
compiler that the function may return via indirect branch.
-@cindex @code{fentry_name} function attribute, x86
+@atindex @code{fentry_name}, x86
@item fentry_name("@var{name}")
This attribute applies to functions.
with @option{-pg -mfentry}. When @var{name} is nop then a 5 byte
nop sequence is generated.
-@cindex @code{fentry_section} function attribute, x86
+@atindex @code{fentry_section}, x86
@item fentry_section("@var{name}")
This attribute applies to functions.
of the section to record function entry instrumentation calls in when
enabled with @option{-pg -mrecord-mcount}
-@cindex @code{nodirect_extern_access} attribute
+@atindex @code{nodirect_extern_access}, x86
@opindex mno-direct-extern-access
@item nodirect_extern_access
This attribute applies to functions and variables.
This attribute, attached to a global variable or function, is the
counterpart to option @option{-mno-direct-extern-access}.
-@cindex @code{ms_struct} attribute, x86
-@cindex @code{gcc_struct} attribute, x86
+@atindex @code{ms_struct}, x86
+@atindex @code{gcc_struct}, x86
@item ms_struct
@itemx gcc_struct
These attributes can be applied to variables and struct types.
These attributes are supported by the Xstormy16 back end:
@table @code
-@cindex @code{interrupt} function attribute, Xstormy16
+@atindex @code{interrupt}, Xstormy16
@item interrupt
This attribute applies to functions.
function entry and exit sequences suitable for use in an interrupt handler
when this attribute is present.
-@cindex @code{below100} variable attribute, Xstormy16
+@atindex @code{below100}, Xstormy16
@item below100
This attribute applies to variables.
Some attributes only make sense for C++ programs.
@table @code
-@cindex @code{abi_tag} attribute
+@atindex @code{abi_tag}
@item abi_tag ("@var{tag}", ...)
The @code{abi_tag} attribute can be applied to a function, variable, class
declaration, or inline namespace.
situation; you can avoid this warning by explicitly tagging the
variable or function or moving it into a tagged inline namespace.
-@cindex @code{init_priority} variable attribute
+@atindex @code{init_priority}
@item init_priority (@var{priority})
This attribute applies to namespace-scope variables.
@code{init_priority} attribute. In that case the attribute is rejected
with an error rather than ignored.
-@cindex @code{no_dangling} attribute
+@atindex @code{no_dangling}
@item no_dangling
This attribute can be applied to a class type, function, or member
@};
@end smallexample
-@cindex @code{warn_unused} type attribute
+@atindex @code{warn_unused}
@item warn_unused
This attribute applies to types.
This attribute is also accepted in C, but it is unnecessary because C
does not have constructors or destructors.
-@cindex @code{cold} type attribute
-@item cold
-@cindex @code{hot} type attribute
+@atindex @code{cold}
+@atindex @code{hot}
@item cold
@itemx hot
In addition to functions and labels, GNU C++ allows the @code{cold} and
projects / thirdparty / gcc.git / commitdiff
