From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2142) id 402CB3857BB2; Thu, 23 Feb 2023 22:42:38 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 402CB3857BB2 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1677192158; bh=rr7O5dovYGSCoGvH+catetCKO8qxfY5jKNQjL/yiFE0=; h=From:To:Subject:Date:From; b=rmfNprVrZgVnWozxyDhgTUGaTj3Db2Q31z18I7t4RB0ENVBOKqmqb1vqLNIRUCfEO i/r/eOhKx2ciurhjy/b5aPo9Y/Kw+9fUHVy09dh7Sii4K/UwCmMBv47twq1mrcVxg1 8hwP5DchB6Q7nq9l2GfhfTvoURlU/a95PYDOUppg= MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset="utf-8" From: Gerald Pfeifer To: gcc-cvs@gcc.gnu.org Subject: [gcc r13-6310] **/*.texi: Reorder index entries X-Act-Checkin: gcc X-Git-Author: =?utf-8?q?Arsen_Arsenovi=C4=87?= X-Git-Refname: refs/heads/trunk X-Git-Oldrev: f83e76c3f998c8708fe2ddca16ae3f317c39c37a X-Git-Newrev: f33d7a88d069d169bbe76da8e5c52de17f68ca05 Message-Id: <20230223224238.402CB3857BB2@sourceware.org> Date: Thu, 23 Feb 2023 22:42:38 +0000 (GMT) List-Id: https://gcc.gnu.org/g:f33d7a88d069d169bbe76da8e5c52de17f68ca05 commit r13-6310-gf33d7a88d069d169bbe76da8e5c52de17f68ca05 Author: Arsen Arsenović Date: Thu Feb 23 11:27:11 2023 +0100 **/*.texi: Reorder index entries This change is a generalization of r13-6292-gddf6fe375d9110. Historically, makeinfo exhibited a bug, due to which a structure like: @item foo @cindex foo @cindex bar ... would be transformed into an item heading, with the first index entry on it, followed by an item body, with the second index entry in it. This has often lead to index entries not linking to relevant items, but rather, just below them. This bug was exhibited in both Info and HTML documentation, and was most glaringly obvious in the latter. After a discussion with the Texinfo developers, it was decided that the appropriate construct for this case is: @cindex foo @cindex bar @item foo ... which behaves correctly in newer versions, linking all the index entries to the item itself. This pattern also produces copiable anchors in HTML output. This commit fixes most indices to follow the pattern above, however, omits relevant changes in the Ada manuals, as the algorithm described below lead to many false positives and unwanted changes in that manual. Much like the previous commit, this change is mostly mechanical, with a simple script. I have, however, gone over the patch myself also, to see if there's anything that ought to be kept as-is. Formatter: # GPL3+ use v5.35; use strict; use warnings; my @lineq = (); my @itemq = (); my @indxq = (); my $lstin = 0; while (<>) { push (@lineq, $_); if (/^\@[a-zA-Z0-9]{1,2}index\W/) { $lstin = @lineq; push (@indxq, $_); next; } if (/^\@itemx?\W/) { $lstin = @lineq; push (@itemq, $_); next; } next if $lstin && /^\s*(\@c(omment)?\W.*)?$/; if (@indxq and @itemq) { print @indxq; print @itemq; print @lineq[$lstin..@lineq-1]; } else { print @lineq; } @lineq = (); @itemq = (); @indxq = (); $lstin = 0; } if (@indxq and @itemq) { print @indxq; print @itemq; print @lineq[$lstin..@lineq-1]; } else { print @lineq; } # Local Variables: # indent-tabs-mode: nil # End: gcc/d/ChangeLog: * implement-d.texi: Reorder index entries around @items. gcc/ChangeLog: * doc/cfg.texi: Reorder index entries around @items. * doc/cpp.texi: Ditto. * doc/cppenv.texi: Ditto. * doc/cppopts.texi: Ditto. * doc/generic.texi: Ditto. * doc/install.texi: Ditto. * doc/extend.texi: Ditto. * doc/invoke.texi: Ditto. * doc/md.texi: Ditto. * doc/rtl.texi: Ditto. * doc/tm.texi.in: Ditto. * doc/trouble.texi: Ditto. * doc/tm.texi: Regenerate. gcc/fortran/ChangeLog: * invoke.texi: Reorder index entries around @items. gcc/go/ChangeLog: * gccgo.texi: Reorder index entries around @items. Diff: --- gcc/d/implement-d.texi | 62 ++-- gcc/doc/cfg.texi | 12 +- gcc/doc/cpp.texi | 12 +- gcc/doc/cppenv.texi | 4 +- gcc/doc/cppopts.texi | 8 +- gcc/doc/extend.texi | 898 ++++++++++++++++++++++++------------------------ gcc/doc/generic.texi | 2 +- gcc/doc/install.texi | 6 +- gcc/doc/invoke.texi | 150 ++++---- gcc/doc/md.texi | 25 +- gcc/doc/rtl.texi | 8 +- gcc/doc/tm.texi | 4 +- gcc/doc/tm.texi.in | 4 +- gcc/doc/trouble.texi | 8 +- gcc/fortran/invoke.texi | 166 ++++----- gcc/go/gccgo.texi | 34 +- 16 files changed, 701 insertions(+), 702 deletions(-) diff --git a/gcc/d/implement-d.texi b/gcc/d/implement-d.texi index 6d0c1ec3661..89a17916a83 100644 --- a/gcc/d/implement-d.texi +++ b/gcc/d/implement-d.texi @@ -126,11 +126,11 @@ The following attributes are supported on most targets. @table @code +@cindex @code{alloc_size} function attribute +@cindex @code{alloc_size} variable attribute @item @@(gcc.attributes.alloc_size (@var{sizeArgIdx})) @itemx @@(gcc.attributes.alloc_size (@var{sizeArgIdx}, @var{numArgIdx})) @itemx @@(gcc.attributes.alloc_size (@var{sizeArgIdx}, @var{numArgIdx}, @var{zeroBasedNumbering})) -@cindex @code{alloc_size} function attribute -@cindex @code{alloc_size} variable attribute The @code{@@alloc_size} attribute may be applied to a function - or a function pointer variable - that returns a pointer and takes at least one argument of @@ -151,8 +151,8 @@ argument specifying the element count. void malloc_cb(@@alloc_size(1) void* function(size_t) ptr) @{ @} @end smallexample -@item @@(gcc.attributes.always_inline) @cindex @code{always_inline} function attribute +@item @@(gcc.attributes.always_inline) The @code{@@always_inline} attribute inlines the function independent of any restrictions that otherwise apply to inlining. Failure to inline such a @@ -162,8 +162,8 @@ function is diagnosed as an error. @@always_inline int func(); @end smallexample -@item @@(gcc.attributes.cold) @cindex @code{cold} function attribute +@item @@(gcc.attributes.cold) The @code{@@cold} attribute on functions is used to inform the compiler that the function is unlikely to be executed. The function is optimized for size @@ -176,8 +176,8 @@ cold functions within code are considered to be cold too. @@cold int func(); @end smallexample -@item @@(gcc.attributes.flatten) @cindex @code{flatten} function attribute +@item @@(gcc.attributes.flatten) The @code{@@flatten} attribute is used to inform the compiler that every call inside this function should be inlined, if possible. Functions declared with @@ -187,8 +187,8 @@ attribute @code{@@noinline} and similar are not inlined. @@flatten int func(); @end smallexample -@item @@(gcc.attributes.no_icf) @cindex @code{no_icf} function attribute +@item @@(gcc.attributes.no_icf) The @code{@@no_icf} attribute prevents a function from being merged with another semantically equivalent function. @@ -197,8 +197,8 @@ another semantically equivalent function. @@no_icf int func(); @end smallexample -@item @@(gcc.attributes.no_sanitize ("@var{sanitize_option}")) @cindex @code{no_sanitize} function attribute +@item @@(gcc.attributes.no_sanitize ("@var{sanitize_option}")) The @code{@@no_sanitize} attribute on functions is used to inform the compiler that it should not do sanitization of any option mentioned in @@ -210,8 +210,8 @@ option can be provided. @@no_sanitize("alignment,object-size") void func2() @{ @} @end smallexample -@item @@(gcc.attributes.noclone) @cindex @code{noclone} function attribute +@item @@(gcc.attributes.noclone) The @code{@@noclone} attribute prevents a function from being considered for cloning - a mechanism that produces specialized copies of functions and which @@ -221,8 +221,8 @@ is (currently) performed by interprocedural constant propagation. @@noclone int func(); @end smallexample -@item @@(gcc.attributes.noinline) @cindex @code{noinline} function attribute +@item @@(gcc.attributes.noinline) The @code{@@noinline} attribute prevents a function from being considered for inlining. If the function does not have side effects, there are optimizations @@ -234,8 +234,8 @@ the function call is live. To keep such calls from being optimized away, put @@noinline int func(); @end smallexample -@item @@(gcc.attributes.noipa) @cindex @code{noipa} function attribute +@item @@(gcc.attributes.noipa) The @code{@@noipa} attribute disables interprocedural optimizations between the function with this attribute and its callers, as if the body of the function is @@ -253,8 +253,8 @@ This attribute is supported mainly for the purpose of testing the compiler. @@noipa int func(); @end smallexample -@item @@(gcc.attributes.noplt) @cindex @code{noplt} function attribute +@item @@(gcc.attributes.noplt) The @code{@@noplt} attribute is the counterpart to option @option{-fno-plt}. Calls to functions marked with this attribute in position-independent code do @@ -267,8 +267,8 @@ are marked to not use the PLT to use the GOT instead. @@noplt int func(); @end smallexample -@item @@(gcc.attributes.optimize (@var{arguments})) @cindex @code{optimize} function attribute +@item @@(gcc.attributes.optimize (@var{arguments})) The @code{@@optimize} attribute is used to specify that a function is to be compiled with different optimization options than specified on the command @@ -295,8 +295,8 @@ It is not suitable in production code. @@optimize("no-finite-math-only", 3) double fn7(double x); @end smallexample -@item @@(gcc.attributes.register ("@var{registerName}")) @cindex @code{register} variable attribute +@item @@(gcc.attributes.register ("@var{registerName}")) The @code{@@register} attribute specifies that a local or @code{__gshared} variable is to be given a register storage-class in the C99 sense of the term, @@ -311,8 +311,8 @@ error to take the address of a register variable. void func() @{ @@register("r10") long r10 = 0x2a; @} @end smallexample -@item @@(gcc.attributes.restrict) @cindex @code{restrict} parameter attribute +@item @@(gcc.attributes.restrict) The @code{@@restrict} attribute specifies that a function parameter is to be restrict-qualified in the C99 sense of the term. The parameter needs to boil @@ -323,9 +323,9 @@ reference, or a @code{ref} parameter. void func(@@restrict ref const float[16] array); @end smallexample -@item @@(gcc.attributes.section ("@var{sectionName}")) @cindex @code{section} function attribute @cindex @code{section} variable attribute +@item @@(gcc.attributes.section ("@var{sectionName}")) The @code{@@section} attribute specifies that a function or variable lives in a particular section. For when you need certain particular functions to appear @@ -341,8 +341,8 @@ instead. @@section("stack") ubyte[10000] stack; @end smallexample -@item @@(gcc.attributes.simd) @cindex @code{simd} function attribute +@item @@(gcc.attributes.simd) The @code{@@simd} attribute enables creation of one or more function versions that can process multiple arguments using SIMD instructions from a single @@ -355,8 +355,8 @@ Vector ABI document. @@simd double sqrt(double x); @end smallexample -@item @@(gcc.attributes.simd_clones ("@var{mask}")) @cindex @code{simd_clones} function attribute +@item @@(gcc.attributes.simd_clones ("@var{mask}")) The @code{@@simd_clones} attribute is the same as @code{@@simd}, but also includes a @var{mask} argument. Valid masks values are @code{notinbranch} or @@ -367,8 +367,8 @@ clones correspondingly. @@simd_clones("notinbranch") double atan2(double y, double x); @end smallexample -@item @@(gcc.attributes.symver ("@var{arguments}")) @cindex @code{symver} function attribute +@item @@(gcc.attributes.symver ("@var{arguments}")) The @code{@@symver} attribute creates a symbol version on ELF targets. The syntax of the string parameter is @code{"@var{name}@@@var{nodename}"}. @@ -387,8 +387,8 @@ resolve @var{name} by the linker. @@symver("foo@@VERS_1") int foo_v1(); @end smallexample -@item @@(gcc.attributes.target ("@var{options}")) @cindex @code{target} function attribute +@item @@(gcc.attributes.target ("@var{options}")) The @code{@@target} attribute is used to specify that a function is to be compiled with different target options than specified on the command line. One @@ -407,8 +407,8 @@ The options supported are specific to each target. @@target("sse3") void sse3_func(); @end smallexample -@item @@(gcc.attributes.target_clones ("@var{options}")) @cindex @code{target_clones} function attribute +@item @@(gcc.attributes.target_clones ("@var{options}")) The @code{@@target_clones} attribute is used to specify that a function be cloned into multiple versions compiled with different target @var{options} than @@ -423,9 +423,9 @@ a function with @code{@@target_clones} attribute. @@target_clones("sse4.1,avx,default") double func(double x); @end smallexample -@item @@(gcc.attributes.used) @cindex @code{used} function attribute @cindex @code{used} variable attribute +@item @@(gcc.attributes.used) The @code{@@used} attribute, annotated to a function or variable, means that code must be emitted for the function even if it appears that the function is @@ -436,9 +436,9 @@ only in inline assembly. @@used __gshared int var = 0x1000; @end smallexample -@item @@(gcc.attributes.visibility ("@var{visibilityName}")) @cindex @code{visibility} function attribute @cindex @code{visibility} variable attribute +@item @@(gcc.attributes.visibility ("@var{visibilityName}")) The @code{@@visibility} attribute affects the linkage of the declaration to which it is attached. It can be applied to variables, types, and functions. @@ -450,9 +450,9 @@ There are four supported visibility_type values: @code{default}, @code{hidden}, @@visibility("protected") void func() @{ @} @end smallexample -@item @@(gcc.attributes.weak) @cindex @code{weak} function attribute @cindex @code{weak} variable attribute +@item @@(gcc.attributes.weak) The @code{@@weak} attribute causes a declaration of an external symbol to be emitted as a weak symbol rather than a global. This is primarily useful in @@ -479,43 +479,43 @@ The following attributes are defined for compatibility with other compilers. @table @code +@cindex @code{allocSize} function attribute @item @@(gcc.attributes.allocSize (@var{sizeArgIdx})) @itemx @@(gcc.attributes.allocSize (@var{sizeArgIdx}, @var{numArgIdx})) @item @@(gcc.attributes.allocSize (@var{sizeArgIdx})) -@cindex @code{allocSize} function attribute These attributes are a synonym for @code{@@alloc_size(@var{sizeArgIdx}, @var{numArgIdx}, true)}. Unlike @code{@@alloc_size}, it uses 0-based index of the function arguments. -@item @@(gcc.attributes.assumeUsed) @cindex @code{assumeUsed} function attribute @cindex @code{assumeUsed} variable attribute +@item @@(gcc.attributes.assumeUsed) This attribute is a synonym for @code{@@used}. +@cindex @code{dynamicCompile} function attribute @item @@(gcc.attributes.dynamicCompile) @itemx @@(gcc.attributes.dynamicCompileConst) @itemx @@(gcc.attributes.dynamicCompileEmit) -@cindex @code{dynamicCompile} function attribute These attributes are accepted, but have no effect. -@item @@(gcc.attributes.fastmath) @cindex @code{fastmath} function attribute +@item @@(gcc.attributes.fastmath) This attribute is a synonym for @code{@@optimize("Ofast")}. Explicitly sets "fast-math" for a function, enabling aggressive math optimizations. -@item @@(gcc.attributes.hidden) @cindex @code{hidden} function attribute @cindex @code{hidden} variable attribute +@item @@(gcc.attributes.hidden) This attribute is a synonym for @code{@@visibility("hidden")}. Sets the visibility of a function or global variable to "hidden". -@item @@(gcc.attributes.naked) @cindex @code{naked} function attribute +@item @@(gcc.attributes.naked) This attribute is a synonym for @code{@@attribute("naked")}. Adds GCC's "naked" attribute to a function, disabling function prologue / epilogue @@ -524,14 +524,14 @@ While using extended @code{asm} or a mixture of basic @code{asm} and D code may appear to work, they cannot be depended upon to work reliably and are not supported. -@item @@(gcc.attributes.noSanitize ("@var{sanitize_option}")) @cindex @code{noSanitize} function attribute +@item @@(gcc.attributes.noSanitize ("@var{sanitize_option}")) This attribute is a synonym for @code{@@no_sanitize("sanitize_option")}. -@item @@(gcc.attributes.optStrategy ("@var{strategy}")) @cindex @code{optStrategy} function attribute +@item @@(gcc.attributes.optStrategy ("@var{strategy}")) This attribute is a synonym for @code{@@optimize("O0")} and @code{@@optimize("Os")}. Sets the optimization strategy for a function. Valid diff --git a/gcc/doc/cfg.texi b/gcc/doc/cfg.texi index fa2f5a80991..6fb9c9f48ec 100644 --- a/gcc/doc/cfg.texi +++ b/gcc/doc/cfg.texi @@ -269,8 +269,8 @@ These edges are used for unconditional or conditional jumps and in RTL also for table jumps. They are the easiest to manipulate as they may be freely redirected when the flow graph is not in SSA form. -@item fall-thru @findex EDGE_FALLTHRU, force_nonfallthru +@item fall-thru Fall-thru edges are present in case where the basic block may continue execution to the following one without branching. These edges have the @code{EDGE_FALLTHRU} flag set. Unlike other types of edges, these @@ -279,9 +279,9 @@ instruction stream. The function @code{force_nonfallthru} is available to insert an unconditional jump in the case that redirection is needed. Note that this may require creation of a new basic block. -@item exception handling @cindex exception handling @findex EDGE_ABNORMAL, EDGE_EH +@item exception handling Exception handling edges represent possible control transfers from a trapping instruction to an exception handler. The definition of ``trapping'' varies. In C++, only function calls can throw, but for @@ -310,17 +310,17 @@ but this predicate only checks for possible memory traps, as in dereferencing an invalid pointer location. -@item sibling calls @cindex sibling call @findex EDGE_ABNORMAL, EDGE_SIBCALL +@item sibling calls Sibling calls or tail calls terminate the function in a non-standard way and thus an edge to the exit must be present. @code{EDGE_SIBCALL} and @code{EDGE_ABNORMAL} are set in such case. These edges only exist in the RTL representation. -@item computed jumps @cindex computed jump @findex EDGE_ABNORMAL +@item computed jumps Computed jumps contain edges to all labels in the function referenced from the code. All those edges have @code{EDGE_ABNORMAL} flag set. The edges used to represent computed jumps often cause compile time @@ -369,9 +369,9 @@ Be aware of that when you work on passes in that area. There have been numerous examples already where the compile time for code with unfactored computed jumps caused some serious headaches. -@item nonlocal goto handlers @cindex nonlocal goto handler @findex EDGE_ABNORMAL, EDGE_ABNORMAL_CALL +@item nonlocal goto handlers GCC allows nested functions to return into caller using a @code{goto} to a label passed to as an argument to the callee. The labels passed to nested functions contain special code to cleanup after function @@ -380,9 +380,9 @@ receivers''. If a function contains such nonlocal goto receivers, an edge from the call to the label is created with the @code{EDGE_ABNORMAL} and @code{EDGE_ABNORMAL_CALL} flags set. -@item function entry points @cindex function entry point, alternate function entry point @findex LABEL_ALTERNATE_NAME +@item function entry points By definition, execution of function starts at basic block 0, so there is always an edge from the @code{ENTRY_BLOCK_PTR} to basic block 0. There is no @code{GIMPLE} representation for alternate entry points at diff --git a/gcc/doc/cpp.texi b/gcc/doc/cpp.texi index 536167445ab..b0a2ce3ac6b 100644 --- a/gcc/doc/cpp.texi +++ b/gcc/doc/cpp.texi @@ -292,8 +292,8 @@ roughly to the first three ``phases of translation'' described in the C standard. @enumerate -@item @cindex line endings +@item The input file is read into memory and broken into lines. Different systems use different conventions to indicate the end of a @@ -312,8 +312,8 @@ of the file is considered to implicitly supply one. The C standard says that this condition provokes undefined behavior, so GCC will emit a warning message. -@item @cindex trigraphs +@item @anchor{trigraphs}If trigraphs are enabled, they are replaced by their corresponding single characters. By default GCC ignores trigraphs, but if you request a strictly conforming mode with the @option{-std} @@ -346,9 +346,9 @@ Trigraph: ??( ??) ??< ??> ??= ??/ ??' ??! ??- Replacement: [ ] @{ @} # \ ^ | ~ @end smallexample -@item @cindex continued lines @cindex backslash-newline +@item Continued lines are merged into one long line. A continued line is a line which ends with a backslash, @samp{\}. The @@ -365,10 +365,10 @@ is still a continued line. However, as this is usually the result of an editing mistake, and many compilers will not accept it as a continued line, GCC will warn you about it. -@item @cindex comments @cindex line comments @cindex block comments +@item All comments are replaced with single spaces. There are two kinds of comments. @dfn{Block comments} begin with @@ -694,8 +694,8 @@ C preprocessing directive @samp{#include}. Header files serve two purposes. @itemize @bullet -@item @cindex system header files +@item System header files declare the interfaces to parts of the operating system. You include them in your program to supply the definitions and declarations you need to invoke system calls and libraries. @@ -1121,8 +1121,8 @@ Header files found in directories added to the search path with the @option{-isystem} and @option{-idirafter} command-line options are treated as system headers for the purposes of diagnostics. -@item @findex #pragma GCC system_header +@item There is also a directive, @code{@w{#pragma GCC system_header}}, which tells GCC to consider the rest of the current include file a system header, no matter where it was found. Code that comes before the diff --git a/gcc/doc/cppenv.texi b/gcc/doc/cppenv.texi index 58ec4df20c7..75feaeb9141 100644 --- a/gcc/doc/cppenv.texi +++ b/gcc/doc/cppenv.texi @@ -44,8 +44,8 @@ See also @ref{Search Path}. @end ifset @c man begin ENVIRONMENT -@item DEPENDENCIES_OUTPUT @cindex dependencies for make as output +@item DEPENDENCIES_OUTPUT If this variable is set, its value specifies how to output dependencies for Make based on the non-system header files processed by the compiler. System header files are ignored in the dependency @@ -67,8 +67,8 @@ the options @option{-MM} and @option{-MF} @end ifclear with an optional @option{-MT} switch too. -@item SUNPRO_DEPENDENCIES @cindex dependencies for make as output +@item SUNPRO_DEPENDENCIES This variable is the same as @env{DEPENDENCIES_OUTPUT} (see above), except that system header files are not ignored, so it implies @option{-M} rather than @option{-MM}. However, the dependence on the diff --git a/gcc/doc/cppopts.texi b/gcc/doc/cppopts.texi index 647d25239ed..872629eeb4d 100644 --- a/gcc/doc/cppopts.texi +++ b/gcc/doc/cppopts.texi @@ -77,9 +77,9 @@ This option is supported on GNU/Linux targets, most other Unix derivatives, and also on x86 Cygwin and MinGW targets. @opindex M -@item -M @cindex @command{make} @cindex dependencies, @command{make} +@item -M Instead of outputting the result of preprocessing, output a rule suitable for @command{make} describing the dependencies of the main source file. The preprocessor outputs one @command{make} rule containing @@ -308,15 +308,15 @@ location independent. This option also affects @option{-ffile-prefix-map}. @opindex fexec-charset -@item -fexec-charset=@var{charset} @cindex character set, execution +@item -fexec-charset=@var{charset} Set the execution character set, used for string and character constants. The default is UTF-8. @var{charset} can be any encoding supported by the system's @code{iconv} library routine. @opindex fwide-exec-charset -@item -fwide-exec-charset=@var{charset} @cindex character set, wide execution +@item -fwide-exec-charset=@var{charset} Set the wide execution character set, used for wide string and character constants. The default is one of UTF-32BE, UTF-32LE, UTF-16BE, or UTF-16LE, whichever corresponds to the width of @code{wchar_t} and the @@ -326,8 +326,8 @@ by the system's @code{iconv} library routine; however, you will have problems with encodings that do not fit exactly in @code{wchar_t}. @opindex finput-charset -@item -finput-charset=@var{charset} @cindex character set, input +@item -finput-charset=@var{charset} Set the input character set, used for translation from the character set of the input file to the source character set used by GCC@. If the locale does not specify, or GCC cannot get this information from the diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi index 1ae68b0f20a..0e11e43536c 100644 --- a/gcc/doc/extend.texi +++ b/gcc/doc/extend.texi @@ -1487,30 +1487,30 @@ to generate the right instructions to access this data without using (inline) assembler code, special address spaces are needed. @table @code -@item __flash @cindex @code{__flash} AVR Named Address Spaces +@item __flash The @code{__flash} qualifier locates data in the @code{.progmem.data} section. Data is read using the @code{LPM} instruction. Pointers to this address space are 16 bits wide. -@item __flash1 -@itemx __flash2 -@itemx __flash3 -@itemx __flash4 -@itemx __flash5 @cindex @code{__flash1} AVR Named Address Spaces @cindex @code{__flash2} AVR Named Address Spaces @cindex @code{__flash3} AVR Named Address Spaces @cindex @code{__flash4} AVR Named Address Spaces @cindex @code{__flash5} AVR Named Address Spaces +@item __flash1 +@itemx __flash2 +@itemx __flash3 +@itemx __flash4 +@itemx __flash5 These are 16-bit address spaces locating data in section @code{.progmem@var{N}.data} where @var{N} refers to address space @code{__flash@var{N}}. The compiler sets the @code{RAMPZ} segment register appropriately before reading data by means of the @code{ELPM} instruction. -@item __memx @cindex @code{__memx} AVR Named Address Spaces +@item __memx This is a 24-bit address space that linearizes flash and RAM: If the high bit of the address is set, data is read from RAM using the lower two bytes as RAM address. @@ -1664,10 +1664,10 @@ On the x86 target, variables may be declared as being relative to the @code{%fs} or @code{%gs} segments. @table @code -@item __seg_fs -@itemx __seg_gs @cindex @code{__seg_fs} x86 named address space @cindex @code{__seg_gs} x86 named address space +@item __seg_fs +@itemx __seg_gs The object is accessed with the respective segment override prefix. The respective segment base must be set via some method specific to @@ -2658,8 +2658,8 @@ at the declaration of a function that unconditionally manipulates a buffer via a pointer argument. See the @code{nonnull} attribute for more information and caveats. -@item alias ("@var{target}") @cindex @code{alias} function attribute +@item alias ("@var{target}") The @code{alias} attribute causes the declaration to be emitted as an alias for another symbol, which must have been previously declared with the same type, and for variables, also the same size and alignment. Declaring an alias @@ -2679,9 +2679,9 @@ the same translation unit. This attribute requires assembler and object file support, and may not be available on all targets. +@cindex @code{aligned} function attribute @item aligned @itemx aligned (@var{alignment}) -@cindex @code{aligned} function attribute The @code{aligned} attribute specifies a minimum alignment for the first instruction of the function, measured in bytes. When specified, @var{alignment} must be an integer constant power of 2. Specifying no @@ -2709,8 +2709,8 @@ further information. The @code{aligned} attribute can also be used for variables and fields (@pxref{Variable Attributes}.) -@item alloc_align (@var{position}) @cindex @code{alloc_align} function attribute +@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 enumerated type. @@ -2733,9 +2733,9 @@ void* my_memalign (size_t, size_t) __attribute__ ((alloc_align (1))); declares that @code{my_memalign} returns memory with minimum alignment given by parameter 1. +@cindex @code{alloc_size} function attribute @item alloc_size (@var{position}) @itemx alloc_size (@var{position-1}, @var{position-2}) -@cindex @code{alloc_size} function attribute The @code{alloc_size} attribute may be applied to a function that returns a pointer and takes at least one argument of an integer or enumerated type. @@ -2763,8 +2763,8 @@ declares that @code{my_calloc} returns memory of the size given by the product of parameter 1 and 2 and that @code{my_realloc} returns memory of the size given by parameter 2. -@item always_inline @cindex @code{always_inline} function attribute +@item always_inline Generally, functions are not inlined unless optimization is specified. For functions declared inline, this attribute inlines the function independent of any restrictions that otherwise apply to inlining. @@ -2773,17 +2773,17 @@ Note that if such a function is called indirectly the compiler may or may not inline it depending on optimization level and a failure to inline an indirect call may or may not be diagnosed. -@item artificial @cindex @code{artificial} function attribute +@item artificial This attribute is useful for small inline wrappers that if possible should appear during debugging as a unit. Depending on the debug info format it either means marking the function as artificial or using the caller location for all instructions within the inlined body. +@cindex @code{assume_aligned} function attribute @item assume_aligned (@var{alignment}) @itemx assume_aligned (@var{alignment}, @var{offset}) -@cindex @code{assume_aligned} function attribute The @code{assume_aligned} attribute may be applied to a function that returns a pointer. It indicates that the returned pointer is aligned on a boundary given by @var{alignment}. If the attribute has two @@ -2803,8 +2803,8 @@ declares that @code{my_alloc1} returns 16-byte aligned pointers and that @code{my_alloc2} returns a pointer whose value modulo 32 is equal to 8. -@item cold @cindex @code{cold} function attribute +@item cold The @code{cold} attribute on functions is used to inform the compiler that the function is unlikely to be executed. The function is optimized for size rather than speed and on many targets it is placed into a special @@ -2818,9 +2818,9 @@ of hot functions that do call marked functions in rare occasions. When profile feedback is available, via @option{-fprofile-use}, cold functions are automatically detected and this attribute is ignored. -@item const @cindex @code{const} function attribute @cindex functions that have no side effects +@item const Calls to functions whose return value is not affected by changes to the observable state of the program and that have no observable effects on such state other than to return a value may lend themselves to @@ -2861,12 +2861,12 @@ from data that cannot, const functions should never take pointer or, 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 @item constructor @itemx destructor @itemx constructor (@var{priority}) @itemx destructor (@var{priority}) -@cindex @code{constructor} function attribute -@cindex @code{destructor} function attribute The @code{constructor} attribute causes the function to be called automatically before execution enters @code{main ()}. Similarly, the @code{destructor} attribute causes the function to be called @@ -2894,9 +2894,9 @@ Using the argument forms of the @code{constructor} and @code{destructor} attributes on targets where the feature is not supported is rejected with an error. +@cindex @code{copy} function attribute @item copy @itemx copy (@var{function}) -@cindex @code{copy} function attribute The @code{copy} attribute applies the set of attributes with which @var{function} has been declared to the declaration of the function to which the attribute is applied. The attribute is designed for @@ -2929,9 +2929,9 @@ extern __attribute__ ((alloc_size (1), malloc, nothrow)) StrongAlias (allocate, alloc); @end smallexample +@cindex @code{deprecated} function attribute @item deprecated @itemx deprecated (@var{msg}) -@cindex @code{deprecated} function attribute The @code{deprecated} attribute results in a warning if the function is used anywhere in the source file. This is useful when identifying functions that are expected to be removed in a future version of a @@ -2957,9 +2957,9 @@ types (@pxref{Variable Attributes}, @pxref{Type Attributes}.) The message attached to the attribute is affected by the setting of the @option{-fmessage-length} option. +@cindex @code{unavailable} function attribute @item unavailable @itemx unavailable (@var{msg}) -@cindex @code{unavailable} function attribute The @code{unavailable} attribute results in an error if the function is used anywhere in the source file. This is useful when identifying functions that have been removed from a particular variation of an @@ -2970,10 +2970,10 @@ interface. Other than emitting an error rather than a warning, the The @code{unavailable} attribute can also be used for variables and types (@pxref{Variable Attributes}, @pxref{Type Attributes}.) -@item error ("@var{message}") -@itemx warning ("@var{message}") @cindex @code{error} function attribute @cindex @code{warning} function attribute +@item error ("@var{message}") +@itemx warning ("@var{message}") If the @code{error} or @code{warning} attribute is used on a function declaration and a call to such a function is not eliminated through dead code elimination or other optimizations, @@ -2990,8 +2990,8 @@ when using these attributes the problem is diagnosed earlier and with exact location of the call even in presence of inline functions or when not emitting debugging information. -@item externally_visible @cindex @code{externally_visible} function attribute +@item externally_visible This attribute, attached to a global variable or function, nullifies the effect of the @option{-fwhole-program} command-line option, so the object remains visible outside the current compilation unit. @@ -3005,9 +3005,9 @@ produced by @command{gold}. For other linkers that cannot generate resolution file, explicit @code{externally_visible} attributes are still necessary. +@cindex @code{fd_arg} function attribute @item fd_arg @itemx fd_arg (@var{N}) -@cindex @code{fd_arg} function attribute The @code{fd_arg} attribute may be applied to a function that takes an open file descriptor at referenced argument @var{N}. @@ -3023,9 +3023,9 @@ validity before usage. Therefore, analyzer may emit which a function with this attribute is called with a file descriptor that has not been checked for validity. +@cindex @code{fd_arg_read} function attribute @item fd_arg_read @itemx fd_arg_read (@var{N}) -@cindex @code{fd_arg_read} function attribute The @code{fd_arg_read} is identical to @code{fd_arg}, but with the additional requirement that it might read from the file descriptor, and thus, the file descriptor must not have been opened as write-only. @@ -3034,26 +3034,26 @@ The analyzer may emit a @option{-Wanalyzer-access-mode-mismatch} diagnostic if it detects a code path in which a function with this attribute is called on a file descriptor opened with @code{O_WRONLY}. +@cindex @code{fd_arg_write} function attribute @item fd_arg_write @itemx fd_arg_write (@var{N}) -@cindex @code{fd_arg_write} function attribute The @code{fd_arg_write} is identical to @code{fd_arg_read} except that the analyzer may emit a @option{-Wanalyzer-access-mode-mismatch} diagnostic if it detects a code path in which a function with this attribute is called on a file descriptor opened with @code{O_RDONLY}. -@item flatten @cindex @code{flatten} function attribute +@item flatten Generally, inlining into a function is limited. For a function marked with this attribute, every call inside this function is inlined, if possible. Functions declared with attribute @code{noinline} and similar are not inlined. Whether the function itself is considered for inlining depends on its size and the current inlining parameters. -@item format (@var{archetype}, @var{string-index}, @var{first-to-check}) @cindex @code{format} function attribute @cindex functions with @code{printf}, @code{scanf}, @code{strftime} or @code{strfmon} style arguments @opindex Wformat +@item format (@var{archetype}, @var{string-index}, @var{first-to-check}) The @code{format} attribute specifies that a function takes @code{printf}, @code{scanf}, @code{strftime} or @code{strfmon} style arguments that should be type-checked against a format string. For example, the @@ -3127,9 +3127,9 @@ The target may also provide additional types of format checks. @xref{Target Format Checks,,Format Checks Specific to Particular Target Machines}. -@item format_arg (@var{string-index}) @cindex @code{format_arg} function attribute @opindex Wformat-nonliteral +@item format_arg (@var{string-index}) The @code{format_arg} attribute specifies that a function takes one or more format strings for a @code{printf}, @code{scanf}, @code{strftime} or @code{strfmon} style function and modifies it (for example, to translate @@ -3188,8 +3188,8 @@ The target may also allow additional types in @code{format-arg} attributes. @xref{Target Format Checks,,Format Checks Specific to Particular Target Machines}. -@item gnu_inline @cindex @code{gnu_inline} function attribute +@item gnu_inline This attribute should be used with a function that is also declared with the @code{inline} keyword. It directs GCC to treat the function as if it were defined in gnu90 mode even when compiling in C99 or @@ -3226,8 +3226,8 @@ In C++, this attribute does not depend on @code{extern} in any way, but it still requires the @code{inline} keyword to enable its special behavior. -@item hot @cindex @code{hot} function attribute +@item hot The @code{hot} attribute on a function is used to inform the compiler that the function is a hot spot of the compiled program. The function is optimized more aggressively and on many targets it is placed into a special @@ -3237,10 +3237,10 @@ improving locality. When profile feedback is available, via @option{-fprofile-use}, hot functions are automatically detected and this attribute is ignored. -@item ifunc ("@var{resolver}") @cindex @code{ifunc} function attribute @cindex indirect functions @cindex functions that are dynamically resolved +@item ifunc ("@var{resolver}") The @code{ifunc} attribute is used to mark a function as an indirect function using the STT_GNU_IFUNC symbol type extension to the ELF standard. This allows the resolution of the symbol value to be @@ -3337,8 +3337,8 @@ entry and exit sequences that differ from those from regular functions. The exact syntax and behavior are target-specific; refer to the following subsections for details. -@item leaf @cindex @code{leaf} function attribute +@item leaf Calls to external functions with this attribute must return to the current compilation unit only by return or by exception handling. In particular, a leaf function is not allowed to invoke callback functions @@ -3374,11 +3374,11 @@ units into one, for example, by using the link-time optimization. For this reason the attribute is not allowed on types to annotate indirect calls. +@cindex @code{malloc} function attribute +@cindex functions that behave like malloc @item malloc @item malloc (@var{deallocator}) @item malloc (@var{deallocator}, @var{ptr-index}) -@cindex @code{malloc} function attribute -@cindex functions that behave like malloc Attribute @code{malloc} indicates that a function is @code{malloc}-like, i.e., that the pointer @var{P} returned by the function cannot alias any other pointer valid when the function returns, and moreover no @@ -3490,29 +3490,29 @@ pointer. If this is not the case, the deallocator can be marked with a @option{-Wanalyzer-possible-null-argument} diagnostic for code paths in which the deallocator is called with NULL. -@item no_icf @cindex @code{no_icf} function attribute +@item no_icf This function attribute prevents a functions from being merged with another semantically equivalent function. -@item no_instrument_function @cindex @code{no_instrument_function} function attribute @opindex finstrument-functions @opindex p @opindex pg +@item no_instrument_function If any of @option{-finstrument-functions}, @option{-p}, or @option{-pg} are given, profiling function calls are generated at entry and exit of most user-compiled functions. Functions with this attribute are not so instrumented. -@item no_profile_instrument_function @cindex @code{no_profile_instrument_function} function attribute +@item no_profile_instrument_function The @code{no_profile_instrument_function} attribute on functions is used to inform the compiler that it should not process any profile feedback based optimization code instrumentation. -@item no_reorder @cindex @code{no_reorder} function attribute +@item no_reorder Do not reorder functions or variables marked @code{no_reorder} against each other or top level assembler statements the executable. The actual order in the program will depend on the linker command @@ -3521,8 +3521,8 @@ This has a similar effect as the @option{-fno-toplevel-reorder} option, but only applies to the marked symbols. -@item no_sanitize ("@var{sanitize_option}") @cindex @code{no_sanitize} function attribute +@item no_sanitize ("@var{sanitize_option}") The @code{no_sanitize} attribute on functions is used to inform the compiler that it should not do sanitization of any option mentioned in @var{sanitize_option}. A list of values acceptable by @@ -3535,9 +3535,9 @@ void __attribute__ ((no_sanitize ("alignment,object-size"))) g () @{ /* @r{Do something.} */; @} @end smallexample +@cindex @code{no_sanitize_address} function attribute @item no_sanitize_address @itemx no_address_safety_analysis -@cindex @code{no_sanitize_address} function attribute The @code{no_sanitize_address} attribute on functions is used to inform the compiler that it should not instrument memory accesses in the function when compiling with the @option{-fsanitize=address} option. @@ -3545,47 +3545,47 @@ The @code{no_address_safety_analysis} is a deprecated alias of the @code{no_sanitize_address} attribute, new code should use @code{no_sanitize_address}. -@item no_sanitize_thread @cindex @code{no_sanitize_thread} function attribute +@item no_sanitize_thread The @code{no_sanitize_thread} attribute on functions is used to inform the compiler that it should not instrument memory accesses in the function when compiling with the @option{-fsanitize=thread} option. -@item no_sanitize_undefined @cindex @code{no_sanitize_undefined} function attribute +@item no_sanitize_undefined The @code{no_sanitize_undefined} attribute on functions is used to inform the compiler that it should not check for undefined behavior in the function when compiling with the @option{-fsanitize=undefined} option. -@item no_sanitize_coverage @cindex @code{no_sanitize_coverage} function attribute +@item no_sanitize_coverage The @code{no_sanitize_coverage} attribute on functions is used to inform the compiler that it should not do coverage-guided fuzzing code instrumentation (@option{-fsanitize-coverage}). -@item no_split_stack @cindex @code{no_split_stack} function attribute @opindex fsplit-stack +@item no_split_stack If @option{-fsplit-stack} is given, functions have a small prologue which decides whether to split the stack. Functions with the @code{no_split_stack} attribute do not have that prologue, and thus may run with only a small amount of stack space available. -@item no_stack_limit @cindex @code{no_stack_limit} function attribute +@item no_stack_limit This attribute locally overrides the @option{-fstack-limit-register} and @option{-fstack-limit-symbol} command-line options; it has the effect of disabling stack limit checking in the function it applies to. -@item noclone @cindex @code{noclone} function attribute +@item noclone This function attribute prevents a function from being considered for cloning---a mechanism that produces specialized copies of functions and which is (currently) performed by interprocedural constant propagation. -@item noinline @cindex @code{noinline} function attribute +@item noinline This function attribute prevents a function from being considered for inlining. @c Don't enumerate the optimizations by name here; we try to be @@ -3602,8 +3602,8 @@ asm (""); (@pxref{Extended Asm}) in the called function, to serve as a special side effect. -@item noipa @cindex @code{noipa} function attribute +@item noipa Disable interprocedural optimizations between the function with this attribute and its callers, as if the body of the function is not available when optimizing callers and the callers are unavailable when optimizing @@ -3615,10 +3615,10 @@ including those that do not have an attribute suitable for disabling them individually. This attribute is supported mainly for the purpose of testing the compiler. -@item nonnull -@itemx nonnull (@var{arg-index}, @dots{}) @cindex @code{nonnull} function attribute @cindex functions with 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 least one argument of a pointer type. It indicates that the referenced arguments must be non-null pointers. For instance, the declaration: @@ -3672,8 +3672,8 @@ my_memcpy (void *dest, const void *src, size_t len) __attribute__((nonnull)); @end smallexample -@item noplt @cindex @code{noplt} function attribute +@item noplt The @code{noplt} attribute is the counterpart to option @option{-fno-plt}. Calls to functions marked with this attribute in position-independent code do not use the PLT. @@ -3702,9 +3702,9 @@ in position-independent code. 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. -@item noreturn @cindex @code{noreturn} function attribute @cindex functions that never return +@item noreturn A few standard library functions, such as @code{abort} and @code{exit}, cannot return. GCC knows this automatically. Some programs define their own functions that never return. You can declare them @@ -3742,17 +3742,17 @@ restored before calling the @code{noreturn} function. It does not make sense for a @code{noreturn} function to have a return type other than @code{void}. -@item nothrow @cindex @code{nothrow} function attribute +@item nothrow The @code{nothrow} attribute is used to inform the compiler that a function cannot throw an exception. For example, most functions in the standard C library can be guaranteed not to throw an exception with the notable exceptions of @code{qsort} and @code{bsearch} that take function pointer arguments. +@cindex @code{optimize} function attribute @item optimize (@var{level}, @dots{}) @item optimize (@var{string}, @dots{}) -@cindex @code{optimize} function attribute The @code{optimize} attribute is used to specify that a function is to be compiled with different optimization options than specified on the command line. The optimize attribute arguments of a function behave @@ -3780,9 +3780,9 @@ specified by the attribute necessarily has an effect on the function. The @code{optimize} attribute should be used for debugging purposes only. It is not suitable in production code. -@item patchable_function_entry @cindex @code{patchable_function_entry} function attribute @cindex extra NOP instructions at the function entry point +@item patchable_function_entry In case the target's text segment can be made writable at run time by any means, padding the function entry with a number of NOPs can be used to provide a universal tool for instrumentation. @@ -3801,9 +3801,9 @@ instrumentation on all functions that are part of the instrumentation framework with the attribute @code{patchable_function_entry (0)} to prevent recursion. -@item pure @cindex @code{pure} function attribute @cindex functions that have no side effects +@item pure Calls to functions that have no observable effects on the state of the program other than to return a value may lend themselves to optimizations @@ -3851,8 +3851,8 @@ diagnosed. Because a pure function cannot have any observable side effects it does not make sense for such a function to return @code{void}. Declaring such a function is diagnosed. -@item returns_nonnull @cindex @code{returns_nonnull} function attribute +@item returns_nonnull The @code{returns_nonnull} attribute specifies that the function return value should be a non-null pointer. For instance, the declaration: @@ -3865,9 +3865,9 @@ mymalloc (size_t len) __attribute__((returns_nonnull)); lets the compiler optimize callers based on the knowledge that the return value will never be null. -@item returns_twice @cindex @code{returns_twice} function attribute @cindex functions that return more than once +@item returns_twice The @code{returns_twice} attribute tells the compiler that a function may return more than one time. The compiler ensures that all registers are dead before calling such a function and emits a warning about @@ -3876,9 +3876,9 @@ function. Examples of such functions are @code{setjmp} and @code{vfork}. The @code{longjmp}-like counterpart of such function, if any, might need to be marked with the @code{noreturn} attribute. -@item section ("@var{section-name}") @cindex @code{section} function attribute @cindex functions in arbitrary sections +@item section ("@var{section-name}") Normally, the compiler places the code it generates in the @code{text} section. Sometimes, however, you need additional sections, or you need certain particular functions to appear in special sections. The @code{section} @@ -3897,9 +3897,9 @@ attribute is not available on all platforms. 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 @item sentinel @itemx sentinel (@var{position}) -@cindex @code{sentinel} function attribute This function attribute indicates that an argument in a call to the function is expected to be an explicit @code{NULL}. The attribute is only valid on variadic functions. By default, the sentinel is expected to be the last @@ -3926,9 +3926,9 @@ a copy that redefines NULL appropriately. The warnings for missing or incorrect sentinels are enabled with @option{-Wformat}. +@cindex @code{simd} function attribute @item simd @itemx simd("@var{mask}") -@cindex @code{simd} function attribute This attribute enables creation of one or more function versions that can process multiple arguments using SIMD instructions from a single invocation. Specifying this attribute allows compiler to @@ -3947,18 +3947,18 @@ If the attribute is specified and @code{#pragma omp declare simd} is present on a declaration and the @option{-fopenmp} or @option{-fopenmp-simd} switch is specified, then the attribute is ignored. -@item stack_protect @cindex @code{stack_protect} function attribute +@item stack_protect This attribute adds stack protection code to the function if flags @option{-fstack-protector}, @option{-fstack-protector-strong} or @option{-fstack-protector-explicit} are set. -@item no_stack_protector @cindex @code{no_stack_protector} function attribute +@item no_stack_protector This attribute prevents stack protection code for the function. -@item target (@var{string}, @dots{}) @cindex @code{target} function attribute +@item target (@var{string}, @dots{}) Multiple target back ends implement the @code{target} attribute to specify that a function is to be compiled with different target options than specified on the @@ -4001,8 +4001,8 @@ Function Attributes}, @ref{PowerPC Function Attributes}, @ref{Nios II Function Attributes}, and @ref{S/390 Function Attributes} for details. -@item symver ("@var{name2}@@@var{nodename}") @cindex @code{symver} function attribute +@item symver ("@var{name2}@@@var{nodename}") On ELF targets this attribute creates a symbol version. The @var{name2} part of the parameter is the actual name of the symbol by which it will be externally referenced. The @code{nodename} portion should be the name of a @@ -4053,8 +4053,8 @@ addition to creating a symbol version (as if @code{"@var{name2}@@@var{nodename}"} was used) the version will be also used to resolve @var{name2} by the linker. -@item tainted_args @cindex @code{tainted_args} function attribute +@item tainted_args The @code{tainted_args} attribute is used to specify that a function is called in a way that requires sanitization of its arguments, such as a system call in an operating system kernel. Such a function can be considered part @@ -4073,8 +4073,8 @@ potentially issuing warnings guarded by @option{-Wanalyzer-tainted-offset}, and @option{-Wanalyzer-tainted-size}. -@item target_clones (@var{options}) @cindex @code{target_clones} function attribute +@item target_clones (@var{options}) The @code{target_clones} attribute is used to specify that a function be cloned into multiple versions compiled with different target options than specified on the command line. The supported options and restrictions @@ -4101,14 +4101,14 @@ from a @code{target_clone} caller will not lead to copying If you want to enforce such behaviour, we recommend declaring the calling function with the @code{flatten} attribute? -@item unused @cindex @code{unused} function attribute +@item unused This attribute, attached to a function, means that the function is meant to be possibly unused. GCC does not produce a warning for this function. -@item used @cindex @code{used} function attribute +@item used This attribute, attached to a function, means that code must be emitted for the function even if it appears that the function is not referenced. This is useful, for example, when the function is referenced only in @@ -4118,8 +4118,8 @@ When applied to a member function of a C++ class template, the attribute also means that the function is instantiated if the class itself is instantiated. -@item retain @cindex @code{retain} function attribute +@item retain For ELF targets that support the GNU or FreeBSD OSABIs, this attribute will save the function from linker garbage collection. To support this behavior, functions that have not been placed in specific sections @@ -4128,8 +4128,8 @@ option), will be placed in new, unique sections. This additional functionality requires Binutils version 2.36 or later. -@item visibility ("@var{visibility_type}") @cindex @code{visibility} function attribute +@item visibility ("@var{visibility_type}") This attribute affects the linkage of the declaration to which it is attached. It can be applied to variables (@pxref{Common Variable Attributes}) and types (@pxref{Common Type Attributes}) as well as functions. @@ -4233,8 +4233,8 @@ visibility of their template. If both the template and enclosing class have explicit visibility, the visibility from the template is used. -@item warn_unused_result @cindex @code{warn_unused_result} function attribute +@item warn_unused_result The @code{warn_unused_result} attribute causes a warning to be emitted if a caller of the function with this attribute does not use its return value. This is useful for functions where not checking @@ -4254,8 +4254,8 @@ int foo () @noindent results in warning on line 5. -@item weak @cindex @code{weak} function attribute +@item weak The @code{weak} attribute causes a declaration of an external symbol to be emitted as a weak symbol rather than a global. This is primarily useful in defining library functions that can be overridden in user code, @@ -4265,9 +4265,9 @@ designates a variable it must also have the same size and alignment as 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} function attribute @item weakref @itemx weakref ("@var{target}") -@cindex @code{weakref} function attribute The @code{weakref} attribute marks a declaration as a weak reference. Without arguments, it should be accompanied by an @code{alias} attribute naming the target symbol. Alternatively, @var{target} may be given as @@ -4310,8 +4310,8 @@ performing a link with relocatable output (i.e.@: @code{ld -r}) on them. A declaration to which @code{weakref} is attached and that is associated with a named @code{target} must be @code{static}. -@item zero_call_used_regs ("@var{choice}") @cindex @code{zero_call_used_regs} function attribute +@item zero_call_used_regs ("@var{choice}") The @code{zero_call_used_regs} attribute causes the compiler to zero a subset of all call-used registers@footnote{A ``call-used'' register @@ -4409,85 +4409,85 @@ similar command-line options (@pxref{AArch64 Options}), but on a per-function basis. @table @code -@item general-regs-only @cindex @code{general-regs-only} function attribute, 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 uses floating-point code, then the compiler gives an error. This is the same behavior as that of the command-line option @option{-mgeneral-regs-only}. -@item fix-cortex-a53-835769 @cindex @code{fix-cortex-a53-835769} function attribute, 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 function specify the negated form: @code{no-fix-cortex-a53-835769}. This corresponds to the behavior of the command line options @option{-mfix-cortex-a53-835769} and @option{-mno-fix-cortex-a53-835769}. -@item cmodel= @cindex @code{cmodel=} function attribute, 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{strict-align} function attribute, AArch64 @item strict-align @itemx no-strict-align -@cindex @code{strict-align} function attribute, AArch64 @code{strict-align} indicates that the compiler should not assume that unaligned memory references are handled by the system. To allow the compiler to assume that aligned memory references are handled by the system, the inverse attribute @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}. -@item omit-leaf-frame-pointer @cindex @code{omit-leaf-frame-pointer} function attribute, 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 @code{no-omit-leaf-frame-pointer} can be specified. These attributes have the same behavior as the command-line options @option{-momit-leaf-frame-pointer} and @option{-mno-omit-leaf-frame-pointer}. -@item tls-dialect= @cindex @code{tls-dialect=} function attribute, 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=}. -@item arch= @cindex @code{arch=} function attribute, 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. -@item tune= @cindex @code{tune=} function attribute, 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. -@item cpu= @cindex @code{cpu=} function attribute, 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. -@item sign-return-address @cindex @code{sign-return-address} function attribute, 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 @option{-msign-return-address=}. The default value is @code{none}. This attribute is deprecated. The @code{branch-protection} attribute should be used instead. -@item branch-protection @cindex @code{branch-protection} function attribute, 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}. -@item outline-atomics @cindex @code{outline-atomics} function attribute, AArch64 +@item 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}. @@ -4569,8 +4569,8 @@ architectural feature rules specified above. These function attributes are supported by the AMD GCN back end: @table @code -@item amdgpu_hsa_kernel @cindex @code{amdgpu_hsa_kernel} function attribute, AMD GCN +@item amdgpu_hsa_kernel This attribute indicates that the corresponding function should be compiled as a kernel function, that is an entry point that can be invoked from the host via the HSA runtime library. By default functions are only callable only from @@ -4659,8 +4659,8 @@ OpenACC/OpenMP). These function attributes are supported by the ARC back end: @table @code -@item interrupt @cindex @code{interrupt} function attribute, ARC +@item interrupt Use this attribute to indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for use in an interrupt handler @@ -4677,13 +4677,13 @@ Permissible values for this parameter are: @w{@code{ilink1}} and @w{@code{ilink2}} for ARCv1 architecture, and @w{@code{ilink}} and @w{@code{firq}} for ARCv2 architecture. -@item long_call -@itemx medium_call -@itemx short_call @cindex @code{long_call} function attribute, ARC @cindex @code{medium_call} function attribute, ARC @cindex @code{short_call} function attribute, ARC @cindex indirect calls, ARC +@item long_call +@itemx medium_call +@itemx short_call These attributes specify how a particular function is called. These attributes override the @option{-mlong-calls} and @option{-mmedium-calls} (@pxref{ARC Options}) @@ -4700,26 +4700,26 @@ attribute will always be close enough to be called with a conditional branch-and-link instruction, which has a 21-bit offset from the call site. -@item jli_always @cindex @code{jli_always} function attribute, ARC +@item jli_always Forces a particular function to be called using @code{jli} instruction. The @code{jli} instruction makes use of a table stored into @code{.jlitab} section, which holds the location of the functions which are addressed using this instruction. -@item jli_fixed @cindex @code{jli_fixed} function attribute, ARC +@item jli_fixed Identical like the above one, but the location of the function in the @code{jli} table is known and given as an attribute parameter. -@item secure_call @cindex @code{secure_call} function attribute, ARC +@item secure_call This attribute allows one to mark secure-code functions that are callable from normal mode. The location of the secure call function into the @code{sjli} table needs to be passed as argument. -@item naked @cindex @code{naked} function attribute, ARC +@item naked This attribute allows the compiler to construct the requisite function declaration, while allowing the body of the function to be assembly code. The specified function will not have prologue/epilogue @@ -4738,16 +4738,16 @@ These function attributes are supported for ARM targets: @table @code -@item general-regs-only @cindex @code{general-regs-only} function attribute, ARM +@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 uses floating-point code, then the compiler gives an error. This is the same behavior as that of the command-line option @option{-mgeneral-regs-only}. -@item interrupt @cindex @code{interrupt} function attribute, ARM +@item interrupt Use this attribute to indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for use in an interrupt handler @@ -4767,16 +4767,16 @@ Permissible values for this parameter are: @code{IRQ}, @code{FIQ}, On ARMv7-M the interrupt type is ignored, and the attribute means the function may be called with a word-aligned stack pointer. -@item isr @cindex @code{isr} function attribute, ARM +@item isr Use this attribute on ARM to write Interrupt Service Routines. This is an alias to the @code{interrupt} attribute above. -@item long_call -@itemx short_call @cindex @code{long_call} function attribute, ARM @cindex @code{short_call} function attribute, ARM @cindex indirect calls, ARM +@item long_call +@itemx short_call These attributes specify how a particular function is called. These attributes override the @option{-mlong-calls} (@pxref{ARM Options}) @@ -4787,8 +4787,8 @@ calling sequence. The @code{short_call} attribute always places the offset to the function from the call site into the @samp{BL} instruction directly. -@item naked @cindex @code{naked} function attribute, ARM +@item naked This attribute allows the compiler to construct the requisite function declaration, while allowing the body of the function to be assembly code. The specified function will not have @@ -4798,8 +4798,8 @@ prologue/epilogue sequences generated by the compiler. Only basic basic @code{asm} and C code may appear to work, they cannot be depended upon to work reliably and are not supported. -@item pcs @cindex @code{pcs} function attribute, ARM +@item pcs The @code{pcs} attribute can be used to control the calling convention used for a function on ARM. The attribute takes an argument that specifies @@ -4820,33 +4820,33 @@ double f2d (float) __attribute__((pcs("aapcs"))); Variadic functions always use the @code{"aapcs"} calling convention and the compiler rejects attempts to specify an alternative. -@item target (@var{options}) @cindex @code{target} function attribute +@item target (@var{options}) As discussed in @ref{Common Function Attributes}, this attribute allows specification of target-specific compilation options. On ARM, the following options are allowed: @table @samp -@item thumb @cindex @code{target("thumb")} function attribute, ARM +@item thumb Force code generation in the Thumb (T16/T32) ISA, depending on the architecture level. -@item arm @cindex @code{target("arm")} function attribute, ARM +@item arm Force code generation in the ARM (A32) ISA. Functions from different modes can be inlined in the caller's mode. -@item fpu= @cindex @code{target("fpu=")} function attribute, 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. -@item arch= @cindex @code{arch=} function attribute, ARM +@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. @@ -4889,8 +4889,8 @@ without modifying an existing @option{-march=} or @option{-mcpu} option. These function attributes are supported by the AVR back end: @table @code -@item interrupt @cindex @code{interrupt} function attribute, AVR +@item interrupt Use this attribute to indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for use in an interrupt handler @@ -4904,8 +4904,8 @@ that does not insert a @code{SEI} instruction. If both @code{signal} and @code{interrupt} are specified for the same function, @code{signal} is silently ignored. -@item naked @cindex @code{naked} function attribute, AVR +@item naked This attribute allows the compiler to construct the requisite function declaration, while allowing the body of the function to be assembly code. The specified function will not have @@ -4915,8 +4915,8 @@ prologue/epilogue sequences generated by the compiler. Only basic basic @code{asm} and C code may appear to work, they cannot be depended upon to work reliably and are not supported. -@item no_gccisr @cindex @code{no_gccisr} function attribute, AVR +@item no_gccisr Do not use @code{__gcc_isr} pseudo instructions in a function with the @code{interrupt} or @code{signal} attribute aka. interrupt service routine (ISR). @@ -4942,10 +4942,10 @@ expects (parts of) the prologue code as outlined above to be present. To disable @code{__gcc_isr} generation for the whole compilation unit, there is option @option{-mno-gas-isr-prologues}, @pxref{AVR Options}. -@item OS_main -@itemx OS_task @cindex @code{OS_main} function attribute, AVR @cindex @code{OS_task} function attribute, AVR +@item OS_main +@itemx OS_task On AVR, functions with the @code{OS_main} or @code{OS_task} attribute do not save/restore any call-saved register in their prologue/epilogue. @@ -4970,8 +4970,8 @@ or a frame pointer whereas @code{OS_main} and @code{OS_task} do this as needed. @end itemize -@item signal @cindex @code{signal} function attribute, AVR +@item signal Use this attribute on the AVR to indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for use in an interrupt handler when this @@ -4997,47 +4997,47 @@ These function attributes are supported by the Blackfin back end: @table @code -@item exception_handler @cindex @code{exception_handler} function attribute @cindex exception handler functions, Blackfin +@item exception_handler Use this attribute on the Blackfin to indicate that the specified function is an exception handler. The compiler generates function entry and exit sequences suitable for use in an exception handler when this attribute is present. -@item interrupt_handler @cindex @code{interrupt_handler} function attribute, Blackfin +@item interrupt_handler Use this attribute to indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for use in an interrupt handler when this attribute is present. -@item kspisusp @cindex @code{kspisusp} function attribute, Blackfin @cindex User stack pointer in interrupts on the Blackfin +@item kspisusp When used together with @code{interrupt_handler}, @code{exception_handler} or @code{nmi_handler}, code is generated to load the stack pointer from the USP register in the function prologue. -@item l1_text @cindex @code{l1_text} function attribute, Blackfin +@item l1_text This attribute specifies a function to be placed into L1 Instruction SRAM@. The function is put into a specific section named @code{.l1.text}. With @option{-mfdpic}, function calls with a such function as the callee or caller uses inlined PLT. -@item l2 @cindex @code{l2} function attribute, Blackfin +@item l2 This attribute specifies a function to be placed into L2 SRAM. The function is put into a specific section named @code{.l2.text}. With @option{-mfdpic}, callers of such functions use an inlined PLT. -@item longcall -@itemx shortcall @cindex indirect calls, Blackfin @cindex @code{longcall} function attribute, Blackfin @cindex @code{shortcall} function attribute, Blackfin +@item longcall +@itemx shortcall The @code{longcall} attribute indicates that the function might be far away from the call site and require a different (more expensive) calling sequence. The @@ -5045,24 +5045,24 @@ require a different (more expensive) calling sequence. The enough for the shorter calling sequence to be used. These attributes override the @option{-mlongcall} switch. -@item nesting @cindex @code{nesting} function attribute, Blackfin @cindex Allow nesting in an interrupt handler on the Blackfin processor +@item nesting Use this attribute together with @code{interrupt_handler}, @code{exception_handler} or @code{nmi_handler} to indicate that the function entry code should enable nested interrupts or exceptions. -@item nmi_handler @cindex @code{nmi_handler} function attribute, Blackfin @cindex NMI handler functions on the Blackfin processor +@item nmi_handler Use this attribute on the Blackfin to indicate that the specified function is an NMI handler. The compiler generates function entry and exit sequences suitable for use in an NMI handler when this attribute is present. -@item saveall @cindex @code{saveall} function attribute, Blackfin @cindex save all registers on the Blackfin +@item saveall Use this attribute to indicate that all registers except the stack pointer should be saved in the prologue regardless of whether they are used or not. @@ -5074,8 +5074,8 @@ regardless of whether they are used or not. These function attributes are supported by the BPF back end: @table @code -@item kernel_helper @cindex @code{kernel helper}, function attribute, BPF +@item kernel_helper use this attribute to indicate the specified function declaration is a kernel helper. The helper function is passed as an argument to the attribute. Example: @@ -5092,10 +5092,10 @@ int bpf_probe_read (void *dst, int size, const void *unsafe_ptr) These function attributes are supported by the C-SKY back end: @table @code -@item interrupt -@itemx isr @cindex @code{interrupt} function attribute, C-SKY @cindex @code{isr} function attribute, C-SKY +@item interrupt +@itemx isr Use these attributes to indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for @@ -5105,8 +5105,8 @@ Use of these options requires the @option{-mistack} command-line option to enable support for the necessary interrupt stack instructions. They are ignored with a warning otherwise. @xref{C-SKY Options}. -@item naked @cindex @code{naked} function attribute, C-SKY +@item naked This attribute allows the compiler to construct the requisite function declaration, while allowing the body of the function to be assembly code. The specified function will not have @@ -5124,22 +5124,22 @@ depended upon to work reliably and are not supported. These function attributes are supported by the Epiphany back end: @table @code -@item disinterrupt @cindex @code{disinterrupt} function attribute, Epiphany +@item disinterrupt This attribute causes the compiler to emit instructions to disable interrupts for the duration of the given function. -@item forwarder_section @cindex @code{forwarder_section} function attribute, Epiphany +@item forwarder_section This attribute modifies the behavior of an interrupt handler. The interrupt handler may be in external memory which cannot be reached by a branch instruction, so generate a local memory trampoline to transfer control. The single parameter identifies the section where the trampoline is placed. -@item interrupt @cindex @code{interrupt} function attribute, Epiphany +@item interrupt Use this attribute to indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for use in an interrupt handler @@ -5179,11 +5179,11 @@ void __attribute__ ((interrupt ("dma0, dma1"), external_dma_handler (); @end smallexample -@item long_call -@itemx short_call @cindex @code{long_call} function attribute, Epiphany @cindex @code{short_call} function attribute, Epiphany @cindex indirect calls, Epiphany +@item long_call +@itemx short_call These attributes specify how a particular function is called. These attributes override the @option{-mlong-calls} (@pxref{Adapteva Epiphany Options}) @@ -5197,8 +5197,8 @@ command-line switch and @code{#pragma long_calls} settings. These function attributes are available for H8/300 targets: @table @code -@item function_vector @cindex @code{function_vector} function attribute, H8/300 +@item function_vector Use this attribute on the H8/300, H8/300H, and H8S to indicate that the specified function should be called through the function vector. Calling a function through the function vector reduces code size; however, @@ -5206,16 +5206,16 @@ the function vector has a limited size (maximum 128 entries on the H8/300 and 64 entries on the H8/300H and H8S) and shares space with the interrupt vector. -@item interrupt_handler @cindex @code{interrupt_handler} function attribute, H8/300 +@item interrupt_handler Use this attribute on the H8/300, H8/300H, and H8S to indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for use in an interrupt handler when this attribute is present. -@item saveall @cindex @code{saveall} function attribute, H8/300 @cindex save all registers on the H8/300, H8/300H, and H8S +@item saveall Use this attribute on the H8/300, H8/300H, and H8S to indicate that all registers except the stack pointer should be saved in the prologue regardless of whether they are used or not. @@ -5227,16 +5227,16 @@ regardless of whether they are used or not. These function attributes are supported on IA-64 targets: @table @code -@item syscall_linkage @cindex @code{syscall_linkage} function attribute, IA-64 +@item syscall_linkage This attribute is used to modify the IA-64 calling convention by marking all input registers as live at all function exits. This makes it possible to restart a system call after an interrupt without having to save/restore the input registers. This also prevents kernel data from leaking into application code. -@item version_id @cindex @code{version_id} function attribute, IA-64 +@item version_id This IA-64 HP-UX attribute, attached to a global variable or function, renames a symbol to contain a version string, thus allowing for function level versioning. HP-UX system header files may use function level versioning @@ -5256,21 +5256,21 @@ Calls to @code{foo} are mapped to calls to @code{foo@{20040821@}}. These function attributes are supported by the M32C back end: @table @code -@item bank_switch @cindex @code{bank_switch} function attribute, M32C +@item bank_switch When added to an interrupt handler with the M32C port, causes the prologue and epilogue to use bank switching to preserve the registers rather than saving them on the stack. -@item fast_interrupt @cindex @code{fast_interrupt} function attribute, M32C +@item fast_interrupt Use this attribute on the M32C port to indicate that the specified function is a fast interrupt handler. This is just like the @code{interrupt} attribute, except that @code{freit} is used to return instead of @code{reit}. -@item function_vector @cindex @code{function_vector} function attribute, M16C/M32C +@item function_vector On M16C/M32C targets, the @code{function_vector} attribute declares a special page subroutine call function. Use of this attribute reduces the code size by 2 bytes for each call generated to the @@ -5305,8 +5305,8 @@ then be sure to write this declaration in both files. This attribute is ignored for R8C target. -@item interrupt @cindex @code{interrupt} function attribute, M32C +@item interrupt Use this attribute to indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for use in an interrupt handler @@ -5319,16 +5319,16 @@ when this attribute is present. These function attributes are supported by the M32R/D back end: @table @code -@item interrupt @cindex @code{interrupt} function attribute, M32R/D +@item interrupt Use this attribute to indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for use in an interrupt handler when this attribute is present. -@item model (@var{model-name}) @cindex @code{model} function attribute, M32R/D @cindex function addressability on the M32R/D +@item model (@var{model-name}) On the M32R/D, use this attribute to set the addressability of an object, and of the code generated for a function. The identifier @@ -5355,17 +5355,17 @@ generates the much slower @code{seth/add3/jl} instruction sequence). These function attributes are supported by the m68k back end: @table @code -@item interrupt -@itemx interrupt_handler @cindex @code{interrupt} function attribute, m68k @cindex @code{interrupt_handler} function attribute, m68k +@item interrupt +@itemx interrupt_handler Use this attribute to indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for use in an interrupt handler when this attribute is present. Either name may be used. -@item interrupt_thread @cindex @code{interrupt_thread} function attribute, fido +@item interrupt_thread Use this attribute on fido, a subarchitecture of the m68k, to indicate that the specified function is an interrupt handler that is designed to run as a thread. The compiler omits generate prologue/epilogue @@ -5379,8 +5379,8 @@ instruction. This attribute is available only on fido. These function attributes are supported by the MCORE back end: @table @code -@item naked @cindex @code{naked} function attribute, MCORE +@item naked This attribute allows the compiler to construct the requisite function declaration, while allowing the body of the function to be assembly code. The specified function will not have @@ -5397,17 +5397,17 @@ depended upon to work reliably and are not supported. These function attributes are supported on MicroBlaze targets: @table @code -@item save_volatiles @cindex @code{save_volatiles} function attribute, MicroBlaze +@item save_volatiles Use this attribute to indicate that the function is an interrupt handler. All volatile registers (in addition to non-volatile registers) are saved in the function prologue. If the function is a leaf function, only volatiles used by the function are saved. A normal function return is generated instead of a return from interrupt. -@item break_handler @cindex @code{break_handler} function attribute, MicroBlaze @cindex break handler functions +@item break_handler Use this attribute to indicate that the specified function is a break handler. The compiler generates function entry and exit sequences suitable for use in an break handler when this @@ -5418,10 +5418,10 @@ the @code{rtbd} instead of @code{rtsd}. void f () __attribute__ ((break_handler)); @end smallexample -@item interrupt_handler -@itemx fast_interrupt @cindex @code{interrupt_handler} function attribute, MicroBlaze @cindex @code{fast_interrupt} function attribute, MicroBlaze +@item interrupt_handler +@itemx fast_interrupt These attributes indicate that the specified function is an interrupt handler. Use the @code{fast_interrupt} attribute to indicate handlers used in low-latency interrupt mode, and @code{interrupt_handler} for @@ -5437,9 +5437,9 @@ The following attributes are available on Microsoft Windows and Symbian OS targets. @table @code -@item dllexport @cindex @code{dllexport} function attribute @cindex @code{__declspec(dllexport)} +@item dllexport On Microsoft Windows targets and Symbian OS targets the @code{dllexport} attribute causes the compiler to provide a global pointer to a pointer in a DLL, so that it can be referenced with the @@ -5473,9 +5473,9 @@ including the symbol in the DLL's export table such as using a @file{.def} file with an @code{EXPORTS} section or, with GNU ld, using the @option{--export-all} linker flag. -@item dllimport @cindex @code{dllimport} function attribute @cindex @code{__declspec(dllimport)} +@item dllimport On Microsoft Windows and Symbian OS targets, the @code{dllimport} attribute causes the compiler to reference a function or variable via a global pointer to a pointer that is set up by the DLL exporting the @@ -5534,8 +5534,8 @@ for functions by setting the @option{-mnop-fun-dllimport} flag. These function attributes are supported by the MIPS back end: @table @code -@item interrupt @cindex @code{interrupt} function attribute, MIPS +@item interrupt Use this attribute to indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for use in an interrupt handler when this attribute is present. @@ -5552,20 +5552,20 @@ all interrupts from sw0 up to and including the specified interrupt vector. You can use the following attributes to modify the behavior of an interrupt handler: @table @code -@item use_shadow_register_set @cindex @code{use_shadow_register_set} function attribute, 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. -@item keep_interrupts_masked @cindex @code{keep_interrupts_masked} function attribute, MIPS +@item keep_interrupts_masked Keep interrupts masked for the whole function. Without this attribute, GCC tries to reenable interrupts for as much of the function as it can. -@item use_debug_exception_return @cindex @code{use_debug_exception_return} function attribute, MIPS +@item use_debug_exception_return Return using the @code{deret} instruction. Interrupt handlers that don't have this attribute return using @code{eret} instead. @end table @@ -5589,15 +5589,15 @@ void __attribute__ ((interrupt("eic"))) v8 (); void __attribute__ ((interrupt("vector=hw3"))) v9 (); @end smallexample -@item long_call -@itemx short_call -@itemx near -@itemx far @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 +@item long_call +@itemx short_call +@itemx near +@itemx far These attributes specify how a particular function is called on MIPS@. The attributes override the @option{-mlong-calls} (@pxref{MIPS Options}) command-line switch. The @code{long_call} and @code{far} attributes are @@ -5608,10 +5608,10 @@ attributes are synonyms, and have the opposite effect; they specify that non-PIC calls should be made using the more efficient @code{jal} instruction. -@item mips16 -@itemx nomips16 @cindex @code{mips16} function attribute, MIPS @cindex @code{nomips16} function attribute, MIPS +@item mips16 +@itemx nomips16 On MIPS targets, you can use the @code{mips16} and @code{nomips16} function attributes to locally select or turn off MIPS16 code generation. @@ -5627,10 +5627,10 @@ not that within individual functions. Mixed MIPS16 and non-MIPS16 code may interact badly with some GCC extensions such as @code{__builtin_apply} (@pxref{Constructing Calls}). -@item micromips, MIPS -@itemx nomicromips, MIPS @cindex @code{micromips} function attribute @cindex @code{nomicromips} function attribute +@item micromips, MIPS +@itemx nomicromips, MIPS On MIPS targets, you can use the @code{micromips} and @code{nomicromips} function attributes to locally select or turn off microMIPS code generation. @@ -5647,8 +5647,8 @@ not that within individual functions. Mixed microMIPS and non-microMIPS code may interact badly with some GCC extensions such as @code{__builtin_apply} (@pxref{Constructing Calls}). -@item nocompression @cindex @code{nocompression} function attribute, MIPS +@item nocompression On MIPS targets, you can use the @code{nocompression} function attribute to locally turn off MIPS16 and microMIPS code generation. This attribute overrides the @option{-mips16} and @option{-mmicromips} options on the @@ -5661,8 +5661,8 @@ command line (@pxref{MIPS Options}). These function attributes are supported by the MSP430 back end: @table @code -@item critical @cindex @code{critical} function attribute, MSP430 +@item critical Critical functions disable interrupts upon entry and restore the previous interrupt state upon exit. Critical functions cannot also have the @code{naked}, @code{reentrant} or @code{interrupt} attributes. @@ -5672,8 +5672,8 @@ The MSP430 hardware ensures that interrupts are disabled on entry to on exit. The @code{critical} attribute is therefore redundant on @code{interrupt} functions. -@item interrupt @cindex @code{interrupt} function attribute, MSP430 +@item interrupt Use this attribute to indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for use in an interrupt handler @@ -5688,8 +5688,8 @@ match up with appropriate entries in the linker script. By default the names @code{watchdog} for vector 26, @code{nmi} for vector 30 and @code{reset} for vector 31 are recognized. -@item naked @cindex @code{naked} function attribute, MSP430 +@item naked This attribute allows the compiler to construct the requisite function declaration, while allowing the body of the function to be assembly code. The specified function will not have @@ -5699,26 +5699,26 @@ prologue/epilogue sequences generated by the compiler. Only basic basic @code{asm} and C code may appear to work, they cannot be depended upon to work reliably and are not supported. -@item reentrant @cindex @code{reentrant} function attribute, MSP430 +@item reentrant Reentrant functions disable interrupts upon entry and enable them upon exit. Reentrant functions cannot also have the @code{naked} or @code{critical} attributes. They can have the @code{interrupt} attribute. -@item wakeup @cindex @code{wakeup} function attribute, MSP430 +@item wakeup This attribute only applies to interrupt functions. It is silently ignored if applied to a non-interrupt function. A wakeup interrupt function will rouse the processor from any low-power state that it might be in when the function exits. -@item lower -@itemx upper -@itemx either @cindex @code{lower} function attribute, MSP430 @cindex @code{upper} function attribute, MSP430 @cindex @code{either} function attribute, MSP430 +@item lower +@itemx upper +@itemx either On the MSP430 target these attributes can be used to specify whether the function or variable should be placed into low memory, high memory, or the placement should be left to the linker to decide. The @@ -5752,43 +5752,43 @@ easier to pack regions. These function attributes are supported by the NDS32 back end: @table @code -@item exception @cindex @code{exception} function attribute @cindex exception handler functions, NDS32 +@item exception Use this attribute on the NDS32 target to indicate that the specified function is an exception handler. The compiler will generate corresponding sections for use in an exception handler. -@item interrupt @cindex @code{interrupt} function attribute, NDS32 +@item interrupt On NDS32 target, this attribute indicates that the specified function is an interrupt handler. The compiler generates corresponding sections for use in an interrupt handler. You can use the following attributes to modify the behavior: @table @code -@item nested @cindex @code{nested} function attribute, NDS32 +@item nested This interrupt service routine is interruptible. -@item not_nested @cindex @code{not_nested} function attribute, NDS32 +@item not_nested This interrupt service routine is not interruptible. -@item nested_ready @cindex @code{nested_ready} function attribute, 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. -@item save_all @cindex @code{save_all} function attribute, NDS32 +@item save_all The system will help save all registers into stack before entering interrupt handler. -@item partial_save @cindex @code{partial_save} function attribute, NDS32 +@item partial_save The system will help save caller registers into stack before entering interrupt handler. @end table -@item naked @cindex @code{naked} function attribute, NDS32 +@item naked This attribute allows the compiler to construct the requisite function declaration, while allowing the body of the function to be assembly code. The specified function will not have @@ -5798,19 +5798,19 @@ prologue/epilogue sequences generated by the compiler. Only basic basic @code{asm} and C code may appear to work, they cannot be depended upon to work reliably and are not supported. -@item reset @cindex @code{reset} function attribute, NDS32 @cindex reset handler functions +@item reset Use this attribute on the NDS32 target to indicate that the specified function is a reset handler. The compiler will generate corresponding sections for use in a reset handler. You can use the following attributes to provide extra exception handling: @table @code -@item nmi @cindex @code{nmi} function attribute, NDS32 +@item nmi Provide a user-defined function to handle NMI exception. -@item warm @cindex @code{warm} function attribute, NDS32 +@item warm Provide a user-defined function to handle warm reset exception. @end table @end table @@ -5821,18 +5821,18 @@ Provide a user-defined function to handle warm reset exception. These function attributes are supported by the Nios II back end: @table @code -@item target (@var{options}) @cindex @code{target} function attribute +@item target (@var{options}) As discussed in @ref{Common Function Attributes}, this attribute allows specification of target-specific compilation options. When compiling for Nios II, the following options are allowed: @table @samp -@item custom-@var{insn}=@var{N} -@itemx no-custom-@var{insn} @cindex @code{target("custom-@var{insn}=@var{N}")} function attribute, Nios II @cindex @code{target("no-custom-@var{insn}")} function attribute, Nios II +@item custom-@var{insn}=@var{N} +@itemx no-custom-@var{insn} Each @samp{custom-@var{insn}=@var{N}} attribute locally enables use of a custom instruction with encoding @var{N} when generating code that uses @var{insn}. Similarly, @samp{no-custom-@var{insn}} locally inhibits use of @@ -5842,8 +5842,8 @@ These target attributes correspond to the command-line options, and support the same set of @var{insn} keywords. @xref{Nios II Options}, for more information. -@item custom-fpu-cfg=@var{name} @cindex @code{target("custom-fpu-cfg=@var{name}")} function attribute, Nios II +@item custom-fpu-cfg=@var{name} This attribute corresponds to the @option{-mcustom-fpu-cfg=@var{name}} command-line option, to select a predefined set of custom instructions named @var{name}. @@ -5857,8 +5857,8 @@ named @var{name}. These function attributes are supported by the Nvidia PTX back end: @table @code -@item kernel @cindex @code{kernel} attribute, Nvidia PTX +@item kernel This attribute indicates that the corresponding function should be compiled as a kernel function, which can be invoked from the host via the CUDA RT library. @@ -5873,11 +5873,11 @@ Kernel functions must have @code{void} return type. These function attributes are supported by the PowerPC back end: @table @code -@item longcall -@itemx shortcall @cindex indirect calls, PowerPC @cindex @code{longcall} function attribute, PowerPC @cindex @code{shortcall} function attribute, PowerPC +@item longcall +@itemx shortcall The @code{longcall} attribute indicates that the function might be far away from the call site and require a different (more expensive) calling sequence. The @@ -5889,169 +5889,169 @@ the @code{#pragma longcall} setting. @xref{RS/6000 and PowerPC Options}, for more information on whether long calls are necessary. -@item target (@var{options}) @cindex @code{target} function attribute +@item target (@var{options}) As discussed in @ref{Common Function Attributes}, this attribute allows specification of target-specific compilation options. On the PowerPC, the following options are allowed: @table @samp +@cindex @code{target("altivec")} function attribute, PowerPC @item altivec @itemx no-altivec -@cindex @code{target("altivec")} function attribute, PowerPC 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 @item cmpb @itemx no-cmpb -@cindex @code{target("cmpb")} function attribute, PowerPC 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 @item dlmzb @itemx no-dlmzb -@cindex @code{target("dlmzb")} function attribute, PowerPC 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 @item fprnd @itemx no-fprnd -@cindex @code{target("fprnd")} function attribute, PowerPC 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 @item hard-dfp @itemx no-hard-dfp -@cindex @code{target("hard-dfp")} function attribute, PowerPC Generate code that uses (does not use) the decimal floating-point instructions implemented on some POWER processors. +@cindex @code{target("isel")} function attribute, PowerPC @item isel @itemx no-isel -@cindex @code{target("isel")} function attribute, PowerPC Generate code that uses (does not use) ISEL instruction. +@cindex @code{target("mfcrf")} function attribute, PowerPC @item mfcrf @itemx no-mfcrf -@cindex @code{target("mfcrf")} function attribute, PowerPC 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 @item mulhw @itemx no-mulhw -@cindex @code{target("mulhw")} function attribute, PowerPC Generate code that uses (does not use) the half-word multiply and multiply-accumulate instructions on the IBM 405, 440, 464 and 476 processors. These instructions are generated by default when targeting those processors. +@cindex @code{target("multiple")} function attribute, PowerPC @item multiple @itemx no-multiple -@cindex @code{target("multiple")} function attribute, PowerPC 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 @item update @itemx no-update -@cindex @code{target("update")} function attribute, PowerPC 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 @item popcntb @itemx no-popcntb -@cindex @code{target("popcntb")} function attribute, PowerPC Generate code that uses (does not use) the popcount and double-precision FP reciprocal estimate instruction implemented on the POWER5 processor and other processors that support the PowerPC V2.02 architecture. +@cindex @code{target("popcntd")} function attribute, PowerPC @item popcntd @itemx no-popcntd -@cindex @code{target("popcntd")} function attribute, PowerPC 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 @item powerpc-gfxopt @itemx no-powerpc-gfxopt -@cindex @code{target("powerpc-gfxopt")} function attribute, PowerPC 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 @item powerpc-gpopt @itemx no-powerpc-gpopt -@cindex @code{target("powerpc-gpopt")} function attribute, PowerPC 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 @item recip-precision @itemx no-recip-precision -@cindex @code{target("recip-precision")} function attribute, PowerPC 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 @item string @itemx no-string -@cindex @code{target("string")} function attribute, PowerPC 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 @item vsx @itemx no-vsx -@cindex @code{target("vsx")} function attribute, PowerPC Generate code that uses (does not use) vector/scalar (VSX) instructions, and also enable the use of built-in functions that allow more direct access to the VSX instruction set. In 32-bit code, you cannot enable VSX or AltiVec instructions unless @option{-mabi=altivec} is used on the command line. +@cindex @code{target("friz")} function attribute, PowerPC @item friz @itemx no-friz -@cindex @code{target("friz")} function attribute, PowerPC Generate (do not generate) the @code{friz} instruction when the @option{-funsafe-math-optimizations} option is used to optimize rounding a floating-point value to 64-bit integer and back to floating 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 @item avoid-indexed-addresses @itemx no-avoid-indexed-addresses -@cindex @code{target("avoid-indexed-addresses")} function attribute, PowerPC Generate code that tries to avoid (not avoid) the use of indexed load or store instructions. +@cindex @code{target("paired")} function attribute, PowerPC @item paired @itemx no-paired -@cindex @code{target("paired")} function attribute, PowerPC Generate code that uses (does not use) the generation of PAIRED simd instructions. +@cindex @code{target("longcall")} function attribute, PowerPC @item longcall @itemx no-longcall -@cindex @code{target("longcall")} function attribute, PowerPC Generate code that assumes (does not assume) that all calls are far away so that a longer more expensive calling sequence is required. -@item cpu=@var{CPU} @cindex @code{target("cpu=@var{CPU}")} function attribute, 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. -@item tune=@var{TUNE} @cindex @code{target("tune=@var{TUNE}")} function attribute, 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 you do specify the @code{target("cpu=@var{CPU}")} attribute, @@ -6070,8 +6070,8 @@ callee has a subset of the target options of the caller. These function attributes are supported by the RISC-V back end: @table @code -@item naked @cindex @code{naked} function attribute, RISC-V +@item naked This attribute allows the compiler to construct the requisite function declaration, while allowing the body of the function to be assembly code. The specified function will not have @@ -6081,8 +6081,8 @@ prologue/epilogue sequences generated by the compiler. Only basic basic @code{asm} and C code may appear to work, they cannot be depended upon to work reliably and are not supported. -@item interrupt @cindex @code{interrupt} function attribute, RISC-V +@item interrupt Use this attribute to indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for use in an interrupt handler when this attribute is present. @@ -6105,10 +6105,10 @@ and @code{machine}. If there is no parameter, then it defaults to These function attributes are supported by the RL78 back end: @table @code -@item interrupt -@itemx brk_interrupt @cindex @code{interrupt} function attribute, RL78 @cindex @code{brk_interrupt} function attribute, RL78 +@item interrupt +@itemx brk_interrupt These attributes indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for use in an interrupt handler @@ -6118,8 +6118,8 @@ Use @code{brk_interrupt} instead of @code{interrupt} for handlers intended to be used with the @code{BRK} opcode (i.e.@: those that must end with @code{RETB} instead of @code{RETI}). -@item naked @cindex @code{naked} function attribute, RL78 +@item naked This attribute allows the compiler to construct the requisite function declaration, while allowing the body of the function to be assembly code. The specified function will not have @@ -6136,15 +6136,15 @@ depended upon to work reliably and are not supported. These function attributes are supported by the RX back end: @table @code -@item fast_interrupt @cindex @code{fast_interrupt} function attribute, RX +@item fast_interrupt Use this attribute on the RX port to indicate that the specified function is a fast interrupt handler. This is just like the @code{interrupt} attribute, except that @code{freit} is used to return instead of @code{reit}. -@item interrupt @cindex @code{interrupt} function attribute, RX +@item interrupt Use this attribute to indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for use in an interrupt handler @@ -6172,8 +6172,8 @@ void __attribute__ ((interrupt (RXD1_VECT,RXD2_VECT,"dct","$default"))) txd1_handler (); @end smallexample -@item naked @cindex @code{naked} function attribute, RX +@item naked This attribute allows the compiler to construct the requisite function declaration, while allowing the body of the function to be assembly code. The specified function will not have @@ -6183,8 +6183,8 @@ prologue/epilogue sequences generated by the compiler. Only basic basic @code{asm} and C code may appear to work, they cannot be depended upon to work reliably and are not supported. -@item vector @cindex @code{vector} function attribute, RX +@item vector This RX attribute is similar to the @code{interrupt} attribute, including its parameters, but does not make the function an interrupt-handler type function (i.e.@: it retains the normal C function calling ABI). See the @@ -6197,8 +6197,8 @@ function (i.e.@: it retains the normal C function calling ABI). See the These function attributes are supported on the S/390: @table @code -@item hotpatch (@var{halfwords-before-function-label},@var{halfwords-after-function-label}) @cindex @code{hotpatch} function attribute, S/390 +@item hotpatch (@var{halfwords-before-function-label},@var{halfwords-after-function-label}) On S/390 System z targets, you can use this function attribute to make GCC generate a ``hot-patching'' function prologue. If the @@ -6211,8 +6211,8 @@ both arguments the maximum allowed value is 1000000. If both arguments are zero, hotpatching is disabled. -@item target (@var{options}) @cindex @code{target} function attribute +@item target (@var{options}) As discussed in @ref{Common Function Attributes}, this attribute allows specification of target-specific compilation options. @@ -6262,9 +6262,9 @@ does not undefine the @code{__VEC__} macro. These function attributes are supported on the SH family of processors: @table @code -@item function_vector @cindex @code{function_vector} function attribute, SH @cindex calling functions through the function vector on SH2A +@item function_vector On SH2A targets, this attribute declares a function to be called using the TBR relative addressing mode. The argument to this attribute is the entry number of the same function in a vector table containing all the TBR @@ -6281,27 +6281,27 @@ saves at least 8 bytes of code; and if other successive calls are being made to the same function, it saves 2 bytes of code per each of these calls. -@item interrupt_handler @cindex @code{interrupt_handler} function attribute, SH +@item interrupt_handler Use this attribute to indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for use in an interrupt handler when this attribute is present. -@item nosave_low_regs @cindex @code{nosave_low_regs} function attribute, SH +@item nosave_low_regs Use this attribute on SH targets to indicate that an @code{interrupt_handler} function should not save and restore registers R0..R7. This can be used on SH3* and SH4* targets that have a second R0..R7 register bank for non-reentrant interrupt handlers. -@item renesas @cindex @code{renesas} function attribute, SH +@item renesas On SH targets this attribute specifies that the function or struct follows the Renesas ABI. -@item resbank @cindex @code{resbank} function attribute, SH +@item resbank On the SH2A target, this attribute enables the high-speed register saving and restoration using a register bank for @code{interrupt_handler} routines. Saving to the bank is performed automatically after the CPU @@ -6313,8 +6313,8 @@ vector table address offset are saved into a register bank. Register banks are stacked in first-in last-out (FILO) sequence. Restoration from the bank is executed by issuing a RESBANK instruction. -@item sp_switch @cindex @code{sp_switch} function attribute, SH +@item sp_switch Use this attribute on the SH to indicate an @code{interrupt_handler} function should switch to an alternate stack. It expects a string argument that names a global variable holding the address of the @@ -6326,14 +6326,14 @@ void f () __attribute__ ((interrupt_handler, sp_switch ("alt_stack"))); @end smallexample -@item trap_exit @cindex @code{trap_exit} function attribute, SH +@item trap_exit Use this attribute on the SH for an @code{interrupt_handler} to return using @code{trapa} instead of @code{rte}. This attribute expects an integer argument specifying the trap number to be used. -@item trapa_handler @cindex @code{trapa_handler} function attribute, SH +@item trapa_handler On SH targets this function attribute is similar to @code{interrupt_handler} but it does not save and restore all registers. @end table @@ -6350,10 +6350,10 @@ but it does not save and restore all registers. The V850 back end supports these function attributes: @table @code -@item interrupt -@itemx interrupt_handler @cindex @code{interrupt} function attribute, V850 @cindex @code{interrupt_handler} function attribute, V850 +@item interrupt +@itemx interrupt_handler Use these attributes to indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for use in an interrupt handler @@ -6366,8 +6366,8 @@ when either attribute is present. These function attributes are supported by the Visium back end: @table @code -@item interrupt @cindex @code{interrupt} function attribute, Visium +@item interrupt Use this attribute to indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for use in an interrupt handler @@ -6380,18 +6380,18 @@ when this attribute is present. These function attributes are supported by the x86 back end: @table @code -@item cdecl @cindex @code{cdecl} function attribute, x86-32 @cindex functions that pop the argument stack on x86-32 @opindex mrtd +@item cdecl On the x86-32 targets, the @code{cdecl} attribute causes the compiler to assume that the calling function pops off the stack space used to pass arguments. This is useful to override the effects of the @option{-mrtd} switch. -@item fastcall @cindex @code{fastcall} function attribute, x86-32 @cindex functions that pop the argument stack on x86-32 +@item fastcall On x86-32 targets, the @code{fastcall} attribute causes the compiler to pass the first argument (if of integral type) in the register ECX and the second argument (if of integral type) in the register EDX@. Subsequent @@ -6399,9 +6399,9 @@ and other typed arguments are passed on the stack. The called function pops the arguments off the stack. If the number of arguments is variable all arguments are pushed on the stack. -@item thiscall @cindex @code{thiscall} function attribute, x86-32 @cindex functions that pop the argument stack on x86-32 +@item thiscall On x86-32 targets, the @code{thiscall} attribute causes the compiler to pass the first argument (if of integral type) in the register ECX. Subsequent and other typed arguments are passed on the stack. The called @@ -6412,10 +6412,10 @@ The @code{thiscall} attribute is intended for C++ non-static member functions. As a GCC extension, this calling convention can be used for C functions and for static member methods. -@item ms_abi -@itemx sysv_abi @cindex @code{ms_abi} function attribute, x86 @cindex @code{sysv_abi} function attribute, x86 +@item ms_abi +@itemx sysv_abi On 32-bit and 64-bit x86 targets, you can use an ABI attribute to indicate which calling convention should be used for a function. The @@ -6428,8 +6428,8 @@ is the System V ELF ABI. Note, the @code{ms_abi} attribute for Microsoft Windows 64-bit targets currently requires the @option{-maccumulate-outgoing-args} option. -@item callee_pop_aggregate_return (@var{number}) @cindex @code{callee_pop_aggregate_return} function attribute, x86 +@item callee_pop_aggregate_return (@var{number}) On x86-32 targets, you can use this attribute to control how aggregates are returned in memory. If the caller is responsible for @@ -6442,16 +6442,16 @@ stack for hidden pointer. However, on x86-32 Microsoft Windows targets, the compiler assumes that the caller pops the stack for hidden pointer. -@item ms_hook_prologue @cindex @code{ms_hook_prologue} function attribute, x86 +@item ms_hook_prologue On 32-bit and 64-bit x86 targets, you can use this function attribute to make GCC generate the ``hot-patching'' function prologue used in Win32 API functions in Microsoft Windows XP Service Pack 2 and newer. -@item naked @cindex @code{naked} function attribute, x86 +@item naked This attribute allows the compiler to construct the requisite function declaration, while allowing the body of the function to be assembly code. The specified function will not have @@ -6461,9 +6461,9 @@ prologue/epilogue sequences generated by the compiler. Only basic basic @code{asm} and C code may appear to work, they cannot be depended upon to work reliably and are not supported. -@item regparm (@var{number}) @cindex @code{regparm} function attribute, x86 @cindex functions that are passed arguments in registers on x86-32 +@item regparm (@var{number}) On x86-32 targets, the @code{regparm} attribute causes the compiler to pass arguments number one to @var{number} if they are of integral type in registers EAX, EDX, and ECX instead of on the stack. Functions that @@ -6481,31 +6481,31 @@ safe since the loaders there save EAX, EDX and ECX. (Lazy binding can be disabled with the linker or the loader if desired, to avoid the problem.) -@item sseregparm @cindex @code{sseregparm} function attribute, x86 +@item sseregparm On x86-32 targets with SSE support, the @code{sseregparm} attribute causes the compiler to pass up to 3 floating-point arguments in SSE registers instead of on the stack. Functions that take a variable number of arguments continue to pass all of their floating-point arguments on the stack. -@item force_align_arg_pointer @cindex @code{force_align_arg_pointer} function attribute, x86 +@item force_align_arg_pointer On x86 targets, the @code{force_align_arg_pointer} attribute may be applied to individual function definitions, generating an alternate prologue and epilogue that realigns the run-time stack if necessary. 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. -@item stdcall @cindex @code{stdcall} function attribute, x86-32 @cindex functions that pop the argument stack on x86-32 +@item stdcall On x86-32 targets, the @code{stdcall} attribute causes the compiler to assume that the called function pops off the stack space used to pass arguments, unless it takes a variable number of arguments. -@item no_caller_saved_registers @cindex @code{no_caller_saved_registers} function attribute, x86 +@item no_caller_saved_registers Use this attribute to indicate that the specified function has no caller-saved registers. That is, all registers are callee-saved. For example, this attribute can be used for a function called from an @@ -6515,8 +6515,8 @@ the EFLAGS register. Since GCC doesn't preserve SSE, MMX nor x87 states, the GCC option @option{-mgeneral-regs-only} should be used to compile functions with @code{no_caller_saved_registers} attribute. -@item interrupt @cindex @code{interrupt} function attribute, x86 +@item interrupt Use this attribute to indicate that the specified function is an interrupt handler or an exception handler (depending on parameters passed to the function, explained further). The compiler generates function @@ -6577,544 +6577,544 @@ Exception handlers should only be used for exceptions that push an error code; you should use an interrupt handler in other cases. The system will crash if the wrong kind of handler is used. -@item target (@var{options}) @cindex @code{target} function attribute +@item target (@var{options}) As discussed in @ref{Common Function Attributes}, this attribute allows specification of target-specific compilation options. On the x86, the following options are allowed: @table @samp +@cindex @code{target("3dnow")} function attribute, x86 @item 3dnow @itemx no-3dnow -@cindex @code{target("3dnow")} function attribute, x86 Enable/disable the generation of the 3DNow!@: instructions. +@cindex @code{target("3dnowa")} function attribute, x86 @item 3dnowa @itemx no-3dnowa -@cindex @code{target("3dnowa")} function attribute, x86 Enable/disable the generation of the enhanced 3DNow!@: instructions. +@cindex @code{target("abm")} function attribute, x86 @item abm @itemx no-abm -@cindex @code{target("abm")} function attribute, x86 Enable/disable the generation of the advanced bit instructions. +@cindex @code{target("adx")} function attribute, x86 @item adx @itemx no-adx -@cindex @code{target("adx")} function attribute, x86 Enable/disable the generation of the ADX instructions. +@cindex @code{target("aes")} function attribute, x86 @item aes @itemx no-aes -@cindex @code{target("aes")} function attribute, x86 Enable/disable the generation of the AES instructions. +@cindex @code{target("avx")} function attribute, x86 @item avx @itemx no-avx -@cindex @code{target("avx")} function attribute, x86 Enable/disable the generation of the AVX instructions. +@cindex @code{target("avx2")} function attribute, x86 @item avx2 @itemx no-avx2 -@cindex @code{target("avx2")} function attribute, x86 Enable/disable the generation of the AVX2 instructions. +@cindex @code{target("avx5124fmaps")} function attribute, x86 @item avx5124fmaps @itemx no-avx5124fmaps -@cindex @code{target("avx5124fmaps")} function attribute, x86 Enable/disable the generation of the AVX5124FMAPS instructions. +@cindex @code{target("avx5124vnniw")} function attribute, x86 @item avx5124vnniw @itemx no-avx5124vnniw -@cindex @code{target("avx5124vnniw")} function attribute, x86 Enable/disable the generation of the AVX5124VNNIW instructions. +@cindex @code{target("avx512bitalg")} function attribute, x86 @item avx512bitalg @itemx no-avx512bitalg -@cindex @code{target("avx512bitalg")} function attribute, x86 Enable/disable the generation of the AVX512BITALG instructions. +@cindex @code{target("avx512bw")} function attribute, x86 @item avx512bw @itemx no-avx512bw -@cindex @code{target("avx512bw")} function attribute, x86 Enable/disable the generation of the AVX512BW instructions. +@cindex @code{target("avx512cd")} function attribute, x86 @item avx512cd @itemx no-avx512cd -@cindex @code{target("avx512cd")} function attribute, x86 Enable/disable the generation of the AVX512CD instructions. +@cindex @code{target("avx512dq")} function attribute, x86 @item avx512dq @itemx no-avx512dq -@cindex @code{target("avx512dq")} function attribute, x86 Enable/disable the generation of the AVX512DQ instructions. +@cindex @code{target("avx512er")} function attribute, x86 @item avx512er @itemx no-avx512er -@cindex @code{target("avx512er")} function attribute, x86 Enable/disable the generation of the AVX512ER instructions. +@cindex @code{target("avx512f")} function attribute, x86 @item avx512f @itemx no-avx512f -@cindex @code{target("avx512f")} function attribute, x86 Enable/disable the generation of the AVX512F instructions. +@cindex @code{target("avx512ifma")} function attribute, x86 @item avx512ifma @itemx no-avx512ifma -@cindex @code{target("avx512ifma")} function attribute, x86 Enable/disable the generation of the AVX512IFMA instructions. +@cindex @code{target("avx512pf")} function attribute, x86 @item avx512pf @itemx no-avx512pf -@cindex @code{target("avx512pf")} function attribute, x86 Enable/disable the generation of the AVX512PF instructions. +@cindex @code{target("avx512vbmi")} function attribute, x86 @item avx512vbmi @itemx no-avx512vbmi -@cindex @code{target("avx512vbmi")} function attribute, x86 Enable/disable the generation of the AVX512VBMI instructions. +@cindex @code{target("avx512vbmi2")} function attribute, x86 @item avx512vbmi2 @itemx no-avx512vbmi2 -@cindex @code{target("avx512vbmi2")} function attribute, x86 Enable/disable the generation of the AVX512VBMI2 instructions. +@cindex @code{target("avx512vl")} function attribute, x86 @item avx512vl @itemx no-avx512vl -@cindex @code{target("avx512vl")} function attribute, x86 Enable/disable the generation of the AVX512VL instructions. +@cindex @code{target("avx512vnni")} function attribute, x86 @item avx512vnni @itemx no-avx512vnni -@cindex @code{target("avx512vnni")} function attribute, x86 Enable/disable the generation of the AVX512VNNI instructions. +@cindex @code{target("avx512vpopcntdq")} function attribute, x86 @item avx512vpopcntdq @itemx no-avx512vpopcntdq -@cindex @code{target("avx512vpopcntdq")} function attribute, x86 Enable/disable the generation of the AVX512VPOPCNTDQ instructions. +@cindex @code{target("bmi")} function attribute, x86 @item bmi @itemx no-bmi -@cindex @code{target("bmi")} function attribute, x86 Enable/disable the generation of the BMI instructions. +@cindex @code{target("bmi2")} function attribute, x86 @item bmi2 @itemx no-bmi2 -@cindex @code{target("bmi2")} function attribute, x86 Enable/disable the generation of the BMI2 instructions. +@cindex @code{target("cldemote")} function attribute, x86 @item cldemote @itemx no-cldemote -@cindex @code{target("cldemote")} function attribute, x86 Enable/disable the generation of the CLDEMOTE instructions. +@cindex @code{target("clflushopt")} function attribute, x86 @item clflushopt @itemx no-clflushopt -@cindex @code{target("clflushopt")} function attribute, x86 Enable/disable the generation of the CLFLUSHOPT instructions. +@cindex @code{target("clwb")} function attribute, x86 @item clwb @itemx no-clwb -@cindex @code{target("clwb")} function attribute, x86 Enable/disable the generation of the CLWB instructions. +@cindex @code{target("clzero")} function attribute, x86 @item clzero @itemx no-clzero -@cindex @code{target("clzero")} function attribute, x86 Enable/disable the generation of the CLZERO instructions. +@cindex @code{target("crc32")} function attribute, x86 @item crc32 @itemx no-crc32 -@cindex @code{target("crc32")} function attribute, x86 Enable/disable the generation of the CRC32 instructions. +@cindex @code{target("cx16")} function attribute, x86 @item cx16 @itemx no-cx16 -@cindex @code{target("cx16")} function attribute, x86 Enable/disable the generation of the CMPXCHG16B instructions. -@item default @cindex @code{target("default")} function attribute, x86 +@item default @xref{Function Multiversioning}, where it is used to specify the default function version. +@cindex @code{target("f16c")} function attribute, x86 @item f16c @itemx no-f16c -@cindex @code{target("f16c")} function attribute, x86 Enable/disable the generation of the F16C instructions. +@cindex @code{target("fma")} function attribute, x86 @item fma @itemx no-fma -@cindex @code{target("fma")} function attribute, x86 Enable/disable the generation of the FMA instructions. +@cindex @code{target("fma4")} function attribute, x86 @item fma4 @itemx no-fma4 -@cindex @code{target("fma4")} function attribute, x86 Enable/disable the generation of the FMA4 instructions. +@cindex @code{target("fsgsbase")} function attribute, x86 @item fsgsbase @itemx no-fsgsbase -@cindex @code{target("fsgsbase")} function attribute, x86 Enable/disable the generation of the FSGSBASE instructions. +@cindex @code{target("fxsr")} function attribute, x86 @item fxsr @itemx no-fxsr -@cindex @code{target("fxsr")} function attribute, x86 Enable/disable the generation of the FXSR instructions. +@cindex @code{target("gfni")} function attribute, x86 @item gfni @itemx no-gfni -@cindex @code{target("gfni")} function attribute, x86 Enable/disable the generation of the GFNI instructions. +@cindex @code{target("hle")} function attribute, x86 @item hle @itemx no-hle -@cindex @code{target("hle")} function attribute, x86 Enable/disable the generation of the HLE instruction prefixes. +@cindex @code{target("lwp")} function attribute, x86 @item lwp @itemx no-lwp -@cindex @code{target("lwp")} function attribute, x86 Enable/disable the generation of the LWP instructions. +@cindex @code{target("lzcnt")} function attribute, x86 @item lzcnt @itemx no-lzcnt -@cindex @code{target("lzcnt")} function attribute, x86 Enable/disable the generation of the LZCNT instructions. +@cindex @code{target("mmx")} function attribute, x86 @item mmx @itemx no-mmx -@cindex @code{target("mmx")} function attribute, x86 Enable/disable the generation of the MMX instructions. +@cindex @code{target("movbe")} function attribute, x86 @item movbe @itemx no-movbe -@cindex @code{target("movbe")} function attribute, x86 Enable/disable the generation of the MOVBE instructions. +@cindex @code{target("movdir64b")} function attribute, x86 @item movdir64b @itemx no-movdir64b -@cindex @code{target("movdir64b")} function attribute, x86 Enable/disable the generation of the MOVDIR64B instructions. +@cindex @code{target("movdiri")} function attribute, x86 @item movdiri @itemx no-movdiri -@cindex @code{target("movdiri")} function attribute, x86 Enable/disable the generation of the MOVDIRI instructions. +@cindex @code{target("mwait")} function attribute, x86 @item mwait @itemx no-mwait -@cindex @code{target("mwait")} function attribute, x86 Enable/disable the generation of the MWAIT and MONITOR instructions. +@cindex @code{target("mwaitx")} function attribute, x86 @item mwaitx @itemx no-mwaitx -@cindex @code{target("mwaitx")} function attribute, x86 Enable/disable the generation of the MWAITX instructions. +@cindex @code{target("pclmul")} function attribute, x86 @item pclmul @itemx no-pclmul -@cindex @code{target("pclmul")} function attribute, x86 Enable/disable the generation of the PCLMUL instructions. +@cindex @code{target("pconfig")} function attribute, x86 @item pconfig @itemx no-pconfig -@cindex @code{target("pconfig")} function attribute, x86 Enable/disable the generation of the PCONFIG instructions. +@cindex @code{target("pku")} function attribute, x86 @item pku @itemx no-pku -@cindex @code{target("pku")} function attribute, x86 Enable/disable the generation of the PKU instructions. +@cindex @code{target("popcnt")} function attribute, x86 @item popcnt @itemx no-popcnt -@cindex @code{target("popcnt")} function attribute, x86 Enable/disable the generation of the POPCNT instruction. +@cindex @code{target("prefetchwt1")} function attribute, x86 @item prefetchwt1 @itemx no-prefetchwt1 -@cindex @code{target("prefetchwt1")} function attribute, x86 Enable/disable the generation of the PREFETCHWT1 instructions. +@cindex @code{target("prfchw")} function attribute, x86 @item prfchw @itemx no-prfchw -@cindex @code{target("prfchw")} function attribute, x86 Enable/disable the generation of the PREFETCHW instruction. +@cindex @code{target("ptwrite")} function attribute, x86 @item ptwrite @itemx no-ptwrite -@cindex @code{target("ptwrite")} function attribute, x86 Enable/disable the generation of the PTWRITE instructions. +@cindex @code{target("rdpid")} function attribute, x86 @item rdpid @itemx no-rdpid -@cindex @code{target("rdpid")} function attribute, x86 Enable/disable the generation of the RDPID instructions. +@cindex @code{target("rdrnd")} function attribute, x86 @item rdrnd @itemx no-rdrnd -@cindex @code{target("rdrnd")} function attribute, x86 Enable/disable the generation of the RDRND instructions. +@cindex @code{target("rdseed")} function attribute, x86 @item rdseed @itemx no-rdseed -@cindex @code{target("rdseed")} function attribute, x86 Enable/disable the generation of the RDSEED instructions. +@cindex @code{target("rtm")} function attribute, x86 @item rtm @itemx no-rtm -@cindex @code{target("rtm")} function attribute, x86 Enable/disable the generation of the RTM instructions. +@cindex @code{target("sahf")} function attribute, x86 @item sahf @itemx no-sahf -@cindex @code{target("sahf")} function attribute, x86 Enable/disable the generation of the SAHF instructions. +@cindex @code{target("sgx")} function attribute, x86 @item sgx @itemx no-sgx -@cindex @code{target("sgx")} function attribute, x86 Enable/disable the generation of the SGX instructions. +@cindex @code{target("sha")} function attribute, x86 @item sha @itemx no-sha -@cindex @code{target("sha")} function attribute, x86 Enable/disable the generation of the SHA instructions. +@cindex @code{target("shstk")} function attribute, x86 @item shstk @itemx no-shstk -@cindex @code{target("shstk")} function attribute, x86 Enable/disable the shadow stack built-in functions from CET. +@cindex @code{target("sse")} function attribute, x86 @item sse @itemx no-sse -@cindex @code{target("sse")} function attribute, x86 Enable/disable the generation of the SSE instructions. +@cindex @code{target("sse2")} function attribute, x86 @item sse2 @itemx no-sse2 -@cindex @code{target("sse2")} function attribute, x86 Enable/disable the generation of the SSE2 instructions. +@cindex @code{target("sse3")} function attribute, x86 @item sse3 @itemx no-sse3 -@cindex @code{target("sse3")} function attribute, x86 Enable/disable the generation of the SSE3 instructions. +@cindex @code{target("sse4")} function attribute, x86 @item sse4 @itemx no-sse4 -@cindex @code{target("sse4")} function attribute, x86 Enable/disable the generation of the SSE4 instructions (both SSE4.1 and SSE4.2). +@cindex @code{target("sse4.1")} function attribute, x86 @item sse4.1 @itemx no-sse4.1 -@cindex @code{target("sse4.1")} function attribute, x86 Enable/disable the generation of the SSE4.1 instructions. +@cindex @code{target("sse4.2")} function attribute, x86 @item sse4.2 @itemx no-sse4.2 -@cindex @code{target("sse4.2")} function attribute, x86 Enable/disable the generation of the SSE4.2 instructions. +@cindex @code{target("sse4a")} function attribute, x86 @item sse4a @itemx no-sse4a -@cindex @code{target("sse4a")} function attribute, x86 Enable/disable the generation of the SSE4A instructions. +@cindex @code{target("ssse3")} function attribute, x86 @item ssse3 @itemx no-ssse3 -@cindex @code{target("ssse3")} function attribute, x86 Enable/disable the generation of the SSSE3 instructions. +@cindex @code{target("tbm")} function attribute, x86 @item tbm @itemx no-tbm -@cindex @code{target("tbm")} function attribute, x86 Enable/disable the generation of the TBM instructions. +@cindex @code{target("vaes")} function attribute, x86 @item vaes @itemx no-vaes -@cindex @code{target("vaes")} function attribute, x86 Enable/disable the generation of the VAES instructions. +@cindex @code{target("vpclmulqdq")} function attribute, x86 @item vpclmulqdq @itemx no-vpclmulqdq -@cindex @code{target("vpclmulqdq")} function attribute, x86 Enable/disable the generation of the VPCLMULQDQ instructions. +@cindex @code{target("waitpkg")} function attribute, x86 @item waitpkg @itemx no-waitpkg -@cindex @code{target("waitpkg")} function attribute, x86 Enable/disable the generation of the WAITPKG instructions. +@cindex @code{target("wbnoinvd")} function attribute, x86 @item wbnoinvd @itemx no-wbnoinvd -@cindex @code{target("wbnoinvd")} function attribute, x86 Enable/disable the generation of the WBNOINVD instructions. +@cindex @code{target("xop")} function attribute, x86 @item xop @itemx no-xop -@cindex @code{target("xop")} function attribute, x86 Enable/disable the generation of the XOP instructions. +@cindex @code{target("xsave")} function attribute, x86 @item xsave @itemx no-xsave -@cindex @code{target("xsave")} function attribute, x86 Enable/disable the generation of the XSAVE instructions. +@cindex @code{target("xsavec")} function attribute, x86 @item xsavec @itemx no-xsavec -@cindex @code{target("xsavec")} function attribute, x86 Enable/disable the generation of the XSAVEC instructions. +@cindex @code{target("xsaveopt")} function attribute, x86 @item xsaveopt @itemx no-xsaveopt -@cindex @code{target("xsaveopt")} function attribute, x86 Enable/disable the generation of the XSAVEOPT instructions. +@cindex @code{target("xsaves")} function attribute, x86 @item xsaves @itemx no-xsaves -@cindex @code{target("xsaves")} function attribute, x86 Enable/disable the generation of the XSAVES instructions. +@cindex @code{target("amx-tile")} function attribute, x86 @item amx-tile @itemx no-amx-tile -@cindex @code{target("amx-tile")} function attribute, x86 Enable/disable the generation of the AMX-TILE instructions. +@cindex @code{target("amx-int8")} function attribute, x86 @item amx-int8 @itemx no-amx-int8 -@cindex @code{target("amx-int8")} function attribute, x86 Enable/disable the generation of the AMX-INT8 instructions. +@cindex @code{target("amx-bf16")} function attribute, x86 @item amx-bf16 @itemx no-amx-bf16 -@cindex @code{target("amx-bf16")} function attribute, x86 Enable/disable the generation of the AMX-BF16 instructions. +@cindex @code{target("uintr")} function attribute, x86 @item uintr @itemx no-uintr -@cindex @code{target("uintr")} function attribute, x86 Enable/disable the generation of the UINTR instructions. +@cindex @code{target("hreset")} function attribute, x86 @item hreset @itemx no-hreset -@cindex @code{target("hreset")} function attribute, x86 Enable/disable the generation of the HRESET instruction. +@cindex @code{target("kl")} function attribute, x86 @item kl @itemx no-kl -@cindex @code{target("kl")} function attribute, x86 Enable/disable the generation of the KEYLOCKER instructions. +@cindex @code{target("widekl")} function attribute, x86 @item widekl @itemx no-widekl -@cindex @code{target("widekl")} function attribute, x86 Enable/disable the generation of the WIDEKL instructions. +@cindex @code{target("avxvnni")} function attribute, x86 @item avxvnni @itemx no-avxvnni -@cindex @code{target("avxvnni")} function attribute, x86 Enable/disable the generation of the AVXVNNI instructions. +@cindex @code{target("avxifma")} function attribute, x86 @item avxifma @itemx no-avxifma -@cindex @code{target("avxifma")} function attribute, x86 Enable/disable the generation of the AVXIFMA instructions. +@cindex @code{target("avxvnniint8")} function attribute, x86 @item avxvnniint8 @itemx no-avxvnniint8 -@cindex @code{target("avxvnniint8")} function attribute, x86 Enable/disable the generation of the AVXVNNIINT8 instructions. +@cindex @code{target("avxneconvert")} function attribute, x86 @item avxneconvert @itemx no-avxneconvert -@cindex @code{target("avxneconvert")} function attribute, x86 Enable/disable the generation of the AVXNECONVERT instructions. +@cindex @code{target("cmpccxadd")} function attribute, x86 @item cmpccxadd @itemx no-cmpccxadd -@cindex @code{target("cmpccxadd")} function attribute, x86 Enable/disable the generation of the CMPccXADD instructions. +@cindex @code{target("amx-fp16")} function attribute, x86 @item amx-fp16 @itemx no-amx-fp16 -@cindex @code{target("amx-fp16")} function attribute, x86 Enable/disable the generation of the AMX-FP16 instructions. +@cindex @code{target("prefetchi")} function attribute, x86 @item prefetchi @itemx no-prefetchi -@cindex @code{target("prefetchi")} function attribute, x86 Enable/disable the generation of the PREFETCHI instructions. +@cindex @code{target("raoint")} function attribute, x86 @item raoint @itemx no-raoint -@cindex @code{target("raoint")} function attribute, x86 Enable/disable the generation of the RAOINT instructions. +@cindex @code{target("cld")} function attribute, x86 @item cld @itemx no-cld -@cindex @code{target("cld")} function attribute, x86 Enable/disable the generation of the CLD before string moves. +@cindex @code{target("fancy-math-387")} function attribute, x86 @item fancy-math-387 @itemx no-fancy-math-387 -@cindex @code{target("fancy-math-387")} function attribute, x86 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 @item ieee-fp @itemx no-ieee-fp -@cindex @code{target("ieee-fp")} function attribute, x86 Enable/disable the generation of floating point that depends on IEEE arithmetic. +@cindex @code{target("inline-all-stringops")} function attribute, x86 @item inline-all-stringops @itemx no-inline-all-stringops -@cindex @code{target("inline-all-stringops")} function attribute, x86 Enable/disable inlining of string operations. +@cindex @code{target("inline-stringops-dynamically")} function attribute, x86 @item inline-stringops-dynamically @itemx no-inline-stringops-dynamically -@cindex @code{target("inline-stringops-dynamically")} function attribute, x86 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 @item align-stringops @itemx no-align-stringops -@cindex @code{target("align-stringops")} function attribute, x86 Do/do not align destination of inlined string operations. +@cindex @code{target("recip")} function attribute, x86 @item recip @itemx no-recip -@cindex @code{target("recip")} function attribute, x86 Enable/disable the generation of RCPSS, RCPPS, RSQRTSS and RSQRTPS instructions followed an additional Newton-Raphson step instead of doing a floating-point division. -@item general-regs-only @cindex @code{target("general-regs-only")} function attribute, x86 +@item general-regs-only Generate code which uses only the general registers. -@item arch=@var{ARCH} @cindex @code{target("arch=@var{ARCH}")} function attribute, x86 +@item arch=@var{ARCH} Specify the architecture to generate code for in compiling the function. -@item tune=@var{TUNE} @cindex @code{target("tune=@var{TUNE}")} function attribute, x86 +@item tune=@var{TUNE} Specify the architecture to tune for in compiling the function. -@item fpmath=@var{FPMATH} @cindex @code{target("fpmath=@var{FPMATH}")} function attribute, 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. -@item prefer-vector-width=@var{OPT} @cindex @code{prefer-vector-width} function attribute, 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 instead of the default on the selected platform. @@ -7142,8 +7142,8 @@ a function declared with @code{target("sse3")} can inline a function with @code{target("sse2")}, since @code{-msse3} implies @code{-msse2}. @end table -@item indirect_branch("@var{choice}") @cindex @code{indirect_branch} function attribute, x86 +@item indirect_branch("@var{choice}") On x86 targets, the @code{indirect_branch} attribute causes the compiler to convert indirect call and jump with @var{choice}. @samp{keep} keeps indirect call and jump unmodified. @samp{thunk} converts indirect @@ -7152,8 +7152,8 @@ indirect call and jump to inlined call and return thunk. @samp{thunk-extern} converts indirect call and jump to external call and return thunk provided in a separate object file. -@item function_return("@var{choice}") @cindex @code{function_return} function attribute, x86 +@item function_return("@var{choice}") On x86 targets, the @code{function_return} attribute causes the compiler to convert function return with @var{choice}. @samp{keep} keeps function return unmodified. @samp{thunk} converts function return to call and @@ -7161,8 +7161,8 @@ return thunk. @samp{thunk-inline} converts function return to inlined call and return thunk. @samp{thunk-extern} converts function return to external call and return thunk provided in a separate object file. -@item nocf_check @cindex @code{nocf_check} function attribute +@item nocf_check The @code{nocf_check} attribute on a function is used to inform the compiler that the function's prologue should not be instrumented when compiled with the @option{-fcf-protection=branch} option. The @@ -7218,36 +7218,36 @@ foo (void) @} @end smallexample -@item cf_check @cindex @code{cf_check} function attribute, x86 +@item cf_check The @code{cf_check} attribute on a function is used to inform the compiler that ENDBR instruction should be placed at the function entry when @option{-fcf-protection=branch} is enabled. -@item indirect_return @cindex @code{indirect_return} function attribute, x86 +@item indirect_return The @code{indirect_return} attribute can be applied to a function, as well as variable or type of function pointer to inform the compiler that the function may return via indirect branch. -@item fentry_name("@var{name}") @cindex @code{fentry_name} function attribute, x86 +@item fentry_name("@var{name}") On x86 targets, the @code{fentry_name} attribute sets the function to call on function entry when function instrumentation is enabled with @option{-pg -mfentry}. When @var{name} is nop then a 5 byte nop sequence is generated. -@item fentry_section("@var{name}") @cindex @code{fentry_section} function attribute, x86 +@item fentry_section("@var{name}") On x86 targets, the @code{fentry_section} attribute sets the name of the section to record function entry instrumentation calls in when enabled with @option{-pg -mrecord-mcount} -@item nodirect_extern_access @cindex @code{nodirect_extern_access} function attribute @opindex mno-direct-extern-access +@item nodirect_extern_access This attribute, attached to a global variable or function, is the counterpart to option @option{-mno-direct-extern-access}. @@ -7259,8 +7259,8 @@ counterpart to option @option{-mno-direct-extern-access}. These function attributes are supported by the Xstormy16 back end: @table @code -@item interrupt @cindex @code{interrupt} function attribute, Xstormy16 +@item interrupt Use this attribute to indicate that the specified function is an interrupt handler. The compiler generates function entry and exit sequences suitable for use in an interrupt handler @@ -7313,8 +7313,8 @@ The following attributes are supported on most targets. @table @code -@item alias ("@var{target}") @cindex @code{alias} variable attribute +@item alias ("@var{target}") The @code{alias} variable attribute causes the declaration to be emitted as an alias for another symbol known as an @dfn{alias target}. Except for top-level qualifiers the alias target must have the same type as @@ -7479,9 +7479,9 @@ When both the attribute and the option present at the same time, the level of the strictness for the specific trailing array field is determined by the attribute. +@cindex @code{alloc_size} variable attribute @item alloc_size (@var{position}) @itemx alloc_size (@var{position-1}, @var{position-2}) -@cindex @code{alloc_size} variable attribute The @code{alloc_size} variable attribute may be applied to the declaration of a pointer to a function that returns a pointer and takes at least one argument of an integer type. It indicates that the returned pointer points @@ -7507,8 +7507,8 @@ is given by the product of arguments 1 and 2, and similarly, that @code{malloc_ptr}, like the standard C function @code{malloc}, returns an object whose size is given by argument 1 to the function. -@item cleanup (@var{cleanup_function}) @cindex @code{cleanup} variable attribute +@item cleanup (@var{cleanup_function}) The @code{cleanup} attribute runs a function when the variable goes out of scope. This attribute can only be applied to auto function scope variables; it may not be applied to parameters or variables @@ -7523,12 +7523,12 @@ does not allow the exception to be caught, only to perform an action. It is undefined what happens if @var{cleanup_function} does not return normally. -@item common -@itemx nocommon @cindex @code{common} variable attribute @cindex @code{nocommon} variable attribute @opindex fcommon @opindex fno-common +@item common +@itemx nocommon The @code{common} attribute requests GCC to place a variable in ``common'' storage. The @code{nocommon} attribute requests the opposite---to allocate space for it directly. @@ -7536,9 +7536,9 @@ opposite---to allocate space for it directly. These attributes override the default chosen by the @option{-fno-common} and @option{-fcommon} flags respectively. +@cindex @code{copy} variable attribute @item copy @itemx copy (@var{variable}) -@cindex @code{copy} variable attribute The @code{copy} attribute applies the set of attributes with which @var{variable} has been declared to the declaration of the variable to which the attribute is applied. The attribute is designed for @@ -7553,9 +7553,9 @@ but not attributes that affect a symbol's linkage or visibility such as attribute is also not copied. @xref{Common Function Attributes}. @xref{Common Type Attributes}. +@cindex @code{deprecated} variable attribute @item deprecated @itemx deprecated (@var{msg}) -@cindex @code{deprecated} variable attribute The @code{deprecated} attribute results in a warning if the variable is used anywhere in the source file. This is useful when identifying variables that are expected to be removed in a future version of a @@ -7582,9 +7582,9 @@ types (@pxref{Common Function Attributes}, The message attached to the attribute is affected by the setting of the @option{-fmessage-length} option. +@cindex @code{unavailable} variable attribute @item unavailable @itemx unavailable (@var{msg}) -@cindex @code{unavailable} variable attribute The @code{unavailable} attribute indicates that the variable so marked is not available, if it is used anywhere in the source file. It behaves in the same manner as the @code{deprecated} attribute except that the @@ -7598,8 +7598,8 @@ The @code{unavailable} attribute can also be used for functions and types (@pxref{Common Function Attributes}, @pxref{Common Type Attributes}). -@item mode (@var{mode}) @cindex @code{mode} variable attribute +@item mode (@var{mode}) This attribute specifies the data type for the declaration---whichever type corresponds to the mode @var{mode}. This in effect lets you request an integer or floating-point type according to its width. @@ -7611,8 +7611,8 @@ indicate the mode corresponding to a one-byte integer, @code{word} or @code{__word__} for the mode of a one-word integer, and @code{pointer} or @code{__pointer__} for the mode used to represent pointers. -@item nonstring @cindex @code{nonstring} variable attribute +@item nonstring The @code{nonstring} variable attribute specifies that an object or member declaration with type array of @code{char}, @code{signed char}, or @code{unsigned char}, or pointer to such a type is intended to store @@ -7646,8 +7646,8 @@ int f (struct Data *pd, const char *s) @} @end smallexample -@item packed @cindex @code{packed} variable attribute +@item packed The @code{packed} attribute specifies that a structure member should have the smallest possible alignment---one bit for a bit-field and one byte otherwise, unless a larger value is specified with the @code{aligned} @@ -7670,8 +7670,8 @@ been fixed in GCC 4.4 but the change can lead to differences in the structure layout. See the documentation of @option{-Wpacked-bitfield-compat} for more information. -@item section ("@var{section-name}") @cindex @code{section} variable attribute +@item section ("@var{section-name}") Normally, the compiler places the objects it generates in sections like @code{data} and @code{bss}. Sometimes, however, you need additional sections, or you need certain particular variables to appear in special sections, @@ -7719,8 +7719,8 @@ attribute is not available on all platforms. If you need to map the entire contents of a module to a particular section, consider using the facilities of the linker instead. -@item tls_model ("@var{tls_model}") @cindex @code{tls_model} variable attribute +@item tls_model ("@var{tls_model}") The @code{tls_model} attribute sets thread-local storage model (@pxref{Thread-Local}) of a particular @code{__thread} variable, overriding @option{-ftls-model=} command-line switch on a per-variable @@ -7730,14 +7730,14 @@ The @var{tls_model} argument should be one of @code{global-dynamic}, Not all targets support this attribute. -@item unused @cindex @code{unused} variable attribute +@item unused This attribute, attached to a variable or structure field, means that the variable or field is meant to be possibly unused. GCC does not produce a warning for this variable or field. -@item used @cindex @code{used} variable attribute +@item used This attribute, attached to a variable with static storage, means that the variable must be emitted even if it appears that the variable is not referenced. @@ -7746,8 +7746,8 @@ When applied to a static data member of a C++ class template, the attribute also means that the member is instantiated if the class itself is instantiated. -@item retain @cindex @code{retain} variable attribute +@item retain For ELF targets that support the GNU or FreeBSD OSABIs, this attribute will save the variable from linker garbage collection. To support this behavior, variables that have not been placed in specific sections @@ -7756,8 +7756,8 @@ will be placed in new, unique sections. This additional functionality requires Binutils version 2.36 or later. -@item uninitialized @cindex @code{uninitialized} variable attribute +@item uninitialized This attribute, attached to a variable with automatic storage, means that the variable should not be automatically initialized by the compiler when the option @code{-ftrivial-auto-var-init} presents. @@ -7772,8 +7772,8 @@ overhead. This attribute has no effect when the option @code{-ftrivial-auto-var-init} does not present. -@item vector_size (@var{bytes}) @cindex @code{vector_size} variable attribute +@item vector_size (@var{bytes}) This attribute specifies the vector size for the type of the declared variable, measured in bytes. The type to which it applies is known as the @dfn{base type}. The @var{bytes} argument must be a positive @@ -7806,19 +7806,19 @@ struct S __attribute__ ((vector_size (16))) foo; is invalid even if the size of the structure is the same as the size of the @code{int}. -@item visibility ("@var{visibility_type}") @cindex @code{visibility} variable attribute +@item visibility ("@var{visibility_type}") This attribute affects the linkage of the declaration to which it is attached. The @code{visibility} attribute is described in @ref{Common Function Attributes}. -@item weak @cindex @code{weak} variable attribute +@item weak The @code{weak} attribute is described in @ref{Common Function Attributes}. -@item noinit @cindex @code{noinit} variable attribute +@item noinit Any data with the @code{noinit} attribute will not be initialized by the C runtime startup code, or the program loader. Not initializing data in this way can reduce program startup times. @@ -7827,8 +7827,8 @@ This attribute is specific to ELF targets and relies on the linker script to place sections with the @code{.noinit} prefix in the right location. -@item persistent @cindex @code{persistent} variable attribute +@item persistent Any data with the @code{persistent} attribute will not be initialized by the C runtime startup code, but will be initialized by the program loader. This enables the value of the variable to @samp{persist} @@ -7839,8 +7839,8 @@ script to place the sections with the @code{.persistent} prefix in the right location. Specifically, some type of non-volatile, writeable memory is required. -@item objc_nullability (@var{nullability kind}) @r{(Objective-C and Objective-C++ only)} @cindex @code{objc_nullability} variable attribute +@item objc_nullability (@var{nullability kind}) @r{(Objective-C and Objective-C++ only)} This attribute applies to pointer variables only. It allows marking the pointer with one of four possible values describing the conditions under which the pointer might have a @code{nil} value. In most cases, the @@ -7871,8 +7871,8 @@ getter will never validly return @code{nil}. @subsection ARC Variable Attributes @table @code -@item aux @cindex @code{aux} variable attribute, ARC +@item aux The @code{aux} attribute is used to directly access the ARC's auxiliary register space from C. The auxilirary register number is given via attribute argument. @@ -7883,8 +7883,8 @@ given via attribute argument. @subsection AVR Variable Attributes @table @code -@item progmem @cindex @code{progmem} variable attribute, AVR +@item progmem The @code{progmem} attribute is used on the AVR to place read-only data in the non-volatile program memory (flash). The @code{progmem} attribute accomplishes this by putting respective variables into a @@ -7957,9 +7957,9 @@ at all. @end table +@cindex @code{io} variable attribute, AVR @item io @itemx io (@var{addr}) -@cindex @code{io} variable attribute, AVR Variables with the @code{io} attribute are used to address memory-mapped peripherals in the io address range. If an address is specified, the variable @@ -7982,17 +7982,17 @@ Example: extern volatile int porta __attribute__((io)); @end smallexample +@cindex @code{io_low} variable attribute, AVR @item io_low @itemx io_low (@var{addr}) -@cindex @code{io_low} variable attribute, AVR This is like the @code{io} attribute, but additionally it informs the compiler that the object lies in the lower half of the I/O area, allowing the use of @code{cbi}, @code{sbi}, @code{sbic} and @code{sbis} instructions. +@cindex @code{address} variable attribute, AVR @item address @itemx address (@var{addr}) -@cindex @code{address} variable attribute, AVR Variables with the @code{address} attribute are used to address memory-mapped peripherals that may lie outside the io address range. @@ -8000,8 +8000,8 @@ memory-mapped peripherals that may lie outside the io address range. volatile int porta __attribute__((address (0x600))); @end smallexample -@item absdata @cindex @code{absdata} variable attribute, AVR +@item absdata Variables in static storage and with the @code{absdata} attribute can be accessed by the @code{LDS} and @code{STS} instructions which take absolute addresses. @@ -8037,20 +8037,20 @@ See also the @option{-mabsdata} @ref{AVR Options,command-line option}. Three attributes are currently defined for the Blackfin. @table @code -@item l1_data -@itemx l1_data_A -@itemx l1_data_B @cindex @code{l1_data} variable attribute, Blackfin @cindex @code{l1_data_A} variable attribute, Blackfin @cindex @code{l1_data_B} variable attribute, Blackfin +@item l1_data +@itemx l1_data_A +@itemx l1_data_B Use these attributes on the Blackfin to place the variable into L1 Data SRAM. Variables with @code{l1_data} attribute are put into the specific section named @code{.l1.data}. Those with @code{l1_data_A} attribute are put into the specific section named @code{.l1.data.A}. Those with @code{l1_data_B} attribute are put into the specific section named @code{.l1.data.B}. -@item l2 @cindex @code{l2} variable attribute, Blackfin +@item l2 Use this attribute on the Blackfin to place the variable into L2 SRAM. Variables with @code{l2} attribute are put into the specific section named @code{.l2.data}. @@ -8062,9 +8062,9 @@ named @code{.l2.data}. These variable attributes are available for H8/300 targets: @table @code -@item eightbit_data @cindex @code{eightbit_data} variable attribute, H8/300 @cindex eight-bit data on the H8/300, H8/300H, and H8S +@item eightbit_data Use this attribute on the H8/300, H8/300H, and H8S to indicate that the specified variable should be placed into the eight-bit data section. The compiler generates more efficient code for certain operations @@ -8074,9 +8074,9 @@ on data in the eight-bit data area. Note the eight-bit data area is limited to You must use GAS and GLD from GNU binutils version 2.7 or later for this attribute to work correctly. -@item tiny_data @cindex @code{tiny_data} variable attribute, H8/300 @cindex tiny data section on the H8/300H and H8S +@item tiny_data Use this attribute on the H8/300H and H8S to indicate that the specified variable should be placed into the tiny data section. The compiler generates more efficient code for loads and stores @@ -8091,8 +8091,8 @@ slightly under 32KB of data. The IA-64 back end supports the following variable attribute: @table @code -@item model (@var{model-name}) @cindex @code{model} variable attribute, IA-64 +@item model (@var{model-name}) On IA-64, use this attribute to set the addressability of an object. At present, the only supported identifier for @var{model-name} is @@ -8110,8 +8110,8 @@ defined by shared libraries. One attribute is currently defined for the LoongArch. @table @code -@item model("@var{name}") @cindex @code{model} variable attribute, LoongArch +@item model("@var{name}") Use this attribute on the LoongArch to use a different code model for addressing this variable, than the code model specified by the global @option{-mcmodel} option. This attribute is mostly useful if a @@ -8126,9 +8126,9 @@ specially. Currently the only supported values of @var{name} are One attribute is currently defined for the M32R/D@. @table @code -@item model (@var{model-name}) @cindex @code{model-name} variable attribute, M32R/D @cindex variable addressability on the M32R/D +@item model (@var{model-name}) Use this attribute on the M32R/D to set the addressability of an object. The identifier @var{model-name} is one of @code{small}, @code{medium}, or @code{large}, representing each of the code models. @@ -8149,15 +8149,15 @@ You can use these attributes on Microsoft Windows targets. attributes available on all x86 targets. @table @code -@item dllimport -@itemx dllexport @cindex @code{dllimport} variable attribute @cindex @code{dllexport} variable attribute +@item dllimport +@itemx dllexport The @code{dllimport} and @code{dllexport} attributes are described in @ref{Microsoft Windows Function Attributes}. -@item selectany @cindex @code{selectany} variable attribute +@item selectany The @code{selectany} attribute causes an initialized global variable to have link-once semantics. When multiple definitions of the variable are encountered by the linker, the first is selected and the remainder are @@ -8177,8 +8177,8 @@ targets. You can use @code{__declspec (selectany)} as a synonym for @code{__attribute__ ((selectany))} for compatibility with other compilers. -@item shared @cindex @code{shared} variable attribute +@item shared On Microsoft Windows, in addition to putting variable definitions in a named section, the section can also be shared among all running copies of an executable or DLL@. For example, this small program defines shared data @@ -8210,15 +8210,15 @@ The @code{shared} attribute is only available on Microsoft Windows@. @subsection MSP430 Variable Attributes @table @code -@item upper -@itemx either @cindex @code{upper} variable attribute, MSP430 @cindex @code{either} variable attribute, MSP430 +@item upper +@itemx either These attributes are the same as the MSP430 function attributes of the same name (@pxref{MSP430 Function Attributes}). -@item lower @cindex @code{lower} variable attribute, MSP430 +@item lower This option behaves mostly the same as the MSP430 function attribute of the same name (@pxref{MSP430 Function Attributes}), but it has some additional functionality. @@ -8242,8 +8242,8 @@ will be used, and the @code{.lower} prefix will not be added. These variable attributes are supported by the Nvidia PTX back end: @table @code -@item shared @cindex @code{shared} attribute, Nvidia PTX +@item shared Use this attribute to place a variable in the @code{.shared} memory space. This memory space is private to each cooperative thread array; only threads within one thread block refer to the same instance of the variable. @@ -8280,18 +8280,18 @@ These variable attributes are supported by the V850 back end: @table @code -@item sda @cindex @code{sda} variable attribute, V850 +@item sda Use this attribute to explicitly place a variable in the small data area, which can hold up to 64 kilobytes. -@item tda @cindex @code{tda} variable attribute, V850 +@item tda Use this attribute to explicitly place a variable in the tiny data area, which can hold up to 256 bytes in total. -@item zda @cindex @code{zda} variable attribute, V850 +@item zda Use this attribute to explicitly place a variable in the first 32 kilobytes of memory. @end table @@ -8303,10 +8303,10 @@ Two attributes are currently defined for x86 configurations: @code{ms_struct} and @code{gcc_struct}. @table @code -@item ms_struct -@itemx gcc_struct @cindex @code{ms_struct} variable attribute, x86 @cindex @code{gcc_struct} variable attribute, x86 +@item ms_struct +@itemx gcc_struct If @code{packed} is used on a structure, or if bit-fields are used, it may be that the Microsoft ABI lays out the structure differently @@ -8331,8 +8331,8 @@ One attribute is currently defined for xstormy16 configurations: @code{below100}. @table @code -@item below100 @cindex @code{below100} variable attribute, Xstormy16 +@item below100 If a variable has the @code{below100} attribute (@code{BELOW100} is allowed also), GCC places the variable in the first 0x100 bytes of @@ -8527,9 +8527,9 @@ struct __attribute__ ((aligned (8))) foo This warning can be disabled by @option{-Wno-if-not-aligned}. +@cindex @code{alloc_size} type attribute @item alloc_size (@var{position}) @itemx alloc_size (@var{position-1}, @var{position-2}) -@cindex @code{alloc_size} type attribute The @code{alloc_size} type attribute may be applied to the definition of a type of a function that returns a pointer and takes at least one argument of an integer type. It indicates that the returned pointer @@ -8555,9 +8555,9 @@ is given by the product of arguments 1 and 2, and that @code{malloc_type}, like the standard C function @code{malloc}, returns an object whose size is given by argument 1 to the function. +@cindex @code{copy} type attribute @item copy @itemx copy (@var{expression}) -@cindex @code{copy} type attribute The @code{copy} attribute applies the set of attributes with which the type of the @var{expression} has been declared to the declaration of the type to which the attribute is applied. The attribute is @@ -8587,9 +8587,9 @@ A @{ /* @r{@dots{}} */ @}; struct __attribute__ ((copy ( (struct A *)0)) B @{ /* @r{@dots{}} */ @}; @end smallexample +@cindex @code{deprecated} type attribute @item deprecated @itemx deprecated (@var{msg}) -@cindex @code{deprecated} type attribute The @code{deprecated} attribute results in a warning if the type is used anywhere in the source file. This is useful when identifying types that are expected to be removed in a future version of a program. @@ -8625,9 +8625,9 @@ variables (@pxref{Function Attributes}, @pxref{Variable Attributes}.) The message attached to the attribute is affected by the setting of the @option{-fmessage-length} option. +@cindex @code{unavailable} type attribute @item unavailable @itemx unavailable (@var{msg}) -@cindex @code{unavailable} type attribute The @code{unavailable} attribute behaves in the same manner as the @code{deprecated} one, but emits an error rather than a warning. It is used to indicate that a (perhaps previously @code{deprecated}) type is @@ -8636,8 +8636,8 @@ no longer usable. The @code{unavailable} attribute can also be used for functions and variables (@pxref{Function Attributes}, @pxref{Variable Attributes}.) -@item designated_init @cindex @code{designated_init} type attribute +@item designated_init This attribute may only be applied to structure types. It indicates that any initialization of an object of this type must use designated initializers rather than positional initializers. The intent of this @@ -8648,8 +8648,8 @@ initialization will result in future breakage. GCC emits warnings based on this attribute by default; use @option{-Wno-designated-init} to suppress them. -@item may_alias @cindex @code{may_alias} type attribute +@item may_alias Accesses through pointers to types with this attribute are not subject to type-based alias analysis, but are instead assumed to be able to alias any other type of objects. @@ -8689,8 +8689,8 @@ declaration, the above program would abort when compiled with @option{-fstrict-aliasing}, which is on by default at @option{-O2} or above. -@item mode (@var{mode}) @cindex @code{mode} type attribute +@item mode (@var{mode}) This attribute specifies the data type for the declaration---whichever type corresponds to the mode @var{mode}. This in effect lets you request an integer or floating-point type according to its width. @@ -8702,8 +8702,8 @@ indicate the mode corresponding to a one-byte integer, @code{word} or @code{__word__} for the mode of a one-word integer, and @code{pointer} or @code{__pointer__} for the mode used to represent pointers. -@item packed @cindex @code{packed} type attribute +@item packed This attribute, attached to a @code{struct}, @code{union}, or C++ @code{class} type definition, specifies that each of its members (other than zero-width bit-fields) is placed to minimize the memory required. This is equivalent @@ -8741,8 +8741,8 @@ of an @code{enum}, @code{struct}, @code{union}, or @code{class}, not on a @code{typedef} that does not also define the enumerated type, structure, union, or class. -@item scalar_storage_order ("@var{endianness}") @cindex @code{scalar_storage_order} type attribute +@item scalar_storage_order ("@var{endianness}") When attached to a @code{union} or a @code{struct}, this attribute sets the storage order, aka endianness, of the scalar fields of the type, as well as the array fields whose component is scalar. The supported @@ -8785,8 +8785,8 @@ is not supported; that is to say, if a given scalar object can be accessed through distinct types that assign a different storage order to it, then the behavior is undefined. -@item transparent_union @cindex @code{transparent_union} type attribute +@item transparent_union This attribute, attached to a @code{union} type definition, indicates that any function parameter having that union type causes calls to that @@ -8847,8 +8847,8 @@ pid_t wait (wait_status_ptr_t p) @} @end smallexample -@item unused @cindex @code{unused} type attribute +@item unused When attached to a type (including a @code{union} or a @code{struct}), this attribute means that variables of that type are meant to appear possibly unused. GCC does not produce a warning for any variables of @@ -8857,8 +8857,8 @@ the case with lock or thread classes, which are usually defined and then not referenced, but contain constructors and destructors that have nontrivial bookkeeping functions. -@item vector_size (@var{bytes}) @cindex @code{vector_size} type attribute +@item vector_size (@var{bytes}) This attribute specifies the vector size for the type, measured in bytes. The type to which it applies is known as the @dfn{base type}. The @var{bytes} argument must be a positive power-of-two multiple of the base type size. For @@ -8890,8 +8890,8 @@ __attribute__ ((vector_size (16))) float get_flt_vec16 (void); declares @code{get_flt_vec16} to be a function returning a 16-byte vector with the base type @code{float}. -@item visibility @cindex @code{visibility} type attribute +@item visibility In C++, attribute visibility (@pxref{Function Attributes}) can also be applied to class, struct, union and enum types. Unlike other type attributes, the attribute must appear between the initial keyword and @@ -8904,8 +8904,8 @@ and caught in another, the class must have default visibility. Otherwise the two shared objects are unable to use the same typeinfo node and exception handling will break. -@item objc_root_class @r{(Objective-C and Objective-C++ only)} @cindex @code{objc_root_class} type attribute +@item objc_root_class @r{(Objective-C and Objective-C++ only)} This attribute marks a class as being a root class, and thus allows the compiler to elide any warnings about a missing superclass and to make additional checks for mandatory methods as needed. @@ -8998,10 +8998,10 @@ Two attributes are currently defined for x86 configurations: @table @code -@item ms_struct -@itemx gcc_struct @cindex @code{ms_struct} type attribute, x86 @cindex @code{gcc_struct} type attribute, x86 +@item ms_struct +@itemx gcc_struct If @code{packed} is used on a structure, or if bit-fields are used it may be that the Microsoft ABI packs them differently @@ -9051,23 +9051,23 @@ NoError: @end smallexample @table @code -@item unused @cindex @code{unused} label attribute +@item unused This feature is intended for program-generated code that may contain unused labels, but which is compiled with @option{-Wall}. It is not normally appropriate to use in it human-written code, though it could be useful in cases where the code that jumps to the label is contained within an @code{#ifdef} conditional. -@item hot @cindex @code{hot} label attribute +@item hot The @code{hot} attribute on a label is used to inform the compiler that the path following the label is more likely than paths that are not so annotated. This attribute is used in cases where @code{__builtin_expect} cannot be used, for instance with computed goto or @code{asm goto}. -@item cold @cindex @code{cold} label attribute +@item cold The @code{cold} attribute on labels is used to inform the compiler that the path following the label is unlikely to be executed. This attribute is used in cases where @code{__builtin_expect} cannot be used, for instance @@ -9102,8 +9102,8 @@ fn (void) @end smallexample @table @code -@item deprecated @cindex @code{deprecated} enumerator attribute +@item deprecated The @code{deprecated} attribute results in a warning if the enumerator is used anywhere in the source file. This is useful when identifying enumerators that are expected to be removed in a future version of a @@ -9112,8 +9112,8 @@ of the deprecated enumerator, to enable users to easily find further information about why the enumerator is deprecated, or what they should do instead. Note that the warnings only occurs for uses. -@item unavailable @cindex @code{unavailable} enumerator attribute +@item unavailable The @code{unavailable} attribute results in an error if the enumerator is used anywhere in the source file. In other respects it behaves in the same manner as the @code{deprecated} attribute. @@ -9131,8 +9131,8 @@ available for functions (@pxref{Function Attributes}), variables (@pxref{Enumerator Attributes}), and for types (@pxref{Type Attributes}). @table @code -@item fallthrough @cindex @code{fallthrough} statement attribute +@item fallthrough The @code{fallthrough} attribute with a null statement serves as a fallthrough statement. It hints to the compiler that a statement that falls through to another case label, or user-defined label @@ -9158,8 +9158,8 @@ switch (cond) @} @end smallexample -@item assume @cindex @code{assume} statement attribute +@item assume The @code{assume} attribute with a null statement serves as portable assumption. It should have a single argument, a conditional expression, which is not evaluated. If the argument would evaluate to true @@ -23811,8 +23811,8 @@ directives for declaring symbols to be weak, and defining weak aliases. @table @code -@item #pragma weak @var{symbol} @cindex pragma, weak +@item #pragma weak @var{symbol} This pragma declares @var{symbol} to be weak, as if the declaration had the attribute of the same name. The pragma may appear before or after the declaration of @var{symbol}. It is not an error for diff --git a/gcc/doc/generic.texi b/gcc/doc/generic.texi index 3f52d3042b8..ad1270f9025 100644 --- a/gcc/doc/generic.texi +++ b/gcc/doc/generic.texi @@ -1743,9 +1743,9 @@ represented. Unrepresented fields will be cleared (zeroed), unless the CONSTRUCTOR_NO_CLEARING flag is set, in which case their value becomes undefined. -@item COMPOUND_LITERAL_EXPR @findex COMPOUND_LITERAL_EXPR_DECL_EXPR @findex COMPOUND_LITERAL_EXPR_DECL +@item COMPOUND_LITERAL_EXPR These nodes represent ISO C99 compound literals. The @code{COMPOUND_LITERAL_EXPR_DECL_EXPR} is a @code{DECL_EXPR} containing an anonymous @code{VAR_DECL} for diff --git a/gcc/doc/install.texi b/gcc/doc/install.texi index 8ef5c1414da..47ea9ea462b 100644 --- a/gcc/doc/install.texi +++ b/gcc/doc/install.texi @@ -2618,18 +2618,18 @@ script provides three variables for this: @table @code -@item build_configargs @cindex @code{build_configargs} +@item build_configargs The contents of this variable is passed to all build @command{configure} scripts. -@item host_configargs @cindex @code{host_configargs} +@item host_configargs The contents of this variable is passed to all host @command{configure} scripts. -@item target_configargs @cindex @code{target_configargs} +@item target_configargs The contents of this variable is passed to all target @command{configure} scripts. diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index 04ca9d9b02b..e1f897e8a84 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -2529,9 +2529,9 @@ ISO C2X. @opindex fno-builtin @opindex fbuiltin +@cindex built-in functions @item -fno-builtin @itemx -fno-builtin-@var{function} -@cindex built-in functions Don't recognize built-in functions that do not begin with @samp{__builtin_} as prefix. @xref{Other Builtins,,Other built-in functions provided by GCC}, for details of the functions affected, @@ -2575,8 +2575,8 @@ third arguments. The value of such an expression is void. This option is not supported for C++. @opindex ffreestanding -@item -ffreestanding @cindex hosted environment +@item -ffreestanding Assert that compilation targets a freestanding environment. This implies @option{-fno-builtin}. A freestanding environment @@ -2631,8 +2631,8 @@ in effect for @code{inline} functions. @xref{Common Predefined Macros,,,cpp,The C Preprocessor}. @opindex fhosted -@item -fhosted @cindex hosted environment +@item -fhosted Assert that compilation targets a hosted environment. This implies @option{-fbuiltin}. A hosted environment is one in which the @@ -2668,12 +2668,12 @@ Note that this option is off for all targets except for x86 targets using ms-abi. @opindex foffload -@item -foffload=disable -@itemx -foffload=default -@itemx -foffload=@var{target-list} @cindex Offloading targets @cindex OpenACC offloading targets @cindex OpenMP offloading targets +@item -foffload=disable +@itemx -foffload=default +@itemx -foffload=@var{target-list} Specify for which OpenMP and OpenACC offload targets code should be generated. The default behavior, equivalent to @option{-foffload=default}, is to generate code for all supported offload targets. The @option{-foffload=disable} form @@ -2686,11 +2686,11 @@ run the compiler with @option{-v} to show the list of configured offload targets under @code{OFFLOAD_TARGET_NAMES}. @opindex foffload-options -@item -foffload-options=@var{options} -@itemx -foffload-options=@var{target-triplet-list}=@var{options} @cindex Offloading options @cindex OpenACC offloading options @cindex OpenMP offloading options +@item -foffload-options=@var{options} +@itemx -foffload-options=@var{target-triplet-list}=@var{options} With @option{-foffload-options=@var{options}}, GCC passes the specified @var{options} to the compilers for all enabled offloading targets. You can @@ -2708,8 +2708,8 @@ Typical command lines are @end smallexample @opindex fopenacc -@item -fopenacc @cindex OpenACC accelerator programming +@item -fopenacc Enable handling of OpenACC directives @code{#pragma acc} in C/C++ and @code{!$acc} in Fortran. When @option{-fopenacc} is specified, the compiler generates accelerated code according to the OpenACC Application @@ -2718,16 +2718,16 @@ implies @option{-pthread}, and thus is only supported on targets that have support for @option{-pthread}. @opindex fopenacc-dim -@item -fopenacc-dim=@var{geom} @cindex OpenACC accelerator programming +@item -fopenacc-dim=@var{geom} Specify default compute dimensions for parallel offload regions that do not explicitly specify. The @var{geom} value is a triple of ':'-separated sizes, in order 'gang', 'worker' and, 'vector'. A size can be omitted, to use a target-specific default value. @opindex fopenmp -@item -fopenmp @cindex OpenMP parallel +@item -fopenmp Enable handling of OpenMP directives @code{#pragma omp} in C/C++, @code{[[omp::directive(...)]]} and @code{[[omp::sequence(...)]]} in C++ and @code{!$omp} in Fortran. When @option{-fopenmp} is specified, the @@ -2738,9 +2738,9 @@ have support for @option{-pthread}. @option{-fopenmp} implies @option{-fopenmp-simd}. @opindex fopenmp-simd -@item -fopenmp-simd @cindex OpenMP SIMD @cindex SIMD +@item -fopenmp-simd Enable handling of OpenMP's @code{simd}, @code{declare simd}, @code{declare reduction}, @code{assume}, @code{ordered}, @code{scan}, @code{loop} directives and combined or composite directives with @@ -2749,9 +2749,9 @@ Enable handling of OpenMP's @code{simd}, @code{declare simd}, and @code{!$omp} in Fortran. Other OpenMP directives are ignored. @opindex fopenmp-target-simd-clone +@cindex OpenMP target SIMD clone @item -fopenmp-target-simd-clone @item -fopenmp-target-simd-clone=@var{device-type} -@cindex OpenMP target SIMD clone In addition to generating SIMD clones for functions marked with the @code{declare simd} directive, GCC also generates clones for functions marked with the OpenMP @code{declare target} directive @@ -3353,14 +3353,14 @@ of a named module remain implicitly inline, regardless.) @item -fno-module-lazy Disable lazy module importing and module mapper creation. +@vindex CXX_MODULE_MAPPER @r{environment variable} +@opindex fmodule-mapper @item -fmodule-mapper=@r{[}@var{hostname}@r{]}:@var{port}@r{[}?@var{ident}@r{]} @itemx -fmodule-mapper=|@var{program}@r{[}?@var{ident}@r{]} @var{args...} @itemx -fmodule-mapper==@var{socket}@r{[}?@var{ident}@r{]} @itemx -fmodule-mapper=<>@r{[}@var{inout}@r{]}@r{[}?@var{ident}@r{]} @itemx -fmodule-mapper=<@var{in}>@var{out}@r{[}?@var{ident}@r{]} @itemx -fmodule-mapper=@var{file}@r{[}?@var{ident}@r{]} -@vindex CXX_MODULE_MAPPER @r{environment variable} -@opindex fmodule-mapper An oracle to query for module name to filename mappings. If unspecified the @env{CXX_MODULE_MAPPER} environment variable is used, and if that is unset, an in-process default is provided. @@ -4025,9 +4025,9 @@ Enabled by default with @option{-std=c++17}. @opindex Wreorder @opindex Wno-reorder -@item -Wreorder @r{(C++ and Objective-C++ only)} @cindex reordering, warning @cindex warning for reordering of member initializers +@item -Wreorder @r{(C++ and Objective-C++ only)} Warn when the order of member initializers given in the code does not match the order in which they must be executed. For instance: @@ -4256,10 +4256,10 @@ less vulnerable to unintended effects and much easier to search for. @opindex Woverloaded-virtual @opindex Wno-overloaded-virtual -@item -Woverloaded-virtual @r{(C++ and Objective-C++ only)} -@itemx -Woverloaded-virtual=@var{n} @cindex overloaded virtual function, warning @cindex warning for overloaded virtual function +@item -Woverloaded-virtual @r{(C++ and Objective-C++ only)} +@itemx -Woverloaded-virtual=@var{n} Warn when a function declaration hides virtual functions from a base class. For example, in: @@ -5067,10 +5067,10 @@ prefix) for physical lines that result from the process of breaking a message which is too long to fit on a single line. @opindex fdiagnostics-color -@item -fdiagnostics-color[=@var{WHEN}] -@itemx -fno-diagnostics-color @cindex highlight, color @vindex GCC_COLORS @r{environment variable} +@item -fdiagnostics-color[=@var{WHEN}] +@itemx -fno-diagnostics-color Use color in diagnostics. @var{WHEN} is @samp{never}, @samp{always}, or @samp{auto}. The default depends on how the compiler has been configured, it can be any of the above @var{WHEN} options or also @samp{never} @@ -5120,86 +5120,86 @@ Setting @env{GCC_COLORS} to the empty string disables colors. Supported capabilities are as follows. @table @code -@item error= @vindex error GCC_COLORS @r{capability} +@item error= SGR substring for error: markers. -@item warning= @vindex warning GCC_COLORS @r{capability} +@item warning= SGR substring for warning: markers. -@item note= @vindex note GCC_COLORS @r{capability} +@item note= SGR substring for note: markers. -@item path= @vindex path GCC_COLORS @r{capability} +@item path= SGR substring for colorizing paths of control-flow events as printed via @option{-fdiagnostics-path-format=}, such as the identifiers of individual events and lines indicating interprocedural calls and returns. -@item range1= @vindex range1 GCC_COLORS @r{capability} +@item range1= SGR substring for first additional range. -@item range2= @vindex range2 GCC_COLORS @r{capability} +@item range2= SGR substring for second additional range. -@item locus= @vindex locus GCC_COLORS @r{capability} +@item locus= SGR substring for location information, @samp{file:line} or @samp{file:line:column} etc. -@item quote= @vindex quote GCC_COLORS @r{capability} +@item quote= SGR substring for information printed within quotes. -@item fnname= @vindex fnname GCC_COLORS @r{capability} +@item fnname= SGR substring for names of C++ functions. -@item targs= @vindex targs GCC_COLORS @r{capability} +@item targs= SGR substring for C++ function template parameter bindings. -@item fixit-insert= @vindex fixit-insert GCC_COLORS @r{capability} +@item fixit-insert= SGR substring for fix-it hints suggesting text to be inserted or replaced. -@item fixit-delete= @vindex fixit-delete GCC_COLORS @r{capability} +@item fixit-delete= SGR substring for fix-it hints suggesting text to be deleted. -@item diff-filename= @vindex diff-filename GCC_COLORS @r{capability} +@item diff-filename= SGR substring for filename headers within generated patches. -@item diff-hunk= @vindex diff-hunk GCC_COLORS @r{capability} +@item diff-hunk= SGR substring for the starts of hunks within generated patches. -@item diff-delete= @vindex diff-delete GCC_COLORS @r{capability} +@item diff-delete= SGR substring for deleted lines within generated patches. -@item diff-insert= @vindex diff-insert GCC_COLORS @r{capability} +@item diff-insert= SGR substring for inserted lines within generated patches. -@item type-diff= @vindex type-diff GCC_COLORS @r{capability} +@item type-diff= SGR substring for highlighting mismatching types within template arguments in the C++ frontend. @end table @opindex fdiagnostics-urls -@item -fdiagnostics-urls[=@var{WHEN}] @cindex urls @vindex GCC_URLS @r{environment variable} @vindex TERM_URLS @r{environment variable} +@item -fdiagnostics-urls[=@var{WHEN}] Use escape sequences to embed URLs in diagnostics. For example, when @option{-fdiagnostics-show-option} emits text showing the command-line option controlling a diagnostic, embed a URL for documentation of that @@ -7564,10 +7564,10 @@ This warning is enabled by @option{-Wall} or @option{-Wextra}. @opindex Wunknown-pragmas @opindex Wno-unknown-pragmas -@item -Wunknown-pragmas @cindex warning for unknown pragmas @cindex unknown pragmas, warning @cindex pragmas, warning of unknown +@item -Wunknown-pragmas Warn when a @code{#pragma} directive is encountered that is not understood by GCC@. If this command-line option is used, warnings are even issued for unknown pragmas in system header files. This is not the case if @@ -8365,9 +8365,9 @@ obtaining infinities and NaNs. @opindex Wsystem-headers @opindex Wno-system-headers -@item -Wsystem-headers @cindex warnings from system headers @cindex system headers, warnings from +@item -Wsystem-headers Print warning messages for constructs found in system header files. Warnings from system headers are normally suppressed, on the assumption that they usually do not indicate real problems and would only make the @@ -8939,15 +8939,15 @@ When compiling C++, warn about the deprecated conversion from string literals to @code{char *}. This warning is enabled by default for C++ programs. -@item -Wclobbered @opindex Wclobbered @opindex Wno-clobbered +@item -Wclobbered Warn for variables that might be changed by @code{longjmp} or @code{vfork}. This warning is also enabled by @option{-Wextra}. -@item -Wno-complain-wrong-lang @opindex Wcomplain-wrong-lang @opindex Wno-complain-wrong-lang +@item -Wno-complain-wrong-lang By default, language front ends complain when a command-line option is valid, but not applicable to that front end. This may be disabled with @option{-Wno-complain-wrong-lang}, @@ -8964,9 +8964,9 @@ The latter front end diagnoses @samp{f951: Warning: command-line option '-fno-rtti' is valid for C++/D/ObjC++ but not for Fortran}, which may be disabled with @option{-Wno-complain-wrong-lang}. -@item -Wconversion @opindex Wconversion @opindex Wno-conversion +@item -Wconversion Warn for implicit conversions that may alter a value. This includes conversions between real and integer, like @code{abs (x)} when @code{x} is @code{double}; conversions between signed and unsigned, @@ -9155,10 +9155,10 @@ can be disabled with the @option{-Wno-jump-misses-init} option. @opindex Wsign-compare @opindex Wno-sign-compare -@item -Wsign-compare @cindex warning for comparison of signed and unsigned values @cindex comparison of signed and unsigned values, warning @cindex signed and unsigned values, comparison warning +@item -Wsign-compare Warn when a comparison between signed and unsigned values could produce an incorrect result when the signed value is converted to unsigned. In C++, this warning is also enabled by @option{-Wall}. In C, it is @@ -9586,10 +9586,10 @@ implementation-defined values, and should not be used in portable code. @opindex Wnormalized= @opindex Wnormalized @opindex Wno-normalized -@item -Wnormalized=@r{[}none@r{|}id@r{|}nfc@r{|}nfkc@r{]} @cindex NFC @cindex NFKC @cindex character set, input normalization +@item -Wnormalized=@r{[}none@r{|}id@r{|}nfc@r{|}nfkc@r{]} In ISO C and ISO C++, two identifiers are different if they are different sequences of characters. However, sometimes when characters outside the basic ASCII character set are used, you can have two @@ -9667,8 +9667,8 @@ Enabled by default. @opindex Wopenacc-parallelism @opindex Wno-openacc-parallelism -@item -Wopenacc-parallelism @cindex OpenACC accelerator programming +@item -Wopenacc-parallelism Warn about potentially suboptimal choices related to OpenACC parallelism. @opindex Wopenmp-simd @@ -11033,9 +11033,9 @@ and which aren't relevant to leak analysis. With @option{-fno-analyzer-state-purge} this purging of state can be suppressed, for debugging state-handling issues. -@item -fno-analyzer-suppress-followups @opindex fanalyzer-suppress-followups @opindex fno-analyzer-suppress-followups +@item -fno-analyzer-suppress-followups This option is intended for analyzer developers. By default the analyzer will stop exploring an execution path after @@ -16638,13 +16638,13 @@ program may yield backtraces with different addresses due to ASLR (Address Space Layout Randomization), it may be desirable to turn ASLR off. On Linux, this can be achieved with @samp{setarch `uname -m` -R ./prog}. -@item -fsanitize=kernel-address @opindex fsanitize=kernel-address +@item -fsanitize=kernel-address Enable AddressSanitizer for Linux kernel. See @uref{https://github.com/google/kernel-sanitizers} for more details. -@item -fsanitize=hwaddress @opindex fsanitize=hwaddress +@item -fsanitize=hwaddress Enable Hardware-assisted AddressSanitizer, which uses a hardware ability to ignore the top byte of a pointer to allow the detection of memory errors with a low memory overhead. @@ -17874,8 +17874,8 @@ option @option{-Xlinker -z -Xlinker defs}). Only a few systems support this option. @opindex T -@item -T @var{script} @cindex linker script +@item -T @var{script} Use @var{script} as the linker script. This option is supported by most systems using the GNU linker. On some targets, such as bare-board targets without an operating system, the @option{-T} option may be required @@ -18272,8 +18272,8 @@ Use it to conform to a non-default application binary interface. @opindex fcommon @opindex fno-common -@item -fcommon @cindex tentative definitions +@item -fcommon In C code, this option controls the placement of global variables defined without an initializer, known as @dfn{tentative definitions} in the C standard. Tentative definitions are distinct from declarations @@ -18413,9 +18413,9 @@ See also @option{-grecord-gcc-switches} for another way of storing compiler options into the object file. @opindex fpic -@item -fpic @cindex global offset table @cindex PIC +@item -fpic Generate position-independent code (PIC) suitable for use in a shared library, if supported for the target machine. Such code accesses all constant addresses through a global offset table (GOT)@. The dynamic @@ -25864,8 +25864,8 @@ Put small global and static data in the small data area, and generate special instructions to reference them. @opindex G -@item -G @var{num} @cindex smaller data references +@item -G @var{num} Put global and static objects less than or equal to @var{num} bytes into the small data or BSS sections instead of the normal data or BSS sections. The default value of @var{num} is 8. @@ -28125,8 +28125,8 @@ These are the options defined for the Altera Nios II processor. @table @gcctabopt @opindex G -@item -G @var{num} @cindex smaller data references +@item -G @var{num} Put global and static objects less than or equal to @var{num} bytes into the small data or BSS sections instead of the normal data or BSS sections. The default value of @var{num} is 8. @@ -30030,9 +30030,9 @@ end of the inline compare a call to @code{strcmp} or @code{strncmp} will take care of the rest of the comparison. The default is 64 bytes. @opindex G -@item -G @var{num} @cindex smaller data references (PowerPC) @cindex .sdata/.sdata2 references (PowerPC) +@item -G @var{num} On embedded PowerPC systems, put global and static items less than or equal to @var{num} bytes into the small data or BSS sections instead of the normal data or BSS section. By default, @var{num} is 8. The @@ -34389,18 +34389,18 @@ Issues a @var{command} to the spec file processor. The commands that can appear here are: @table @code -@item %include <@var{file}> @cindex @code{%include} +@item %include <@var{file}> Search for @var{file} and insert its text at the current point in the specs file. -@item %include_noerr <@var{file}> @cindex @code{%include_noerr} +@item %include_noerr <@var{file}> Just like @samp{%include}, but do not generate an error message if the include file cannot be found. -@item %rename @var{old_name} @var{new_name} @cindex @code{%rename} +@item %rename @var{old_name} @var{new_name} Rename the spec string @var{old_name} to @var{new_name}. @end table @@ -35078,6 +35078,15 @@ in turn take precedence over those specified by the configuration of GCC@. GNU Compiler Collection (GCC) Internals}. @table @env +@vindex LANG +@vindex LC_CTYPE +@c @vindex LC_COLLATE +@vindex LC_MESSAGES +@c @vindex LC_MONETARY +@c @vindex LC_NUMERIC +@c @vindex LC_TIME +@vindex LC_ALL +@cindex locale @item LANG @itemx LC_CTYPE @c @itemx LC_COLLATE @@ -35086,15 +35095,6 @@ GNU Compiler Collection (GCC) Internals}. @c @itemx LC_NUMERIC @c @itemx LC_TIME @itemx LC_ALL -@findex LANG -@findex LC_CTYPE -@c @findex LC_COLLATE -@findex LC_MESSAGES -@c @findex LC_MONETARY -@c @findex LC_NUMERIC -@c @findex LC_TIME -@findex LC_ALL -@cindex locale These environment variables control the way that GCC uses localization information which allows GCC to work with different national conventions. GCC inspects the locale categories @@ -35118,22 +35118,22 @@ and @env{LC_MESSAGES} default to the value of the @env{LANG} environment variable. If none of these variables are set, GCC defaults to traditional C English behavior. +@vindex TMPDIR @item TMPDIR -@findex TMPDIR If @env{TMPDIR} is set, it specifies the directory to use for temporary files. GCC uses temporary files to hold the output of one stage of compilation which is to be used as input to the next stage: for example, the output of the preprocessor, which is the input to the compiler proper. +@vindex GCC_COMPARE_DEBUG @item GCC_COMPARE_DEBUG -@findex GCC_COMPARE_DEBUG Setting @env{GCC_COMPARE_DEBUG} is nearly equivalent to passing @option{-fcompare-debug} to the compiler driver. See the documentation of this option for more details. +@vindex GCC_EXEC_PREFIX @item GCC_EXEC_PREFIX -@findex GCC_EXEC_PREFIX If @env{GCC_EXEC_PREFIX} is set, it specifies a prefix to use in the names of the subprograms executed by the compiler. No slash is added when this prefix is combined with the name of a subprogram, but you can @@ -35167,15 +35167,15 @@ If a standard directory begins with the configured @var{prefix} then the value of @var{prefix} is replaced by @env{GCC_EXEC_PREFIX} when looking for header files. +@vindex COMPILER_PATH @item COMPILER_PATH -@findex COMPILER_PATH The value of @env{COMPILER_PATH} is a colon-separated list of directories, much like @env{PATH}. GCC tries the directories thus specified when searching for subprograms, if it cannot find the subprograms using @env{GCC_EXEC_PREFIX}. +@vindex LIBRARY_PATH @item LIBRARY_PATH -@findex LIBRARY_PATH The value of @env{LIBRARY_PATH} is a colon-separated list of directories, much like @env{PATH}. When configured as a native compiler, GCC tries the directories thus specified when searching for special @@ -35184,9 +35184,9 @@ using GCC also uses these directories when searching for ordinary libraries for the @option{-l} option (but directories specified with @option{-L} come first). -@item LANG -@findex LANG +@vindex LANG @cindex locale definition +@item LANG This variable is used to pass locale information to the compiler. One way in which this information is used is to determine the character set to be used when character literals, string literals and comments are parsed in C and C++. @@ -35206,8 +35206,8 @@ If @env{LANG} is not defined, or if it has some other value, then the compiler uses @code{mblen} and @code{mbtowc} as defined by the default locale to recognize and translate multibyte characters. +@vindex GCC_EXTRA_DIAGNOSTIC_OUTPUT @item GCC_EXTRA_DIAGNOSTIC_OUTPUT -@findex GCC_EXTRA_DIAGNOSTIC_OUTPUT If @env{GCC_EXTRA_DIAGNOSTIC_OUTPUT} is set to one of the following values, then additional text will be emitted to stderr when fix-it hints are emitted. @option{-fdiagnostics-parseable-fixits} and diff --git a/gcc/doc/md.texi b/gcc/doc/md.texi index 7235d34c4b3..8e3113599fd 100644 --- a/gcc/doc/md.texi +++ b/gcc/doc/md.texi @@ -156,9 +156,9 @@ operands of the instruction. If the vector has multiple elements, the RTL template is treated as a @code{parallel} expression. -@item @cindex pattern conditions @cindex conditions, in patterns +@item The condition: This is a string which contains a C expression. When the compiler attempts to match RTL against a pattern, the condition is evaluated. If the condition evaluates to @code{true}, the match is @@ -2193,8 +2193,7 @@ An integer constant with exactly a single bit set. An integer constant with all bits set except exactly one. @item H - -@item Q +@itemx Q Any SYMBOL_REF. @end table @@ -5291,10 +5290,10 @@ operand 0 is the scalar result, with mode equal to the mode of the elements of the input vector. @cindex @code{reduc_and_scal_@var{m}} instruction pattern -@item @samp{reduc_and_scal_@var{m}} @cindex @code{reduc_ior_scal_@var{m}} instruction pattern -@itemx @samp{reduc_ior_scal_@var{m}} @cindex @code{reduc_xor_scal_@var{m}} instruction pattern +@item @samp{reduc_and_scal_@var{m}} +@itemx @samp{reduc_ior_scal_@var{m}} @itemx @samp{reduc_xor_scal_@var{m}} Compute the bitwise @code{AND}/@code{IOR}/@code{XOR} reduction of the elements of a vector of mode @var{m}. Operand 1 is the vector input and operand 0 @@ -5382,8 +5381,8 @@ usdot == @end smallexample @cindex @code{ssad@var{m}} instruction pattern -@item @samp{ssad@var{m}} @cindex @code{usad@var{m}} instruction pattern +@item @samp{ssad@var{m}} @item @samp{usad@var{m}} Compute the sum of absolute differences of two signed/unsigned elements. Operand 1 and operand 2 are of the same mode. Their absolute difference, which @@ -5392,8 +5391,8 @@ equal or wider than the mode of the absolute difference. The result is placed in operand 0, which is of the same mode as operand 3. @cindex @code{widen_ssum@var{m3}} instruction pattern -@item @samp{widen_ssum@var{m3}} @cindex @code{widen_usum@var{m3}} instruction pattern +@item @samp{widen_ssum@var{m3}} @itemx @samp{widen_usum@var{m3}} Operands 0 and 2 are of the same mode, which is wider than the mode of operand 1. Add operand 1 to operand 2 and place the widened result in @@ -5401,8 +5400,8 @@ operand 0. (This is used express accumulation of elements into an accumulator of a wider mode.) @cindex @code{smulhs@var{m3}} instruction pattern -@item @samp{smulhs@var{m3}} @cindex @code{umulhs@var{m3}} instruction pattern +@item @samp{smulhs@var{m3}} @itemx @samp{umulhs@var{m3}} Signed/unsigned multiply high with scale. This is equivalent to the C code: @smallexample @@ -5414,8 +5413,8 @@ where the sign of @samp{narrow} determines whether this is a signed or unsigned operation, and @var{N} is the size of @samp{wide} in bits. @cindex @code{smulhrs@var{m3}} instruction pattern -@item @samp{smulhrs@var{m3}} @cindex @code{umulhrs@var{m3}} instruction pattern +@item @samp{smulhrs@var{m3}} @itemx @samp{umulhrs@var{m3}} Signed/unsigned multiply high with round and scale. This is equivalent to the C code: @@ -5428,8 +5427,8 @@ where the sign of @samp{narrow} determines whether this is a signed or unsigned operation, and @var{N} is the size of @samp{wide} in bits. @cindex @code{sdiv_pow2@var{m3}} instruction pattern -@item @samp{sdiv_pow2@var{m3}} @cindex @code{sdiv_pow2@var{m3}} instruction pattern +@item @samp{sdiv_pow2@var{m3}} @itemx @samp{sdiv_pow2@var{m3}} Signed division by power-of-2 immediate. Equivalent to: @smallexample @@ -8213,12 +8212,12 @@ can itself be a @code{plus}. @code{and}, @code{ior}, @code{xor}, @code{umax} are associative when applied to integers, and sometimes to floating-point. -@item @cindex @code{neg}, canonicalization of @cindex @code{not}, canonicalization of @cindex @code{mult}, canonicalization of @cindex @code{plus}, canonicalization of @cindex @code{minus}, canonicalization of +@item For these operators, if only one operand is a @code{neg}, @code{not}, @code{mult}, @code{plus}, or @code{minus} expression, it will be the first operand. @@ -11088,8 +11087,8 @@ values in @file{sync.md} rather than in the main @file{.md} file. Some enumeration names have special significance to GCC: @table @code -@item unspecv @findex unspec_volatile +@item unspecv If an enumeration called @code{unspecv} is defined, GCC will use it when printing out @code{unspec_volatile} expressions. For example: @@ -11105,8 +11104,8 @@ causes GCC to print @samp{(unspec_volatile @dots{} 0)} as: (unspec_volatile ... UNSPECV_BLOCKAGE) @end smallexample -@item unspec @findex unspec +@item unspec If an enumeration called @code{unspec} is defined, GCC will use it when printing out @code{unspec} expressions. GCC will also use it when printing out @code{unspec_volatile} expressions unless an diff --git a/gcc/doc/rtl.texi b/gcc/doc/rtl.texi index d1380e1eb3b..1de24943c2e 100644 --- a/gcc/doc/rtl.texi +++ b/gcc/doc/rtl.texi @@ -1028,8 +1028,8 @@ the symbol has already been written. @findex volatil @cindex @samp{/v} in RTL dump -@item volatil @cindex volatile memory references +@item volatil In a @code{mem}, @code{asm_operands}, or @code{asm_input} expression, it is 1 if the memory reference is volatile. Volatile memory references may not be deleted, @@ -2187,14 +2187,14 @@ laid out in memory order. The memory order of bytes is defined by two target macros, @code{WORDS_BIG_ENDIAN} and @code{BYTES_BIG_ENDIAN}: @itemize -@item @cindex @code{WORDS_BIG_ENDIAN}, effect on @code{subreg} +@item @code{WORDS_BIG_ENDIAN}, if set to 1, says that byte number zero is part of the most significant word; otherwise, it is part of the least significant word. -@item @cindex @code{BYTES_BIG_ENDIAN}, effect on @code{subreg} +@item @code{BYTES_BIG_ENDIAN}, if set to 1, says that byte number zero is the most significant byte within a word; otherwise, it is the least significant byte within a word. @@ -2336,8 +2336,8 @@ that both performs the arithmetic and sets the condition code register. For examples, search for @samp{addcc} and @samp{andcc} in @file{sparc.md}. @findex pc -@item (pc) @cindex program counter +@item (pc) This represents the machine's program counter. It has no operands and may not have a machine mode. @code{(pc)} may be validly used only in certain specific contexts in jump instructions. diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi index c6c891972d1..09eab4131ce 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -4970,9 +4970,9 @@ function's arguments that this function should pop is available in @end deftypefn @itemize @bullet -@item @findex pretend_args_size @findex crtl->args.pretend_args_size +@item A region of @code{crtl->args.pretend_args_size} bytes of uninitialized space just underneath the first argument arriving on the stack. (This may not be at the very start of the allocated stack region @@ -4997,8 +4997,8 @@ boundary, to contain the local variables of the function. On some machines, this region and the save area may occur in the opposite order, with the save area closer to the top of the stack. -@item @cindex @code{ACCUMULATE_OUTGOING_ARGS} and stack frames +@item Optionally, when @code{ACCUMULATE_OUTGOING_ARGS} is defined, a region of @code{crtl->outgoing_args_size} bytes to be used for outgoing argument lists of the function. @xref{Stack Arguments}. diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in index 613b2534149..83aa3e732b1 100644 --- a/gcc/doc/tm.texi.in +++ b/gcc/doc/tm.texi.in @@ -3534,9 +3534,9 @@ This section describes the macros that output function entry @hook TARGET_ASM_FUNCTION_EPILOGUE @itemize @bullet -@item @findex pretend_args_size @findex crtl->args.pretend_args_size +@item A region of @code{crtl->args.pretend_args_size} bytes of uninitialized space just underneath the first argument arriving on the stack. (This may not be at the very start of the allocated stack region @@ -3561,8 +3561,8 @@ boundary, to contain the local variables of the function. On some machines, this region and the save area may occur in the opposite order, with the save area closer to the top of the stack. -@item @cindex @code{ACCUMULATE_OUTGOING_ARGS} and stack frames +@item Optionally, when @code{ACCUMULATE_OUTGOING_ARGS} is defined, a region of @code{crtl->outgoing_args_size} bytes to be used for outgoing argument lists of the function. @xref{Stack Arguments}. diff --git a/gcc/doc/trouble.texi b/gcc/doc/trouble.texi index ea17921eb4e..155be210992 100644 --- a/gcc/doc/trouble.texi +++ b/gcc/doc/trouble.texi @@ -198,8 +198,8 @@ with GCC does not produce the same floating-point formats that the assembler accepts. If you have this problem, set the @env{LANG} environment variable to @samp{C} or @samp{En_US}. -@item @opindex fdollars-in-identifiers +@item Even if you specify @option{-fdollars-in-identifiers}, you cannot successfully use @samp{$} in identifiers on the RS/6000 due to a restriction in the IBM assembler. GAS supports these @@ -588,8 +588,8 @@ to update the corrected header files. They can be updated using the @command{mkheaders} script installed in @file{@var{libexecdir}/gcc/@var{target}/@var{version}/install-tools/}. -@item @cindex floating point precision +@item On 68000 and x86 systems, for instance, you can get paradoxical results if you test the precise values of floating point numbers. For example, you can find that a floating point value which is not a NaN is not equal @@ -953,8 +953,8 @@ where the return value should never be ignored, use the @code{warn_unused_result} function attribute (@pxref{Function Attributes}). -@item @opindex fshort-enums +@item Making @option{-fshort-enums} the default. This would cause storage layout to be incompatible with most other C @@ -1021,9 +1021,9 @@ to be considered in the future. explicitly in each bit-field whether it is signed or not. In this way, they write programs which have the same meaning in both C dialects.) -@item @opindex ansi @opindex std +@item Undefining @code{__STDC__} when @option{-ansi} is not used. Currently, GCC defines @code{__STDC__} unconditionally. This provides diff --git a/gcc/fortran/invoke.texi b/gcc/fortran/invoke.texi index 86d3f33cb40..5679e2f2650 100644 --- a/gcc/fortran/invoke.texi +++ b/gcc/fortran/invoke.texi @@ -214,11 +214,11 @@ accepted by the compiler: @table @gcctabopt @opindex @code{ffree-form} @opindex @code{ffixed-form} -@item -ffree-form -@itemx -ffixed-form @cindex options, Fortran dialect @cindex file format, free @cindex file format, fixed +@item -ffree-form +@itemx -ffixed-form Specify the layout used by the source file. The free form layout was introduced in Fortran 90. Fixed form was traditionally used in older Fortran programs. When neither option is specified, the source @@ -326,19 +326,19 @@ Enable a blank format item at the end of a format specification i.e. nothing following the final comma. @opindex @code{fdollar-ok} -@item -fdollar-ok @cindex @code{$} @cindex symbol names @cindex character set +@item -fdollar-ok Allow @samp{$} as a valid non-first character in a symbol name. Symbols that start with @samp{$} are rejected since it is unclear which rules to apply to implicit typing as different vendors implement different rules. Using @samp{$} in @code{IMPLICIT} statements is also rejected. @opindex @code{backslash} -@item -fbackslash @cindex backslash @cindex escape characters +@item -fbackslash Change the interpretation of backslashes in string literals from a single backslash character to ``C-style'' escape characters. The following combinations are expanded @code{\a}, @code{\b}, @code{\f}, @code{\n}, @@ -352,16 +352,16 @@ points. All other combinations of a character preceded by \ are unexpanded. @opindex @code{fmodule-private} -@item -fmodule-private @cindex module entities @cindex private +@item -fmodule-private Set the default accessibility of module entities to @code{PRIVATE}. Use-associated entities will not be accessible unless they are explicitly declared as @code{PUBLIC}. @opindex @code{ffixed-line-length-}@var{n} -@item -ffixed-line-length-@var{n} @cindex file format, fixed +@item -ffixed-line-length-@var{n} Set column after which characters are ignored in typical fixed-form lines in the source file, and, unless @code{-fno-pad-source}, through which spaces are assumed (as if padded to that length) after the ends of short @@ -386,8 +386,8 @@ continued character constants never have implicit spaces appended to them to fill out the line. @opindex @code{ffree-line-length-}@var{n} -@item -ffree-line-length-@var{n} @cindex file format, free +@item -ffree-line-length-@var{n} Set column after which characters are ignored in typical free-form lines in the source file. The default value is 132. @var{n} may be @samp{none}, meaning that the entire line is meaningful. @@ -411,8 +411,8 @@ Enable the Cray pointer extension, which provides C-like pointer functionality. @opindex @code{fopenacc} -@item -fopenacc @cindex OpenACC +@item -fopenacc Enable the OpenACC extensions. This includes OpenACC @code{!$acc} directives in free form and @code{c$acc}, @code{*$acc} and @code{!$acc} directives in fixed form, @code{!$} conditional @@ -421,8 +421,8 @@ compilation sentinels in free form and @code{c$}, @code{*$} and OpenACC runtime library to be linked in. @opindex @code{fopenmp} -@item -fopenmp @cindex OpenMP +@item -fopenmp Enable the OpenMP extensions. This includes OpenMP @code{!$omp} directives in free form and @code{c$omp}, @code{*$omp} and @code{!$omp} directives in fixed form, @@ -511,13 +511,13 @@ representation of the translated Fortran code, produced by @opindex @code{freal-8-real-4} @opindex @code{freal-8-real-10} @opindex @code{freal-8-real-16} +@cindex options, real kind type promotion @item -freal-4-real-8 @itemx -freal-4-real-10 @itemx -freal-4-real-16 @itemx -freal-8-real-4 @itemx -freal-8-real-10 @itemx -freal-8-real-16 -@cindex options, real kind type promotion Promote all @code{REAL(KIND=M)} entities to @code{REAL(KIND=N)} entities. If @code{REAL(KIND=N)} is unavailable, then an error will be issued. The @code{-freal-4-} flags also affect the default real kind and the @@ -614,10 +614,10 @@ The following options control preprocessing of Fortran code: @table @gcctabopt @opindex @code{cpp} @opindex @code{fpp} -@item -cpp -@itemx -nocpp @cindex preprocessor, enable @cindex preprocessor, disable +@item -cpp +@itemx -nocpp Enable preprocessing. The preprocessor is automatically invoked if the file extension is @file{.fpp}, @file{.FPP}, @file{.F}, @file{.FOR}, @file{.FTN}, @file{.F90}, @file{.F95}, @file{.F03} or @file{.F08}. Use @@ -633,9 +633,9 @@ preprocessed output as well, so it might be advisable to use the options. @opindex @code{dM} -@item -dM @cindex preprocessor, debugging @cindex debugging, preprocessor +@item -dM Instead of the normal output, generate a list of @code{'#define'} directives for all the macros defined during the execution of the preprocessor, including predefined macros. This gives you a way @@ -647,39 +647,39 @@ Assuming you have no file @file{foo.f90}, the command will show all the predefined macros. @opindex @code{dD} -@item -dD @cindex preprocessor, debugging @cindex debugging, preprocessor +@item -dD Like @option{-dM} except in two respects: it does not include the predefined macros, and it outputs both the @code{#define} directives and the result of preprocessing. Both kinds of output go to the standard output file. @opindex @code{dN} -@item -dN @cindex preprocessor, debugging @cindex debugging, preprocessor +@item -dN Like @option{-dD}, but emit only the macro names, not their expansions. @opindex @code{dU} -@item -dU @cindex preprocessor, debugging @cindex debugging, preprocessor +@item -dU Like @option{dD} except that only macros that are expanded, or whose definedness is tested in preprocessor directives, are output; the output is delayed until the use or test of the macro; and @code{'#undef'} directives are also output for macros tested but undefined at the time. @opindex @code{dI} -@item -dI @cindex preprocessor, debugging @cindex debugging, preprocessor +@item -dI Output @code{'#include'} directives in addition to the result of preprocessing. @opindex @code{fworking-directory} -@item -fworking-directory @cindex preprocessor, working directory +@item -fworking-directory Enable generation of linemarkers in the preprocessor output that will let the compiler know the current working directory at the time of preprocessing. When this option is enabled, the preprocessor will emit, @@ -694,8 +694,8 @@ in the command line, this option has no effect, since no @code{#line} directives are emitted whatsoever. @opindex @code{idirafter @var{dir}} -@item -idirafter @var{dir} @cindex preprocessing, include path +@item -idirafter @var{dir} Search @var{dir} for include files, but do it after all directories specified with @option{-I} and the standard system directories have been exhausted. @var{dir} is treated as a system include directory. @@ -703,27 +703,27 @@ If dir begins with @code{=}, then the @code{=} will be replaced by the sysroot prefix; see @option{--sysroot} and @option{-isysroot}. @opindex @code{imultilib @var{dir}} -@item -imultilib @var{dir} @cindex preprocessing, include path +@item -imultilib @var{dir} Use @var{dir} as a subdirectory of the directory containing target-specific C++ headers. @opindex @code{iprefix @var{prefix}} -@item -iprefix @var{prefix} @cindex preprocessing, include path +@item -iprefix @var{prefix} Specify @var{prefix} as the prefix for subsequent @option{-iwithprefix} options. If the @var{prefix} represents a directory, you should include the final @code{'/'}. @opindex @code{isysroot @var{dir}} -@item -isysroot @var{dir} @cindex preprocessing, include path +@item -isysroot @var{dir} This option is like the @option{--sysroot} option, but applies only to header files. See the @option{--sysroot} option for more information. @opindex @code{iquote @var{dir}} -@item -iquote @var{dir} @cindex preprocessing, include path +@item -iquote @var{dir} Search @var{dir} only for header files requested with @code{#include "file"}; they are not searched for @code{#include }, before all directories specified by @option{-I} and before the standard system directories. If @@ -731,8 +731,8 @@ specified by @option{-I} and before the standard system directories. If sysroot prefix; see @option{--sysroot} and @option{-isysroot}. @opindex @code{isystem @var{dir}} -@item -isystem @var{dir} @cindex preprocessing, include path +@item -isystem @var{dir} Search @var{dir} for header files, after all directories specified by @option{-I} but before the standard system directories. Mark it as a system directory, so that it gets the same special treatment as is @@ -752,20 +752,20 @@ Do not predefine any system-specific or GCC-specific macros. The standard predefined macros remain defined. @opindex @code{A@var{predicate}=@var{answer}} -@item -A@var{predicate}=@var{answer} @cindex preprocessing, assertion +@item -A@var{predicate}=@var{answer} Make an assertion with the predicate @var{predicate} and answer @var{answer}. This form is preferred to the older form -A predicate(answer), which is still supported, because it does not use shell special characters. @opindex @code{A-@var{predicate}=@var{answer}} -@item -A-@var{predicate}=@var{answer} @cindex preprocessing, assertion +@item -A-@var{predicate}=@var{answer} Cancel an assertion with the predicate @var{predicate} and answer @var{answer}. @opindex @code{C} -@item -C @cindex preprocessing, keep comments +@item -C Do not discard comments. All comments are passed through to the output file, except for comments in processed directives, which are deleted along with the directive. @@ -780,8 +780,8 @@ Warning: this currently handles C-Style comments only. The preprocessor does not yet recognize Fortran-style comments. @opindex @code{CC} -@item -CC @cindex preprocessing, keep comments +@item -CC Do not discard comments, including during macro expansion. This is like @option{-C}, except that comments contained within macros are also passed through to the output file where the macro is expanded. @@ -796,13 +796,13 @@ Warning: this currently handles C- and C++-Style comments only. The preprocessor does not yet recognize Fortran-style comments. @opindex @code{D@var{name}} -@item -D@var{name} @cindex preprocessing, define macros +@item -D@var{name} Predefine name as a macro, with definition @code{1}. @opindex @code{D@var{name}=@var{definition}} -@item -D@var{name}=@var{definition} @cindex preprocessing, define macros +@item -D@var{name}=@var{definition} The contents of @var{definition} are tokenized and processed as if they appeared during translation phase three in a @code{'#define'} directive. In particular, the definition will be truncated by embedded newline @@ -829,16 +829,16 @@ activities. Each name is indented to show how deep in the @code{'#include'} stack it is. @opindex @code{P} -@item -P @cindex preprocessing, no linemarkers +@item -P Inhibit generation of linemarkers in the output from the preprocessor. This might be useful when running the preprocessor on something that is not C code, and will be sent to a program which might be confused by the linemarkers. @opindex @code{U@var{name}} -@item -U@var{name} @cindex preprocessing, undefine macros +@item -U@var{name} Cancel any previous definition of @var{name}, either built in or provided with a @option{-D} option. @end table @@ -875,16 +875,16 @@ by GNU Fortran: @table @gcctabopt @opindex @code{fmax-errors=}@var{n} -@item -fmax-errors=@var{n} @cindex errors, limiting +@item -fmax-errors=@var{n} Limits the maximum number of error messages to @var{n}, at which point GNU Fortran bails out rather than attempting to continue processing the source code. If @var{n} is 0, there is no limit on the number of error messages produced. @opindex @code{fsyntax-only} -@item -fsyntax-only @cindex syntax checking +@item -fsyntax-only Check the code for syntax errors, but do not actually compile it. This will generate module files for each module present in the code, but no other output file. @@ -918,9 +918,9 @@ Like @option{-pedantic}, except that errors are produced rather than warnings. @opindex @code{Wall} -@item -Wall @cindex all warnings @cindex warnings, all +@item -Wall Enables commonly used warning options pertaining to usage that we recommend avoiding and that we believe are easy to avoid. This currently includes @option{-Waliasing}, @option{-Wampersand}, @@ -931,9 +931,9 @@ This currently includes @option{-Waliasing}, @option{-Wampersand}, and @option{-Wundefined-do-loop}. @opindex @code{Waliasing} -@item -Waliasing @cindex aliasing @cindex warnings, aliasing +@item -Waliasing Warn about possible aliasing of dummy arguments. Specifically, it warns if the same actual argument is associated with a dummy argument with @code{INTENT(IN)} and a dummy argument with @code{INTENT(OUT)} in a call @@ -953,9 +953,9 @@ The following example will trigger the warning. @end smallexample @opindex @code{Wampersand} -@item -Wampersand @cindex warnings, ampersand @cindex @code{&} +@item -Wampersand Warn about missing ampersand in continued character constants. The warning is given with @option{-Wampersand}, @option{-pedantic}, @option{-std=f95}, @option{-std=f2003}, @option{-std=f2008} and @@ -965,15 +965,15 @@ non-comment, non-whitespace character after the ampersand that initiated the continuation. @opindex @code{Warray-temporaries} -@item -Warray-temporaries @cindex warnings, array temporaries +@item -Warray-temporaries Warn about array temporaries generated by the compiler. The information generated by this warning is sometimes useful in optimization, in order to avoid such temporaries. @opindex @code{Wc-binding-type} -@item -Wc-binding-type @cindex warning, C binding type +@item -Wc-binding-type Warn if the a variable might not be C interoperable. In particular, warn if the variable has been declared using an intrinsic type with default kind instead of using a kind parameter defined for C interoperability in the @@ -981,71 +981,71 @@ intrinsic @code{ISO_C_Binding} module. This option is implied by @option{-Wall}. @opindex @code{Wcharacter-truncation} -@item -Wcharacter-truncation @cindex warnings, character truncation +@item -Wcharacter-truncation Warn when a character assignment will truncate the assigned string. @opindex @code{Wline-truncation} -@item -Wline-truncation @cindex warnings, line truncation +@item -Wline-truncation Warn when a source code line will be truncated. This option is implied by @option{-Wall}. For free-form source code, the default is @option{-Werror=line-truncation} such that truncations are reported as error. @opindex @code{Wconversion} -@item -Wconversion @cindex warnings, conversion @cindex conversion +@item -Wconversion Warn about implicit conversions that are likely to change the value of the expression after conversion. Implied by @option{-Wall}. @opindex @code{Wconversion-extra} -@item -Wconversion-extra @cindex warnings, conversion @cindex conversion +@item -Wconversion-extra Warn about implicit conversions between different types and kinds. This option does @emph{not} imply @option{-Wconversion}. @opindex @code{Wextra} -@item -Wextra @cindex extra warnings @cindex warnings, extra +@item -Wextra Enables some warning options for usages of language features which may be problematic. This currently includes @option{-Wcompare-reals}, @option{-Wunused-parameter} and @option{-Wdo-subscript}. @opindex @code{Wfrontend-loop-interchange} -@item -Wfrontend-loop-interchange @cindex warnings, loop interchange @cindex loop interchange, warning +@item -Wfrontend-loop-interchange Warn when using @option{-ffrontend-loop-interchange} for performing loop interchanges. @opindex @code{Wimplicit-interface} -@item -Wimplicit-interface @cindex warnings, implicit interface +@item -Wimplicit-interface Warn if a procedure is called without an explicit interface. Note this only checks that an explicit interface is present. It does not check that the declared interfaces are consistent across program units. @opindex @code{Wimplicit-procedure} -@item -Wimplicit-procedure @cindex warnings, implicit procedure +@item -Wimplicit-procedure Warn if a procedure is called that has neither an explicit interface nor has been declared as @code{EXTERNAL}. @opindex @code{Winteger-division} -@item -Winteger-division @cindex warnings, integer division @cindex warnings, division of integers +@item -Winteger-division Warn if a constant integer division truncates its result. As an example, 3/5 evaluates to 0. @opindex @code{Wintrinsics-std} -@item -Wintrinsics-std @cindex warnings, non-standard intrinsics @cindex warnings, intrinsics of other standards +@item -Wintrinsics-std Warn if @command{gfortran} finds a procedure named like an intrinsic not available in the currently selected standard (with @option{-std}) and treats it as @code{EXTERNAL} procedure because of this. @option{-fall-intrinsics} can @@ -1053,8 +1053,8 @@ be used to never trigger this behavior and always link to the intrinsic regardless of the selected standard. @opindex @code{Woverwrite-recursive} -@item -Wno-overwrite-recursive @cindex warnings, overwrite recursive +@item -Wno-overwrite-recursive Do not warn when @option{-fno-automatic} is used with @option{-frecursive}. Recursion will be broken if the relevant local variables do not have the attribute @code{AUTOMATIC} explicitly declared. This option can be used to suppress the warning @@ -1062,14 +1062,14 @@ when it is known that recursion is not broken. Useful for build environments tha @option{-Werror}. @opindex @code{Wreal-q-constant} -@item -Wreal-q-constant @cindex warnings, @code{q} exponent-letter +@item -Wreal-q-constant Produce a warning if a real-literal-constant contains a @code{q} exponent-letter. @opindex @code{Wsurprising} -@item -Wsurprising @cindex warnings, suspicious code +@item -Wsurprising Produce a warning when ``suspicious'' code constructs are encountered. While technically legal these usually indicate that an error has been made. @@ -1100,9 +1100,9 @@ used in free-form source code, is diagnosed by default.) @end itemize @opindex @code{Wtabs} -@item -Wtabs @cindex warnings, tabs @cindex tabulators +@item -Wtabs By default, tabs are accepted as whitespace, but tabs are not members of the Fortran Character Set. For continuation lines, a tab followed by a digit between 1 and 9 is supported. @option{-Wtabs} will cause a @@ -1112,46 +1112,46 @@ active for @option{-pedantic}, @option{-std=f95}, @option{-std=f2003}, @option{-Wall}. @opindex @code{Wundefined-do-loop} -@item -Wundefined-do-loop @cindex warnings, undefined do loop +@item -Wundefined-do-loop Warn if a DO loop with step either 1 or -1 yields an underflow or an overflow during iteration of an induction variable of the loop. This option is implied by @option{-Wall}. @opindex @code{Wunderflow} -@item -Wunderflow @cindex warnings, underflow @cindex underflow +@item -Wunderflow Produce a warning when numerical constant expressions are encountered, which yield an UNDERFLOW during compilation. Enabled by default. @opindex @code{Wintrinsic-shadow} -@item -Wintrinsic-shadow @cindex warnings, intrinsic @cindex intrinsic +@item -Wintrinsic-shadow Warn if a user-defined procedure or module procedure has the same name as an intrinsic; in this case, an explicit interface or @code{EXTERNAL} or @code{INTRINSIC} declaration might be needed to get calls later resolved to the desired intrinsic/procedure. This option is implied by @option{-Wall}. @opindex @code{Wuse-without-only} -@item -Wuse-without-only @cindex warnings, use statements @cindex intrinsic +@item -Wuse-without-only Warn if a @code{USE} statement has no @code{ONLY} qualifier and thus implicitly imports all public entities of the used module. @opindex @code{Wunused-dummy-argument} -@item -Wunused-dummy-argument @cindex warnings, unused dummy argument @cindex unused dummy argument @cindex dummy argument, unused +@item -Wunused-dummy-argument Warn about unused dummy arguments. This option is implied by @option{-Wall}. @opindex @code{Wunused-parameter} -@item -Wunused-parameter @cindex warnings, unused parameter @cindex unused parameter +@item -Wunused-parameter Contrary to @command{gcc}'s meaning of @option{-Wunused-parameter}, @command{gfortran}'s implementation of this option does not warn about unused dummy arguments (see @option{-Wunused-dummy-argument}), @@ -1160,24 +1160,24 @@ is implied by @option{-Wextra} if also @option{-Wunused} or @option{-Wall} is used. @opindex @code{Walign-commons} -@item -Walign-commons @cindex warnings, alignment of @code{COMMON} blocks @cindex alignment of @code{COMMON} blocks +@item -Walign-commons By default, @command{gfortran} warns about any occasion of variables being padded for proper alignment inside a @code{COMMON} block. This warning can be turned off via @option{-Wno-align-commons}. See also @option{-falign-commons}. @opindex @code{Wfunction-elimination} -@item -Wfunction-elimination @cindex function elimination @cindex warnings, function elimination +@item -Wfunction-elimination Warn if any calls to impure functions are eliminated by the optimizations enabled by the @option{-ffrontend-optimize} option. This option is implied by @option{-Wextra}. @opindex @code{Wrealloc-lhs} -@item -Wrealloc-lhs @cindex Reallocate the LHS in assignments, notification +@item -Wrealloc-lhs Warn when the compiler might insert code to for allocation or reallocation of an allocatable array variable of intrinsic type in intrinsic assignments. In hot loops, the Fortran 2003 reallocation feature may reduce the performance. @@ -1224,8 +1224,8 @@ statement is actually executed, in cases like This option is implied by @option{-Wextra}. @opindex @code{Werror} -@item -Werror @cindex warnings, to errors +@item -Werror Turns all warnings into errors. @end table @@ -1337,9 +1337,9 @@ last one will be used. By default, a summary for all exceptions but @samp{inexact} is shown. @opindex @code{fno-backtrace} -@item -fno-backtrace @cindex backtrace @cindex trace +@item -fno-backtrace When a serious runtime error is encountered or a deadly signal is emitted (segmentation fault, illegal instruction, bus error, floating-point exception, and the other POSIX signals that have the @@ -1370,12 +1370,12 @@ Fortran source. @table @gcctabopt @opindex @code{I}@var{dir} -@item -I@var{dir} @cindex directory, search paths for inclusion @cindex inclusion, directory search paths for @cindex search paths, for included files @cindex paths, search @cindex module search path +@item -I@var{dir} These affect interpretation of the @code{INCLUDE} directive (as well as of the @code{#include} directive of the @command{cpp} preprocessor). @@ -1394,9 +1394,9 @@ gcc,Using the GNU Compiler Collection (GCC)}, for information on the @opindex @code{J}@var{dir} @opindex @code{M}@var{dir} -@item -J@var{dir} @cindex paths, search @cindex module search path +@item -J@var{dir} This option specifies where to put @file{.mod} files for compiled modules. It is also added to the list of directories to searched by an @code{USE} statement. @@ -1404,9 +1404,9 @@ statement. The default is the current directory. @opindex @code{fintrinsic-modules-path} @var{dir} -@item -fintrinsic-modules-path @var{dir} @cindex paths, search @cindex module search path +@item -fintrinsic-modules-path @var{dir} This option specifies the location of pre-compiled intrinsic modules, if they are not in the default location expected by the compiler. @end table @@ -1515,9 +1515,9 @@ it. @table @gcctabopt @opindex @code{fno-automatic} -@item -fno-automatic @cindex @code{SAVE} statement @cindex statement, @code{SAVE} +@item -fno-automatic Treat each program unit (except those marked as RECURSIVE) as if the @code{SAVE} statement were specified for every local variable and array referenced in it. Does not affect common blocks. (Some Fortran compilers @@ -1530,11 +1530,11 @@ Local variables or arrays having an explicit @code{SAVE} attribute are silently ignored unless the @option{-pedantic} option is added. @opindex ff2c -@item -ff2c @cindex calling convention @cindex @command{f2c} calling convention @cindex @command{g77} calling convention @cindex libf2c calling convention +@item -ff2c Generate code designed to be compatible with code generated by @command{g77} and @command{f2c}. @@ -1564,11 +1564,11 @@ of type default @code{REAL} or @code{COMPLEX} as actual arguments, as the library implementations use the @option{-fno-f2c} calling conventions. @opindex @code{fno-underscoring} -@item -fno-underscoring @cindex underscore @cindex symbol names, underscores @cindex transforming symbol names @cindex symbol names, transforming +@item -fno-underscoring Do not transform names of entities specified in the Fortran source file by appending underscores to them. @@ -1633,7 +1633,6 @@ prevent accidental linking between procedures with incompatible interfaces. @opindex @code{fsecond-underscore} -@item -fsecond-underscore @cindex underscore @cindex symbol names, underscores @cindex transforming symbol names @@ -1641,6 +1640,7 @@ interfaces. @cindex @command{f2c} calling convention @cindex @command{g77} calling convention @cindex libf2c calling convention +@item -fsecond-underscore By default, GNU Fortran appends an underscore to external names. If this option is used GNU Fortran appends two underscores to names with underscores and one underscore to external names @@ -1658,8 +1658,8 @@ for compatibility with @command{g77} and @command{f2c}, and is implied by use of the @option{-ff2c} option. @opindex @code{fcoarray} -@item -fcoarray=@var{} @cindex coarrays +@item -fcoarray=@var{} @table @asis @item @samp{none} @@ -1676,7 +1676,6 @@ library needs to be linked. @opindex @code{fcheck} -@item -fcheck=@var{} @cindex array, bounds checking @cindex bit intrinsics checking @cindex bounds checking @@ -1687,6 +1686,7 @@ library needs to be linked. @cindex checking subscripts @cindex run-time checking @cindex checking array temporaries +@item -fcheck=@var{} Enable the generation of run-time checks; the argument shall be a comma-delimited list of the following keywords. Prefixing a check with @@ -1836,15 +1836,15 @@ by default at optimization level @option{-Ofast} unless @option{-fmax-stack-var-size} is specified. @opindex @code{fpack-derived} -@item -fpack-derived @cindex structure packing +@item -fpack-derived This option tells GNU Fortran to pack derived type members as closely as possible. Code compiled with this option is likely to be incompatible with code compiled without this option, and may execute slower. @opindex @code{frepack-arrays} -@item -frepack-arrays @cindex repacking arrays +@item -frepack-arrays In some circumstances GNU Fortran may pass assumed shape array sections via a descriptor describing a noncontiguous area of memory. This option adds code to the function prologue to repack the data into @@ -1986,8 +1986,8 @@ silence warnings that would have been emitted by @option{-Wuninitialized} for the affected local variables. @opindex @code{falign-commons} -@item -falign-commons @cindex alignment of @code{COMMON} blocks +@item -falign-commons By default, @command{gfortran} enforces proper alignment of all variables in a @code{COMMON} block by padding them as needed. On certain platforms this is mandatory, on others it increases performance. If a @code{COMMON} block is not declared with @@ -1998,8 +1998,8 @@ To avoid potential alignment issues in @code{COMMON} blocks, it is recommended t objects from largest to smallest. @opindex @code{fno-protect-parens} -@item -fno-protect-parens @cindex re-association of parenthesized expressions +@item -fno-protect-parens By default the parentheses in expression are honored for all optimization levels such that the compiler does not do any re-association. Using @option{-fno-protect-parens} allows the compiler to reorder @code{REAL} and @@ -2009,16 +2009,16 @@ need to be in effect. The parentheses protection is enabled by default, unless @option{-Ofast} is given. @opindex @code{frealloc-lhs} -@item -frealloc-lhs @cindex Reallocate the LHS in assignments +@item -frealloc-lhs An allocatable left-hand side of an intrinsic assignment is automatically (re)allocated if it is either unallocated or has a different shape. The option is enabled by default except when @option{-std=f95} is given. See also @option{-Wrealloc-lhs}. @opindex @code{faggressive-function-elimination} -@item -faggressive-function-elimination @cindex Elimination of functions with identical argument lists +@item -faggressive-function-elimination Functions with identical argument lists are eliminated within statements, regardless of whether these functions are marked @code{PURE} or not. For example, in @@ -2029,8 +2029,8 @@ there will only be a single call to @code{f}. This option only works if @option{-ffrontend-optimize} is in effect. @opindex @code{frontend-optimize} -@item -ffrontend-optimize @cindex Front-end optimization +@item -ffrontend-optimize This option performs front-end optimization, based on manipulating parts the Fortran parse tree. Enabled by default by any @option{-O} option except @option{-O0} and @option{-Og}. Optimizations enabled by this option @@ -2045,8 +2045,8 @@ include: It can be deselected by specifying @option{-fno-frontend-optimize}. @opindex @code{frontend-loop-interchange} -@item -ffrontend-loop-interchange @cindex loop interchange, Fortran +@item -ffrontend-loop-interchange Attempt to interchange loops in the Fortran front end where profitable. Enabled by default by any @option{-O} option. At the moment, this option only affects @code{FORALL} and @@ -2066,8 +2066,8 @@ shared by @command{gfortran}, @command{gcc}, and other GNU compilers. @table @asis @opindex @code{c-prototypes} -@item -fc-prototypes @cindex Generating C prototypes from Fortran BIND(C) enteties +@item -fc-prototypes This option will generate C prototypes from @code{BIND(C)} variable declarations, types and procedure interfaces and writes them to standard output. @code{ENUM} is not yet supported. @@ -2088,8 +2088,8 @@ where the C code intended for interoperating with the Fortran code then uses @code{#include "foo.h"}. @opindex @code{c-prototypes-external} -@item -fc-prototypes-external @cindex Generating C prototypes from external procedures +@item -fc-prototypes-external This option will generate C prototypes from external functions and subroutines and write them to standard output. This may be useful for making sure that C bindings to Fortran code are correct. This option diff --git a/gcc/go/gccgo.texi b/gcc/go/gccgo.texi index b540957b985..4ab1a76818f 100644 --- a/gcc/go/gccgo.texi +++ b/gcc/go/gccgo.texi @@ -152,18 +152,18 @@ program will generally cause it to misbehave or fail. @c man begin OPTIONS gccgo @table @gcctabopt -@item -I@var{dir} @cindex @option{-I} +@item -I@var{dir} Specify a directory to use when searching for an import package at compile time. -@item -L@var{dir} @cindex @option{-L} +@item -L@var{dir} When linking, specify a library search directory, as with @command{gcc}. -@item -fgo-pkgpath=@var{string} @cindex @option{-fgo-pkgpath} +@item -fgo-pkgpath=@var{string} Set the package path to use. This sets the value returned by the PkgPath method of reflect.Type objects. It is also used for the names of globally visible symbols. The argument to this option should @@ -171,8 +171,8 @@ normally be the string that will be used to import this package after it has been installed; in other words, a pathname within the directories specified by the @option{-I} option. -@item -fgo-prefix=@var{string} @cindex @option{-fgo-prefix} +@item -fgo-prefix=@var{string} An alternative to @option{-fgo-pkgpath}. The argument will be combined with the package name from the source file to produce the package path. If @option{-fgo-pkgpath} is used, @option{-fgo-prefix} @@ -189,24 +189,24 @@ Using either @option{-fgo-pkgpath} or @option{-fgo-prefix} disables the special treatment of the @code{main} package and permits that package to be imported like any other. -@item -fgo-relative-import-path=@var{dir} @cindex @option{-fgo-relative-import-path} +@item -fgo-relative-import-path=@var{dir} A relative import is an import that starts with @file{./} or @file{../}. If this option is used, @command{gccgo} will use @var{dir} as a prefix for the relative import when searching for it. -@item -frequire-return-statement -@itemx -fno-require-return-statement @cindex @option{-frequire-return-statement} @cindex @option{-fno-require-return-statement} +@item -frequire-return-statement +@itemx -fno-require-return-statement By default @command{gccgo} will warn about functions which have one or more return parameters but lack an explicit @code{return} statement. This warning may be disabled using @option{-fno-require-return-statement}. -@item -fgo-check-divide-zero @cindex @option{-fgo-check-divide-zero} @cindex @option{-fno-go-check-divide-zero} +@item -fgo-check-divide-zero Add explicit checks for division by zero. In Go a division (or modulos) by zero causes a panic. On Unix systems this is detected in the runtime by catching the @code{SIGFPE} signal. Some processors, @@ -217,9 +217,9 @@ systems, this option may be used. Or the checks may be removed via default, but in the future may be off by default on systems that do not require it. -@item -fgo-check-divide-overflow @cindex @option{-fgo-check-divide-overflow} @cindex @option{-fno-go-check-divide-overflow} +@item -fgo-check-divide-overflow Add explicit checks for division overflow. For example, division overflow occurs when computing @code{INT_MIN / -1}. In Go this should be wrapped, to produce @code{INT_MIN}. Some processors, such as x86, @@ -229,41 +229,41 @@ may be used. Or the checks may be removed via by default, but in the future may be off by default on systems that do not require it. -@item -fno-go-optimize-allocs @cindex @option{-fno-go-optimize-allocs} +@item -fno-go-optimize-allocs Disable escape analysis, which tries to allocate objects on the stack rather than the heap. -@item -fgo-debug-escape@var{n} @cindex @option{-fgo-debug-escape} +@item -fgo-debug-escape@var{n} Output escape analysis debugging information. Larger values of @var{n} generate more information. -@item -fgo-debug-escape-hash=@var{n} @cindex @option{-fgo-debug-escape-hash} +@item -fgo-debug-escape-hash=@var{n} A hash value to debug escape analysis. @var{n} is a binary string. This runs escape analysis only on functions whose names hash to values that match the given suffix @var{n}. This can be used to binary search across functions to uncover escape analysis bugs. -@item -fgo-debug-optimization @cindex @option{-fgo-debug-optimization} @cindex @option{-fno-go-debug-optimization} +@item -fgo-debug-optimization Output optimization diagnostics. -@item -fgo-c-header=@var{file} @cindex @option{-fgo-c-header} +@item -fgo-c-header=@var{file} Write top-level named Go struct definitions to @var{file} as C code. This is used when compiling the runtime package. -@item -fgo-compiling-runtime @cindex @option{-fgo-compiling-runtime} +@item -fgo-compiling-runtime Apply special rules for compiling the runtime package. Implicit memory allocation is forbidden. Some additional compiler directives are supported. -@item -fgo-embedcfg=@var{file} @cindex @option{-fgo-embedcfg} +@item -fgo-embedcfg=@var{file} Identify a JSON file used to map patterns used with special @code{//go:embed} comments to the files named by the patterns. The JSON file should have two components: @code{Patterns} maps each @@ -271,8 +271,8 @@ pattern to a list of file names, and @code{Files} maps each file name to a full path to the file. This option is intended for use by the @command{go} command to implement @code{//go:embed}. -@item -g @cindex @option{-g for gccgo} +@item -g This is the standard @command{gcc} option (@pxref{Debugging Options, , Debugging Options, gcc, Using the GNU Compiler Collection (GCC)}). It is mentioned here because by default @command{gccgo} turns on