HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGE.
+SUCH DAMAGE.
\ No newline at end of file
And finally we'd like to thank everyone who uses the compiler, provides
feedback and generally reminds us why we're doing this work in the first
-place.
+place.
\ No newline at end of file
for information on how to make useful contributions and avoid
duplication of effort. Suggested projects are listed at
-https://gcc.gnu.org/projects/.
+https://gcc.gnu.org/projects/.
\ No newline at end of file
.. option:: -Wendif-labels
- Default setting; overrides :option:`-Wno-endif-labels`.
+ Default setting; overrides :option:`-Wno-endif-labels`.
\ No newline at end of file
The value should be a known timestamp such as the last modification
time of the source or package and it should be set by the build
- process.
+ process.
\ No newline at end of file
token in the output is preceded by the dump of the map its location
belongs to.
- When used from GCC without :option:`-E`, this option has no effect.
+ When used from GCC without :option:`-E`, this option has no effect.
\ No newline at end of file
..
Copyright 1988-2022 Free Software Foundation, Inc.
This is part of the GCC manual.
- For copying conditions, see the copyright.rst file.
+ For copying conditions, see the copyright.rst file.
\ No newline at end of file
By establishing the idea that supporting further development is 'the
proper thing to do' when distributing free software for a fee, we can
-assure a steady flow of resources into making more free software.
+assure a steady flow of resources into making more free software.
\ No newline at end of file
referred to as 'Linux', they are more accurately called GNU/Linux
systems.
-For more information, see: https://www.gnu.org/ and https://www.gnu.org/gnu/linux-and-gnu.html.
+For more information, see: https://www.gnu.org/ and https://www.gnu.org/gnu/linux-and-gnu.html.
\ No newline at end of file
If your document contains nontrivial examples of program code, we
recommend releasing these examples in parallel under your choice of
free software license, such as the GNU General Public License,
-to permit their use in free software.
+to permit their use in free software.
\ No newline at end of file
library, you may consider it more useful to permit linking proprietary
applications with the library. If this is what you want to do, use the
GNU Lesser General Public License instead of this License. But first,
-please read https://www.gnu.org/licenses/why-not-lgpl.html.
+please read https://www.gnu.org/licenses/why-not-lgpl.html.
\ No newline at end of file
TODO
----
- .. todolist::
+ .. todolist::
\ No newline at end of file
signature of Ty Coon, 1 April 1990
Ty Coon, President of Vice
-That's all there is to it!
+That's all there is to it!
\ No newline at end of file
Integer constant valid for BccI instructions
``L``
- Unsigned constant valid for BccUI instructions
+ Unsigned constant valid for BccUI instructions
\ No newline at end of file
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with no
Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
-A copy of the license is in the :ref:`gnu_fdl`.
+A copy of the license is in the :ref:`gnu_fdl`.
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../doc/gpl-3.0.rst
+.. include:: ../../../doc/gpl-3.0.rst
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../doc/gnu_free_documentation_license.rst
+.. include:: ../../../doc/gnu_free_documentation_license.rst
\ No newline at end of file
general-public-license-3
gnu-free-documentation-license
- indices-and-tables
+ indices-and-tables
\ No newline at end of file
-.. include:: ../../../doc/indices-and-tables.rst
+.. include:: ../../../doc/indices-and-tables.rst
\ No newline at end of file
.. only:: man
- .. include:: copyright.rst
+ .. include:: copyright.rst
\ No newline at end of file
Generates code expanded from D ``mixin`` statements and writes the
processed sources to :samp:`{file}`. This is useful to debug errors in compilation
- and provides source for debuggers to show when requested.
+ and provides source for debuggers to show when requested.
\ No newline at end of file
program is being compiled. This includes listing all modules that are
processed through the ``parse``, ``semantic``, ``semantic2``, and
``semantic3`` stages; all ``import`` modules and their file paths;
- and all ``function`` bodies that are being compiled.
+ and all ``function`` bodies that are being compiled.
\ No newline at end of file
primarily designed for use in producing user documentation from embedded
comments, with a slight affinity towards HTML generation. If a :samp:`.d`
source file starts with the string ``Ddoc`` then it is treated as general
-purpose documentation, not as a D source file.
+purpose documentation, not as a D source file.
\ No newline at end of file
Do not search the standard system directories for D source and interface
files. Only the directories that have been specified with :option:`-I` options
- (and the directory of the current file, if appropriate) are searched.
+ (and the directory of the current file, if appropriate) are searched.
\ No newline at end of file
On systems that provide :samp:`libgphobos` and :samp:`libgdruntime` as a
shared and a static library, this option forces the use of the static
version. If no static version was built when the compiler was configured,
- this option has no effect.
+ this option has no effect.
\ No newline at end of file
Turns off emission of declarations that can be defined in multiple objects as
weak symbols. The default is to emit all public symbols as weak, unless the
target lacks support for weak symbols. Disabling this option means that common
- symbols are instead put in COMDAT or become private.
+ symbols are instead put in COMDAT or become private.
\ No newline at end of file
List all variables going into thread local storage.
:samp:`vmarkdown`
- List instances of Markdown replacements in Ddoc.
+ List instances of Markdown replacements in Ddoc.
\ No newline at end of file
.. [#f1] UTF-16 does not meet the requirements of the C
standard for a wide character set, but the choice of 16-bit
``wchar_t`` is enshrined in some system ABIs so we cannot fix
- this.
+ this.
\ No newline at end of file
#if defined __has_include && __has_include ("header.h") /* not portable */
...
- #endif
+ #endif
\ No newline at end of file
Simple programs that do not need system-specific logic or complex
debugging hooks generally will not need to use preprocessing
-conditionals.
+conditionals.
\ No newline at end of file
conditional-uses
conditional-syntax
- deleted-code
+ deleted-code
\ No newline at end of file
You have freedom to copy and modify this GNU Manual, like GNU
software. Copies published by the Free Software Foundation raise
- funds for GNU development.
+ funds for GNU development.
\ No newline at end of file
tokens; in particular, single-quote characters must balance. Comments
often contain unbalanced single-quote characters (known in English as
apostrophes). These confuse ``#if 0``. They don't confuse
-:samp:`/*`.
+:samp:`/*`.
\ No newline at end of file
Internal whitespace sequences are each replaced with a single space.
The line must consist of complete tokens. It is wisest to make the
argument of these directives be a single string constant; this avoids
-problems with apostrophes and the like.
+problems with apostrophes and the like.
\ No newline at end of file
environment variables, which in turn take precedence over the
configuration of GCC.
-.. include:: ../../../doc/cppenv.rst
+.. include:: ../../../doc/cppenv.rst
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../doc/gnu_free_documentation_license.rst
+.. include:: ../../../doc/gnu_free_documentation_license.rst
\ No newline at end of file
header-files/alternatives-to-wrapper-ifndef
header-files/computed-includes
header-files/wrapper-headers
- header-files/system-headers
+ header-files/system-headers
\ No newline at end of file
is with the :samp:`#pragma once` directive (see :ref:`pragmas`).
:samp:`#pragma once` does not have the problems that :samp:`#import` does,
but it is not recognized by all preprocessors, so you cannot rely on it
-in a portable program.
+in a portable program.
\ No newline at end of file
standard. To minimize the risk of different compilers interpreting your
computed includes differently, we recommend you use only a single
object-like macro which expands to a string constant. This will also
-minimize confusion for people reading your program.
+minimize confusion for people reading your program.
\ No newline at end of file
The line following the :samp:`#include` directive is always treated as a
separate line by the C preprocessor, even if the included file lacks a
-final newline.
+final newline.
\ No newline at end of file
to use only :samp:`/`.)
It is an error if there is anything (other than comments) on the line
-after the file name.
+after the file name.
\ No newline at end of file
begin with :samp:`_`. In a system header file, it should begin with
:samp:`__` to avoid conflicts with user programs. In any kind of header
file, the macro name should contain the name of the file and some
-additional text, to avoid conflicts with other header files.
+additional text, to avoid conflicts with other header files.
\ No newline at end of file
the default system header directories with the :option:`-nostdinc`
option. This is useful when you are compiling an operating system
kernel or some other program that does not use the standard C library
-facilities, or the standard C library itself.
+facilities, or the standard C library itself.
\ No newline at end of file
system_header`` has no effect in the primary source file.
On some targets, such as RS/6000 AIX, GCC implicitly surrounds all
-system headers with an :samp:`extern "C"` block when compiling as C++.
+system headers with an :samp:`extern "C"` block when compiling as C++.
\ No newline at end of file
recommend it be used only when there is no other alternative. In
particular, it should not be used in the headers belonging to a specific
program; it should be used only to make global corrections along the
-lines of :command:`fixincludes`.
+lines of :command:`fixincludes`.
\ No newline at end of file
question does not arise.
Note that GCC does not yet implement any of the standard
- pragmas.
+ pragmas.
\ No newline at end of file
implementation-defined-behavior
implementation-limits
- obsolete-features
+ obsolete-features
\ No newline at end of file
source file. GNU cpp maps files into memory, so it is limited by the
available address space. This is generally at least two gigabytes.
Depending on the operating system, the size of physical memory may or
- may not be a limitation.
+ may not be a limitation.
\ No newline at end of file
environment-variables
gnu-free-documentation-license
- indices-and-tables
+ indices-and-tables
\ No newline at end of file
-.. include:: ../../../doc/indices-and-tables.rst
+.. include:: ../../../doc/indices-and-tables.rst
\ No newline at end of file
There is no way to prevent a backslash at the end of a line from being
interpreted as a backslash-newline. This cannot affect any correct
-program, however.
+program, however.
\ No newline at end of file
.. only:: man
- .. include:: copyright.rst
+ .. include:: copyright.rst
\ No newline at end of file
:samp:`#line` directives alter the results of the ``__FILE__`` and
``__LINE__`` predefined macros from that point on. See :ref:`standard-predefined-macros`. They do not have any effect on :samp:`#include`'s
-idea of the directory containing the current file.
+idea of the directory containing the current file.
\ No newline at end of file
macros/predefined-macros
macros/undefining-and-redefining-macros
macros/directives-within-macro-arguments
- macros/macro-pitfalls
+ macros/macro-pitfalls
\ No newline at end of file
COMMAND (quit),
COMMAND (help),
...
- };
+ };
\ No newline at end of file
1 2 1 2
-with the semantics described above.
+with the semantics described above.
\ No newline at end of file
The first two pairs of parentheses in this expansion come from the
macro. The third is the pair that was originally after the macro
invocation. Since ``lang_init`` is an object-like macro, it does not
-consume those parentheses.
+consume those parentheses.
\ No newline at end of file
.. code-block::
#define foo(x) x, "x"
- foo(bar) → bar, "x"
+ foo(bar) → bar, "x"
\ No newline at end of file
an error message citing line three---the line of ignore_second_arg---
even though the problematic code comes from line five.
-We consider this a bug, and intend to fix it in the near future.
+We consider this a bug, and intend to fix it in the near future.
\ No newline at end of file
If the expansion of a macro contains its own name, either directly or
via intermediate macros, it is not expanded again when the expansion is
examined for more macros. This prevents infinite recursion.
-See :ref:`self-referential-macros`, for the precise details.
+See :ref:`self-referential-macros`, for the precise details.
\ No newline at end of file
* - ``xor``
- ``^``
* - ``xor_eq``
- - ``^=``
+ - ``^=``
\ No newline at end of file
macro-expanded first. But ``s`` is an ordinary argument to
``xstr``, so it is completely macro-expanded before ``xstr``
itself is expanded (see :ref:`argument-prescan`). Therefore, by the time
-``str`` gets to its argument, it has already been macro-expanded.
+``str`` gets to its argument, it has already been macro-expanded.
\ No newline at end of file
macro to use the new definition. If the new definition is effectively
the same, the redefinition is silently ignored. This allows, for
instance, two different headers to define a common macro. The
-preprocessor will only complain if the definitions do not match.
+preprocessor will only complain if the definitions do not match.
\ No newline at end of file
GNU CPP previously supported them
with a named variable argument
(:samp:`args...`, not :samp:`...` and ``__VA_ARGS__``), which
-is still supported for backward compatibility.
+is still supported for backward compatibility.
\ No newline at end of file
no effect.
You can also make or cancel assertions using command-line options.
-See :ref:`invocation`.
+See :ref:`invocation`.
\ No newline at end of file
preprocessor output. The primary significance of the existence of the
null directive is that an input line consisting of just a :samp:`#` will
produce no output, rather than a line of output containing just a
-:samp:`#`. Supposedly some old C programs contain such lines.
+:samp:`#`. Supposedly some old C programs contain such lines.
\ No newline at end of file
character-sets
initial-processing
tokenization
- the-preprocessing-language
+ the-preprocessing-language
\ No newline at end of file
If ``#pragma once`` is seen when scanning a header file, that
file will never be read again, no matter what. It is a less-portable
alternative to using :samp:`#ifndef` to guard the contents of header files
- against multiple inclusions.
+ against multiple inclusions.
\ No newline at end of file
will be no space between the :samp:`#` and the directive name. If macro
expansion happens to generate tokens which might be mistaken for a
duplicated directive, a space will be inserted between the :samp:`#` and
-the directive name.
+the directive name.
\ No newline at end of file
may, however, be continued with backslash-newline, or by a block comment
which extends past the end of the line. In either case, when the
directive is processed, the continuations have already been merged with
-the first line to make one long line.
+the first line to make one long line.
\ No newline at end of file
.. [#f1] The C
standard uses the term :dfn:`string literal` to refer only to what we are
- calling :dfn:`string constants`.
+ calling :dfn:`string constants`.
\ No newline at end of file
#include <stdio.h
Just as for the ISO preprocessor, what would be a closing quote can be
-escaped with a backslash to prevent the quoted text from closing.
+escaped with a backslash to prevent the quoted text from closing.
\ No newline at end of file
#define suffix(x) foo_/**/x
suffix(bar)
- → foo_bar
+ → foo_bar
\ No newline at end of file
* If you use digraphs the behavior is undefined.
* If a line that looks like a directive appears within macro arguments,
- the behavior is undefined.
+ the behavior is undefined.
\ No newline at end of file
traditional-lexical-analysis
traditional-macros
traditional-miscellany
- traditional-warnings
+ traditional-warnings
\ No newline at end of file
You can usually avoid the warning, and the related warning about
constants which are so large that they are unsigned, by writing the
integer constant in question in hexadecimal, with no U suffix. Take
- care, though, because this gives the wrong result in exotic cases.
+ care, though, because this gives the wrong result in exotic cases.
\ No newline at end of file
permission notice identical to this one.
Permission is granted to copy and distribute translations of this manual
-into another language, under the above conditions for modified versions.
+into another language, under the above conditions for modified versions.
\ No newline at end of file
:maxdepth: 2
just-which-line-number-anyway
- representation-of-line-numbers
+ representation-of-line-numbers
\ No newline at end of file
the way they have.
.. toctree::
- :maxdepth: 2
+ :maxdepth: 2
\ No newline at end of file
other is found in a special file called :samp:`header.gcc`, stored in the
command line (or system) include directories to which the mapping
applies. This may be higher up the directory tree than the full path to
-the file minus the base name.
+the file minus the base name.
\ No newline at end of file
multiple-include-optimization
files
- indices-and-tables
+ indices-and-tables
\ No newline at end of file
-.. include:: ../../../doc/indices-and-tables.rst
+.. include:: ../../../doc/indices-and-tables.rst
\ No newline at end of file
expansion. Despite this optimization it is still necessary to store
the original parameters to the macro, both for dumping with e.g.,
:option:`-dD`, and to warn about non-trivial macro redefinitions when
-the parameter names have changed.
+the parameter names have changed.
\ No newline at end of file
other than a directive. It passes this token (which may be a
``CPP_EOF`` token indicating the end of the translation unit) to the
callback routine, which can then use the line and column of this token
-to produce correct output.
+to produce correct output.
\ No newline at end of file
failed conditional blocks, and invalidates the control macro of the
multiple-include optimization if a token was successfully lexed outside
a directive. In other words, its callers do not need to concern
-themselves with such issues.
+themselves with such issues.
\ No newline at end of file
correct even if its source buffer is freed with ``_cpp_pop_buffer``.
The storage holding the spellings of such tokens remains until the
client program calls cpp_destroy, probably at the end of the translation
-unit.
+unit.
\ No newline at end of file
function, ``funlike_invocation_p``, which remembers padding
information as it reads tokens. If the next real token is not an
opening parenthesis, it backs up that one token, and then pushes an
-extra context just containing the padding information if necessary.
+extra context just containing the padding information if necessary.
\ No newline at end of file
later popped from the context stack, as described above. This strict
ordering ensures that a macro is disabled whilst its expansion is
being scanned, but that it is *not* disabled whilst any arguments
-to it are being expanded.
+to it are being expanded.
\ No newline at end of file
end of a line if it happens to be in the middle of a macro argument
list, and cpplib only wants to back-up more than one lexer token in
situations where no macro expansion is involved, so the optimization
-is safe.
+is safe.
\ No newline at end of file
``enter_macro_context`` sets ``mi_valid`` to false, so if a macro
was expanded whilst parsing any part of the expression, then the
top-of-file test in ``push_conditional`` fails and the optimization
-is turned off.
+is turned off.
\ No newline at end of file
clients of the library can easily spell a given token, such as
``cpp_spell_token`` and ``cpp_token_len``. These functions are
useful when generating diagnostics, and for emitting the preprocessed
-output.
+output.
\ No newline at end of file
``#assert`` directive. Some built-in macros are handled similarly.
Since these are all processed before the first line of the main input
file, it will typically have an assigned line closer to twenty than to
-one.
+one.
\ No newline at end of file
then tested whether the macro were disabled it would be subtly wrong.
In the example above, the replacement list of :samp:`foo` would be
popped in the process of finding the parenthesis, re-enabling
-:samp:`foo` and expanding it a second time.
+:samp:`foo` and expanding it a second time.
\ No newline at end of file
library. It might also be necessary to specify different startup files
and other runtime support libraries, and to suppress the use of GCC's
support libraries with one or more of the options :option:`-nostdlib`,
-:option:`-nostartfiles`, and :option:`-nodefaultlibs`.
+:option:`-nostartfiles`, and :option:`-nodefaultlibs`.
\ No newline at end of file
:maxdepth: 2
conditionally-supported-behavior
- exception-handling
+ exception-handling
\ No newline at end of file
c-implementation-defined-behavior/preprocessing-directives
c-implementation-defined-behavior/library-functions
c-implementation-defined-behavior/architecture
- c-implementation-defined-behavior/locale-specific-behavior
+ c-implementation-defined-behavior/locale-specific-behavior
\ No newline at end of file
* The value of the result of the ``sizeof`` and ``_Alignof``
operators (C90 6.3.3.4, C99 and C11 6.5.3.4).
- Determined by ABI.
+ Determined by ABI.
\ No newline at end of file
The value is as specified in the standard and the type is determined
by the ABI.
-.. [#f1] Future versions of GCC may zero-extend, or use a target-defined ``ptr_extend`` pattern. Do not rely on sign extension.
+.. [#f1] Future versions of GCC may zero-extend, or use a target-defined ``ptr_extend`` pattern. Do not rely on sign extension.
\ No newline at end of file
See :ref:`cpp:implementation-defined-behavior`. ``char16_t`` and
``char32_t`` literals are always encoded in UTF-16 and UTF-32
- respectively.
+ respectively.
\ No newline at end of file
* The maximum number of declarators that may modify an arithmetic,
structure or union type (C90 6.5.4).
- GCC is only limited by available memory.
+ GCC is only limited by available memory.
\ No newline at end of file
and the source character set in translation phase 1 (C90, C99 and C11
5.1.1.2).
- See :ref:`cpp:implementation-defined-behavior`.
+ See :ref:`cpp:implementation-defined-behavior`.
\ No newline at end of file
IEC 60559 conformant implementation (C99 F.9).
This is dependent on the implementation of the C library, and is not
- defined by GCC itself.
+ defined by GCC itself.
\ No newline at end of file
GCC will not inline any functions if the :option:`-fno-inline` option is
used or if :option:`-O0` is used. Otherwise, GCC may still be unable to
inline a function for many reasons; the :option:`-Winline` option may be
- used to determine if a function has not been inlined and why not.
+ used to determine if a function has not been inlined and why not.
\ No newline at end of file
This is a property of the linker. C99 and C11 require that case distinctions
are always significant in identifiers with external linkage and
- systems without this property are not supported by GCC.
+ systems without this property are not supported by GCC.
\ No newline at end of file
* The sign of the remainder on integer division (C90 6.3.5).
GCC always follows the C99 and C11 requirement that the result of division is
- truncated towards zero.
+ truncated towards zero.
\ No newline at end of file
In ``<stddef.h>``, ``NULL`` expands to ``((void *)0)``. GCC
does not provide the other headers which define ``NULL`` and some
- library implementations may use other definitions in those headers.
+ library implementations may use other definitions in those headers.
\ No newline at end of file
************************
The behavior of these points are dependent on the implementation
-of the C library, and are not defined by GCC itself.
+of the C library, and are not defined by GCC itself.
\ No newline at end of file
* The definitions for ``__DATE__`` and ``__TIME__`` when
respectively, the date and time of translation are not available (C90
- 6.8.8, C99 6.10.8, C11 6.10.8.1).
+ 6.8.8, C99 6.10.8, C11 6.10.8.1).
\ No newline at end of file
When an object of an aggregate type, with the same size and alignment as a
scalar type ``S``, is the subject of a volatile access by an assignment
expression or an atomic function, the access to it is performed as if the
- object's declared type were ``volatile S``.
+ object's declared type were ``volatile S``.
\ No newline at end of file
* The maximum number of ``case`` values in a ``switch``
statement (C90 6.6.4.2).
- GCC is only limited by available memory.
+ GCC is only limited by available memory.
\ No newline at end of file
.. conforming to C90 on those targets.
On some targets, :option:`-fshort-enums` is the default; this is
- determined by the ABI.
+ determined by the ABI.
\ No newline at end of file
new-line is retained or replaced by one space character in translation
phase 3 (C90, C99 and C11 5.1.1.2).
- See :ref:`cpp:implementation-defined-behavior`.
+ See :ref:`cpp:implementation-defined-behavior`.
\ No newline at end of file
Such argument passing is supported, using the same
pass-by-invisible-reference approach used for normal function
- arguments of such types.
+ arguments of such types.
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../doc/contribute.rst
+.. include:: ../../../doc/contribute.rst
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../doc/contrib.rst
+.. include:: ../../../doc/contrib.rst
\ No newline at end of file
You have freedom to copy and modify this GNU Manual, like GNU
software. Copies published by the Free Software Foundation raise
- funds for GNU development.
+ funds for GNU development.
\ No newline at end of file
implementation-defined whether or not the stack is unwound before
std::terminate() is called (C++98 15.5.1).
- The stack is not unwound before std::terminate is called.
+ The stack is not unwound before std::terminate is called.
\ No newline at end of file
extensions-to-the-c++-language/c++-interface-and-implementation-pragmas
extensions-to-the-c++-language/wheres-the-template
extensions-to-the-c++-language/extracting-the-function-pointer-from-a-bound-pointer-to-member-function
- extensions-to-the-c++-language/c++-specific-variable-function-and-type-attributes
+ extensions-to-the-c++-language/c++-specific-variable-function-and-type-attributes
\ No newline at end of file
scope to set the language. On such systems, all system header files are
implicitly scoped inside a C language scope. Such headers must
correctly prototype function argument types, there is no leeway for
- ``()`` to indicate an unspecified set of arguments.
+ ``()`` to indicate an unspecified set of arguments.
\ No newline at end of file
likely to be removed in the future.
``__is_same (type1, type2)``
- A binary type trait: ``true`` whenever the type arguments are the same.
+ A binary type trait: ``true`` whenever the type arguments are the same.
\ No newline at end of file
that can be found via pointers (or by callers compiled without
inlining). If all calls to the function can be inlined, you can avoid
emitting the function by compiling with :option:`-fno-implement-inlines`.
-If any calls are not inlined, you will get linker errors.
+If any calls are not inlined, you will get linker errors.
\ No newline at end of file
control a resource, such as ``std::lock_guard``.
This attribute is also accepted in C, but it is unnecessary because C
- does not have constructors or destructors.
+ does not have constructors or destructors.
\ No newline at end of file
G++ allows anonymous structs and unions to have members that are not
public non-static data members (i.e. fields). These extensions are
-deprecated.
+deprecated.
\ No newline at end of file
.. index:: Wno-pmf-conversions
-You must specify :option:`-Wno-pmf-conversions` to use this extension.
+You must specify :option:`-Wno-pmf-conversions` to use this extension.
\ No newline at end of file
taken just like a regular function. GCC takes care of doing the
dispatching to call the right version at runtime. Refer to the
`GCC wiki on
-Function Multiversioning <https://gcc.gnu.org/wiki/FunctionMultiVersioning>`_ for more details.
+Function Multiversioning <https://gcc.gnu.org/wiki/FunctionMultiVersioning>`_ for more details.
\ No newline at end of file
As with all outermost parameter qualifiers, ``__restrict__`` is
ignored in function definition matching. This means you only need to
specify ``__restrict__`` in a function definition, rather than
-in a function prototype as well.
+in a function prototype as well.
\ No newline at end of file
When used as the pattern of a pack expansion within a template
definition, expands to a template argument pack containing integers
from ``0`` to ``length-1``. This is provided for efficient
- implementation of ``std::make_integer_sequence``.
+ implementation of ``std::make_integer_sequence``.
\ No newline at end of file
almost certainly breaks things.
See :ref:`c++-interface`, for
-another way to control placement of these constructs.
+another way to control placement of these constructs.
\ No newline at end of file
.. code-block:: c++
volatile int vobj;
- volatile int &vref = vobj = something;
+ volatile int &vref = vobj = something;
\ No newline at end of file
.. code-block:: c++
inline template class Foo<int>;
- static template class Foo<int>;
+ static template class Foo<int>;
\ No newline at end of file
extensions-to-the-c-language-family/pragmas-accepted-by-gcc
extensions-to-the-c-language-family/unnamed-structure-and-union-fields
extensions-to-the-c-language-family/thread-local-storage
- extensions-to-the-c-language-family/binary-constants-using-the-0b-prefix
+ extensions-to-the-c-language-family/binary-constants-using-the-0b-prefix
\ No newline at end of file
Simply write ``__int128`` for a signed 128-bit integer, or
``unsigned __int128`` for an unsigned 128-bit integer. There is no
support in GCC for expressing an integer constant of type ``__int128``
-for targets with ``long long`` integer less than 128 bits wide.
+for targets with ``long long`` integer less than 128 bits wide.
\ No newline at end of file
.. code-block:: c++
typedef _Complex float __attribute__((mode(KC))) _Complex_float128;
- typedef _Complex float __attribute__((mode(IC))) _Complex_ibm128;
+ typedef _Complex float __attribute__((mode(IC))) _Complex_ibm128;
\ No newline at end of file
You can
prevent such warnings within one expression by writing
``__extension__`` before the expression. ``__extension__`` has no
-effect aside from this.
+effect aside from this.
\ No newline at end of file
definition (lacking ``inline`` and ``extern``) in a library file.
The definition in the header file causes most calls to the function
to be inlined. If any uses of the function remain, they refer to
-the single copy in the library.
+the single copy in the library.
\ No newline at end of file
.. index:: Wpointer-arith
The option :option:`-Wpointer-arith` requests a warning if these extensions
-are used.
+are used.
\ No newline at end of file
struct foo a = { 1, { 2, 3, 4 } }; // Valid.
struct bar b = { { 1, { 2, 3, 4 } } }; // Invalid.
struct bar c = { { 1, { } } }; // Valid.
- struct foo d[1] = { { 1, { 2, 3, 4 } } }; // Invalid.
+ struct foo d[1] = { { 1, { 2, 3, 4 } } }; // Invalid.
\ No newline at end of file
last one must end with a semicolon, which is followed by the 'real'
parameter declarations. Each forward declaration must match a 'real'
declaration in parameter name and data type. ISO C99 does not support
-parameter forward declarations.
+parameter forward declarations.
\ No newline at end of file
pointer-to-function type, it is treated as applying to the pointer
target type; if such an attribute is applied to a function return type
that is not a pointer-to-function type, it is treated as applying
-to the function type.
+to the function type.
\ No newline at end of file
The type of these constants follows the same rules as for octal or
hexadecimal integer constants, so suffixes like :samp:`L` or :samp:`UL`
-can be applied.
+can be applied.
\ No newline at end of file
:samp:`{ptr}` is an optional pointer to the object that may be used to determine
alignment. A value of 0 indicates typical alignment should be used. The
- compiler may also ignore this parameter.
+ compiler may also ignore this parameter.
\ No newline at end of file
The compiler will attempt to use hardware instructions to implement
these built-in functions where possible, like conditional jump on overflow
- after addition, conditional jump on carry etc.
+ after addition, conditional jump on carry etc.
\ No newline at end of file
such comments, and they are included in the 1999 C standard. However,
C++ style comments are not recognized if you specify an :option:`-std`
option specifying a version of ISO C before C99, or :option:`-ansi`
-(equivalent to :option:`-std=c90`).
+(equivalent to :option:`-std=c90`).
\ No newline at end of file
.. code-block:: c++
- case 1...5:
+ case 1...5:
\ No newline at end of file
void hack (union foo);
/* ... */
- hack ((union foo) x);
+ hack ((union foo) x);
\ No newline at end of file
real binary floating-point type, and the result has the corresponding
complex type with real and imaginary parts :samp:`{real}` and :samp:`{imag}`.
Unlike :samp:`{real} + I * {imag}`, this works even when
- infinities, NaNs and negative zeros are involved.
+ infinities, NaNs and negative zeros are involved.
\ No newline at end of file
elements of type ``char *const`` rather than ``char *``, or if
``foo`` were a global variable, the array would have static storage
duration. But it is probably safest just to avoid the use of array
-compound literals in C++ code.
+compound literals in C++ code.
\ No newline at end of file
or may (if it is a macro argument), contain a side effect. Then repeating
the operand in the middle would perform the side effect twice. Omitting
the middle operand uses the value already computed without the undesirable
-effects of recomputing it.
+effects of recomputing it.
\ No newline at end of file
return open (path, oflag, __builtin_va_arg_pack ());
}
- #endif
+ #endif
\ No newline at end of file
the technical report.
Types ``_Decimal32``, ``_Decimal64``, and ``_Decimal128``
-are supported by the DWARF debug information format.
+are supported by the DWARF debug information format.
\ No newline at end of file
declaring-attributes-of-functions/v850-function-attributes
declaring-attributes-of-functions/visium-function-attributes
declaring-attributes-of-functions/x86-function-attributes
- declaring-attributes-of-functions/xstormy16-function-attributes
+ declaring-attributes-of-functions/xstormy16-function-attributes
\ No newline at end of file
Note that CPU tuning options and attributes such as the :option:`-mcpu=`,
:option:`-mtune=` do not inhibit inlining unless the CPU specified by the
:option:`-mcpu=` option or the :gcc-attr:`cpu=` attribute conflicts with the
-architectural feature rules specified above.
+architectural feature rules specified above.
\ No newline at end of file
``work_item_id_Z``
Set ``enable_vgpr_workitem_id`` parameter. Always on (required to use
- OpenACC/OpenMP).
+ OpenACC/OpenMP).
\ No newline at end of file
can safely be included in naked functions (see :ref:`basic-asm`). While
using extended ``asm`` or a mixture of basic ``asm`` and C code
may appear to work, they cannot be depended upon to work reliably and
- are not supported.
+ are not supported.
\ No newline at end of file
In this example ``target("+crc+nocrypto")`` enables the ``crc``
extension and disables the ``crypto`` extension for the function ``foo``
- without modifying an existing :option:`-march=` or :option:`-mcpu` option.
+ without modifying an existing :option:`-march=` or :option:`-mcpu` option.
\ No newline at end of file
application which is responsibility of the application.
If both :avr-fn-attr:`signal` and :avr-fn-attr:`interrupt` are specified for the same
- function, :avr-fn-attr:`signal` is silently ignored.
+ function, :avr-fn-attr:`signal` is silently ignored.
\ No newline at end of file
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.
+ regardless of whether they are used or not.
\ No newline at end of file
.. code-block:: c++
int bpf_probe_read (void *dst, int size, const void *unsafe_ptr)
- __attribute__ ((kernel_helper (4)));
+ __attribute__ ((kernel_helper (4)));
\ No newline at end of file
``asm`` statements can safely be included in naked functions
(see :ref:`basic-asm`). While using extended ``asm`` or a mixture of
basic ``asm`` and C code may appear to work, they cannot be
- depended upon to work reliably and are not supported.
+ depended upon to work reliably and are not supported.
\ No newline at end of file
therefore, a caller cannot assume that the register has the same contents
on return from the function as it had before calling the function. Such
registers are also called 'call-clobbered', 'caller-saved', or
- 'volatile'.
+ 'volatile'.
\ No newline at end of file
These attributes specify how a particular function is called.
These attributes override the
:option:`-mlong-calls` (see :ref:`adapteva-epiphany-options`)
- command-line switch and ``#pragma long_calls`` settings.
+ command-line switch and ``#pragma long_calls`` settings.
\ No newline at end of file
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.
+ regardless of whether they are used or not.
\ No newline at end of file
extern int foo () __attribute__((version_id ("20040821")));
- Calls to ``foo`` are mapped to calls to ``foo{20040821}``.
+ Calls to ``foo`` are mapped to calls to ``foo{20040821}``.
\ No newline at end of file
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.
+ when this attribute is present.
\ No newline at end of file
Large model objects may live anywhere in the 32-bit address space (the
compiler generates ``seth/add3`` instructions to load their addresses),
and may not be reachable with the ``bl`` instruction (the compiler
- generates the much slower ``seth/add3/jl`` instruction sequence).
+ generates the much slower ``seth/add3/jl`` instruction sequence).
\ No newline at end of file
that the specified function is an interrupt handler that is designed
to run as a thread. The compiler omits generate prologue/epilogue
sequences and replaces the return instruction with a ``sleep``
- instruction. This attribute is available only on fido.
+ instruction. This attribute is available only on fido.
\ No newline at end of file
``asm`` statements can safely be included in naked functions
(see :ref:`basic-asm`). While using extended ``asm`` or a mixture of
basic ``asm`` and C code may appear to work, they cannot be
- depended upon to work reliably and are not supported.
+ depended upon to work reliably and are not supported.
\ No newline at end of file
The :mep-fn-attr:`vliw` attribute tells the compiler to emit
instructions in VLIW mode instead of core mode. Note that this
attribute is not allowed unless a VLIW coprocessor has been configured
- and enabled through command-line options.
+ and enabled through command-line options.
\ No newline at end of file
used in low-latency interrupt mode, and :microblaze-fn-attr:`interrupt_handler` for
interrupts that do not use low-latency handlers. In both cases, GCC
emits appropriate prologue code and generates a return from the handler
- using ``rtid`` instead of ``rtsd``.
+ using ``rtid`` instead of ``rtsd``.
\ No newline at end of file
:microsoft-windows-fn-attr:`dllimport` attribute can be used as a constant initializer; in
this case, the address of a stub function in the import lib is
referenced. On Microsoft Windows targets, the attribute can be disabled
- for functions by setting the :option:`-mnop-fun-dllimport` flag.
+ for functions by setting the :option:`-mnop-fun-dllimport` flag.
\ No newline at end of file
On MIPS targets, you can use the :mips-fn-attr:`nocompression` function attribute
to locally turn off MIPS16 and microMIPS code generation. This attribute
overrides the :option:`-mips16` and :option:`-mmicromips` options on the
- command line (see :ref:`mips-options`).
+ command line (see :ref:`mips-options`).
\ No newline at end of file
one pass over the objects and does the best that it can. Using the
:option:`-ffunction-sections` and :option:`-fdata-sections` command-line
options can help the packing, however, since they produce smaller,
- easier to pack regions.
+ easier to pack regions.
\ No newline at end of file
.. index:: warm function attribute, NDS32
- Provide a user-defined function to handle warm reset exception.
+ Provide a user-defined function to handle warm reset exception.
\ No newline at end of file
This attribute corresponds to the :option:`-mcustom-fpu-cfg=name`
command-line option, to select a predefined set of custom instructions
named :samp:`{name}`.
- See :ref:`nios-ii-options`, for more information.
+ See :ref:`nios-ii-options`, for more information.
\ No newline at end of file
library.
By default functions are only callable only from other PTX functions.
- Kernel functions must have ``void`` return type.
+ Kernel functions must have ``void`` return type.
\ No newline at end of file
On the PowerPC, the inliner does not inline a
function that has different target options than the caller, unless the
- callee has a subset of the target options of the caller.
+ callee has a subset of the target options of the caller.
\ No newline at end of file
Permissible values for this parameter are ``user``, ``supervisor``,
and ``machine``. If there is no parameter, then it defaults to
- ``machine``.
+ ``machine``.
\ No newline at end of file
``asm`` statements can safely be included in naked functions
(see :ref:`basic-asm`). While using extended ``asm`` or a mixture of
basic ``asm`` and C code may appear to work, they cannot be
- depended upon to work reliably and are not supported.
+ depended upon to work reliably and are not supported.
\ No newline at end of file
This RX attribute is similar to the :rx-fn-attr:`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
- :rx-fn-attr:`interrupt` attribute for a description of its arguments.
+ :rx-fn-attr:`interrupt` attribute for a description of its arguments.
\ No newline at end of file
target("no-vx")
- does not undefine the ``__VEC__`` macro.
+ does not undefine the ``__VEC__`` macro.
\ No newline at end of file
.. sh-fn-attr:: trapa_handler
On SH targets this function attribute is similar to :sh-fn-attr:`interrupt_handler`
- but it does not save and restore all registers.
+ but it does not save and restore all registers.
\ No newline at end of file
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
See :ref:`microsoft-windows-function-attributes`, for discussion of the
-:symbian-os-fn-attr:`dllexport` and :symbian-os-fn-attr:`dllimport` attributes.
+:symbian-os-fn-attr:`dllexport` and :symbian-os-fn-attr:`dllimport` attributes.
\ No newline at end of file
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
- when either attribute is present.
+ when either attribute is present.
\ No newline at end of file
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.
+ when this attribute is present.
\ No newline at end of file
.. option:: nodirect_extern_access
This attribute, attached to a global variable or function, is the
- counterpart to option :option:`-mno-direct-extern-access`.
+ counterpart to option :option:`-mno-direct-extern-access`.
\ No newline at end of file
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.
+ when this attribute is present.
\ No newline at end of file
the entire structure from the last field initialized is used. If any previous
initializer has side effect, it is unspecified whether the side effect
happens or not. Currently, GCC discards the side-effecting
-initializer expressions and issues a warning.
+initializer expressions and issues a warning.
\ No newline at end of file
If the operand of the ``__alignof__`` expression is a function,
the expression evaluates to the alignment of the function which may
-be specified by attribute :fn-attr:`aligned` (see :ref:`common-function-attributes`).
+be specified by attribute :fn-attr:`aligned` (see :ref:`common-function-attributes`).
\ No newline at end of file
In GNU C, you may normally use dollar signs in identifier names.
This is because many traditional C implementations allow such identifiers.
However, dollar signs in identifiers are not supported on a few target
-machines, typically because the target assembler does not allow them.
+machines, typically because the target assembler does not allow them.
\ No newline at end of file
``long long int``, confusion results because the caller and the
subroutine disagree about the number of bytes for the argument.
Likewise, if the function expects ``long long int`` and you pass
-``int``. The best way to avoid such problems is to use prototypes.
+``int``. The best way to avoid such problems is to use prototypes.
\ No newline at end of file
The :enum-attr:`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 :enum-attr:`deprecated` attribute.
+ same manner as the :enum-attr:`deprecated` attribute.
\ No newline at end of file
* Pragmas to control overflow and rounding behaviors are not implemented.
-Fixed-point types are supported by the DWARF debug information format.
+Fixed-point types are supported by the DWARF debug information format.
\ No newline at end of file
also be used as format arguments. Note that the relevant headers are only likely to be
available on Darwin (OSX) installations. On such installations, the XCode and system
documentation provide descriptions of ``CFString``, ``CFStringRefs`` and
-associated functions.
+associated functions.
\ No newline at end of file
These identifiers are variables, not preprocessor macros, and may not
be used to initialize ``char`` arrays or be concatenated with string
-literals.
+literals.
\ No newline at end of file
effects, including crashing the calling program. As a result, calls
that are considered unsafe are diagnosed when the :option:`-Wframe-address`
option is in effect. Such calls should only be made in debugging
- situations.
+ situations.
\ No newline at end of file
and :option:`-mfpmath=sse`. If there is no :option:`-mfpmath=sse`,
:option:`-fexcess-precision=standard` alone does the same thing as before,
It is useful for code that does not have ``_Float16`` and runs on the x87
-FPU.
+FPU.
\ No newline at end of file
is always required in the hexadecimal notation. Otherwise the compiler
would not be able to resolve the ambiguity of, e.g., ``0x1.f``. This
could mean ``1.0f`` or ``1.9375`` since :samp:`f` is also the
-extension for floating-point constants of type ``float``.
+extension for floating-point constants of type ``float``.
\ No newline at end of file
This size is also used for inlining decisions. If you use ``asm inline``
instead of just ``asm``, then for inlining purposes the size of the asm
-is taken as the minimum size, ignoring how many instructions GCC thinks it is.
+is taken as the minimum size, ignoring how many instructions GCC thinks it is.
\ No newline at end of file
``enum`` more consistent with the way ``struct`` and ``union``
are handled.
-This extension is not supported by GNU C++.
+This extension is not supported by GNU C++.
\ No newline at end of file
The :label-attr:`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 ``__builtin_expect`` cannot be used, for instance
- with computed goto or ``asm goto``.
+ with computed goto or ``asm goto``.
\ No newline at end of file
.. [#f1] The analogous feature in Fortran is called an assigned goto, but that name seems inappropriate in
C, where one can do more than simply store label addresses in label
- variables.
+ variables.
\ No newline at end of file
but rather a :dfn:`release barrier`.
This means that all previous memory stores are globally visible, and all
previous memory loads have been satisfied, but following memory reads
- are not prevented from being speculated to before the barrier.
+ are not prevented from being speculated to before the barrier.
\ No newline at end of file
})
Local label declarations also make the labels they declare visible to
-nested functions, if there are any. See :ref:`nested-functions`, for details.
+nested functions, if there are any. See :ref:`nested-functions`, for details.
\ No newline at end of file
do provide some variable arguments in your macro invocation, GNU CPP
does not complain about the paste operation and instead places the
variable arguments after the comma. Just like any other pasted macro
-argument, these arguments are not macro expanded.
+argument, these arguments are not macro expanded.
\ No newline at end of file
int j = i + 2;
Each identifier is visible from where it is declared until the end of
-the enclosing block.
+the enclosing block.
\ No newline at end of file
that it installed previously.
The preprocessor symbols ``__SEG_FS`` and ``__SEG_GS`` are
- defined when these address spaces are supported.
+ defined when these address spaces are supported.
\ No newline at end of file
return array[index + offset];
}
/* ... */
- }
+ }
\ No newline at end of file
{
float beat_freqs[2] = { f-g, f+g };
/* ... */
- }
+ }
\ No newline at end of file
bar (int index)
{
return f().a[index];
- }
+ }
\ No newline at end of file
mechanism to restore the stack context, it cannot be called
from the same function calling ``__builtin_setjmp`` to
initialize :samp:`{buf}`. It can only be called from a function called
- (directly or indirectly) from the function calling ``__builtin_setjmp``.
+ (directly or indirectly) from the function calling ``__builtin_setjmp``.
\ No newline at end of file
These have just one additional argument, :samp:`{flag}`, right before
format string :samp:`{fmt}`. If the compiler is able to optimize them to
``fputc`` etc. functions, it does, otherwise the checking function
-is called and the :samp:`{flag}` argument passed to it.
+is called and the :samp:`{flag}` argument passed to it.
\ No newline at end of file
.. function:: int __builtin_goacc_parlevel_size (int x)
Returns the openacc gang, worker or vector size depending on whether :samp:`{x}` is
- 0, 1 or 2.
+ 0, 1 or 2.
\ No newline at end of file
pointer type.
In particular, in GNU C :samp:`va_arg (ap, void *)` can safely be used
-to consume an argument of any pointer type.
+to consume an argument of any pointer type.
\ No newline at end of file
double x[3][2];
double y[2][3];
...
- transpose(3, 2, y, x);
+ transpose(3, 2, y, x);
\ No newline at end of file
It must be placed immediately before a ``for``, ``while`` or ``do``
loop or a ``#pragma GCC ivdep``, and applies only to the loop that follows.
:samp:`{n}` is an integer constant expression specifying the unrolling factor.
- The values of 0 and 1 block any unrolling of the loop.
+ The values of 0 and 1 block any unrolling of the loop.
\ No newline at end of file
}
GNU C++ does not support old-style function definitions, so this
-extension is irrelevant.
+extension is irrelevant.
\ No newline at end of file
* If the argument to the macro has variably modified type, it is
evaluated only once when using ``__auto_type``, but twice if
- ``typeof`` is used.
+ ``typeof`` is used.
\ No newline at end of file
lines to form a single logical line. This works within comments and
tokens, as well as between tokens. Comments are *not* treated as
whitespace for the purposes of this relaxation, since they have not
-yet been replaced with spaces.
+yet been replaced with spaces.
\ No newline at end of file
command-line options, respectively;
see :ref:`x86-options`, for details of how structure layout is affected.
See :ref:`x86-variable-attributes`, for information about the corresponding
- attributes on variables.
+ attributes on variables.
\ No newline at end of file
allowed also), GCC places the variable in the first 0x100 bytes of
memory and use special opcodes to access it. Such variables are
placed in either the ``.bss_below100`` section or the
- ``.data_below100`` section.
+ ``.data_below100`` section.
\ No newline at end of file
}
``y`` is not actually incremented and the compiler can but does not
- have to optimize it to just ``return 42 + 42;``.
+ have to optimize it to just ``return 42 + 42;``.
\ No newline at end of file
calls ``foo`` and ``bar1`` and does not call ``baz`` but
may or may not call ``bar2``. If ``bar2`` is called, it is
-called after ``foo`` and before ``bar1``.
+called after ``foo`` and before ``bar1``.
\ No newline at end of file
The structure has size zero. In C++, empty structures are part
of the language. G++ treats empty structures as if they had a single
-member of type ``char``.
+member of type ``char``.
\ No newline at end of file
is a suitable definition of the ``offsetof`` macro. In C++, :samp:`{type}`
may be dependent. In either case, :samp:`{member}` may consist of a single
-identifier, or a sequence of member accesses and array references.
+identifier, or a sequence of member accesses and array references.
\ No newline at end of file
target-builtins/ti-c6x-built-in-functions
target-builtins/x86-built-in-functions
target-builtins/x86-transactional-memory-intrinsics
- target-builtins/x86-control-flow-protection-intrinsics
+ target-builtins/x86-control-flow-protection-intrinsics
\ No newline at end of file
unsigned long long __builtin_aarch64_get_fpcr64 ();
void __builtin_aarch64_set_fpcr64 (unsigned long long);
unsigned long long __builtin_aarch64_get_fpsr64 ();
- void __builtin_aarch64_set_fpsr64 (unsigned long long);
+ void __builtin_aarch64_set_fpsr64 (unsigned long long);
\ No newline at end of file
.. code-block:: c++
void *__builtin_thread_pointer (void);
- void __builtin_set_thread_pointer (void *);
+ void __builtin_set_thread_pointer (void *);
\ No newline at end of file
void * __builtin_custom_pnfp (float, void *);
void * __builtin_custom_pnpi (void *, int);
void * __builtin_custom_pnpf (void *, float);
- void * __builtin_custom_pnpp (void *, void *);
+ void * __builtin_custom_pnpp (void *, void *);
\ No newline at end of file
__builtin_arc_lr()
__builtin_arc_sleep()
__builtin_arc_sr()
- __builtin_arc_swi()
+ __builtin_arc_swi()
\ No newline at end of file
.. code-block:: c++
void __builtin_arc_vst16_n (__v8hi, const int, const int, const int);
- void __builtin_arc_vst32_n (__v8hi, const int, const int, const int);
+ void __builtin_arc_vst32_n (__v8hi, const int, const int, const int);
\ No newline at end of file
void * cmse_check_address_range (void *, size_t, int);
typeof(p) cmse_nsfptr_create (FPTR p);
intptr_t cmse_is_nsfptr (FPTR);
- int cmse_nonsecure_caller (void);
+ int cmse_nonsecure_caller (void);
\ No newline at end of file
intrinsics yet.
See :ref:`arm-options` and :ref:`aarch64-options` for more information on the
-availability of extensions.
+availability of extensions.
\ No newline at end of file
.. code-block:: c++
unsigned int __builtin_arm_get_fpscr ();
- void __builtin_arm_set_fpscr (unsigned int);
+ void __builtin_arm_set_fpscr (unsigned int);
\ No newline at end of file
v4hi __builtin_arm_wunpckilh (v4hi, v4hi);
v2si __builtin_arm_wunpckilw (v2si, v2si);
long long __builtin_arm_wxor (long long, long long);
- long long __builtin_arm_wzero ();
+ long long __builtin_arm_wzero ();
\ No newline at end of file
unsigned fract get_bits (uint_ur_t uval)
{
return urbits (uval);
- }
+ }
\ No newline at end of file
ISA 3.1 ``stxvrbx``, ``stxvrhx``, ``stxvrwx``, and ``stxvrdx``
instructions.
-.. index:: vec_xst_trunc
+.. index:: vec_xst_trunc
\ No newline at end of file
.. code-block:: c++
void __builtin_bfin_csync (void);
- void __builtin_bfin_ssync (void);
+ void __builtin_bfin_ssync (void);
\ No newline at end of file
val >>= __builtin_preserve_field_info (arg->y, FIELD_RSHIFT_U64);
return val;
- }
+ }
\ No newline at end of file
.. function:: void __data_prefetch (const void *x)
Use the ``nldub`` instruction to load the contents of address :samp:`{x}`
- into the data cache. The instruction is issued in slot I1.
+ into the data cache. The instruction is issued in slot I1.
\ No newline at end of file
a64 __builtin_mips_dpaqx_s_w_ph (a64, v2q15, v2q15);
a64 __builtin_mips_dpaqx_sa_w_ph (a64, v2q15, v2q15);
a64 __builtin_mips_dpsqx_s_w_ph (a64, v2q15, v2q15);
- a64 __builtin_mips_dpsqx_sa_w_ph (a64, v2q15, v2q15);
+ a64 __builtin_mips_dpsqx_sa_w_ph (a64, v2q15, v2q15);
\ No newline at end of file
if (__builtin_mips_all_c_eq_4s (a, b, c, d))
all_are_true ();
else
- some_are_false ();
+ some_are_false ();
\ No newline at end of file
On little-endian targets, the first value is the lower one and the second
value is the upper one. The opposite order applies to big-endian targets.
For example, the code above sets the lower half of ``a`` to
- ``1.5`` on little-endian targets and ``9.1`` on big-endian targets.
+ ``1.5`` on little-endian targets and ``9.1`` on big-endian targets.
\ No newline at end of file
v16u8 __builtin_msa_xor_v (v16u8, v16u8);
- v16u8 __builtin_msa_xori_b (v16u8, imm0_255);
+ v16u8 __builtin_msa_xori_b (v16u8, imm0_255);
\ No newline at end of file
instructions. Note that :samp:`{cycles}` must be a compile-time constant
integer - that is, you must pass a number, not a variable that may be
optimized to a constant later. The number of cycles delayed by this
- builtin is exact.
+ builtin is exact.
\ No newline at end of file
.. function:: void __builtin_nds32_setgie_dis (void)
- Disable global interrupt.
+ Disable global interrupt.
\ No newline at end of file
code but can be called in both MIPS16 and non-MIPS16 contexts.
``__builtin_mips_set_fcsr`` can be used to change any bit of the
- register except the condition codes, which GCC assumes are preserved.
+ register except the condition codes, which GCC assumes are preserved.
\ No newline at end of file
.. function:: void __builtin_halt (void)
Halt. The processor stops execution. This built-in is useful for
- implementing assertions.
+ implementing assertions.
\ No newline at end of file
int vec_any_ge (vector signed __int128, vector signed __int128);
int vec_any_ge (vector unsigned __int128, vector unsigned __int128);
int vec_any_le (vector signed __int128, vector signed __int128);
- int vec_any_le (vector unsigned __int128, vector unsigned __int128);
+ int vec_any_le (vector unsigned __int128, vector unsigned __int128);
\ No newline at end of file
void amo_stdat_sadd (int64_t *, int64_t);
void amo_stdat_smax (int64_t *, int64_t);
- void amo_stdat_smin (int64_t *, int64_t);
+ void amo_stdat_smin (int64_t *, int64_t);
\ No newline at end of file
break;
}
}
- }
+ }
\ No newline at end of file
vec_t __builtin_vsx_xvcvbf16spn (vec_t);
__vector_pair __builtin_vsx_lxvp (size_t, __vector_pair *);
- void __builtin_vsx_stxvp (__vector_pair, size_t, __vector_pair *);
+ void __builtin_vsx_stxvp (__vector_pair, size_t, __vector_pair *);
\ No newline at end of file
This inserts LMBD instruction to calculate the left-most bit with value
:samp:`{bitval}` in value :samp:`{wordval}`. Only the least significant bit
- of :samp:`{bitval}` is taken into account.
+ of :samp:`{bitval}` is taken into account.
\ No newline at end of file
.. function:: void * __builtin_thread_pointer (void)
- Returns the value that is currently set in the :samp:`tp` register.
+ Returns the value that is currently set in the :samp:`tp` register.
\ No newline at end of file
.. function:: void __builtin_rx_wait (void)
- Generates the ``wait`` machine instruction.
+ Generates the ``wait`` machine instruction.
\ No newline at end of file
Generates the ``ntstg`` machine instruction. The second argument
is written to the first arguments location. The store operation will
- not be rolled-back in case of an transaction abort.
+ not be rolled-back in case of an transaction abort.
\ No newline at end of file
.. function:: void __builtin_sh_set_fpscr (unsigned int val)
Sets the :samp:`FPSCR` register to the specified value :samp:`{val}`, while
- preserving the current values of the FR, SZ and PR bits.
+ preserving the current values of the FR, SZ and PR bits.
\ No newline at end of file
long __builtin_vis_fpcmpur8shl (v8qi, v8qi, int);
long __builtin_vis_fpcmpur16shl (v4hi, v4hi, int);
- long __builtin_vis_fpcmpur32shl (v2si, v2si, int);
+ long __builtin_vis_fpcmpur32shl (v2si, v2si, int);
\ No newline at end of file
int _extr (int, int);
int _extru (int, int);
int _abs (int);
- int _abs2 (int);
+ int _abs2 (int);
\ No newline at end of file
void __builtin_ia32_wrussd(unsigned int, void *);
void __builtin_ia32_wrussq(unsigned long long, void *);
void __builtin_ia32_setssbsy(void);
- void __builtin_ia32_clrssbsy(void *);
+ void __builtin_ia32_clrssbsy(void *);
\ No newline at end of file
while (0)
This code runs unconditionally on all 64-bit processors. For 32-bit
-processors the code runs on those that support multi-byte NOP instructions.
+processors the code runs on those that support multi-byte NOP instructions.
\ No newline at end of file
}
Note that, in most cases, the transactional and non-transactional code
-must synchronize together to ensure consistency.
+must synchronize together to ensure consistency.
\ No newline at end of file
******************************
You can use the sequence :samp:`\\e` in a string or character constant to
-stand for the ASCII character ESC.
+stand for the ASCII character ESC.
\ No newline at end of file
Add after paragraph 6
- Non- ``static`` members shall not be ``__thread``.
+ Non- ``static`` members shall not be ``__thread``.
\ No newline at end of file
struct s2 { s1; };
s1 f1 (struct s2 *p) { return p->s1; }
-These usages are only permitted when they are not ambiguous.
+These usages are only permitted when they are not ambiguous.
\ No newline at end of file
/* Instead of a variable, a compound literal may be used to pass the
return value of an intrinsic call to a function expecting the union: */
v128 foo (v128);
- x = foo ((v128) {_mm_adds_epu8 (x.mm, y.mm)});
+ x = foo ((v128) {_mm_adds_epu8 (x.mm, y.mm)});
\ No newline at end of file
accessed. Bit-field operations may be optimized such that adjacent
bit-fields are only partially accessed, if they straddle a storage unit
boundary. For these reasons it is unwise to use volatile bit-fields to
-access hardware.
+access hardware.
\ No newline at end of file
_mm_pause(); /* Abort failed transaction */
...
/* Free lock with lock elision */
- __atomic_store_n(&lockvar, 0, __ATOMIC_RELEASE|__ATOMIC_HLE_RELEASE);
+ __atomic_store_n(&lockvar, 0, __ATOMIC_RELEASE|__ATOMIC_HLE_RELEASE);
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../doc/funding.rst
+.. include:: ../../../doc/funding.rst
\ No newline at end of file
.. only:: man
- .. include:: copyright.rst
+ .. include:: copyright.rst
\ No newline at end of file
See :ref:`c-dialect-options`, for
explanations of options for languages related to C.
See :ref:`c++-dialect-options`, for
-explanations of options that are meaningful only for C++ programs.
+explanations of options that are meaningful only for C++ programs.
\ No newline at end of file
.. only:: html
- See :ref:`genindex`, for an index to GCC's options.
+ See :ref:`genindex`, for an index to GCC's options.
\ No newline at end of file
Some additional environment variables affect the behavior of the
preprocessor.
-.. include:: ../../../../doc/cppenv.rst
+.. include:: ../../../../doc/cppenv.rst
\ No newline at end of file
.. option:: -dumpspecs
Print the compiler's built-in specs---and don't do anything else. (This
- is used when GCC itself is being built.) See :ref:`spec-files`.
+ is used when GCC itself is being built.) See :ref:`spec-files`.
\ No newline at end of file
machine-dependent-options/xtensa-options
machine-dependent-options/zseries-options
-.. program:: None
+.. program:: None
\ No newline at end of file
Feature ``crypto`` implies ``aes``, ``sha2``, and ``simd``,
which implies ``fp``.
Conversely, ``nofp`` implies ``nosimd``, which implies
-``nocrypto``, ``noaes`` and ``nosha2``.
+``nocrypto``, ``noaes`` and ``nosha2``.
\ No newline at end of file
Allowable values for :samp:`{reg}` are :samp:`r43` and :samp:`r63`,
which specify use of that register as a fixed register,
and :samp:`none`, which means that no register is used for this
- purpose. The default is :option:`-m1reg-none`.
+ purpose. The default is :option:`-m1reg-none`.
\ No newline at end of file
devices always require XNACK and some allow the user to configure XNACK. The
compiled code must match the device mode. The default is :samp:`-mno-xnack`.
At present this option is a placeholder for support that is not yet
- implemented.
+ implemented.
\ No newline at end of file
.. option:: -multcost={num}
- Replaced by :option:`-mmultcost`.
+ Replaced by :option:`-mmultcost`.
\ No newline at end of file
The opposite :option:`-mno-fdpic` option is useful (and required) to
build the Linux kernel using the same (``arm-*-uclinuxfdpiceabi``)
- toolchain as the one used to build the userland programs.
+ toolchain as the one used to build the userland programs.
\ No newline at end of file
and is defined to ``2`` or ``3``.
``__WITH_LIBF7_LIBGCC__`` ``__WITH_LIBF7_MATH__`` ``__WITH_LIBF7_MATH_SYMBOLS__``
- Reflects the :option:`install:--with-libf7`.
+ Reflects the :option:`install:--with-libf7`.
\ No newline at end of file
Assume that ICPLBs are enabled at run time. This has an effect on certain
anomaly workarounds. For Linux targets, the default is to assume ICPLBs
- are enabled; for standalone applications the default is off.
+ are enabled; for standalone applications the default is off.
\ No newline at end of file
.. option:: -msim
Links the library libsemi.a which is in compatible with simulator. Applicable
- to ELF compiler only.
+ to ELF compiler only.
\ No newline at end of file
addresses to access all data. Put all initialized global and static
data in the ``.fardata`` section, and all uninitialized data in the
``.far`` section. Put all constant data into the ``.const``
- section.
+ section.
\ No newline at end of file
.. option:: -sim2
Like :option:`-sim`, but pass linker options to locate initialized data at
- 0x40000000 and zero-initialized data at 0x80000000.
+ 0x40000000 and zero-initialized data at 0x80000000.
\ No newline at end of file
.. option:: -whatsloaded
These options are passed to the Darwin linker. The Darwin linker man page
- describes them in detail.
+ describes them in detail.
\ No newline at end of file
The compiler contains estimates of the number of clock cycles for
'typical' EV4 & EV5 hardware for the Level 1, 2 & 3 caches
(also called Dcache, Scache, and Bcache), as well as to main memory.
- Note that L3 is only valid for EV5.
+ Note that L3 is only valid for EV5.
\ No newline at end of file
the restrictions imposed by the BPF architecture:
* Save and restore callee-saved registers at function entry and
- exit, respectively.
+ exit, respectively.
\ No newline at end of file
Assume that runtime support has been provided and so there is no need
to include the simulator library (:samp:`libsim.a`) on the linker
- command line.
+ command line.
\ No newline at end of file
Select the processor type for which to generate code. Possible values are
:samp:`frv`, :samp:`fr550`, :samp:`tomcat`, :samp:`fr500`, :samp:`fr450`,
- :samp:`fr405`, :samp:`fr400`, :samp:`fr300` and :samp:`simple`.
+ :samp:`fr405`, :samp:`fr400`, :samp:`fr300` and :samp:`simple`.
\ No newline at end of file
.. option:: -mnopm
- Do not generate code that reads program memory.
+ Do not generate code that reads program memory.
\ No newline at end of file
.. option:: -tno-android-ld
Disable linking effects of :option:`-mandroid`, i.e., pass standard Linux
- linking options to the linker.
+ linking options to the linker.
\ No newline at end of file
The default for the H8/300H and H8S is to align longs and floats on
4-byte boundaries.
:option:`-malign-300` causes them to be aligned on 2-byte boundaries.
- This option has no effect on the H8/300.
+ This option has no effect on the H8/300.
\ No newline at end of file
Add support for multithreading with the :dfn:`dce thread` library
under HP-UX. This option sets flags for both the preprocessor and
- linker.
+ linker.
\ No newline at end of file
disallowing more than that number in an instruction group.
Otherwise, the limit is 'soft', meaning that non-memory operations
are preferred when the limit is reached, but memory operations may still
- be scheduled.
+ be scheduled.
\ No newline at end of file
The vectorizer will check with target information to determine whether it
would be beneficial to unroll the main vectorized loop and by how much. This
parameter sets the upper bound of how much the vectorizer will unroll the main
- loop. The default value is four.
+ loop. The default value is four.
\ No newline at end of file
.. option:: -muser-enabled
- Enable user-defined instructions.
+ Enable user-defined instructions.
\ No newline at end of file
environments where no dynamic link is performed, like firmwares, OS
kernels, executables linked with :option:`-static` or :option:`-static-pie`.
:option:`-mdirect-extern-access` is not compatible with :option:`-fPIC` or
- :option:`-fpic`.
+ :option:`-fpic`.
\ No newline at end of file
code into available registers, and the performance penalty of using
memory instead of registers. Note that all modules in a program must
be compiled with the same value for this option. Because of that, you
- must not use this option with GCC's default runtime libraries.
+ must not use this option with GCC's default runtime libraries.
\ No newline at end of file
.. option:: -mno-flush-func
- Indicates that there is no OS function for flushing the cache.
+ Indicates that there is no OS function for flushing the cache.
\ No newline at end of file
.. option:: -mlong-jump-table-offsets
Use 32-bit offsets in ``switch`` tables. The default is to use
- 16-bit offsets.
+ 16-bit offsets.
\ No newline at end of file
values can increase the speed of programs that contain functions
that need a large amount of stack space, but they can also trigger a
segmentation fault if the stack is extended too much. The default
- value is 0x1000.
+ value is 0x1000.
\ No newline at end of file
Variables that are :samp:`{n}` bytes or smaller are allocated to the
``.tiny`` section. These variables use the ``$gp`` base
register. The default for this option is 4, but note that there's a
- 65536-byte limit to the ``.tiny`` section.
+ 65536-byte limit to the ``.tiny`` section.
\ No newline at end of file
Assume that the displacement between the text and data segments is fixed
at static link time. This allows data to be referenced by offset from start of
- text address instead of GOT since PC-relative addressing is not supported.
+ text address instead of GOT since PC-relative addressing is not supported.
\ No newline at end of file
.. option:: -mmadd4, -mno-madd4
When applicable, enable (disable) the generation of 4-operand ``madd.s``,
- ``madd.d`` and related instructions. Enabled by default.
+ ``madd.d`` and related instructions. Enabled by default.
\ No newline at end of file
.. option:: -msingle-exit, -mno-single-exit
Force (do not force) generated code to have a single exit point in each
- function.
+ function.
\ No newline at end of file
Do not allow the compiler to generate *SETLB* or *Lcc*
instructions. This option defines the preprocessor macro
- ``__NO_SETLB__``.
+ ``__NO_SETLB__``.
\ No newline at end of file
.. option:: -mno-crt0
- Do not link in the C run-time initialization object file.
+ Do not link in the C run-time initialization object file.
\ No newline at end of file
.. option:: -mwarn-devices-csv, -mno-warn-devices-csv
Warn if :samp:`devices.csv` is not found or there are problem parsing it
- (default: on).
+ (default: on).
\ No newline at end of file
.. option:: -mrelax
- Guide linker to relax instructions.
+ Guide linker to relax instructions.
\ No newline at end of file
:samp:`{systemlib}` is the library name of the library that provides
low-level system calls required by the C library,
e.g. ``read`` and ``write``.
- This option is typically used to link with a library provided by a HAL BSP.
+ This option is typically used to link with a library provided by a HAL BSP.
\ No newline at end of file
.. option:: -mgomp
Generate code for use in OpenMP offloading: enables :option:`-msoft-stack` and
- :option:`-muniform-simt` options, and selects corresponding multilib variant.
+ :option:`-muniform-simt` options, and selects corresponding multilib variant.
\ No newline at end of file
.. option:: -mcmodel=large
- Generate OpenRISC code for the large model: The GOT may grow up to 4G in size.
+ Generate OpenRISC code for the large model: The GOT may grow up to 4G in size.
\ No newline at end of file
.. This is supposed to go with a -Yd for predefined M4 macro files, but
- .. the generic assembler that comes with Solaris takes just -Ym.
+ .. the generic assembler that comes with Solaris takes just -Ym.
\ No newline at end of file
.. option:: -mlra
Use the new LRA register allocator. By default, the old 'reload'
- allocator is used.
+ allocator is used.
\ No newline at end of file
inefficient and a warning is generated to indicate
that you should rewrite the code to avoid byte operations, or to target
an AE type that has the necessary hardware support. This option disables
- these warnings.
+ these warnings.
\ No newline at end of file
PowerPC Options
^^^^^^^^^^^^^^^
-These are listed under See :ref:`rs-6000-and-powerpc-options`.
+These are listed under See :ref:`rs-6000-and-powerpc-options`.
\ No newline at end of file
Relaxation is a GNU feature and for safety reasons is disabled when using
:option:`-mabi=ti`. The TI toolchain does not emit relocations for QBBx
instructions, so the GNU linker cannot adjust them when shortening adjacent
- LDI32 pseudo instructions.
+ LDI32 pseudo instructions.
\ No newline at end of file
which register to use as base register for reading the canary,
and from what offset from that base register. There is no default
register or offset as this is entirely for use within the Linux
- kernel.
+ kernel.
\ No newline at end of file
needs to be passed for this to work as this feature is only available
on the G13 target (S2 core). The MDUC registers will only be saved
if the interrupt handler performs a multiplication or division
- operation or it calls another function.
+ operation or it calls another function.
\ No newline at end of file
and/or ``r13`` and only provided that the normal use of the
corresponding registers have been restricted via the
:option:`-ffixed-reg` or :option:`-mint-register` command-line
- options.
+ options.
\ No newline at end of file
If both arguments are zero, hotpatching is disabled.
This option can be overridden for individual functions with the
- ``hotpatch`` attribute.
+ ``hotpatch`` attribute.
\ No newline at end of file
.. option:: -mscore7d
- Specify the SCORE7D as the target architecture.
+ Specify the SCORE7D as the target architecture.
\ No newline at end of file
.. option:: -mfdpic
- Generate code using the FDPIC ABI.
+ Generate code using the FDPIC ABI.
\ No newline at end of file
.. option:: -pthreads
- This is a synonym for :option:`-pthread`.
+ This is a synonym for :option:`-pthread`.
\ No newline at end of file
With :option:`-mstack-bias`, GCC assumes that the stack pointer, and
frame pointer if present, are offset by -2047 which must be added back
when making stack frame references. This is the default in 64-bit mode.
- Otherwise, assume no such offset is present.
+ Otherwise, assume no such offset is present.
\ No newline at end of file
.. option:: -mno-app-regs
- This option causes r2 and r5 to be treated as fixed registers.
+ This option causes r2 and r5 to be treated as fixed registers.
\ No newline at end of file
.. option:: -mlra, -mno-lra
Enable Local Register Allocation. This is still experimental for the VAX,
- so by default the compiler uses standard reload.
+ so by default the compiler uses standard reload.
\ No newline at end of file
Generate code for the user mode, where the access to some general registers
is forbidden: on the GR5, registers r24 to r31 cannot be accessed in this
- mode; on the GR6, only registers r29 to r31 are affected.
+ mode; on the GR6, only registers r29 to r31 are affected.
\ No newline at end of file
Set the default size of pointers. Possible options for :samp:`{size}` are
:samp:`32` or :samp:`short` for 32 bit pointers, :samp:`64` or :samp:`long`
for 64 bit pointers, and :samp:`no` for supporting only 32 bit pointers.
- The later option disables ``pragma pointer_size``.
+ The later option disables ``pragma pointer_size``.
\ No newline at end of file
.. option:: -Xbind-now
Disable lazy binding of function calls. This option is the default and
- is defined for compatibility with Diab.
+ is defined for compatibility with Diab.
\ No newline at end of file
GCC detects that the target assembler found during configuration
supports the feature.
-See also under :ref:`x86-options` for standard options.
+See also under :ref:`x86-options` for standard options.
\ No newline at end of file
.. option:: -msim
- Choose startup files and linker script suitable for the simulator.
+ Choose startup files and linker script suitable for the simulator.
\ No newline at end of file
instructions, in clock cycles. This affects, when optimizing for speed,
whether loading a constant from literal pool using ``L32R`` or
synthesizing the constant from a small one with a couple of arithmetic
- instructions. The default value is 0.
+ instructions. The default value is 0.
\ No newline at end of file
zSeries Options
^^^^^^^^^^^^^^^
-These are listed under See :ref:`s-390-and-zseries-options`.
+These are listed under See :ref:`s-390-and-zseries-options`.
\ No newline at end of file
.. option:: -Wconversion-null
- Default setting; overrides :option:`-Wno-conversion-null`.
+ Default setting; overrides :option:`-Wno-conversion-null`.
\ No newline at end of file
The :option:`-fsso-struct` switch causes GCC to generate
code that is not binary compatible with code generated without it if the
- specified endianness is not the native endianness of the target.
+ specified endianness is not the native endianness of the target.
\ No newline at end of file
.. option:: -print-objc-runtime-info
Generate C header describing the largest structure that is passed by
- value, if any.
+ value, if any.
\ No newline at end of file
option in either single or double quotes. Any character (including a
backslash) may be included by prefixing the character to be included
with a backslash. The :samp:`{file}` may itself contain additional
- :samp:`@{file}` options; any such options will be processed recursively.
+ :samp:`@{file}` options; any such options will be processed recursively.
\ No newline at end of file
It also means that options like :option:`-Wmisleading-indentation` cease to work
at that point, although the compiler prints a note if this happens.
Passing :option:`-flarge-source-files` significantly increases the number
- of source lines that GCC can process before it stops tracking columns.
+ of source lines that GCC can process before it stops tracking columns.
\ No newline at end of file
The default value of this option is enabled, thus the only useful form
of the option is :option:`-fno-sync-libcalls`. This option is used in
- the implementation of the :samp:`libatomic` runtime library.
+ the implementation of the :samp:`libatomic` runtime library.
\ No newline at end of file
.. option:: -feliminate-unused-debug-types
- Default setting; overrides :option:`-fno-eliminate-unused-debug-types`.
+ Default setting; overrides :option:`-fno-eliminate-unused-debug-types`.
\ No newline at end of file
headers may for example be found in
:samp:`{dir}/{suffix}/usr/include` instead of
:samp:`{dir}/usr/include`. This option disables the addition of
- such a suffix.
+ such a suffix.
\ No newline at end of file
:option:`-z` is passed directly on to the linker along with the keyword
:samp:`{keyword}`. See the section in the documentation of your linker for
- permitted values and their meanings.
+ permitted values and their meanings.
\ No newline at end of file
.. gcc-param:: x86-stlf-window-ninsns
- Instructions number above which STFL stall penalty can be compensated.
+ Instructions number above which STFL stall penalty can be compensated.
\ No newline at end of file
.. option:: -fdump-analyzer-untracked
- Emit custom warnings with internal details intended for analyzer developers.
+ Emit custom warnings with internal details intended for analyzer developers.
\ No newline at end of file
Diagnostics have a boolean attribute ``escape-source``, hinting whether
non-ASCII bytes should be escaped when printing the pertinent lines of
- source code (``true`` for diagnostics involving source encoding issues).
+ source code (``true`` for diagnostics involving source encoding issues).
\ No newline at end of file
.. option:: -Wdesignated-init
- Default setting; overrides :option:`-Wno-designated-init`.
+ Default setting; overrides :option:`-Wno-designated-init`.
\ No newline at end of file
recognize.
If you want to pass an option that takes an argument, you must use
- :option:`-Xassembler` twice, once for the option and once for the argument.
+ :option:`-Xassembler` twice, once for the option and once for the argument.
\ No newline at end of file
The maximum value of :samp:`{N}` and :samp:`{M}` is 65535. On PowerPC with the
ELFv2 ABI, for a function with dual entry points, the supported values
- for :samp:`{M}` are 0, 2, 6 and 14.
+ for :samp:`{M}` are 0, 2, 6 and 14.
\ No newline at end of file
GCC also knows implicitly that arguments starting in :option:`-l` are to be
treated as compiler output files, and passed to the linker in their
- proper position among the other output files.
+ proper position among the other output files.
\ No newline at end of file
precompiled header, the actual behavior is a mixture of the
behavior for the options. For instance, if you use :option:`-g` to
generate the precompiled header but not when using it, you may or may
- not get debugging information for routines in the precompiled header.
+ not get debugging information for routines in the precompiled header.
\ No newline at end of file
version |gcc_version|.
The internals of the GNU compilers, including how to port them to new
targets and some information about how to write front ends for new
-languages, are documented in a separate manual. See :ref:`gccint:top`.
+languages, are documented in a separate manual. See :ref:`gccint:top`.
\ No newline at end of file
.. only:: man
- .. include:: copyright.rst
+ .. include:: copyright.rst
\ No newline at end of file
.. only:: man
- .. include:: copyright.rst
+ .. include:: copyright.rst
\ No newline at end of file
.. only:: man
- .. include:: copyright.rst
+ .. include:: copyright.rst
\ No newline at end of file
It is not recommended to access the coverage files directly.
Consumers should use the intermediate format that is provided
-by :command:`gcov` tool via :option:`--json-format` option.
+by :command:`gcov` tool via :option:`--json-format` option.
\ No newline at end of file
You must move the data files to the expected directory tree in order to
use them for profile directed optimizations (:option:`-fprofile-use`), or to
-use the :command:`gcov` tool.
+use the :command:`gcov` tool.
\ No newline at end of file
:command:`gcov`.
:command:`gcov` works only on code compiled with GCC. It is not
-compatible with any other profiling or test coverage mechanism.
+compatible with any other profiling or test coverage mechanism.
\ No newline at end of file
profiling code first attempts to read in an existing :samp:`.gcda` file; if
the file doesn't match the executable (differing number of basic block
counts) it will ignore the contents of the file. It then adds in the
-new execution counts and finally writes the data to the file.
+new execution counts and finally writes the data to the file.
\ No newline at end of file
zero or the initialized data is loaded, is undefined behaviour. Clearing the
zero-initialized data to zero through a function instrumented for profiling or
test coverage is undefined behaviour, since it may produce inconsistent program
-flow graph edge counters for example.
+flow graph edge counters for example.
\ No newline at end of file
In order to terminate immediately after an errors occurs
set :samp:`GCOV_EXIT_AT_ERROR` environment variable.
That can help users to find profile clashing which leads
-to a misleading profile.
+to a misleading profile.
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../doc/gpl-3.0.rst
+.. include:: ../../../doc/gpl-3.0.rst
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../doc/gnu_free_documentation_license.rst
+.. include:: ../../../doc/gnu_free_documentation_license.rst
\ No newline at end of file
gnu-objective-c-features/exceptions
gnu-objective-c-features/synchronization
gnu-objective-c-features/fast-enumeration
- gnu-objective-c-features/messaging-with-the-gnu-objective-c-runtime
+ gnu-objective-c-features/messaging-with-the-gnu-objective-c-runtime
\ No newline at end of file
* ``WOApplication`` (the alias) must not be an existing class;
-* ``GSWApplication`` (the real class) must be an existing class.
+* ``GSWApplication`` (the real class) must be an existing class.
\ No newline at end of file
will be instances of the class specified as argument to this option. It
is possible to have multiple compilation units referring to different
constant string classes, neither the compiler nor the linker impose any
-restrictions in doing this.
+restrictions in doing this.
\ No newline at end of file
Objective-C++, the Objective-C exception model does not interoperate with C++
exceptions at this time. This means you cannot ``@throw`` an exception
from Objective-C and ``catch`` it in C++, or vice versa
- (i.e., ``throw ... @catch``).
+ (i.e., ``throw ... @catch``).
\ No newline at end of file
Finally, note how we declared the ``len`` argument and the return
value to be of type ``unsigned long``. They could also be declared
-to be of type ``unsigned int`` and everything would still work.
+to be of type ``unsigned int`` and everything would still work.
\ No newline at end of file
represented by the :samp:`!` character. The
``class_ivar_set_gcinvisible()`` function adds or removes this
specifier to the string type description of the instance variable named
-as argument.
+as argument.
\ No newline at end of file
:samp:`objc/objc-api.h` where it is declared.
Starting with GCC 4.7.0, the traditional GNU runtime API is no longer
-available.
+available.
\ No newline at end of file
intervening operation from you. When you write bundles and you need to
write ``+load`` you can safely create and send messages to objects whose
classes already exist in the running program. The same restrictions as
-above apply to classes defined in bundle.
+above apply to classes defined in bundle.
\ No newline at end of file
If the forwarding hook does not exist or returns ``NULL``, the
runtime currently attempts forwarding using an older, deprecated API,
and if that fails, it aborts the program. In future versions of the
-GNU Objective-C runtime, the runtime will immediately abort.
+GNU Objective-C runtime, the runtime will immediately abort.
\ No newline at end of file
Because of the interactions between synchronization and exception
handling, you can only use ``@synchronized`` when compiling with
exceptions enabled, that is with the command line option
-:option:`-fobjc-exceptions`.
+:option:`-fobjc-exceptions`.
\ No newline at end of file
You can easily find more examples by running the 'strings' program
on an Objective-C object file compiled by GCC. You'll see a lot of
strings that look very much like ``i8@0:4``. They are signatures
-of Objective-C methods.
+of Objective-C methods.
\ No newline at end of file
-.. include:: ../../../doc/gnu.rst
+.. include:: ../../../doc/gnu.rst
\ No newline at end of file
'support for traditional practice'.
* If you are an experienced user of one of the languages GCC supports, your
- suggestions for improvement of GCC are welcome in any case.
+ suggestions for improvement of GCC are welcome in any case.
\ No newline at end of file
How and Where to Report Bugs
****************************
-Bugs should be reported to the bug database at |bugurl|.
+Bugs should be reported to the bug database at |bugurl|.
\ No newline at end of file
https://www.fsf.org/resources/service.
For further information, see
-https://gcc.gnu.org/faq.html#support.
+https://gcc.gnu.org/faq.html#support.
\ No newline at end of file
gnu-free-documentation-license
contributors-to-gcc
- indices-and-tables
+ indices-and-tables
\ No newline at end of file
-.. include:: ../../../doc/indices-and-tables.rst
+.. include:: ../../../doc/indices-and-tables.rst
\ No newline at end of file
known-causes-of-trouble-with-gcc/disappointments-and-misunderstandings
known-causes-of-trouble-with-gcc/common-misunderstandings-with-gnu-c
known-causes-of-trouble-with-gcc/certain-changes-we-dont-want-to-make
- known-causes-of-trouble-with-gcc/warning-messages-and-error-messages
+ known-causes-of-trouble-with-gcc/warning-messages-and-error-messages
\ No newline at end of file
* The ``fixincludes`` script interacts badly with automounters; if the
directory of system header files is automounted, it tends to be
unmounted while ``fixincludes`` is running. This would seem to be a
- bug in the automounter. We don't know any good way to work around it.
+ bug in the automounter. We don't know any good way to work around it.
\ No newline at end of file
GCC produces a warning but not an error, that is correct ISO C support.
If testsuites call this 'failure', they should be run with the GCC
option :option:`-pedantic-errors`, which will turn these warnings into
- errors.
+ errors.
\ No newline at end of file
If application code relies on copy-assignment, a user-defined
copy-assignment operator removes any uncertainties. With such an
operator, the application can define whether and how the virtual base
-subobject is assigned.
+subobject is assigned.
\ No newline at end of file
All static constructors and destructors found will be referenced even
though the modules in which they occur may not be used by the program.
This may lead to both increased executable size and unexpected symbol
- references.
+ references.
\ No newline at end of file
It is possible to make separate sets of fixed header files for the
different machine models, and arrange a structure of symbolic links so
- as to use the proper set, but you'll have to do this by hand.
+ as to use the proper set, but you'll have to do this by hand.
\ No newline at end of file
appear in preprocessing numbers.)
To make the above program fragment valid, place whitespace in front of
- the minus sign. This whitespace will end the preprocessing number.
+ the minus sign. This whitespace will end the preprocessing number.
\ No newline at end of file
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
- identifiers.
+ identifiers.
\ No newline at end of file
GNU/Linux and HURD-based GNU systems; no recent version of it supports
other systems, though some very old versions did. Version 2.2 of the
GNU C library includes nearly complete C99 support. You could also ask
-your operating system vendor if newer libraries are available.
+your operating system vendor if newer libraries are available.
\ No newline at end of file
or errors.
See :ref:`warning-options`, for
-more detail on these and related command-line options.
+more detail on these and related command-line options.
\ No newline at end of file
language-standards-supported-by-gcc/objective-c-and-objective-c++-languages
language-standards-supported-by-gcc/go-language
language-standards-supported-by-gcc/d-language
- language-standards-supported-by-gcc/references-for-other-languages
+ language-standards-supported-by-gcc/references-for-other-languages
\ No newline at end of file
:option:`-std=gnu++20` (for C++20 with GNU extensions).
The default, if
-no C++ language dialect options are given, is :option:`-std=gnu++17`.
+no C++ language dialect options are given, is :option:`-std=gnu++17`.
\ No newline at end of file
For references to Technical Corrigenda, Rationale documents and
information concerning the history of C that is available online, see
-https://gcc.gnu.org/readings.html
+https://gcc.gnu.org/readings.html
\ No newline at end of file
GCC supports the D 2.0 programming language. The D language itself is
currently defined by its reference implementation and supporting language
-specification, described at https://dlang.org/spec/spec.html.
+specification, described at https://dlang.org/spec/spec.html.
\ No newline at end of file
***********
As of the GCC 4.7.1 release, GCC supports the Go 1 language standard,
-described at https://golang.org/doc/go1.
+described at https://golang.org/doc/go1.
\ No newline at end of file
* https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/Introduction/Introduction.html
For more information concerning the history of Objective-C that is
-available online, see https://gcc.gnu.org/readings.html
+available online, see https://gcc.gnu.org/readings.html
\ No newline at end of file
.. only:: man
- .. include:: copyright.rst
+ .. include:: copyright.rst
\ No newline at end of file
implemented this way; they all generate machine code directly. This
sort of preprocessor should not be confused with the :dfn:`C
preprocessor`, which is an integral feature of the C, C++, Objective-C
-and Objective-C++ languages.
+and Objective-C++ languages.
\ No newline at end of file
:maxdepth: 2
have-you-found-a-bug
- how-and-where-to-report-bugs
+ how-and-where-to-report-bugs
\ No newline at end of file
analysis-and-optimization-of-gimple-tuples/ssa-operands
analysis-and-optimization-of-gimple-tuples/alias-analysis
analysis-and-optimization-of-gimple-tuples/memory-model
- analysis-and-optimization-of-gimple-tuples/static-single-assignment
+ analysis-and-optimization-of-gimple-tuples/static-single-assignment
\ No newline at end of file
the first clobbering statement or if asked to.
``walk_aliased_vdefs`` walks over dominating memory defining
statements and calls back on each statement clobbering ref
- providing its aliasing VDEF. The walk stops if asked to.
+ providing its aliasing VDEF. The walk stops if asked to.
\ No newline at end of file
optimization process. For instance, we need to know whether a
variable has aliases. All these attributes are stored in data
structures called annotations which are then linked to the field
-``ann`` in ``struct tree_common``.
+``ann`` in ``struct tree_common``.
\ No newline at end of file
of the modified object for that access and for subsequent accesses that
do not modify the value is undetermined. For all other accesses to an
object, the effective type of the object is simply the type of the
- lvalue used for the access.
+ lvalue used for the access.
\ No newline at end of file
{
for (bsi = bsi_start (bb); !bsi_end_p (bsi); bsi_next (&bsi))
update_stmt_if_modified (bsi_stmt (bsi));
- }
+ }
\ No newline at end of file
* Once after walking the statements in :samp:`{bb}` and :samp:`{bb}` 's
dominator children. At this stage, the block local data stack
- is popped.
+ is popped.
\ No newline at end of file
analysis-and-representation-of-loops/scalar-evolutions
analysis-and-representation-of-loops/iv-analysis-on-rtl
analysis-and-representation-of-loops/number-of-iterations-analysis
- analysis-and-representation-of-loops/data-dependency-analysis
+ analysis-and-representation-of-loops/data-dependency-analysis
\ No newline at end of file
``dump_dist_dir_vectors`` prints only the classical distance and
direction vectors for a data dependence relations array, and
``dump_data_references`` prints the details of the data references
-contained in a data reference array.
+contained in a data reference array.
\ No newline at end of file
subreg_{mode} (base + i * step)
The function ``get_iv_value`` can be used to perform these
-calculations.
+calculations.
\ No newline at end of file
provided to make these manipulations simple).
``rewrite_into_loop_closed_ssa`` is used to rewrite SSA form to
LCSSA, and ``verify_loop_closed_ssa`` to check that the invariant of
-LCSSA is preserved.
+LCSSA is preserved.
\ No newline at end of file
* ``tree_unroll_loop`` : Unrolls the loop, including peeling the
extra iterations to make the number of iterations divisible by unroll
factor, updating the exit condition, and removing the exits that now
- cannot be taken. Works only on GIMPLE.
+ cannot be taken. Works only on GIMPLE.
\ No newline at end of file
* ``just_once_each_iteration_p`` : Returns true if the basic block
is executed exactly once during each iteration of a loop (that is, it
- does not belong to a sub-loop, and it dominates the latch of the loop).
+ does not belong to a sub-loop, and it dominates the latch of the loop).
\ No newline at end of file
At the moment loop structure is preserved from the start of GIMPLE
loop optimizations until the end of RTL loop optimizations. During
-this time a loop can be tracked by its ``struct loop`` and number.
+this time a loop can be tracked by its ``struct loop`` and number.
\ No newline at end of file
Other constraints may be added in the future, for example, a constraint
indicating that loops' latch must roll thus ``may_be_zero`` would be
-false unconditionally.
+false unconditionally.
\ No newline at end of file
induction variables. In this case, the extra expressive power of SCEV
is not useful, and may complicate the optimizations. In this case,
``simple_iv`` function may be used to analyze a value -- the result
-is a loop-invariant base and step.
+is a loop-invariant base and step.
\ No newline at end of file
* Linux kernel internal APIs
-* Signal handling
+* Signal handling
\ No newline at end of file
second place in the search path.
``collect2`` searches for the utilities ``nm`` and ``strip``
-using the same algorithm as above for ``ld``.
+using the same algorithm as above for ``ld``.
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../doc/contribute.rst
+.. include:: ../../../doc/contribute.rst
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../doc/contrib.rst
+.. include:: ../../../doc/contrib.rst
\ No newline at end of file
control-flow-graph/edges
control-flow-graph/profile-information
control-flow-graph/maintaining-the-cfg
- control-flow-graph/liveness-information
+ control-flow-graph/liveness-information
\ No newline at end of file
gimple stmt = gsi_stmt (si);
print_gimple_stmt (dump_file, stmt, 0, TDF_SLIM);
}
- }
+ }
\ No newline at end of file
instruction in the insn chain and no explicit return instructions are
used. This corresponds to the fall-thru edge into exit block. After
reload, optimal RTL epilogues are used that use explicit (conditional)
- return instructions that are represented by edges with no flags set.
+ return instructions that are represented by edges with no flags set.
\ No newline at end of file
representing that the value of a given register is no longer needed, or
``REG_UNUSED`` notes representing that the value computed by the
instruction is never used. The second is useful for instructions
-computing multiple values at once.
+computing multiple values at once.
\ No newline at end of file
While debugging the optimization pass, the ``verify_flow_info``
function may be useful to find bugs in the control flow graph updating
-code.
+code.
\ No newline at end of file
``BB_FREQ_BASE`` are both set low enough to be possible to compute
second power of any frequency or probability in the flow graph, it is
not possible to even square the ``count`` field, as modern CPUs are
-fast enough to execute $2^32$ operations quickly.
+fast enough to execute $2^32$ operations quickly.
\ No newline at end of file
You have freedom to copy and modify this GNU Manual, like GNU
software. Copies published by the Free Software Foundation raise
- funds for GNU development.
+ funds for GNU development.
\ No newline at end of file
gcc_assert (!m_base_region->is_named_decl_p ("yy_buffer_stack"));
to ``binding_cluster::mark_as_escaped`` to trap a point where
-``yy_buffer_stack`` was mistakenly being treated as having escaped.
+``yy_buffer_stack`` was mistakenly being treated as having escaped.
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../doc/funding.rst
+.. include:: ../../../doc/funding.rst
\ No newline at end of file
strategies. You will know
if this happens because the compiler will call ``abort``. Fortunately,
the new strategies can be added in a machine-independent fashion, and will
-affect only the target machines that need them.
+affect only the target machines that need them.
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../doc/gpl-3.0.rst
+.. include:: ../../../doc/gpl-3.0.rst
\ No newline at end of file
generic/statements
generic/functions
generic/language-dependent-trees
- generic/c-and-c++-trees
+ generic/c-and-c++-trees
\ No newline at end of file
.. function:: tree TYPE_ATTRIBUTES (tree type)
- This macro returns the attributes on the type :samp:`{type}`.
+ This macro returns the attributes on the type :samp:`{type}`.
\ No newline at end of file
is taken, and this value replaces the first argument in the argument
list.
- In either case, the expression is void.
+ In either case, the expression is void.
\ No newline at end of file
Reading them from the generated :samp:`all-tree.def` file (which in
turn includes all the :samp:`tree.def` files), :samp:`gencheck.cc` is
used during GCC's build to generate the ``*_CHECK`` macros for all
- tree codes.
+ tree codes.
\ No newline at end of file
.. The spelling of "incomplet" and "incorrekt" below is intentional.
There are many places in which this document is incomplet and incorrekt.
-It is, as of yet, only *preliminary* documentation.
+It is, as of yet, only *preliminary* documentation.
\ No newline at end of file
must have the same type. The size of the vector element of the third
operand must be at lease twice of the size of the vector element of the
first and second one. The SAD is calculated between the first and second
- operands, added to the third operand, and returned.
+ operands, added to the third operand, and returned.
\ No newline at end of file
This macro returns a tree node that holds the optimization options
that are to be used to compile this particular function or
``NULL_TREE`` if the function is to be compiled with the
- optimization options specified on the command line.
+ optimization options specified on the command line.
\ No newline at end of file
conversion to GIMPLE. The intermediate representation used while
parsing C and C++ looks very little like GENERIC, but the C and
C++ gimplifier hooks are perfectly happy to take it as input and
-spit out GIMPLE.
+spit out GIMPLE.
\ No newline at end of file
nodes themselves are accessed using the ``TREE_VEC_ELT`` macro, which
takes two arguments. The first is the ``TREE_VEC`` in question; the
second is an integer indicating which element in the vector is desired.
-The elements are indexed from zero.
+The elements are indexed from zero.
\ No newline at end of file
.. envvar:: OACC_UPDATE
- Represents ``#pragma acc update [clause1 ... clauseN]``.
+ Represents ``#pragma acc update [clause1 ... clauseN]``.
\ No newline at end of file
A node for ``char``.
It may sometimes be useful to compare one of these variables with a type
- in hand, using ``same_type_p``.
+ in hand, using ``same_type_p``.
\ No newline at end of file
which is supposed to replace ``force_gimple_operand (fold_buildN (...), ...)``
and calls to ``fold_convert``. Overloads without the ``location_t``
argument exist. Built statements are inserted on the provided sequence
-and simplification is performed using the optional valueization hook.
+and simplification is performed using the optional valueization hook.
\ No newline at end of file
gimple/sequence-iterators
gimple/adding-a-new-gimple-statement-code
gimple/statement-and-operand-traversals
- gimple/exception-handling
+ gimple/exception-handling
\ No newline at end of file
corresponding prototype in ``gimple.h``.
You should add the new statement subclass to the class hierarchy diagram
-in ``gimple.texi``.
+in ``gimple.texi``.
\ No newline at end of file
| code: GIMPLE_OMP_ATOMIC_STORE
|
+ gomp_return
- code: GIMPLE_OMP_RETURN
+ code: GIMPLE_OMP_RETURN
\ No newline at end of file
Just before running the optimizers, the compiler lowers the
high-level EH constructs above into a set of ``goto`` s, magic
labels, and EH regions. Continuing to unwind at the end of a
-cleanup is represented with a ``GIMPLE_RESX``.
+cleanup is represented with a ``GIMPLE_RESX``.
\ No newline at end of file
- x
* - ``GIMPLE_TRY``
- x
- -
+ -
\ No newline at end of file
.. function:: bool gimple_seq_singleton_p (gimple_seq seq)
- Determine whether ``SEQ`` contains exactly one statement.
+ Determine whether ``SEQ`` contains exactly one statement.
\ No newline at end of file
.. function:: gimple gimple_copy (gimple stmt)
- Return a deep copy of statement ``STMT``.
+ Return a deep copy of statement ``STMT``.
\ No newline at end of file
.. function:: bool gimple_debug_nonbind_marker_p (gimple g)
Return true if g is a ``GIMPLE_DEBUG`` that marks a program location,
- without any variable binding.
+ without any variable binding.
\ No newline at end of file
.. function:: void gsi_commit_edge_inserts (void)
This routine will commit all pending edge insertions, creating
- any new basic blocks which are necessary.
+ any new basic blocks which are necessary.
\ No newline at end of file
calling ``walk_gimple_stmt`` on each one. ``WI`` is as in
``walk_gimple_stmt``. If ``walk_gimple_stmt`` returns non- ``NULL``, the walk
is stopped and the value returned. Otherwise, all the statements
- are walked and ``NULL_TREE`` returned.
+ are walked and ``NULL_TREE`` returned.
\ No newline at end of file
the value of an expression to a memory variable goes through a
temporary.
-.. [#f1] These restrictions are derived from those in Morgan 4.8.
+.. [#f1] These restrictions are derived from those in Morgan 4.8.
\ No newline at end of file
reduce memory utilization further by removing these sets).
All the other tuples are defined in terms of these three basic
-ones. Each tuple will add some fields.
+ones. Each tuple will add some fields.
\ No newline at end of file
tuple-specific-accessors/gimplereturn
tuple-specific-accessors/gimpleswitch
tuple-specific-accessors/gimpletry
- tuple-specific-accessors/gimplewithcleanupexpr
+ tuple-specific-accessors/gimplewithcleanupexpr
\ No newline at end of file
.. function:: void gimple_asm_set_volatile (gasm *g, bool volatile_p)
Mark asm statement ``G`` as volatile or non-volatile based on
- ``VOLATILE_P``.
+ ``VOLATILE_P``.
\ No newline at end of file
.. function:: bool gimple_assign_cast_p (const_gimple s)
- Return true if ``S`` is a type-cast assignment.
+ Return true if ``S`` is a type-cast assignment.
\ No newline at end of file
.. function:: void gimple_bind_set_block (gbind *g, tree block)
Set ``BLOCK`` to be the ``TREE_BLOCK`` node associated with ``GIMPLE_BIND``
- statement ``G``.
+ statement ``G``.
\ No newline at end of file
.. function:: gimple gimple_call_copy_skip_args (gcall *stmt, bitmap args_to_skip)
Build a ``GIMPLE_CALL`` identical to ``STMT`` but skipping the arguments
- in the positions marked by the set ``ARGS_TO_SKIP``.
+ in the positions marked by the set ``ARGS_TO_SKIP``.
\ No newline at end of file
.. function:: void gimple_catch_set_handler (gcatch *g, gimple_seq handler)
- Set ``HANDLER`` to be the body of ``GIMPLE_CATCH`` ``G``.
+ Set ``HANDLER`` to be the body of ``GIMPLE_CATCH`` ``G``.
\ No newline at end of file
.. function:: void gimple_cond_make_true (gcond *g)
- Set the conditional ``COND_STMT`` to be of the form 'if (1 == 1)'.
+ Set the conditional ``COND_STMT`` to be of the form 'if (1 == 1)'.
\ No newline at end of file
substitution, and that at the point of the program in which the stmt is
inserted, all parameters for the inlined function are bound to the
respective arguments, and none of the side effects of its stmts are
- observable.
+ observable.
\ No newline at end of file
.. function:: void gimple_eh_must_not_throw_set_fndecl ( geh_mnt *eh_mnt_stmt, tree decl)
- Set the function decl to be called by GS to DECL.
+ Set the function decl to be called by GS to DECL.
\ No newline at end of file
.. function:: void gimple_goto_set_dest (ggoto *g, tree dest)
- Set ``DEST`` to be the destination of the unconditional jump ``G``.
+ Set ``DEST`` to be the destination of the unconditional jump ``G``.
\ No newline at end of file
.. function:: void gimple_label_set_label (glabel *g, tree label)
Set ``LABEL`` to be the ``LABEL_DECL`` node used by ``GIMPLE_LABEL``
- statement ``G``.
+ statement ``G``.
\ No newline at end of file
.. function:: bool gimple_nop_p (gimple g)
- Returns ``TRUE`` if statement ``G`` is a ``GIMPLE_NOP``.
+ Returns ``TRUE`` if statement ``G`` is a ``GIMPLE_NOP``.
\ No newline at end of file
.. function:: tree gimple_omp_atomic_load_rhs ( const gomp_atomic_load *g)
- Get the ``RHS`` of an atomic set.
+ Get the ``RHS`` of an atomic set.
\ No newline at end of file
.. function:: tree gimple_omp_atomic_store_val ( const gomp_atomic_store *g)
- Return the value being stored in an atomic store.
+ Return the value being stored in an atomic store.
\ No newline at end of file
.. function:: tree gimple_omp_continue_set_control_use ( gomp_continue *s)
Set the control variable use for a ``GIMPLE_OMP_CONTINUE`` statement
- in ``S``.
+ in ``S``.
\ No newline at end of file
.. function:: void gimple_omp_critical_set_name ( gomp_critical *g, tree name)
- Set ``NAME`` to be the name associated with ``OMP`` critical statement ``G``.
+ Set ``NAME`` to be the name associated with ``OMP`` critical statement ``G``.
\ No newline at end of file
.. function:: enum tree_code gimple_omp_for_cond (gimple g)
- Return the condition code associated with ``OMP_FOR`` ``G``.
+ Return the condition code associated with ``OMP_FOR`` ``G``.
\ No newline at end of file
.. function:: gimple gimple_build_omp_master (gimple_seq body)
Build a ``GIMPLE_OMP_MASTER`` statement. ``BODY`` is the sequence of
- statements to be executed by just the master.
+ statements to be executed by just the master.
\ No newline at end of file
Build a ``GIMPLE_OMP_ORDERED`` statement.
``BODY`` is the sequence of statements inside a loop that will
- executed in sequence.
+ executed in sequence.
\ No newline at end of file
.. function:: void gimple_omp_parallel_set_data_arg ( gomp_parallel *g, tree data_arg)
- Set ``DATA_ARG`` to be the data argument for ``OMP_PARALLEL`` ``G``.
+ Set ``DATA_ARG`` to be the data argument for ``OMP_PARALLEL`` ``G``.
\ No newline at end of file
.. function:: bool gimple_omp_return_nowait_p (gimple g)
Return true if ``OMP`` return statement ``G`` has the
- ``GF_OMP_RETURN_NOWAIT`` flag set.
+ ``GF_OMP_RETURN_NOWAIT`` flag set.
\ No newline at end of file
.. function:: void gimple_omp_section_set_last (gimple g)
- Set the ``GF_OMP_SECTION_LAST`` flag on ``G``.
+ Set the ``GF_OMP_SECTION_LAST`` flag on ``G``.
\ No newline at end of file
.. function:: void gimple_omp_sections_set_clauses (gimple g, tree clauses)
Set ``CLAUSES`` to be the set of clauses associated with ``OMP_SECTIONS``
- ``G``.
+ ``G``.
\ No newline at end of file
.. function:: void gimple_omp_single_set_clauses ( gomp_single *g, tree clauses)
- Set ``CLAUSES`` to be the clauses associated with ``OMP_SINGLE`` ``G``.
+ Set ``CLAUSES`` to be the clauses associated with ``OMP_SINGLE`` ``G``.
\ No newline at end of file
.. function:: void gimple_phi_set_arg (gphi *g, index, struct phi_arg_d * phiarg)
Set ``PHIARG`` to be the argument corresponding to incoming edge
- ``INDEX`` for ``GIMPLE_PHI`` ``G``.
+ ``INDEX`` for ``GIMPLE_PHI`` ``G``.
\ No newline at end of file
.. function:: void gimple_resx_set_region (gresx *g, int region)
- Set ``REGION`` to be the region number for ``GIMPLE_RESX`` ``G``.
+ Set ``REGION`` to be the region number for ``GIMPLE_RESX`` ``G``.
\ No newline at end of file
.. function:: void gimple_return_set_retval (greturn *g, tree retval)
- Set ``RETVAL`` to be the return value for ``GIMPLE_RETURN`` ``G``.
+ Set ``RETVAL`` to be the return value for ``GIMPLE_RETURN`` ``G``.
\ No newline at end of file
.. function:: void gimple_switch_set_default_label (gswitch *g, tree label)
- Set the default label for a switch statement.
+ Set the default label for a switch statement.
\ No newline at end of file
.. function:: void gimple_try_set_cleanup (gtry *g, gimple_seq cleanup)
Set ``CLEANUP`` to be the sequence of statements to use as the
- cleanup body for ``GIMPLE_TRY`` ``G``.
+ cleanup body for ``GIMPLE_TRY`` ``G``.
\ No newline at end of file
.. function:: void gimple_wce_set_cleanup_eh_only (gimple g, bool eh_only_p)
- Set the ``CLEANUP_EH_ONLY`` flag for a ``WCE`` tuple.
+ Set the ``CLEANUP_EH_ONLY`` flag for a ``WCE`` tuple.
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../doc/gnu_free_documentation_license.rst
+.. include:: ../../../doc/gnu_free_documentation_license.rst
\ No newline at end of file
``rich_location::fixits_cannot_be_auto_applied`` on each note's
``rich_location``. If this is called, then the fix-it hints in
the ``rich_location`` will be printed, but will not be added to
-generated patches.
+generated patches.
\ No newline at end of file
Guidelines for Options
**********************
-.. todo:: write part
+.. todo:: write part
\ No newline at end of file
This host hook returns the alignment required for allocating virtual
memory. Usually this is the same as getpagesize, but on some hosts the
alignment for reserving memory differs from the pagesize for committing
- memory.
+ memory.
\ No newline at end of file
host-common
host-misc
- host-filesystem
+ host-filesystem
\ No newline at end of file
.. envvar:: HOST_LACKS_INODE_NUMBERS
Define this macro if the host filesystem does not report meaningful inode
- numbers in struct stat.
+ numbers in struct stat.
\ No newline at end of file
***********************
The use of :samp:`x-{host}` fragments is discouraged. You should only
-use it for makefile dependencies.
+use it for makefile dependencies.
\ No newline at end of file
In addition, if :command:`configure` generates an incorrect definition of
any of the macros in :samp:`auto-host.h`, you can override that
definition in a host configuration header. If you need to do this,
-first see if it is possible to fix :command:`configure`.
+first see if it is possible to fix :command:`configure`.
\ No newline at end of file
general-public-license-3
gnu-free-documentation-license
- indices-and-tables
+ indices-and-tables
\ No newline at end of file
-.. include:: ../../../doc/indices-and-tables.rst
+.. include:: ../../../doc/indices-and-tables.rst
\ No newline at end of file
values after a ``longjmp``. And this is all GCC promises to do,
because it is very difficult to restore register variables correctly, and
one of GCC's features is that it can put variables in registers without
-your asking it to.
+your asking it to.
\ No newline at end of file
implemented in GCC.
Additional tutorial information is linked to from
-https://gcc.gnu.org/readings.html.
+https://gcc.gnu.org/readings.html.
\ No newline at end of file
from those for which GCC was designed, such as the declarative
logic/functional language Mercury. For these reasons, it may also be
useful to implement compilers created for specialized purposes (for
-example, as part of a research project) as GCC front ends.
+example, as part of a research project) as GCC front ends.
\ No newline at end of file
link-time-optimization/lto-file-sections
link-time-optimization/using-summary-information-in-ipa-passes
link-time-optimization/whole-program-assumptions-linker-plugin-and-symbol-visibilities
- link-time-optimization/internal-flags-controlling-lto1
+ link-time-optimization/internal-flags-controlling-lto1
\ No newline at end of file
The main advantage of WHOPR is to allow the parallel execution of
LTRANS stages, which are the most time-consuming part of the
compilation process. Additionally, it avoids the need to load the
-whole program into memory.
+whole program into memory.
\ No newline at end of file
This option specifies the linker resolution file. This option is
only meaningful in conjunction with :option:`-fwpa` and as option
- to pass through to the LTO linker plugin.
+ to pass through to the LTO linker plugin.
\ No newline at end of file
hooks: one for writing the summary and another for reading it in. The
format of these sections is entirely up to each individual pass. The
only requirement is that the writer and reader hooks agree on the
- format.
+ format.
\ No newline at end of file
Jump functions are used by several optimizations, such as the
inter-procedural constant propagation pass and the
devirtualization pass. The inliner also uses jump functions to
-perform inlining of callbacks.
+perform inlining of callbacks.
\ No newline at end of file
information is missing too and thus GCC needs to make an educated
guess based on :option:`-fwhole-program`. Without the linker
plugin GCC also assumes that symbols are declared ``hidden``
-and not referred by non-LTO code by default.
+and not referred by non-LTO code by default.
\ No newline at end of file
machine-descriptions/conditional-execution
machine-descriptions/rtl-templates-transformations
machine-descriptions/constant-definitions
- machine-descriptions/iterators
+ machine-descriptions/iterators
\ No newline at end of file
"@
clrreg %0
* return stack_mem_p (operands[0]) ? \"push 0\" : \"clrmem %0\";
- clrmem %0")
+ clrmem %0")
\ No newline at end of file
original operation had sufficient precision to prevent overflow.
Further canonicalization rules are defined in the function
-``commutative_operand_precedence`` in :samp:`gcc/rtlanal.cc`.
+``commutative_operand_precedence`` in :samp:`gcc/rtlanal.cc`.
\ No newline at end of file
(plus:SI (match_operand:SI 1 "register_operand" "r")
(match_operand:SI 2 "register_operand" "r"))))]
"(test2) && (test1)"
- "(%3) add %2,%1,%0")
+ "(%3) add %2,%1,%0")
\ No newline at end of file
where :samp:`{cvaluei}` is the capitalized form of :samp:`{valuei}`.
However, unlike ``define_c_enum``, the enumerations defined
by ``define_enum`` can be used in attribute specifications
-(see :ref:`define_enum_attr`).
+(see :ref:`define_enum_attr`).
\ No newline at end of file
{
operands[1] = CONSTM1_RTX (<MODE>mode);
}
- )
+ )
\ No newline at end of file
comparison of the given operands (with the branch insns coming in distinct
signed and unsigned flavors) as in the x86 or SPARC, and the case where
there are distinct signed and unsigned compare instructions and only
-one set of conditional branch instructions as in the PowerPC.
+one set of conditional branch instructions as in the PowerPC.
\ No newline at end of file
If the ``doloop_end`` pattern is a ``define_expand``, there must
also be a ``define_insn`` or ``define_insn_and_split`` matching
the generated pattern. Otherwise, the compiler will fail during loop
-optimization.
+optimization.
\ No newline at end of file
``jump_insn`` or ``call_insn``. If you don't need a real insn
at the end, emit an insn to copy the result of the operation into
itself. Such an insn will generate no code, but it can avoid problems
- in the compiler.
+ in the compiler.
\ No newline at end of file
of C code to compute the output. See :ref:`output-statement`.
* The :dfn:`insn attributes`: This is an optional vector containing the values of
- attributes for insns matching this pattern (see :ref:`insn-attributes`).
+ attributes for insns matching this pattern (see :ref:`insn-attributes`).
\ No newline at end of file
output template to return based on the kind of operand and the specific
type of CPU for which code is being generated.
-:samp:`"rm"` is an operand constraint. Its meaning is explained below.
+:samp:`"rm"` is an operand constraint. Its meaning is explained below.
\ No newline at end of file
file, substituting your own version, since these directories are
searched before the default machine description file directories. If you use more than
one :option:`-I` option, the directories are scanned in left-to-right
-order; the standard default directory come after.
+order; the standard default directory come after.
\ No newline at end of file
.. code-block::
(define_insn_reservation "simple" 2 (eq_attr "type" "int")
- "(i0_pipeline | i1_pipeline), finish")
+ "(i0_pipeline | i1_pipeline), finish")
\ No newline at end of file
you should not provide separate patterns for increment and decrement
instructions. Instead, they should be generated from the same pattern
that supports register-register add insns by examining the operands and
-generating the appropriate machine instruction.
+generating the appropriate machine instruction.
\ No newline at end of file
output and three inputs). This combination would produce separate
:samp:`maybe_gen_{name}` and :samp:`gen_{name}` functions for
each operand count, but it would still produce a single
-:samp:`maybe_code_for_{name}` and a single :samp:`code_for_{name}`.
+:samp:`maybe_code_for_{name}` and a single :samp:`code_for_{name}`.
\ No newline at end of file
If we had not added the ``(match_dup 4)`` in the middle of the input
sequence, it might have been the case that the register we chose at the
-beginning of the sequence is killed by the first or second ``set``.
+beginning of the sequence is killed by the first or second ``set``.
\ No newline at end of file
[(set (match_dup 3) (match_dup 1))
(set (match_dup 0) (mult:SI (match_dup 3) (match_dup 2)))]
- "")
+ "")
\ No newline at end of file
If the macro ``ASSEMBLER_DIALECT`` is defined, you can use construct
of the form :samp:`{option0|option1|option2}` in the templates. These
describe multiple variants of assembler language syntax.
-See :ref:`instruction-output`.
+See :ref:`instruction-output`.
\ No newline at end of file
Finally, the insn list's RTL is matched up with the RTL templates in the
``define_insn`` patterns, and those patterns are used to emit the
final assembly code. For this purpose, each named ``define_insn``
-acts like it's unnamed, since the names are ignored.
+acts like it's unnamed, since the names are ignored.
\ No newline at end of file
The program :command:`genpreds` is responsible for generating code to
test predicates. It also writes a header file containing function
declarations for all machine-specific predicates. It is not necessary
-to declare these predicates in :samp:`{cpu}-protos.h`.
+to declare these predicates in :samp:`{cpu}-protos.h`.
\ No newline at end of file
:samp:`(match_par_dup {n} [{subpat}...])`
Like ``match_op_dup``, but for ``match_parallel`` instead of
- ``match_operator``.
+ ``match_operator``.
\ No newline at end of file
the original pattern ``N``, so in the resultant pattern there would
be ``N*M`` alternatives. Thus, constraints from the original pattern
would be duplicated ``N`` times, constraints from the output pattern
-would be duplicated ``M`` times, producing all possible combinations.
+would be duplicated ``M`` times, producing all possible combinations.
\ No newline at end of file
operand 2, greater than operand 2 or is unordered with operand 2.
:samp:`{m}` should be a scalar floating point mode.
- This pattern is not allowed to ``FAIL``.
+ This pattern is not allowed to ``FAIL``.
\ No newline at end of file
be generated as a single-byte immediate quantity, which would not work.)
Instead of using this pattern ordering it would be possible to make the
pattern for convert-a-byte smart enough to deal properly with any
-constant value.
+constant value.
\ No newline at end of file
:maxdepth: 2
target-makefile-fragments
- host-makefile-fragments
+ host-makefile-fragments
\ No newline at end of file
:maxdepth: 2
gimple-api
- the-language
+ the-language
\ No newline at end of file
memory-management-and-type-information/marking-roots-for-the-garbage-collector
memory-management-and-type-information/source-files-containing-type-information
memory-management-and-type-information/how-to-invoke-the-garbage-collector
- memory-management-and-type-information/troubleshooting-the-garbage-collector
+ memory-management-and-type-information/troubleshooting-the-garbage-collector
\ No newline at end of file
if your code never reads or writes those fields at a particular
instance. One way to ensure this is to use cleared versions of
allocators unless all the fields are initialized manually immediately
-after allocation.
+after allocation.
\ No newline at end of file
is *not* accepted. There should be an ``extern`` declaration
of such a variable in a header somewhere---mark that, not the
definition. Or, if the variable is only used in one file, make it
-``static``.
+``static``.
\ No newline at end of file
Plugins can add additional root tables. Run the ``gengtype``
utility in plugin mode as ``gengtype -P pluginout.h source-dirfile-listplugin*.c`` with your plugin files
:samp:`{plugin*.c}` using ``GTY`` to generate the :samp:`{pluginout.h}` file.
-The GCC build tree is needed to be present in that mode.
+The GCC build tree is needed to be present in that mode.
\ No newline at end of file
.. [#f1] Classes lacking such a marker will not be identified as being
part of the hierarchy, and so the marking routines will not handle them,
leading to a assertion failure within the marking routines due to an
- unknown tag value (assuming that assertions are enabled).
+ unknown tag value (assuming that assertions are enabled).
\ No newline at end of file
will, in turn, walk all the pointers inside fields of ``T``).
In the case of ``TP<T *>``, references to ``T *`` must be
handled by calling the ``op`` function on the address of the
- pointer (see the code snippets above).
+ pointer (see the code snippets above).
\ No newline at end of file
``user``
The ``user`` option indicates that the code to mark structure
fields is completely handled by user-provided routines. See section
- :ref:`user-gc` for details on what functions need to be provided.
+ :ref:`user-gc` for details on what functions need to be provided.
\ No newline at end of file
* Link-time errors about undefined ``gt_ggc_r_foo_bar`` and
similarly-named symbols. Check if your :samp:`foo_bar` source file has
- ``#include "gt-foo_bar.h"`` as its very last line.
+ ``#include "gt-foo_bar.h"`` as its very last line.
\ No newline at end of file
They are primarily intended to declare target masks that are not
associated with user options, either because these masks represent
internal switches or because the options are not available on all
- configurations and yet the masks always need to be defined.
+ configurations and yet the masks always need to be defined.
\ No newline at end of file
:samp:`CppReason({CPP_W_Enum})`
This warning option corresponds to ``cpplib.h`` warning reason code
:samp:`{CPP_W_Enum}`. This should only be used for warning options of the
- C-family front-ends.
+ C-family front-ends.
\ No newline at end of file
:maxdepth: 2
option-file-format
- option-properties
+ option-properties
\ No newline at end of file
passes-and-files-of-the-compiler/inter-procedural-optimization-passes
passes-and-files-of-the-compiler/tree-ssa-passes
passes-and-files-of-the-compiler/rtl-passes
- passes-and-files-of-the-compiler/optimization-info
+ passes-and-files-of-the-compiler/optimization-info
\ No newline at end of file
``GS_OK``, which will cause the expression to be processed again.
If the callback encounters an error during the transformation (because
the front end is relying on the gimplification process to finish
-semantic checks), it should return ``GS_ERROR``.
+semantic checks), it should return ``GS_ERROR``.
\ No newline at end of file
This is the OpenMP constructs' SIMD clone pass. It creates the appropriate
SIMD clones for functions tagged as elemental SIMD functions.
It is located in :samp:`omp-simd-clone.cc` and is described by
- ``pass_omp_simd_clone``.
+ ``pass_omp_simd_clone``.
\ No newline at end of file
in conflict since only one output file is allowed. In this case, only
the first option takes effect and the subsequent options are
ignored. Thus only the :samp:`vec.miss` is produced which containts
-dumps from the vectorizer about missed opportunities.
+dumps from the vectorizer about missed opportunities.
\ No newline at end of file
that is more descriptive than "rest_of".
The middle-end will, at its option, emit the function and data
-definitions immediately or queue them for later processing.
+definitions immediately or queue them for later processing.
\ No newline at end of file
.. todo:: describe the global variables set up by the pass manager,
and a brief description of how a new pass should use it.
- I need to look at what info RTL passes use first…
+ I need to look at what info RTL passes use first…
\ No newline at end of file
are :samp:`dwarfout.c` for
DWARF symbol table format, files :samp:`dwarf2out.cc` and :samp:`dwarf2asm.cc`
for DWARF2 symbol table format, and :samp:`vmsdbgout.cc` for VMS debug
- symbol table format.
+ symbol table format.
\ No newline at end of file
be used in ``va_arg`` macros. For instance, if ``va_arg`` is
only used with integral types in the function, floating point
registers don't need to be saved. This pass is located in
- ``tree-stdarg.cc`` and described by ``pass_stdarg``.
+ ``tree-stdarg.cc`` and described by ``pass_stdarg``.
\ No newline at end of file
plugins/recording-information-about-pass-execution
plugins/controlling-which-passes-are-being-run
plugins/keeping-track-of-available-passes
- plugins/building-gcc-plugins
+ plugins/building-gcc-plugins
\ No newline at end of file
When a plugin needs to use :command:`gengtype`, be sure that both
:samp:`gengtype` and :samp:`gtype.state` have the same version as the
-GCC for which the plugin is built.
+GCC for which the plugin is built.
\ No newline at end of file
Then the event ``PLUGIN_OVERRIDE_GATE`` is invoked, with a pointer
to the gate status in the ``gcc_data`` parameter to the callback function.
A nonzero value of the gate status means that the pass is to be executed.
-You can both read and write the gate status via the passed pointer.
+You can both read and write the gate status via the passed pointer.
\ No newline at end of file
Such a structure is passed as the ``user_data`` by the plugin's
init routine using ``register_callback`` with the
-``PLUGIN_INFO`` pseudo-event and a null callback.
+``PLUGIN_INFO`` pseudo-event and a null callback.
\ No newline at end of file
utility generates these extra root tables.
You should understand the details of memory management inside GCC
-before using ``PLUGIN_GGC_MARKING`` or ``PLUGIN_REGISTER_GGC_ROOTS``.
+before using ``PLUGIN_GGC_MARKING`` or ``PLUGIN_REGISTER_GGC_ROOTS``.
\ No newline at end of file
register_callback (plugin_info->base_name, PLUGIN_PASS_MANAGER_SETUP, NULL, &pass_info);
...
- }
+ }
\ No newline at end of file
generic passes to be added after plugin loading.
When a pass is first added to one of the pass lists, the event
``PLUGIN_NEW_PASS`` is invoked, with the callback parameter
-``gcc_data`` pointing to the new pass.
+``gcc_data`` pointing to the new pass.
\ No newline at end of file
slashes). When simply passing :option:`-fplugin=name`, the plugin is
loaded from the :samp:`plugin` directory, so :option:`-fplugin=name` is
the same as :option:`-fplugin\=\`gcc -print-file-name=plugin\`/name.ext`,
-using backquote shell syntax to query the :samp:`plugin` directory.
+using backquote shell syntax to query the :samp:`plugin` directory.
\ No newline at end of file
The PLUGIN_FINISH event is the last time that plugins can call GCC
functions, notably emit diagnostics with ``warning``, ``error``
-etc.
+etc.
\ No newline at end of file
``PLUGIN_ALL_PASSES_END``, ``PLUGIN_ALL_IPA_PASSES_START``,
``PLUGIN_ALL_IPA_PASSES_END``, ``PLUGIN_EARLY_GIMPLE_PASSES_START``,
and/or ``PLUGIN_EARLY_GIMPLE_PASSES_END`` to manipulate global state
-in your plugin(s) in order to get context for the pass execution.
+in your plugin(s) in order to get context for the pass execution.
\ No newline at end of file
.. code-block:: c++
#define NUMBER 10
- #pragma GCCPLUGIN foothreshold (NUMBER)
+ #pragma GCCPLUGIN foothreshold (NUMBER)
\ No newline at end of file
rtl-representation/rtl-representation-of-function-call-insns
rtl-representation/on-the-side-ssa-form-for-rtl
rtl-representation/structure-sharing-assumptions
- rtl-representation/reading-rtl
+ rtl-representation/reading-rtl
\ No newline at end of file
All the macros defined in this section expand into lvalues and therefore
can be used to assign the operands, lengths and vector elements as well as
-to access them.
+to access them.
\ No newline at end of file
If :samp:`SYMBOL_REF_HAS_BLOCK_INFO_P ({x})`, this is the offset of :samp:`{x}`
from the first object in :samp:`SYMBOL_REF_BLOCK ({x})`. The value is
negative if :samp:`{x}` has not yet been assigned to a block, or it has not
- been given an offset within that block.
+ been given an offset within that block.
\ No newline at end of file
contains an ``asm_operands`` ; all of these share the same assembler
template and vectors, but each contains the constraint for the respective
output operand. They are also distinguished by the output-operand index
-number, which is 0, 1, ... for successive output operands.
+number, which is 0, 1, ... for successive output operands.
\ No newline at end of file
Unlike ``sign_extract``, this type of expressions can be lvalues
in RTL; they may appear on the left side of an assignment, indicating
- insertion of a value into the specified bit-field.
+ insertion of a value into the specified bit-field.
\ No newline at end of file
none of the tests are nonzero expressions.
This is currently not valid for instruction patterns and is supported only
- for insn attributes. See :ref:`insn-attributes`.
+ for insn attributes. See :ref:`insn-attributes`.
\ No newline at end of file
``CONST1_RTX (mode)`` refers to an expression with value 1 in
mode :samp:`{mode}` and similarly for ``CONST2_RTX``. The
``CONST1_RTX`` and ``CONST2_RTX`` macros are undefined
-for vector modes.
+for vector modes.
\ No newline at end of file
Represents the result of converting unsigned integer value :samp:`{x}` to
fixed-point mode :samp:`{m}`.
When overflows or underflows happen, the results are saturated to the
- maximum or the minimum.
+ maximum or the minimum.
\ No newline at end of file
register which is meaningful in mode :samp:`{n}`, but is not part of
mode :samp:`{m}`, is not to be altered. Normally, an assignment to such
a subreg is allowed to have undefined effects on the rest of the
- register when :samp:`{m}` is smaller than :samp:`REGMODE_NATURAL_SIZE ({n})`.
+ register when :samp:`{m}` is smaller than :samp:`REGMODE_NATURAL_SIZE ({n})`.
\ No newline at end of file
done because machines that allow these operations at all typically
allow them wherever a memory address is called for. Describing them as
additional parallel stores would require doubling the number of entries
-in the machine description.
+in the machine description.
\ No newline at end of file
In ``prefetch`` expressions, 1 means that the containing insn is a
scheduling barrier.
- In an RTL dump, this flag is represented as :samp:`/v`.
+ In an RTL dump, this flag is represented as :samp:`/v`.
\ No newline at end of file
``expr_list`` is that the first operand of an ``insn_list`` is
assumed to be an insn and is printed in debugging dumps as the insn's
unique id; the first operand of an ``expr_list`` is printed in the
-ordinary way as an expression.
+ordinary way as an expression.
\ No newline at end of file
The global variables ``byte_mode`` and ``word_mode`` contain modes
whose classes are ``MODE_INT`` and whose bitsizes are either
``BITS_PER_UNIT`` or ``BITS_PER_WORD``, respectively. On 32-bit
-machines, these are ``QImode`` and ``SImode``, respectively.
+machines, these are ``QImode`` and ``SImode``, respectively.
\ No newline at end of file
return false;
confirm_change_group ();
- crtl->ssa->change_insns (changes);
+ crtl->ssa->change_insns (changes);
\ No newline at end of file
The proper way to interface GCC to a new language front end is with
the 'tree' data structure, described in the files :samp:`tree.h` and
:samp:`tree.def`. The documentation for this structure (see :ref:`generic`)
-is incomplete.
+is incomplete.
\ No newline at end of file
:samp:`(concatn{m} [{rtx} ...])`
This RTX represents the concatenation of all the :samp:`{rtx}` to make a
single value. Like ``concat``, this should only appear in
- declarations, and not in the insn chain.
+ declarations, and not in the insn chain.
\ No newline at end of file
.. envvar:: RTX_CONST_OBJ
- You can make no assumptions about the format of these codes.
+ You can make no assumptions about the format of these codes.
\ No newline at end of file
:samp:`(bswap:{m} {x})`
Represents the value :samp:`{x}` with the order of bytes reversed, carried out
in mode :samp:`{m}`, which must be a fixed-point machine mode.
- The mode of :samp:`{x}` must be :samp:`{m}` or ``VOIDmode``.
+ The mode of :samp:`{x}` must be :samp:`{m}` or ``VOIDmode``.
\ No newline at end of file
.. index:: (nil), nil
In a few contexts a null pointer is valid where an expression is normally
-wanted. The written form of this is ``(nil)``.
+wanted. The written form of this is ``(nil)``.
\ No newline at end of file
function. Similarly, if registers other than those in
``CALL_USED_REGISTERS`` are clobbered by the called function, insns
containing a single ``clobber`` follow immediately after the call to
-indicate which registers.
+indicate which registers.
\ No newline at end of file
This insn is used to minimize cache-miss latency by moving data into a
cache before it is accessed. It should use only non-faulting data prefetch
- instructions.
+ instructions.
\ No newline at end of file
temporarily. However, the shared structure is copied before the
combiner is finished with the insn. This is done by calling
``copy_rtx_if_shared``, which is a subroutine of
- ``unshare_all_rtl``.
+ ``unshare_all_rtl``.
\ No newline at end of file
all prior side effects, and before any subsequent side effects. With
``BLKmode``, it indicates an inline entry point: the lexical block
encoded in the ``INSN_LOCATION`` is the enclosing block that encloses
- the inlined function.
+ the inlined function.
\ No newline at end of file
:samp:`(vec_series:{m} {base} {step})`
This operation creates a vector in which element :samp:`{i}` is equal to
- :samp:`{base} + {i}*{step}`. :samp:`{m}` must be a vector integer mode.
+ :samp:`{base} + {i}*{step}`. :samp:`{m}` must be a vector integer mode.
\ No newline at end of file
sizes-and-offsets-as-runtime-invariants/computing-bounds-on-polyints
sizes-and-offsets-as-runtime-invariants/converting-polyints
sizes-and-offsets-as-runtime-invariants/miscellaneous-polyint-routines
- sizes-and-offsets-as-runtime-invariants/guidelines-for-using-polyint
+ sizes-and-offsets-as-runtime-invariants/guidelines-for-using-polyint
\ No newline at end of file
Assert that we can calculate the misalignment of :samp:`{value}` with
respect to :samp:`{align}` at compile time and return the misalignment.
When using this function, please add a comment explaining why
- the assertion is known to hold.
+ the assertion is known to hold.
\ No newline at end of file
When using this routine, please add a comment explaining why the
assertion is known to hold.
- Please add any other operations that you find to be useful.
+ Please add any other operations that you find to be useful.
\ No newline at end of file
Note that the values do not necessarily end up in numerical order.
For example, :samp:`1 + 1{x}` would come after :samp:`100` in the sort order,
- but may well be less than :samp:`100` at run time.
+ but may well be less than :samp:`100` at run time.
\ No newline at end of file
:samp:`upper_bound ({a}, {b})`
Return a value that is always greater than or equal to both :samp:`{a}` and
:samp:`{b}`. It will be the least such value for some indeterminate values
- but necessarily for all.
+ but necessarily for all.
\ No newline at end of file
However, it would be very artificial to force target-specific code
to follow these restrictions if the target has no runtime indeterminates.
There is therefore an implicit conversion from ``poly_int<1, T>``
-to :samp:`{T}` when compiling target-specific translation units.
+to :samp:`{T}` when compiling target-specific translation units.
\ No newline at end of file
:samp:`poly_widest_int::from ({value}, {sign})`
Convert :samp:`{value}` to a ``poly_widest_int``, extending its coefficients
- according to :samp:`{sign}` if they have fewer bits than ``widest_int``.
+ according to :samp:`{sign}` if they have fewer bits than ``widest_int``.
\ No newline at end of file
* Add ``to_constant ()`` calls where necessary. The previous option
is preferable because it will help with any future conversion of the
- macro to a hook.
+ macro to a hook.
\ No newline at end of file
``poly_int64`` values print as signed by default and
``poly_uint64`` values print as unsigned by default.
- This is a simply a ``poly_int`` version of a wide-int routine.
+ This is a simply a ``poly_int`` version of a wide-int routine.
\ No newline at end of file
a :samp:`poly_int` with ``widest_int`` coefficients.
Since the main purpose of ``poly_int`` is to represent sizes and
- offsets, the last two typedefs are only rarely used.
+ offsets, the last two typedefs are only rarely used.
\ No newline at end of file
source-tree-structure-and-build-system/configure-terms-and-history
source-tree-structure-and-build-system/top-level-source-directory
- source-tree-structure-and-build-system/the-gcc-subdirectory
+ source-tree-structure-and-build-system/the-gcc-subdirectory
\ No newline at end of file
for the host, once for the target (even if they are the same), and once
for the build if build and host are different. This allows it to be
used by all programs which are generated in the course of the build
-process.
+process.
\ No newline at end of file
the-gcc-subdirectory/headers-installed-by-gcc
the-gcc-subdirectory/building-documentation
the-gcc-subdirectory/anatomy-of-a-language-front-end
- the-gcc-subdirectory/anatomy-of-a-target-back-end
+ the-gcc-subdirectory/anatomy-of-a-target-back-end
\ No newline at end of file
but should not delete anything that is.
:samp:`Make-lang.in` must also define a variable ``lang_OBJS``
- to a list of host object files that are used by that language.
+ to a list of host object files that are used by that language.
\ No newline at end of file
a maintainer when support is added.
* Target triplets covering all :samp:`config.gcc` stanzas for the target,
- in the list in :samp:`contrib/config-list.mk`.
+ in the list in :samp:`contrib/config-list.mk`.
\ No newline at end of file
.. todo:: describe the build system, including what is built in what
stages. Also list the various source files that are used in the build
process but aren't source files of GCC itself and so aren't documented
- below (see :ref:`passes`).
+ below (see :ref:`passes`).
\ No newline at end of file
The :samp:`tm_p.h` also
includes the header :samp:`tm-preds.h` which is generated by
:samp:`genpreds` program during the build to define the declarations
- and inline functions for the predicate functions.
+ and inline functions for the predicate functions.
\ No newline at end of file
needs fixing, :samp:`syslimits.h` is the fixed copy.
GCC can also install ``<tgmath.h>``. It will do this when
-:samp:`config.gcc` sets ``use_gcc_tgmath`` to ``yes``.
+:samp:`config.gcc` sets ``use_gcc_tgmath`` to ``yes``.
\ No newline at end of file
under the :samp:`gcc` directory that aren't built into the GCC
executable but rather are part of runtime libraries and object files,
such as :samp:`crtstuff.c` and :samp:`unwind-dw2.c`. See :ref:`headers`, for more information about the
- :samp:`ginclude` directory.
+ :samp:`ginclude` directory.
\ No newline at end of file
Alternatively, you can use per-language targets to build and test
languages that are not enabled by default in stage1. For example,
:command:`make f951` will build a Fortran compiler even in the stage1
-build directory.
+build directory.
\ No newline at end of file
:samp:`testsuite`
The GCC testsuites (except for those for runtime libraries).
- See :ref:`testsuites`.
+ See :ref:`testsuites`.
\ No newline at end of file
The build system in the top level directory, including how recursion
into subdirectories works and how building runtime libraries for
multilibs is handled, is documented in a separate manual, included
-with GNU Binutils.
+with GNU Binutils.
\ No newline at end of file
is the place for other packages to install header files that GCC will
use. For a cross-compiler, this is the equivalent of
:samp:`/usr/include`. When you build a cross-compiler,
-``fixincludes`` processes any header files in this directory.
+``fixincludes`` processes any header files in this directory.
\ No newline at end of file
:maxdepth: 2
analyzer-internals
- debugging-the-analyzer
+ debugging-the-analyzer
\ No newline at end of file
target-macros/c++-abi-parameters
target-macros/d-abi-parameters
target-macros/adding-support-for-named-address-spaces
- target-macros/miscellaneous-parameters
+ target-macros/miscellaneous-parameters
\ No newline at end of file
.. c:macro:: BTF_DEBUGGING_INFO
Define this macro if GCC should produce debugging output in BTF debug
- format in response to the :option:`-gbtf` option.
+ format in response to the :option:`-gbtf` option.
\ No newline at end of file
* The macro ``STANDARD_STARTFILE_PREFIX_2``, but only if this is a native
compiler, or we have a target system root. The default for this macro is
- :samp:`/usr/lib/`.
+ :samp:`/usr/lib/`.
\ No newline at end of file
.. function:: REAL_VALUE_TYPE REAL_VALUE_ABS (REAL_VALUE_TYPE x)
- Returns the absolute value of :samp:`{x}`.
+ Returns the absolute value of :samp:`{x}`.
\ No newline at end of file
Another note: according to the MIPS spec, coprocessor 1 (if present) is
the FPU. One accesses COP1 registers through standard mips
-floating-point support; they are not included in this mechanism.
+floating-point support; they are not included in this mechanism.
\ No newline at end of file
``struct machine_function`` structures are expected to be freed by GC.
Generally, any memory that they reference must be allocated by using
-GC allocation, including the structure itself.
+GC allocation, including the structure itself.
\ No newline at end of file
defining-the-output-assembler-language/output-of-assembler-instructions
defining-the-output-assembler-language/output-of-dispatch-tables
defining-the-output-assembler-language/assembler-commands-for-exception-regions
- defining-the-output-assembler-language/assembler-commands-for-alignment
+ defining-the-output-assembler-language/assembler-commands-for-alignment
\ No newline at end of file
command to advance the location counter to a multiple of 2 to the
:samp:`{power}` bytes, but only if :samp:`{max_skip}` or fewer bytes are needed to
satisfy the alignment request. :samp:`{power}` and :samp:`{max_skip}` will be
- a C expression of type ``int``.
+ a C expression of type ``int``.
\ No newline at end of file
the ordinary linker, but also arranges to include the vectors of
initialization and termination functions. These functions are called
via ``__main`` as described above. In order to use this method,
-``use_collect2`` must be defined in the target in :samp:`config.gcc`.
+``use_collect2`` must be defined in the target in :samp:`config.gcc`.
\ No newline at end of file
library extension of the target (e.g., :samp:`".so"`). :command:`collect2`
strips version information after this suffix when generating global
constructor and destructor names. This define is only needed on targets
- that use :command:`collect2` to process constructors and destructors.
+ that use :command:`collect2` to process constructors and destructors.
\ No newline at end of file
in a category); and :samp:`{sel_name}` is the name of the selector.
On systems where the assembler can handle quoted names, you can use this
- macro to provide more human-readable names.
+ macro to provide more human-readable names.
\ No newline at end of file
A C expression to output to :samp:`{stream}` some assembler code
which will pop hard register number :samp:`{regno}` off of the stack.
The code need not be optimal, since this macro is used only when
- profiling.
+ profiling.
\ No newline at end of file
The array element values are designed so that you can print them out
using ``fprintf`` in the order they should appear in the target
- machine's memory.
+ machine's memory.
\ No newline at end of file
is no corresponding variable. If you define this macro, GCC will use it
in place of both ``ASM_OUTPUT_LOCAL`` and
``ASM_OUTPUT_ALIGNED_LOCAL``. Define this macro when you need to see
- the variable's decl in order to chose what to output.
+ the variable's decl in order to chose what to output.
\ No newline at end of file
selector to the method-lookup function, which returns a pointer to the method.
In either case, it remains possible to select code-generation for the alternate
- scheme, by means of compiler command line switches.
+ scheme, by means of compiler command line switches.
\ No newline at end of file
There are a few non-descriptor entries in the vtable at offsets below
zero. If these entries must be padded (say, to preserve the alignment
specified by ``TARGET_VTABLE_ENTRY_ALIGN``), set this to the number
- of words in each data entry.
+ of words in each data entry.
\ No newline at end of file
check this. You can also assume :samp:`{flag_pic}` is true, so you need not
check it either. You need not define this macro if all constants
(including ``SYMBOL_REF``) can be immediate operands when generating
- position independent code.
+ position independent code.
\ No newline at end of file
.. c:macro:: LAST_STACK_REG
The number of the last stack-like register. This one is the bottom of
- the stack.
+ the stack.
\ No newline at end of file
stack-layout-and-calling-conventions/permitting-tail-calls
stack-layout-and-calling-conventions/shrink-wrapping-separate-components
stack-layout-and-calling-conventions/stack-smashing-protection
- stack-layout-and-calling-conventions/miscellaneous-register-hooks
+ stack-layout-and-calling-conventions/miscellaneous-register-hooks
\ No newline at end of file
If defined, a C expression whose value is an integer giving the offset
in bytes from the canonical frame address (cfa) to the frame base used
in DWARF 2 debug information. The default is zero. A different value
- may reduce the size of debug information on some ports.
+ may reduce the size of debug information on some ports.
\ No newline at end of file
of a pseudo-register in call-clobbered hard register :samp:`{regno}`. If
:samp:`{regno}` is unsuitable for caller save, ``VOIDmode`` should be
returned. For most machines this macro need not be defined since GCC
- will select the smallest suitable mode.
+ will select the smallest suitable mode.
\ No newline at end of file
A C expression that evaluates to true if the target requires unwind
info to be given comdat linkage. Define it to be ``1`` if comdat
- linkage is necessary. The default is ``0``.
+ linkage is necessary. The default is ``0``.
\ No newline at end of file
that pops certain registers off the stack, depending on the arguments
that have been passed to the function. Since this is a property of the
call site, not of the called function, ``RETURN_POPS_ARGS`` is not
- appropriate.
+ appropriate.
\ No newline at end of file
Define this macro if the target has pseudo DWARF registers whose
values need to be computed lazily on demand by the unwinder (such as when
referenced in a CFA expression). The macro returns true if :samp:`{regno}`
- is such a register and stores its value in :samp:`*{value}` if so.
+ is such a register and stores its value in :samp:`*{value}` if so.
\ No newline at end of file
special label of your own in the assembler code. Use one ``asm``
statement to generate an assembler label, and another to make the label
global. Then trampolines can use that label to jump directly to your
- special assembler code.
+ special assembler code.
\ No newline at end of file
``TARGETDM_INITIALIZER`` in :samp:`d/d-target-def.h`. If targets
initialize ``targetdm`` themselves, they should set
``target_has_targetdm=yes`` in :samp:`config.gcc`; otherwise a default
-definition is used.
+definition is used.
\ No newline at end of file
These are extra flags to pass to the C compiler. They are used both
when building GCC, and when compiling things with the just-built GCC.
- This variable is deprecated and should not be used.
+ This variable is deprecated and should not be used.
\ No newline at end of file
testsuites/support-for-testing-binary-compatibility
testsuites/support-for-torture-testing-using-multiple-options
testsuites/support-for-testing-gimple-passes
- testsuites/support-for-testing-rtl-passes
+ testsuites/support-for-testing-rtl-passes
\ No newline at end of file
customization section at the top of :samp:`run_all.sh`.
These tests are run using the build tree: they can be run without doing
-a ``make install``.
+a ``make install``.
\ No newline at end of file
Test the testsuite itself using :samp:`gcc.test-framework/test-framework.exp`.
.. todo:: merge in :samp:`testsuite/README.gcc` and discuss the format of
- test cases and magic comments more.
+ test cases and magic comments more.
\ No newline at end of file
directives-used-within-dejagnu-tests/keywords-describing-target-attributes
directives-used-within-dejagnu-tests/features-for-dg-add-options
directives-used-within-dejagnu-tests/variants-of-dg-require-support
- directives-used-within-dejagnu-tests/commands-for-use-in-dg-final
+ directives-used-within-dejagnu-tests/commands-for-use-in-dg-final
\ No newline at end of file
// { dg-keep-saved-temps ".ii" ".o" } ! or just .ii and .o
``cleanup-profile-file``
- Removes profiling files generated for this test.
+ Removes profiling files generated for this test.
\ No newline at end of file
instructions, if any.
``tls``
- Add the target-specific flags needed to use thread-local storage.
+ Add the target-specific flags needed to use thread-local storage.
\ No newline at end of file
Always returns 0.
``yes``
- Always returns 1.
+ Always returns 1.
\ No newline at end of file
{ target { ! "hppa*-*-* ia64*-*-*" } }
{ target { powerpc*-*-* && lp64 } }
{ xfail { lp64 || vect_no_align } }
- { xfail { aarch64*-*-* && { any-opts "-O2" } } }
+ { xfail { aarch64*-*-* && { any-opts "-O2" } } }
\ No newline at end of file
source file and is processed after the test has been compiled and run.
Multiple :samp:`dg-final` commands are processed in the order in which
they appear in the source file. See :ref:`final-actions`, for a list
- of directives that can be used within ``dg-final``.
+ of directives that can be used within ``dg-final``.
\ No newline at end of file
Skip the test if the target does not support weak symbols.
``dg-require-weak-override ""``
- Skip the test if the target does not support overriding weak symbols.
+ Skip the test if the target does not support overriding weak symbols.
\ No newline at end of file
appropriate code to avoid causing failures on unsupported systems;
unfortunately, the mechanisms for this differ by directory.
-.. todo:: discuss non-C testsuites here
+.. todo:: discuss non-C testsuites here
\ No newline at end of file
``dg-xfail-if``
This command can be used in a secondary source file to specify that
compilation is expected to fail for particular options on particular
- targets.
+ targets.
\ No newline at end of file
percentages, and call return percentages. The command to check a
line count must appear on the line that will report that count, but
commands to check branch percentages and call return percentages can
-bracket the lines that report them.
+bracket the lines that report them.
\ No newline at end of file
The ``__GIMPLE`` parser is integrated with the C tokenizer and
preprocessor, so it should be possible to use macros to build out
-test coverage.
+test coverage.
\ No newline at end of file
This directive adds :samp:`{options}` to the linker options used.
:samp:`{ dg-suppress-ld-options {options} [{ target {selector} }]}`
- This directive removes :samp:`{options}` from the set of linker options used.
+ This directive removes :samp:`{options}` from the set of linker options used.
\ No newline at end of file
:samp:`{ dg-final-use { {local-directive} } }`
The :samp:`{local-directive}` is run after the profile data have been
- used.
+ used.
\ No newline at end of file
The ``__RTL`` parser is not integrated with the C tokenizer or
preprocessor, and works simply by reading the relevant lines within
the braces. In particular, the RTL body must be on separate lines from
-the enclosing braces, and the preprocessor is not usable within it.
+the enclosing braces, and the preprocessor is not usable within it.
\ No newline at end of file
set ADDITIONAL_TORTURE_OPTIONS [list \
{ -O2 -ftree-loop-linear } \
- { -O2 -fpeel-loops } ]
+ { -O2 -fpeel-loops } ]
\ No newline at end of file
the-gcc-low-level-runtime-library/routines-for-decimal-floating-point-emulation
the-gcc-low-level-runtime-library/routines-for-fixed-point-fractional-emulation
the-gcc-low-level-runtime-library/language-independent-routines-for-exception-handling
- the-gcc-low-level-runtime-library/miscellaneous-runtime-library-routines
+ the-gcc-low-level-runtime-library/miscellaneous-runtime-library-routines
\ No newline at end of file
__register_frame_info_bases
__register_frame_info_table
__register_frame_info_table_bases
- __register_frame_table
+ __register_frame_table
\ No newline at end of file
.. c:var:: struct initial_sp __morestack_initial_sp
-Internal variables used by the :option:`-fsplit-stack` implementation.
+Internal variables used by the :option:`-fsplit-stack` implementation.
\ No newline at end of file
int __bid_gttd2 (_Decimal128 a, _Decimal128 b)
These functions return a value greater than zero if neither argument
- is NaN, and :samp:`{a}` is strictly greater than :samp:`{b}`.
+ is NaN, and :samp:`{a}` is strictly greater than :samp:`{b}`.
\ No newline at end of file
unsigned long long accum __satfractunstiuta (unsigned long long a)
These functions convert from unsigned non-fractionals to fractionals,
- with saturation.
+ with saturation.
\ No newline at end of file
These functions return the quotient of :samp:`{a}` + i :samp:`{b}` and
:samp:`{c}` + i :samp:`{d}` (i.e., (:samp:`{a}` + i :samp:`{b}`) / (:samp:`{c}`
- + i :samp:`{d}`)), following the rules of C99 Annex G.
+ + i :samp:`{d}`)), following the rules of C99 Annex G.
\ No newline at end of file
.. function:: int32_t __bswapsi2 (int32_t a)
int64_t __bswapdi2 (int64_t a)
- These functions return the :samp:`{a}` byteswapped.
+ These functions return the :samp:`{a}` byteswapped.
\ No newline at end of file
{ build_zero_cst (type); })
Which will match a bitwise and of an operand with its logical
-inverted value.
+inverted value.
\ No newline at end of file
:maxdepth: 2
guidelines-for-diagnostics
- guidelines-for-options
+ guidelines-for-options
\ No newline at end of file
number of platforms.
* The `GFortran Wiki <https://gcc.gnu.org/wiki/GFortranBinaries>`_ has
- links to GNU Fortran binaries for several platforms.
+ links to GNU Fortran binaries for several platforms.
\ No newline at end of file
building/building-in-parallel
building/building-the-ada-compiler
building/building-the-d-compiler
- building/building-with-profile-feedback
+ building/building-with-profile-feedback
\ No newline at end of file
:samp:`crtn.o` which are linked into each executable. There may be several
alternatives for :samp:`crt0.o`, for use with profiling or other
compilation options. Check your target's definition of
-``STARTFILE_SPEC`` to find out what start files it uses.
+``STARTFILE_SPEC`` to find out what start files it uses.
\ No newline at end of file
bootstrap-hwasan
Compiles GCC itself using HWAddress Sanitization in order to catch invalid
memory accesses within the GCC code. This option is only available on AArch64
- systems that are running Linux kernel version 5.4 or later.
+ systems that are running Linux kernel version 5.4 or later.
\ No newline at end of file
in most cases using a value greater than the number of processors in
your machine will result in fewer and shorter I/O latency hits, thus
improving overall throughput; this is especially true for slow drives
-and network filesystems.
+and network filesystems.
\ No newline at end of file
Building the Ada compiler
*************************
-:ref:`GNAT <gnat-prerequisite>`.
+:ref:`GNAT <gnat-prerequisite>`.
\ No newline at end of file
Building the D compiler
***********************
-:ref:`GDC <gdc-prerequisite>`.
+:ref:`GDC <gdc-prerequisite>`.
\ No newline at end of file
Only the profile from the current build is used, so when an error
occurs it is recommended to clean before restarting. Otherwise
-the code quality may be much worse.
+the code quality may be much worse.
\ No newline at end of file
Use installed :samp:`zlib` rather than that included with GCC. This needs
to be available for each multilib variant, unless configured with
:option:`--with-target-system-zlib=auto` in which case the GCCincluded
- :samp:`zlib` is only used when the system installed library is not available.
+ :samp:`zlib` is only used when the system installed library is not available.
\ No newline at end of file
You have freedom to copy and modify this GNU Manual, like GNU
software. Copies published by the Free Software Foundation raise
- funds for GNU development.
+ funds for GNU development.
\ No newline at end of file
Otherwise unpack the GMP, MPFR and/or MPC source
distributions in the directory containing the GCC sources and rename
their directories to :samp:`gmp`, :samp:`mpfr` and :samp:`mpc`,
-respectively (or use symbolic links with the same name).
+respectively (or use symbolic links with the same name).
\ No newline at end of file
recent version of GCC.
If you would like to generate online HTML documentation, do :samp:`cd
-{objdir}; make html`.
+{objdir}; make html`.
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../doc/gnu_free_documentation_license.rst
+.. include:: ../../../doc/gnu_free_documentation_license.rst
\ No newline at end of file
C++ support is significantly better on ELF targets if you use the
GNU linker; duplicate copies of
inlines, vtables and template instantiations will be discarded
-automatically.
+automatically.
\ No newline at end of file
:samp:`execute.exp`, :samp:`dg.exp` and :samp:`old-deja.exp`.
To get a list of the possible :samp:`*.exp` files, pipe the
output of :samp:`make check` into a file and look at the
-:samp:`Running ... .exp` lines.
+:samp:`Running ... .exp` lines.
\ No newline at end of file
It is normal for some tests to report unexpected failures. At the
current time the testing harness does not allow fine grained control
over whether or not a test is expected to fail. This problem should
-be fixed in future releases.
+be fixed in future releases.
\ No newline at end of file
host-target-specific-installation-notes-for-gcc
gnu-free-documentation-license.rst
- indices-and-tables
+ indices-and-tables
\ No newline at end of file
-.. include:: ../../../doc/indices-and-tables.rst
+.. include:: ../../../doc/indices-and-tables.rst
\ No newline at end of file
we suggest that you install GCC into a directory of its own and simply
remove that directory when you do not need that specific version of GCC
any longer, and, if shared libraries are installed there as well, no
-more binaries exist that use them.
+more binaries exist that use them.
\ No newline at end of file
will run three concurrent 'make-gcc' testsuites, eventually testing all
ten combinations as described above. Note that this is currently only
supported in the :samp:`gcc` subdirectory. (To see how this works, try
-typing :command:`echo` before the example given here.)
+typing :command:`echo` before the example given here.)
\ No newline at end of file
* patch version 2.5.4 (or later)
Necessary when applying patches, created with :command:`diff`, to one's
- own sources.
+ own sources.
\ No newline at end of file
prepended to the testsuite summary and should contain any special
remarks you have on your results or your build environment. Please
do not edit the testsuite result block or the subject line, as these
-messages may be automatically processed.
+messages may be automatically processed.
\ No newline at end of file
how-can-you-run-the-testsuite-on-selected-tests
passing-options-and-running-multiple-testsuites
how-to-interpret-test-results
- submitting-test-results
+ submitting-test-results
\ No newline at end of file
:maxdepth: 2
command-line-options
- error-handling
+ error-handling
\ No newline at end of file
``gfc_option_t`` struct, which is defined in :samp:`gfortran.h`.
Before the options are processed, initial values for these flags are set
in ``gfc_init_option`` in :samp:`options.cc`; these become the default
-values for the options.
+values for the options.
\ No newline at end of file
You have freedom to copy and modify this GNU Manual, like GNU
software. Copies published by the Free Software Foundation raise
- funds for GNU development.
+ funds for GNU development.
\ No newline at end of file
the various error and warning functions is similar to the ``printf``
syntax, with :samp:`%`-escapes to insert variable values. The details,
and the allowable codes, are documented in the ``error_print``
-function in :samp:`error.cc`.
+function in :samp:`error.cc`.
\ No newline at end of file
:maxdepth: 2
gfccode
- gfcexpr
+ gfcexpr
\ No newline at end of file
generating-the-intermediate-language-for-later-stages/basic-data-structures
generating-the-intermediate-language-for-later-stages/converting-expressions-to-tree
generating-the-intermediate-language-for-later-stages/translating-statements
- generating-the-intermediate-language-for-later-stages/accessing-declarations
+ generating-the-intermediate-language-for-later-stages/accessing-declarations
\ No newline at end of file
used for accessing that entity in the middle-end.
Accessing declarations is usually done by functions called
-``gfc_get*``.
+``gfc_get*``.
\ No newline at end of file
tree var, *block;
/* Initialize block somewhere here. */
var = gfc_create_var (integer_type_node, "everything");
- gfc_add_modify (block, var, build_int_cst (integer_type_node, 42));
+ gfc_add_modify (block, var, build_int_cst (integer_type_node, 42));
\ No newline at end of file
corresponding argument.
``gfc_se`` also contains pointers to a ``gfc_ss`` and a
-``gfc_loopinfo`` structure. These are needed by the scalarizer.
+``gfc_loopinfo`` structure. These are needed by the scalarizer.
\ No newline at end of file
Translating statements to ``tree`` is done by functions called
``gfc_trans_*``. These functions usually get passed a
``gfc_code`` structure, evaluate any expressions and then
-return a ``tree`` structure.
+return a ``tree`` structure.
\ No newline at end of file
of the ``BLOCK`` construct assignments are automatically generated to
set the corresponding variables to their target expressions' values, and
later on the compiler simply disallows using such associate-names in contexts
-that may change the value.
+that may change the value.
\ No newline at end of file
In this case, ``value.character`` contains the full string's data as if it
was a string constant, but the ``ref`` member is also set and points to a
-substring reference as described in the subsection above.
+substring reference as described in the subsection above.
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../../doc/gnu_free_documentation_license.rst
+.. include:: ../../../../doc/gnu_free_documentation_license.rst
\ No newline at end of file
the-libgfortran-runtime-library
gnu-free-documentation-license
- indices-and-tables
+ indices-and-tables
\ No newline at end of file
-.. include:: ../../../../doc/indices-and-tables.rst
+.. include:: ../../../../doc/indices-and-tables.rst
\ No newline at end of file
:maxdepth: 2
type-bound-procedures
- type-bound-operators
+ type-bound-operators
\ No newline at end of file
that at some point in the future it will become a reasonably complete
guide; in the interim, GNU Fortran developers are strongly encouraged to
contribute to it as a way of keeping notes while working on the
-compiler.
+compiler.
\ No newline at end of file
``old_foo``, ``old_foo1``, and ``new_foo``.
In this case the map file must contain ``foo`` in ``VERS_1.1``
-and ``VERS_1.2`` as well as in ``VERS_2.0``.
+and ``VERS_1.2`` as well as in ``VERS_2.0``.
\ No newline at end of file
.. toctree::
:maxdepth: 2
- symbol-versioning
+ symbol-versioning
\ No newline at end of file
the operator call. If there's indeed a relevant definition, the
operator call is replaced with an internally generated ``GENERIC``
type-bound procedure call to the respective definition and that call is
-further processed.
+further processed.
\ No newline at end of file
need not be of type ``EXPR_VARIABLE`` and thus representable in this way.
Finally, if ``value.compcall.assign`` is set, the call was produced in
expansion of a type-bound assignment; this means that proper dependency-checking
-needs to be done when relevant.
+needs to be done when relevant.
\ No newline at end of file
assembler code. You would typically not use this
program directly;
instead, the :command:`gcc` or :command:`gfortran` driver
- programs call it for you.
+ programs call it for you.
\ No newline at end of file
:maxdepth: 2
type-and-enum-abi-documentation
- function-abi-documentation
+ function-abi-documentation
\ No newline at end of file
compiler-characteristics/files-opened-without-an-explicit-action=-specifier
compiler-characteristics/file-operations-on-symbolic-links
compiler-characteristics/file-format-of-unformatted-sequential-files
- compiler-characteristics/asynchronous-i-o
+ compiler-characteristics/asynchronous-i-o
\ No newline at end of file
On some systems, such as Darwin or Solaris, the POSIX thread library
is always linked in, so asynchronous I/O is always performed. On other
sytems, such as Linux, it is necessary to specify :option:`-pthread`,
-:option:`-lpthread` or :option:`-fopenmp` during the linking step.
+:option:`-lpthread` or :option:`-fopenmp` during the linking step.
\ No newline at end of file
data. ``fsync`` will also force a flush of dirty data and metadata
to the server. Similar to ``open`` and ``close``, acquiring and
releasing ``fcntl`` file locks, if the server supports them, will
-also force cache validation and flushing dirty data and metadata.
+also force cache validation and flushing dirty data and metadata.
\ No newline at end of file
result of the expression can be established without them. However, since not
all compilers do that, and such an optimization can potentially modify the
program flow and subsequent results, GNU Fortran throws warnings for such
-situations with the :option:`-Wfunction-elimination` flag.
+situations with the :option:`-Wfunction-elimination` flag.
\ No newline at end of file
open (10,file='test.dat',form='unformatted')
read (10) b
if (all (a == b)) print *,'success!'
- end program main
+ end program main
\ No newline at end of file
* If a symbolic link was connected, using the ``CLOSE`` statement
with a ``STATUS="DELETE"`` specifier will cause the symbolic link itself
- to be deleted, not its target.
+ to be deleted, not its target.
\ No newline at end of file
* If that fails, try to open with ``ACTION='WRITE'``
-* If that fails, generate an error
+* If that fails, generate an error
\ No newline at end of file
values: ``1`` for ``.TRUE.`` and ``0`` for
``.FALSE.``. Any other integer value results in undefined behavior.
-See also :ref:`argument-passing-conventions` and :ref:`interoperability-with-c`.
+See also :ref:`argument-passing-conventions` and :ref:`interoperability-with-c`.
\ No newline at end of file
The available kind parameters can be found in the constant arrays
``CHARACTER_KINDS``, ``INTEGER_KINDS``, ``LOGICAL_KINDS`` and
``REAL_KINDS`` in the :ref:`ISO_FORTRAN_ENV` module. For C interoperability,
-the kind parameters of the :ref:`ISO_C_BINDING` module should be used.
+the kind parameters of the :ref:`ISO_C_BINDING` module should be used.
\ No newline at end of file
case one of the arguments is a ``NaN``, it is necessary to
explicitly test the arguments before calling ``MAX`` or ``MIN``,
e.g. with the ``IEEE_IS_NAN`` function from the intrinsic module
-``IEEE_ARITHMETIC``.
+``IEEE_ARITHMETIC``.
\ No newline at end of file
concurrently from another thread while a Fortran formatted I/O
operation is in progress. Also, other threads doing something
dependent on the LC_NUMERIC locale might not work correctly if a
-formatted I/O operation is in progress in another thread.
+formatted I/O operation is in progress in another thread.
\ No newline at end of file
:maxdepth: 2
contributors-to-gnu-fortran
- projects
+ projects
\ No newline at end of file
and we welcome you to do the same!
If you already have done so,
and you would like to see your name listed in the
-list above, please contact us.
+list above, please contact us.
\ No newline at end of file
You have freedom to copy and modify this GNU Manual, like GNU
software. Copies published by the Free Software Foundation raise
- funds for GNU development.
+ funds for GNU development.
\ No newline at end of file
For compatibility, GNU Fortran supports a default exponent of zero in real
constants with :option:`-fdec`. For example, ``9e`` would be
-interpreted as ``9e0``, rather than an error.
+interpreted as ``9e0``, rather than an error.
\ No newline at end of file
formatted stream, read the data up to the position where the ``Q``
descriptor occurred, use ``INQUIRE`` to get the file position,
count the characters up to the next ``NEW_LINE`` and then start
-reading from the position marked previously.
+reading from the position marked previously.
\ No newline at end of file
:maxdepth: 2
extensions-implemented-in-gnu-fortran
- extensions-not-implemented-in-gnu-fortran
+ extensions-not-implemented-in-gnu-fortran
\ No newline at end of file
(2) The generic name is to be used.
(3) The specific names are included in the function index and in a
table at the end of the node (See ABS entry).
-(4) Try to maintain the same style for each entry.
+(4) Try to maintain the same style for each entry.
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../../doc/funding.rst
+.. include:: ../../../../doc/funding.rst
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../../doc/gpl-3.0.rst
+.. include:: ../../../../doc/gpl-3.0.rst
\ No newline at end of file
that relate to the optimization passes and the back-end code generation
are documented in the GCC manual; see :ref:`gcc:top`.
The two manuals together provide a complete reference for the GNU
-Fortran compiler.
+Fortran compiler.
\ No newline at end of file
.. toctree::
- copyright
+ copyright
\ No newline at end of file
In some cases, options have positive and negative forms;
the negative form of :samp:`-ffoo` would be :samp:`-fno-foo`.
This manual documents only one of these two forms, whichever
-one is not the default.
+one is not the default.
\ No newline at end of file
.. option:: -Uname
Cancel any previous definition of :samp:`{name}`, either built in or provided
- with a :option:`-D` option.
+ with a :option:`-D` option.
\ No newline at end of file
variables.
See :ref:`runtime`, for environment variables that affect the
-run-time behavior of programs compiled with GNU Fortran.
+run-time behavior of programs compiled with GNU Fortran.
\ No newline at end of file
negative in the ``SIGN`` intrinsic. :option:`-fno-sign-zero` does not
print the negative sign of zero values (or values rounded to zero for I/O)
and regards zero as positive number in the ``SIGN`` intrinsic for
- compatibility with Fortran 77. The default is :option:`-fsign-zero`.
+ compatibility with Fortran 77. The default is :option:`-fsign-zero`.
\ No newline at end of file
Please note that the :samp:`libquadmath` runtime library is licensed under the
GNU Lesser General Public License (LGPL), and linking it statically introduces
- requirements when redistributing the resulting binaries.
+ requirements when redistributing the resulting binaries.
\ No newline at end of file
:option:`-fmax-stack-var-size=n` :option:`-fno-align-commons` :option:`-fno-automatic` |gol|
:option:`-fno-protect-parens` :option:`-fno-underscoring` :option:`-fsecond-underscore` |gol|
:option:`-fpack-derived` :option:`-frealloc-lhs` :option:`-frecursive` :option:`-frepack-arrays` |gol|
- :option:`-fshort-enums` :option:`-fstack-arrays`
+ :option:`-fshort-enums` :option:`-fstack-arrays`
\ No newline at end of file
.. option:: -ftest-forall-temp
- Enhance test coverage by forcing most forall assignments to use temporary.
+ Enhance test coverage by forcing most forall assignments to use temporary.
\ No newline at end of file
See :ref:`gcc:code-gen-options`, for information on more options
offered by the GBE
-shared by :command:`gfortran`, :command:`gcc`, and other GNU compilers.
+shared by :command:`gfortran`, :command:`gcc`, and other GNU compilers.
\ No newline at end of file
Fortran main program.
See :ref:`gcc:debugging-options`, for more information on
-debugging options.
+debugging options.
\ No newline at end of file
.. option:: -fintrinsic-modules-path {dir}
This option specifies the location of pre-compiled intrinsic modules, if
- they are not in the default location expected by the compiler.
+ they are not in the default location expected by the compiler.
\ No newline at end of file
$ gfortran -fc-prototypes-external -fsyntax-only foo.f > foo.h
where the C code intended for interoperating with the Fortran code
- then uses ``#include "foo.h"``.
+ then uses ``#include "foo.h"``.
\ No newline at end of file
more options offered by the GBE shared by :command:`gfortran`, :command:`gcc`
and other GNU compilers.
-Some of these have no effect when compiling programs written in Fortran.
+Some of these have no effect when compiling programs written in Fortran.
\ No newline at end of file
This directive tells the compiler to not vectorize the following loop.
It must be placed immediately before a ``DO`` loop and applies only
-to the loop that follows.
+to the loop that follows.
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../../doc/gnu_free_documentation_license.rst
+.. include:: ../../../../doc/gnu_free_documentation_license.rst
\ No newline at end of file
gnu-free-documentation-license
funding
- indices-and-tables
+ indices-and-tables
\ No newline at end of file
-.. include:: ../../../../doc/indices-and-tables.rst
+.. include:: ../../../../doc/indices-and-tables.rst
\ No newline at end of file
``BIND(C)`` attribute. Arguments to functions marked ``BIND(C)``
are converted to the specified form. If you need to access GNU Fortran's
internal array descriptor, you can use the Chasm Language Interoperability
-Tools, http://chasm-interop.sourceforge.net/.
+Tools, http://chasm-interop.sourceforge.net/.
\ No newline at end of file
intrinsic-modules/isofortranenv
intrinsic-modules/isocbinding
intrinsic-modules/ieee-modules-ieeeexceptions-ieeearithmetic-and-ieeefeatures
- intrinsic-modules/openmp-modules-omplib-and-omplibkinds
+ intrinsic-modules/openmp-modules-omplib-and-omplibkinds
\ No newline at end of file
For full compliance with the Fortran standards, code using the
``IEEE_EXCEPTIONS`` or ``IEEE_ARITHMETIC`` modules should be compiled
with the following options: ``-fno-unsafe-math-optimizations
--frounding-math -fsignaling-nans``.
+-frounding-math -fsignaling-nans``.
\ No newline at end of file
* - ``C_NULL_FUNPTR``
- ``C_FUNPTR``
-Both are equivalent to the value ``NULL`` in C.
+Both are equivalent to the value ``NULL`` in C.
\ No newline at end of file
(Fortran 2008 or later.)
The module also provides the following intrinsic procedures:
- :ref:`COMPILER_OPTIONS` and :ref:`COMPILER_VERSION`.
+ :ref:`COMPILER_OPTIONS` and :ref:`COMPILER_VERSION`.
\ No newline at end of file
``OPENACC`` provides the scalar default-integer
named constant ``openacc_version`` with a value of the form
:samp:`{yyyymm}`, where ``yyyy`` is the year and :samp:`{mm}` the month
-of the OpenACC version; for OpenACC v2.6 the value is ``201711``.
+of the OpenACC version; for OpenACC v2.6 the value is ``201711``.
\ No newline at end of file
omp_large_cap_mem_space
omp_const_mem_space
omp_high_bw_mem_space
- omp_low_lat_mem_space
+ omp_low_lat_mem_space
\ No newline at end of file
intrinsic-procedures/unlink
intrinsic-procedures/unpack
intrinsic-procedures/verify
- intrinsic-procedures/xor
+ intrinsic-procedures/xor
\ No newline at end of file
See also:
:ref:`EXIT`,
:ref:`KILL`,
- :ref:`BACKTRACE`
+ :ref:`BACKTRACE`
\ No newline at end of file
* - ``CDABS(A)``
- ``COMPLEX(8) A``
- ``REAL(8)``
- - GNU extension
+ - GNU extension
\ No newline at end of file
if(access(file,'x') == 0) print *, trim(file),' is executable'
if(access(file2,'rwx') == 0) &
print *, trim(file2),' is readable, writable and executable'
- end program access_test
+ end program access_test
\ No newline at end of file
See also:
:ref:`CHAR`,
:ref:`IACHAR`,
- :ref:`ICHAR`
+ :ref:`ICHAR`
\ No newline at end of file
Inverse function:
:ref:`COS`
Degrees function:
- :ref:`ACOSD`
+ :ref:`ACOSD`
\ No newline at end of file
Inverse function:
:ref:`COSD`
Radians function:
- :ref:`ACOS`
+ :ref:`ACOS`
\ No newline at end of file
See also:
Inverse function:
- :ref:`COSH`
+ :ref:`COSH`
\ No newline at end of file
See also:
:ref:`ADJUSTR`,
- :ref:`TRIM`
+ :ref:`TRIM`
\ No newline at end of file
See also:
:ref:`ADJUSTL`,
- :ref:`TRIM`
+ :ref:`TRIM`
\ No newline at end of file
* - ``IMAGPART(Z)``
- ``COMPLEX Z``
- ``REAL``
- - GNU extension
+ - GNU extension
\ No newline at end of file
end program test_alarm
This will cause the external routine :samp:`{handler_print}` to be called
- after 3 seconds.
+ after 3 seconds.
\ No newline at end of file
print *, all(a .eq. b, 1)
print *, all(a .eq. b, 2)
end subroutine section
- end program test_all
+ end program test_all
\ No newline at end of file
integer :: i = 4
real(4), allocatable :: x(:)
if (.not. allocated(x)) allocate(x(i))
- end program test_allocated
+ end program test_allocated
\ No newline at end of file
See also:
Fortran 95 elemental function:
- :ref:`IAND`
+ :ref:`IAND`
\ No newline at end of file
print *, any(a .eq. b, 1)
print *, any(a .eq. b, 2)
end subroutine section
- end program test_any
+ end program test_any
\ No newline at end of file
Inverse function:
:ref:`SIN`
Degrees function:
- :ref:`ASIND`
+ :ref:`ASIND`
\ No newline at end of file
Inverse function:
:ref:`SIND`
Radians function:
- :ref:`ASIN`
+ :ref:`ASIN`
\ No newline at end of file
See also:
Inverse function:
- :ref:`SINH`
+ :ref:`SINH`
\ No newline at end of file
end program test_associated
See also:
- :ref:`NULL`
+ :ref:`NULL`
\ No newline at end of file
Inverse function:
:ref:`TAN`
Degrees function:
- :ref:`ATAND`
+ :ref:`ATAND`
\ No newline at end of file
Alias:
:ref:`ATAN`
Degrees function:
- :ref:`ATAN2D`
+ :ref:`ATAN2D`
\ No newline at end of file
Alias:
:ref:`ATAND`
Radians function:
- :ref:`ATAN2`
+ :ref:`ATAN2`
\ No newline at end of file
Inverse function:
:ref:`TAND`
Radians function:
- :ref:`ATAN`
+ :ref:`ATAN`
\ No newline at end of file
See also:
Inverse function:
- :ref:`TANH`
+ :ref:`TANH`
\ No newline at end of file
:ref:`ISO_FORTRAN_ENV`,
:ref:`ATOMIC_AND`,
:ref:`ATOMIC_OR`,
- :ref:`ATOMIC_XOR`
+ :ref:`ATOMIC_XOR`
\ No newline at end of file
:ref:`ISO_FORTRAN_ENV`,
:ref:`ATOMIC_ADD`,
:ref:`ATOMIC_OR`,
- :ref:`ATOMIC_XOR`
+ :ref:`ATOMIC_XOR`
\ No newline at end of file
See also:
:ref:`ATOMIC_DEFINE`,
:ref:`ATOMIC_REF`,
- :ref:`ISO_FORTRAN_ENV`
+ :ref:`ISO_FORTRAN_ENV`
\ No newline at end of file
:ref:`ATOMIC_ADD`,
:ref:`ATOMIC_AND`,
:ref:`ATOMIC_OR`,
- :ref:`ATOMIC_XOR`
+ :ref:`ATOMIC_XOR`
\ No newline at end of file
:ref:`ISO_FORTRAN_ENV`,
:ref:`ATOMIC_FETCH_AND`,
:ref:`ATOMIC_FETCH_OR`,
- :ref:`ATOMIC_FETCH_XOR`
+ :ref:`ATOMIC_FETCH_XOR`
\ No newline at end of file
:ref:`ISO_FORTRAN_ENV`,
:ref:`ATOMIC_FETCH_ADD`,
:ref:`ATOMIC_FETCH_OR`,
- :ref:`ATOMIC_FETCH_XOR`
+ :ref:`ATOMIC_FETCH_XOR`
\ No newline at end of file
:ref:`ISO_FORTRAN_ENV`,
:ref:`ATOMIC_FETCH_ADD`,
:ref:`ATOMIC_FETCH_AND`,
- :ref:`ATOMIC_FETCH_XOR`
+ :ref:`ATOMIC_FETCH_XOR`
\ No newline at end of file
:ref:`ISO_FORTRAN_ENV`,
:ref:`ATOMIC_FETCH_ADD`,
:ref:`ATOMIC_FETCH_AND`,
- :ref:`ATOMIC_FETCH_OR`
+ :ref:`ATOMIC_FETCH_OR`
\ No newline at end of file
:ref:`ISO_FORTRAN_ENV`,
:ref:`ATOMIC_ADD`,
:ref:`ATOMIC_OR`,
- :ref:`ATOMIC_XOR`
+ :ref:`ATOMIC_XOR`
\ No newline at end of file
:ref:`ATOMIC_FETCH_ADD`,
:ref:`ATOMIC_FETCH_AND`,
:ref:`ATOMIC_FETCH_OR`,
- :ref:`ATOMIC_FETCH_XOR`
+ :ref:`ATOMIC_FETCH_XOR`
\ No newline at end of file
:ref:`ISO_FORTRAN_ENV`,
:ref:`ATOMIC_ADD`,
:ref:`ATOMIC_OR`,
- :ref:`ATOMIC_XOR`
+ :ref:`ATOMIC_XOR`
\ No newline at end of file
None
See also:
- :ref:`ABORT`
+ :ref:`ABORT`
\ No newline at end of file
* - ``DBESJ0(X)``
- ``REAL(8) X``
- ``REAL(8)``
- - GNU extension
+ - GNU extension
\ No newline at end of file
* - ``DBESJ1(X)``
- ``REAL(8) X``
- ``REAL(8)``
- - GNU extension
+ - GNU extension
\ No newline at end of file
* -
- ``REAL(8) X``
-
- -
+ -
\ No newline at end of file
* - ``DBESY0(X)``
- ``REAL(8) X``
- ``REAL(8)``
- - GNU extension
+ - GNU extension
\ No newline at end of file
* - ``DBESY1(X)``
- ``REAL(8) X``
- ``REAL(8)``
- - GNU extension
+ - GNU extension
\ No newline at end of file
* -
- ``REAL(8) X``
-
- -
+ -
\ No newline at end of file
See also:
:ref:`BGT`,
:ref:`BLE`,
- :ref:`BLT`
+ :ref:`BLT`
\ No newline at end of file
See also:
:ref:`BGE`,
:ref:`BLE`,
- :ref:`BLT`
+ :ref:`BLT`
\ No newline at end of file
integer :: size
size = bit_size(i)
print *, size
- end program test_bit_size
+ end program test_bit_size
\ No newline at end of file
See also:
:ref:`BGT`,
:ref:`BGE`,
- :ref:`BLT`
+ :ref:`BLT`
\ No newline at end of file
See also:
:ref:`BGE`,
:ref:`BGT`,
- :ref:`BLE`
+ :ref:`BLE`
\ No newline at end of file
* - ``BKTEST(I,POS)``
- ``INTEGER(8) I,POS``
- ``LOGICAL(8)``
- - GNU extension
+ - GNU extension
\ No newline at end of file
See also:
:ref:`C_LOC`,
- :ref:`C_FUNLOC`
+ :ref:`C_FUNLOC`
\ No newline at end of file
See also:
:ref:`FLOOR`,
- :ref:`NINT`
+ :ref:`NINT`
\ No newline at end of file
See also:
:ref:`C_LOC`,
- :ref:`C_F_PROCPOINTER`
+ :ref:`C_F_PROCPOINTER`
\ No newline at end of file
See also:
:ref:`C_LOC`,
- :ref:`C_F_POINTER`
+ :ref:`C_F_POINTER`
\ No newline at end of file
:ref:`C_ASSOCIATED`,
:ref:`C_LOC`,
:ref:`C_F_POINTER`,
- :ref:`C_F_PROCPOINTER`
+ :ref:`C_F_PROCPOINTER`
\ No newline at end of file
END PROGRAM
See also:
- :ref:`GETCWD`
+ :ref:`GETCWD`
\ No newline at end of file
integer :: status
status = chmod('test.dat','u+x')
print *, 'Status: ', status
- end program chmod_test
+ end program chmod_test
\ No newline at end of file
:ref:`C_ASSOCIATED`,
:ref:`C_FUNLOC`,
:ref:`C_F_POINTER`,
- :ref:`C_F_PROCPOINTER`
+ :ref:`C_F_PROCPOINTER`
\ No newline at end of file
end program test_cmplx
See also:
- :ref:`COMPLEX`
+ :ref:`COMPLEX`
\ No newline at end of file
:ref:`CO_MAX`,
:ref:`CO_MIN`,
:ref:`CO_SUM`,
- :ref:`CO_REDUCE`
+ :ref:`CO_REDUCE`
\ No newline at end of file
:ref:`CO_MIN`,
:ref:`CO_SUM`,
:ref:`CO_REDUCE`,
- :ref:`CO_BROADCAST`
+ :ref:`CO_BROADCAST`
\ No newline at end of file
:ref:`CO_MAX`,
:ref:`CO_SUM`,
:ref:`CO_REDUCE`,
- :ref:`CO_BROADCAST`
+ :ref:`CO_BROADCAST`
\ No newline at end of file
See also:
:ref:`GET_COMMAND`,
- :ref:`GET_COMMAND_ARGUMENT`
+ :ref:`GET_COMMAND_ARGUMENT`
\ No newline at end of file
See also:
:ref:`COMPILER_VERSION`,
- :ref:`ISO_FORTRAN_ENV`
+ :ref:`ISO_FORTRAN_ENV`
\ No newline at end of file
See also:
:ref:`COMPILER_OPTIONS`,
- :ref:`ISO_FORTRAN_ENV`
+ :ref:`ISO_FORTRAN_ENV`
\ No newline at end of file
end program test_complex
See also:
- :ref:`CMPLX`
+ :ref:`CMPLX`
\ No newline at end of file
* - ``DCONJG(Z)``
- ``COMPLEX(8) Z``
- ``COMPLEX(8)``
- - GNU extension
+ - GNU extension
\ No newline at end of file
:ref:`CO_MIN`,
:ref:`CO_MAX`,
:ref:`CO_SUM`,
- :ref:`CO_BROADCAST`
+ :ref:`CO_BROADCAST`
\ No newline at end of file
Inverse function:
:ref:`ACOS`
Degrees function:
- :ref:`COSD`
+ :ref:`COSD`
\ No newline at end of file
Inverse function:
:ref:`ACOSD`
Radians function:
- :ref:`COS`
+ :ref:`COS`
\ No newline at end of file
See also:
Inverse function:
- :ref:`ACOSH`
+ :ref:`ACOSH`
\ No newline at end of file
:ref:`CO_MAX`,
:ref:`CO_MIN`,
:ref:`CO_REDUCE`,
- :ref:`CO_BROADCAST`
+ :ref:`CO_BROADCAST`
\ No newline at end of file
Converse function:
:ref:`TAN`
Degrees function:
- :ref:`COTAND`
+ :ref:`COTAND`
\ No newline at end of file
Converse function:
:ref:`TAND`
Radians function:
- :ref:`COTAN`
+ :ref:`COTAN`
\ No newline at end of file
print '(3i3)', count(mask, 1)
print *
print '(3i3)', count(mask, 2)
- end program test_count
+ end program test_count
\ No newline at end of file
See also:
:ref:`SYSTEM_CLOCK`,
- :ref:`DATE_AND_TIME`
+ :ref:`DATE_AND_TIME`
\ No newline at end of file
print '(3i3)', a(1,:)
print '(3i3)', a(2,:)
print '(3i3)', a(3,:)
- end program test_cshift
+ end program test_cshift
\ No newline at end of file
See also:
:ref:`SIZEOF`,
- :ref:`STORAGE_SIZE`
+ :ref:`STORAGE_SIZE`
\ No newline at end of file
:ref:`GMTIME`,
:ref:`LTIME`,
:ref:`TIME`,
- :ref:`TIME8`
+ :ref:`TIME8`
\ No newline at end of file
See also:
:ref:`CPU_TIME`,
- :ref:`SYSTEM_CLOCK`
+ :ref:`SYSTEM_CLOCK`
\ No newline at end of file
end program test_dble
See also:
- :ref:`REAL`
+ :ref:`REAL`
\ No newline at end of file
print *, dcmplx(x)
print *, dcmplx(z)
print *, dcmplx(x,i)
- end program test_dcmplx
+ end program test_dcmplx
\ No newline at end of file
print *, digits(i)
print *, digits(x)
print *, digits(y)
- end program test_digits
+ end program test_digits
\ No newline at end of file
* - ``DDIM(X,Y)``
- ``REAL(8) X, Y``
- ``REAL(8)``
- - Fortran 77 and later
+ - Fortran 77 and later
\ No newline at end of file
print '(3i3)', b
print *
print *, dot_product(a,b)
- end program test_dot_prod
+ end program test_dot_prod
\ No newline at end of file
* - ``DPROD(X,Y)``
- ``REAL(4) X, Y``
- ``REAL(8)``
- - Fortran 77 and later
+ - Fortran 77 and later
\ No newline at end of file
end program test_dreal
See also:
- :ref:`AIMAG`
+ :ref:`AIMAG`
\ No newline at end of file
RESULT = DSHIFTL(I, J, SHIFT)
See also:
- :ref:`DSHIFTR`
+ :ref:`DSHIFTR`
\ No newline at end of file
RESULT = DSHIFTR(I, J, SHIFT)
See also:
- :ref:`DSHIFTL`
+ :ref:`DSHIFTL`
\ No newline at end of file
end program test_dtime
See also:
- :ref:`CPU_TIME`
+ :ref:`CPU_TIME`
\ No newline at end of file
print '(3i3)', a(1,:)
print '(3i3)', a(2,:)
print '(3i3)', a(3,:)
- end program test_eoshift
+ end program test_eoshift
\ No newline at end of file
real(8) :: y = 2.33
print *, EPSILON(x)
print *, EPSILON(y)
- end program test_epsilon
+ end program test_epsilon
\ No newline at end of file
* - ``DERF(X)``
- ``REAL(8) X``
- ``REAL(8)``
- - GNU extension
+ - GNU extension
\ No newline at end of file
* - ``DERFC(X)``
- ``REAL(8) X``
- ``REAL(8)``
- - GNU extension
+ - GNU extension
\ No newline at end of file
program test_erfc_scaled
real(8) :: x = 0.17_8
x = erfc_scaled(x)
- end program test_erfc_scaled
+ end program test_erfc_scaled
\ No newline at end of file
end program test_etime
See also:
- :ref:`CPU_TIME`
+ :ref:`CPU_TIME`
\ No newline at end of file
elseif (this_image() == 2) then
event post (event_value_has_been_set[1])
end if
- end program atomic
+ end program atomic
\ No newline at end of file
terminated alongside.
See also:
- :ref:`SYSTEM`
+ :ref:`SYSTEM`
\ No newline at end of file
See also:
:ref:`ABORT`,
- :ref:`KILL`
+ :ref:`KILL`
\ No newline at end of file
* - ``CDEXP(X)``
- ``COMPLEX(8) X``
- ``COMPLEX(8)``
- - GNU extension
+ - GNU extension
\ No newline at end of file
i = exponent(x)
print *, i
print *, exponent(0.0)
- end program test_exponent
+ end program test_exponent
\ No newline at end of file
RESULT = EXTENDS_TYPE_OF(A, MOLD)
See also:
- :ref:`SAME_TYPE_AS`
+ :ref:`SAME_TYPE_AS`
\ No newline at end of file
See also:
:ref:`DATE_AND_TIME`,
- :ref:`CTIME`
+ :ref:`CTIME`
\ No newline at end of file
See also:
:ref:`FGETC`,
:ref:`FPUT`,
- :ref:`FPUTC`
+ :ref:`FPUTC`
\ No newline at end of file
See also:
:ref:`FGET`,
:ref:`FPUT`,
- :ref:`FPUTC`
+ :ref:`FPUTC`
\ No newline at end of file
See also:
:ref:`MAXLOC`,
- :ref:`MINLOC`
+ :ref:`MINLOC`
\ No newline at end of file
See also:
:ref:`CEILING`,
- :ref:`NINT`
+ :ref:`NINT`
\ No newline at end of file
ret = fsync(fnum(10))
! Handle possible error
- if (ret /= 0) stop "Error calling FSYNC"
+ if (ret /= 0) stop "Error calling FSYNC"
\ No newline at end of file
i = fnum(10)
print *, i
close (10)
- end program test_fnum
+ end program test_fnum
\ No newline at end of file
See also:
:ref:`FPUTC`,
:ref:`FGET`,
- :ref:`FGETC`
+ :ref:`FGETC`
\ No newline at end of file
See also:
:ref:`FPUT`,
:ref:`FGET`,
- :ref:`FGETC`
+ :ref:`FGETC`
\ No newline at end of file
real :: x
x = 178.1387e-4
print *, fraction(x), x * radix(x)**(-exponent(x))
- end program test_fraction
+ end program test_fraction
\ No newline at end of file
See ``MALLOC`` for an example.
See also:
- :ref:`MALLOC`
+ :ref:`MALLOC`
\ No newline at end of file
END PROGRAM
See also:
- :ref:`FTELL`
+ :ref:`FTELL`
\ No newline at end of file
To stat a link:
:ref:`LSTAT`
To stat a file:
- :ref:`STAT`
+ :ref:`STAT`
\ No newline at end of file
END PROGRAM
See also:
- :ref:`FSEEK`
+ :ref:`FSEEK`
\ No newline at end of file
See also:
Logarithm of the Gamma function:
- :ref:`LOG_GAMMA`
+ :ref:`LOG_GAMMA`
\ No newline at end of file
See also:
:ref:`IERRNO`,
- :ref:`PERROR`
+ :ref:`PERROR`
\ No newline at end of file
Fortran 2003 functions and subroutines:
:ref:`GET_COMMAND`,
:ref:`GET_COMMAND_ARGUMENT`,
- :ref:`COMMAND_ARGUMENT_COUNT`
+ :ref:`COMMAND_ARGUMENT_COUNT`
\ No newline at end of file
See also:
:ref:`GET_COMMAND_ARGUMENT`,
- :ref:`COMMAND_ARGUMENT_COUNT`
+ :ref:`COMMAND_ARGUMENT_COUNT`
\ No newline at end of file
See also:
:ref:`GET_COMMAND`,
- :ref:`COMMAND_ARGUMENT_COUNT`
+ :ref:`COMMAND_ARGUMENT_COUNT`
\ No newline at end of file
END PROGRAM
See also:
- :ref:`CHDIR`
+ :ref:`CHDIR`
\ No newline at end of file
END PROGRAM
See also:
- :ref:`GET_ENVIRONMENT_VARIABLE`
+ :ref:`GET_ENVIRONMENT_VARIABLE`
\ No newline at end of file
CHARACTER(len=255) :: homedir
CALL get_environment_variable("HOME", homedir)
WRITE (*,*) TRIM(homedir)
- END PROGRAM
+ END PROGRAM
\ No newline at end of file
See also:
:ref:`GETPID`,
- :ref:`GETUID`
+ :ref:`GETUID`
\ No newline at end of file
END PROGRAM
See also:
- :ref:`GETUID`
+ :ref:`GETUID`
\ No newline at end of file
See also:
:ref:`GETGID`,
- :ref:`GETUID`
+ :ref:`GETUID`
\ No newline at end of file
See also:
:ref:`GETPID`,
- :ref:`GETLOG`
+ :ref:`GETLOG`
\ No newline at end of file
:ref:`CTIME`,
:ref:`LTIME`,
:ref:`TIME`,
- :ref:`TIME8`
+ :ref:`TIME8`
\ No newline at end of file
.. code-block:: fortran
CALL HOSTNM(C [, STATUS])
- STATUS = HOSTNM(NAME)
+ STATUS = HOSTNM(NAME)
\ No newline at end of file
program test_huge_tiny
print *, huge(0), huge(0.0), huge(0.0d0)
print *, tiny(0.0), tiny(0.0d0)
- end program test_huge_tiny
+ end program test_huge_tiny
\ No newline at end of file
program test_hypot
real(4) :: x = 1.e0_4, y = 0.5e0_4
x = hypot(x,y)
- end program test_hypot
+ end program test_hypot
\ No newline at end of file
See also:
:ref:`ACHAR`,
:ref:`CHAR`,
- :ref:`ICHAR`
+ :ref:`ICHAR`
\ No newline at end of file
See also:
:ref:`IANY`,
:ref:`IPARITY`,
- :ref:`IAND`
+ :ref:`IAND`
\ No newline at end of file
:ref:`IBITS`,
:ref:`IBSET`,
:ref:`IBCLR`,
- :ref:`NOT`
+ :ref:`NOT`
\ No newline at end of file
See also:
:ref:`IPARITY`,
:ref:`IALL`,
- :ref:`IOR`
+ :ref:`IOR`
\ No newline at end of file
Fortran 2003 functions and subroutines:
:ref:`GET_COMMAND`,
:ref:`GET_COMMAND_ARGUMENT`,
- :ref:`COMMAND_ARGUMENT_COUNT`
+ :ref:`COMMAND_ARGUMENT_COUNT`
\ No newline at end of file
:ref:`IAND`,
:ref:`IOR`,
:ref:`IEOR`,
- :ref:`MVBITS`
+ :ref:`MVBITS`
\ No newline at end of file
:ref:`IBSET`,
:ref:`IAND`,
:ref:`IOR`,
- :ref:`IEOR`
+ :ref:`IEOR`
\ No newline at end of file
:ref:`IAND`,
:ref:`IOR`,
:ref:`IEOR`,
- :ref:`MVBITS`
+ :ref:`MVBITS`
\ No newline at end of file
See also:
:ref:`ACHAR`,
:ref:`CHAR`,
- :ref:`IACHAR`
+ :ref:`IACHAR`
\ No newline at end of file
end program test_idate
See also:
- :ref:`DATE_AND_TIME`
+ :ref:`DATE_AND_TIME`
\ No newline at end of file
:ref:`IBITS`,
:ref:`IBSET`,
:ref:`IBCLR`,
- :ref:`NOT`
+ :ref:`NOT`
\ No newline at end of file
None
See also:
- :ref:`PERROR`
+ :ref:`PERROR`
\ No newline at end of file
See also:
:ref:`THIS_IMAGE`,
- :ref:`NUM_IMAGES`
+ :ref:`NUM_IMAGES`
\ No newline at end of file
See also:
:ref:`SCAN`,
- :ref:`VERIFY`
+ :ref:`VERIFY`
\ No newline at end of file
See also:
:ref:`INT`,
- :ref:`INT8`
+ :ref:`INT8`
\ No newline at end of file
See also:
:ref:`INT`,
- :ref:`INT2`
+ :ref:`INT2`
\ No newline at end of file
have been implemented in :command:`gfortran` for backwards compatibility
with :command:`g77`. It is noted here that these functions and subroutines
cannot be intermixed in a given subprogram. In the descriptions that follow,
-the applicable standard for each intrinsic procedure is noted.
+the applicable standard for each intrinsic procedure is noted.
\ No newline at end of file
:ref:`IBITS`,
:ref:`IBSET`,
:ref:`IBCLR`,
- :ref:`NOT`
+ :ref:`NOT`
\ No newline at end of file
:ref:`IANY`,
:ref:`IALL`,
:ref:`IEOR`,
- :ref:`PARITY`
+ :ref:`PARITY`
\ No newline at end of file
call srand(seed)
print *, irand(), irand(), irand(), irand()
print *, irand(seed), irand(), irand(), irand()
- end program test_irand
+ end program test_irand
\ No newline at end of file
END PROGRAM
See also:
- :ref:`TTYNAM`
+ :ref:`TTYNAM`
\ No newline at end of file
write (*,*) 'X is not contiguous'
end if
end subroutine sub
- end program test
+ end program test
\ No newline at end of file
- GNU extension
See also:
- :ref:`ISHFTC`
+ :ref:`ISHFTC`
\ No newline at end of file
- GNU extension
See also:
- :ref:`ISHFT`
+ :ref:`ISHFT`
\ No newline at end of file
OPEN(88, FILE='test.dat')
READ(88, *, IOSTAT=stat) i
IF(IS_IOSTAT_END(stat)) STOP 'END OF FILE'
- END PROGRAM
+ END PROGRAM
\ No newline at end of file
OPEN(88, FILE='test.dat', FORM='UNFORMATTED')
READ(88, IOSTAT=stat) i
IF(IS_IOSTAT_EOR(stat)) STOP 'END OF RECORD'
- END PROGRAM
+ END PROGRAM
\ No newline at end of file
x = -1.0
x = sqrt(x)
if (isnan(x)) stop '"x" is a NaN'
- end program test_nan
+ end program test_nan
\ No newline at end of file
end program test_itime
See also:
- :ref:`DATE_AND_TIME`
+ :ref:`DATE_AND_TIME`
\ No newline at end of file
See also:
:ref:`ABORT`,
- :ref:`EXIT`
+ :ref:`EXIT`
\ No newline at end of file
print *, "The default character kind is ", kc
print *, "The default logical kind is ", kl
- end program test_kind
+ end program test_kind
\ No newline at end of file
See also:
:ref:`UBOUND`,
- :ref:`LCOBOUND`
+ :ref:`LCOBOUND`
\ No newline at end of file
See also:
:ref:`UCOBOUND`,
- :ref:`LBOUND`
+ :ref:`LBOUND`
\ No newline at end of file
:ref:`BIT_SIZE`,
:ref:`TRAILZ`,
:ref:`POPCNT`,
- :ref:`POPPAR`
+ :ref:`POPPAR`
\ No newline at end of file
See also:
:ref:`LEN_TRIM`,
:ref:`ADJUSTL`,
- :ref:`ADJUSTR`
+ :ref:`ADJUSTR`
\ No newline at end of file
See also:
:ref:`LEN`,
:ref:`ADJUSTL`,
- :ref:`ADJUSTR`
+ :ref:`ADJUSTR`
\ No newline at end of file
See also:
:ref:`LGT`,
:ref:`LLE`,
- :ref:`LLT`
+ :ref:`LLT`
\ No newline at end of file
See also:
:ref:`LGE`,
:ref:`LLE`,
- :ref:`LLT`
+ :ref:`LLT`
\ No newline at end of file
See also:
:ref:`SYMLNK`,
- :ref:`UNLINK`
+ :ref:`UNLINK`
\ No newline at end of file
See also:
:ref:`LGE`,
:ref:`LGT`,
- :ref:`LLT`
+ :ref:`LLT`
\ No newline at end of file
See also:
:ref:`LGE`,
:ref:`LGT`,
- :ref:`LLE`
+ :ref:`LLE`
\ No newline at end of file
See also:
:ref:`index-intrinsic`,
- :ref:`LEN_TRIM`
+ :ref:`LEN_TRIM`
\ No newline at end of file
real :: r
i = loc(r)
print *, i
- end program test_loc
+ end program test_loc
\ No newline at end of file
* - ``CDLOG(X)``
- ``COMPLEX(8) X``
- ``COMPLEX(8)``
- - GNU extension
+ - GNU extension
\ No newline at end of file
* - ``DLOG10(X)``
- ``REAL(8) X``
- ``REAL(8)``
- - Fortran 77 and later
+ - Fortran 77 and later
\ No newline at end of file
See also:
Gamma function:
- :ref:`GAMMA`
+ :ref:`GAMMA`
\ No newline at end of file
See also:
:ref:`INT`,
:ref:`REAL`,
- :ref:`CMPLX`
+ :ref:`CMPLX`
\ No newline at end of file
:ref:`RSHIFT`,
:ref:`SHIFTA`,
:ref:`SHIFTL`,
- :ref:`SHIFTR`
+ :ref:`SHIFTR`
\ No newline at end of file
To stat an open file:
:ref:`FSTAT`
To stat a file:
- :ref:`STAT`
+ :ref:`STAT`
\ No newline at end of file
:ref:`CTIME`,
:ref:`GMTIME`,
:ref:`TIME`,
- :ref:`TIME8`
+ :ref:`TIME8`
\ No newline at end of file
end program test_malloc
See also:
- :ref:`FREE`
+ :ref:`FREE`
\ No newline at end of file
RESULT = MASKL(I[, KIND])
See also:
- :ref:`MASKR`
+ :ref:`MASKR`
\ No newline at end of file
RESULT = MASKR(I[, KIND])
See also:
- :ref:`MASKL`
+ :ref:`MASKL`
\ No newline at end of file
Syntax:
.. code-block:: fortran
- RESULT = MATMUL(MATRIX_A, MATRIX_B)
+ RESULT = MATMUL(MATRIX_A, MATRIX_B)
\ No newline at end of file
See also:
:ref:`MAXLOC`
:ref:`MAXVAL`,
- :ref:`MIN`
+ :ref:`MIN`
\ No newline at end of file
print *, minexponent(x), maxexponent(x)
print *, minexponent(y), maxexponent(y)
- end program exponents
+ end program exponents
\ No newline at end of file
See also:
:ref:`FINDLOC`,
:ref:`MAX`,
- :ref:`MAXVAL`
+ :ref:`MAXVAL`
\ No newline at end of file
See also:
:ref:`MAX`,
- :ref:`MAXLOC`
+ :ref:`MAXLOC`
\ No newline at end of file
:ref:`GMTIME`,
:ref:`LTIME`,
:ref:`MCLOCK`,
- :ref:`TIME`
+ :ref:`TIME`
\ No newline at end of file
:ref:`GMTIME`,
:ref:`LTIME`,
:ref:`MCLOCK`,
- :ref:`TIME8`
+ :ref:`TIME8`
\ No newline at end of file
Syntax:
.. code-block:: fortran
- RESULT = MERGE(TSOURCE, FSOURCE, MASK)
+ RESULT = MERGE(TSOURCE, FSOURCE, MASK)
\ No newline at end of file
Syntax:
.. code-block:: fortran
- RESULT = MERGE_BITS(I, J, MASK)
+ RESULT = MERGE_BITS(I, J, MASK)
\ No newline at end of file
See also:
:ref:`MAX`,
:ref:`MINLOC`,
- :ref:`MINVAL`
+ :ref:`MINVAL`
\ No newline at end of file
RESULT = MINEXPONENT(X)
Example:
- See ``MAXEXPONENT`` for an example.
+ See ``MAXEXPONENT`` for an example.
\ No newline at end of file
See also:
:ref:`FINDLOC`,
:ref:`MIN`,
- :ref:`MINVAL`
+ :ref:`MINVAL`
\ No newline at end of file
See also:
:ref:`MIN`,
- :ref:`MINLOC`
+ :ref:`MINLOC`
\ No newline at end of file
- GNU extension
See also:
- :ref:`MODULO`
+ :ref:`MODULO`
\ No newline at end of file
end program
See also:
- :ref:`MOD`
+ :ref:`MOD`
\ No newline at end of file
call move_alloc(a, b)
print *, allocated(a), allocated(b)
print *, b
- end program test_move_alloc
+ end program test_move_alloc
\ No newline at end of file
:ref:`IBITS`,
:ref:`IAND`,
:ref:`IOR`,
- :ref:`IEOR`
+ :ref:`IEOR`
\ No newline at end of file
x = nearest(42.0, 1.0)
y = nearest(42.0, -1.0)
write (*,"(3(G20.15))") x, y, x - y
- end program test_nearest
+ end program test_nearest
\ No newline at end of file
program newline
implicit none
write(*,'(A)') 'This is record 1.'//NEW_LINE('A')//'This is record 2.'
- end program newline
+ end program newline
\ No newline at end of file
See also:
:ref:`CEILING`,
- :ref:`FLOOR`
+ :ref:`FLOOR`
\ No newline at end of file
PROGRAM test_sum
REAL :: x(5) = [ real :: 1, 2, 3, 4, 5 ]
print *, NORM2(x) ! = sqrt(55.) ~ 7.416
- END PROGRAM
+ END PROGRAM
\ No newline at end of file
:ref:`IOR`,
:ref:`IBITS`,
:ref:`IBSET`,
- :ref:`IBCLR`
+ :ref:`IBCLR`
\ No newline at end of file
REAL, POINTER, DIMENSION(:) :: VEC => NULL ()
See also:
- :ref:`ASSOCIATED`
+ :ref:`ASSOCIATED`
\ No newline at end of file
See also:
:ref:`THIS_IMAGE`,
- :ref:`IMAGE_INDEX`
+ :ref:`IMAGE_INDEX`
\ No newline at end of file
See also:
Fortran 95 elemental function:
- :ref:`IOR`
+ :ref:`IOR`
\ No newline at end of file
END PROGRAM
See also:
- :ref:`UNPACK`
+ :ref:`UNPACK`
\ No newline at end of file
PROGRAM test_sum
LOGICAL :: x(2) = [ .true., .false. ]
print *, PARITY(x) ! prints "T" (true).
- END PROGRAM
+ END PROGRAM
\ No newline at end of file
CALL PERROR(STRING)
See also:
- :ref:`IERRNO`
+ :ref:`IERRNO`
\ No newline at end of file
See also:
:ref:`POPPAR`,
:ref:`LEADZ`,
- :ref:`TRAILZ`
+ :ref:`TRAILZ`
\ No newline at end of file
See also:
:ref:`POPCNT`,
:ref:`LEADZ`,
- :ref:`TRAILZ`
+ :ref:`TRAILZ`
\ No newline at end of file
See also:
:ref:`SELECTED_REAL_KIND`,
- :ref:`RANGE`
+ :ref:`RANGE`
\ No newline at end of file
INTEGER, INTENT(IN), OPTIONAL :: x
f = PRESENT(x)
END FUNCTION
- END PROGRAM
+ END PROGRAM
\ No newline at end of file
END PROGRAM
See also:
- :ref:`SUM`
+ :ref:`SUM`
\ No newline at end of file
end program test_radix
See also:
- :ref:`SELECTED_REAL_KIND`
+ :ref:`SELECTED_REAL_KIND`
\ No newline at end of file
See also:
:ref:`RAND`,
- :ref:`RANDOM_NUMBER`
+ :ref:`RANDOM_NUMBER`
\ No newline at end of file
See also:
:ref:`SRAND`,
- :ref:`RANDOM_NUMBER`
+ :ref:`RANDOM_NUMBER`
\ No newline at end of file
See also:
:ref:`RANDOM_NUMBER`,
- :ref:`RANDOM_SEED`
+ :ref:`RANDOM_SEED`
\ No newline at end of file
See also:
:ref:`RANDOM_SEED`,
- :ref:`RANDOM_INIT`
+ :ref:`RANDOM_INIT`
\ No newline at end of file
See also:
:ref:`RANDOM_NUMBER`,
- :ref:`RANDOM_INIT`
+ :ref:`RANDOM_INIT`
\ No newline at end of file
See also:
:ref:`SELECTED_REAL_KIND`,
- :ref:`PRECISION`
+ :ref:`PRECISION`
\ No newline at end of file
real, allocatable :: b(:,:)
print *, rank(a), rank(b) ! Prints: 0 2
- end program test_rank
+ end program test_rank
\ No newline at end of file
STATUS = RENAME(PATH1, PATH2)
See also:
- :ref:`LINK`
+ :ref:`LINK`
\ No newline at end of file
program test_repeat
write(*,*) repeat("x", 5) ! "xxxxx"
- end program
+ end program
\ No newline at end of file
END PROGRAM
See also:
- :ref:`SHAPE`
+ :ref:`SHAPE`
\ No newline at end of file
RESULT = RRSPACING(X)
See also:
- :ref:`SPACING`
+ :ref:`SPACING`
\ No newline at end of file
:ref:`LSHIFT`,
:ref:`SHIFTA`,
:ref:`SHIFTR`,
- :ref:`SHIFTL`
+ :ref:`SHIFTL`
\ No newline at end of file
RESULT = SAME_TYPE_AS(A, B)
See also:
- :ref:`EXTENDS_TYPE_OF`
+ :ref:`EXTENDS_TYPE_OF`
\ No newline at end of file
real :: x = 178.1387e-4
integer :: i = 5
print *, scale(x,i), x*radix(x)**i
- end program test_scale
+ end program test_scale
\ No newline at end of file
See also:
:ref:`index-intrinsic`,
- :ref:`VERIFY`
+ :ref:`VERIFY`
\ No newline at end of file
end do
t2 = secnds (t1) ! elapsed time
print *, "Something took ", t2, " seconds."
- end program test_secnds
+ end program test_secnds
\ No newline at end of file
TIME = SECOND()
See also:
- :ref:`CPU_TIME`
+ :ref:`CPU_TIME`
\ No newline at end of file
open (output_unit, encoding='UTF-8')
write (*,*) trim (hello_world)
- end program character_kind
+ end program character_kind
\ No newline at end of file
! The following inequalities are always true
print *, huge(i5) >= 10_k5**5-1
print *, huge(i15) >= 10_k15**15-1
- end program large_integers
+ end program large_integers
\ No newline at end of file
See also:
:ref:`PRECISION`,
:ref:`RANGE`,
- :ref:`RADIX`
+ :ref:`RADIX`
\ No newline at end of file
REAL :: x = 178.1387e-4
INTEGER :: i = 17
PRINT *, SET_EXPONENT(x, i), FRACTION(x) * RADIX(x)**i
- END PROGRAM
+ END PROGRAM
\ No newline at end of file
See also:
:ref:`RESHAPE`,
- :ref:`SIZE`
+ :ref:`SIZE`
\ No newline at end of file
See also:
:ref:`SHIFTL`,
- :ref:`SHIFTR`
+ :ref:`SHIFTR`
\ No newline at end of file
See also:
:ref:`SHIFTA`,
- :ref:`SHIFTR`
+ :ref:`SHIFTR`
\ No newline at end of file
See also:
:ref:`SHIFTA`,
- :ref:`SHIFTL`
+ :ref:`SHIFTL`
\ No newline at end of file
* - ``DSIGN(A,B)``
- ``REAL(8) A, B``
- ``REAL(8)``
- - Fortran 77 and later
+ - Fortran 77 and later
\ No newline at end of file
call signal (10, 1)
call sleep (30)
- end program test_signal
+ end program test_signal
\ No newline at end of file
Inverse function:
:ref:`ASIN`
Degrees function:
- :ref:`SIND`
+ :ref:`SIND`
\ No newline at end of file
Inverse function:
:ref:`ASIND`
Radians function:
- :ref:`SIN`
+ :ref:`SIN`
\ No newline at end of file
- Fortran 90 and later
See also:
- :ref:`ASINH`
+ :ref:`ASINH`
\ No newline at end of file
See also:
:ref:`SHAPE`,
- :ref:`RESHAPE`
+ :ref:`RESHAPE`
\ No newline at end of file
See also:
:ref:`C_SIZEOF`,
- :ref:`STORAGE_SIZE`
+ :ref:`STORAGE_SIZE`
\ No newline at end of file
program test_sleep
call sleep(5)
- end
+ end
\ No newline at end of file
END PROGRAM
See also:
- :ref:`RRSPACING`
+ :ref:`RRSPACING`
\ No newline at end of file
END PROGRAM
See also:
- :ref:`UNPACK`
+ :ref:`UNPACK`
\ No newline at end of file
* - ``CDSQRT(X)``
- ``COMPLEX(8) X``
- ``COMPLEX(8)``
- - GNU extension
+ - GNU extension
\ No newline at end of file
See also:
:ref:`RAND`,
:ref:`RANDOM_SEED`,
- :ref:`RANDOM_NUMBER`
+ :ref:`RANDOM_NUMBER`
\ No newline at end of file
To stat an open file:
:ref:`FSTAT`
To stat a link:
- :ref:`LSTAT`
+ :ref:`LSTAT`
\ No newline at end of file
See also:
:ref:`C_SIZEOF`,
- :ref:`SIZEOF`
+ :ref:`SIZEOF`
\ No newline at end of file
END PROGRAM
See also:
- :ref:`PRODUCT`
+ :ref:`PRODUCT`
\ No newline at end of file
See also:
:ref:`LINK`,
- :ref:`UNLINK`
+ :ref:`UNLINK`
\ No newline at end of file
See also:
:ref:`EXECUTE_COMMAND_LINE`, which is part of the Fortran 2008 standard
- and should considered in new code for future portability.
+ and should considered in new code for future portability.
\ No newline at end of file
See also:
:ref:`DATE_AND_TIME`,
- :ref:`CPU_TIME`
+ :ref:`CPU_TIME`
\ No newline at end of file
Inverse function:
:ref:`ATAN`
Degrees function:
- :ref:`TAND`
+ :ref:`TAND`
\ No newline at end of file
Inverse function:
:ref:`ATAND`
Radians function:
- :ref:`TAN`
+ :ref:`TAN`
\ No newline at end of file
- Fortran 77 and later
See also:
- :ref:`ATANH`
+ :ref:`ATANH`
\ No newline at end of file
See also:
:ref:`NUM_IMAGES`,
- :ref:`IMAGE_INDEX`
+ :ref:`IMAGE_INDEX`
\ No newline at end of file
:ref:`GMTIME`,
:ref:`LTIME`,
:ref:`MCLOCK`,
- :ref:`TIME8`
+ :ref:`TIME8`
\ No newline at end of file
:ref:`GMTIME`,
:ref:`LTIME`,
:ref:`MCLOCK8`,
- :ref:`TIME`
+ :ref:`TIME`
\ No newline at end of file
RESULT = TINY(X)
Example:
- See ``HUGE`` for an example.
+ See ``HUGE`` for an example.
\ No newline at end of file
:ref:`BIT_SIZE`,
:ref:`LEADZ`,
:ref:`POPPAR`,
- :ref:`POPCNT`
+ :ref:`POPCNT`
\ No newline at end of file
PROGRAM test_transfer
integer :: x = 2143289344
print *, transfer(x, 1.0) ! prints "NaN" on i686
- END PROGRAM
+ END PROGRAM
\ No newline at end of file
Syntax:
.. code-block:: fortran
- RESULT = TRANSPOSE(MATRIX)
+ RESULT = TRANSPOSE(MATRIX)
\ No newline at end of file
See also:
:ref:`ADJUSTL`,
- :ref:`ADJUSTR`
+ :ref:`ADJUSTR`
\ No newline at end of file
END PROGRAM
See also:
- :ref:`ISATTY`
+ :ref:`ISATTY`
\ No newline at end of file
See also:
:ref:`LBOUND`,
- :ref:`LCOBOUND`
+ :ref:`LCOBOUND`
\ No newline at end of file
See also:
:ref:`LCOBOUND`,
- :ref:`LBOUND`
+ :ref:`LBOUND`
\ No newline at end of file
.. code-block:: fortran
CALL UMASK(MASK [, OLD])
- OLD = UMASK(MASK)
+ OLD = UMASK(MASK)
\ No newline at end of file
See also:
:ref:`LINK`,
- :ref:`SYMLNK`
+ :ref:`SYMLNK`
\ No newline at end of file
See also:
:ref:`PACK`,
- :ref:`SPREAD`
+ :ref:`SPREAD`
\ No newline at end of file
See also:
:ref:`SCAN`,
- :ref:`index-intrinsic`
+ :ref:`index-intrinsic`
\ No newline at end of file
See also:
Fortran 95 elemental function:
- :ref:`IEOR`
+ :ref:`IEOR`
\ No newline at end of file
about-gnu-fortran
gnu-fortran-and-gcc
- standards
+ standards
\ No newline at end of file
or :command:`g++` if you also add an explicit :option:`-lgfortran` option
to link with the Fortran library. If your main program is written in
C or some other language instead of Fortran, see
-:ref:`non-fortran-main-program`, below.
+:ref:`non-fortran-main-program`, below.
\ No newline at end of file
* The character length and/or coarray token and offset for the first
argument which is a ``CHARACTER`` or a nonallocatable coarray dummy
argument, followed by the hidden arguments of the next dummy argument
- of such a type
+ of such a type
\ No newline at end of file
_gfortran_set_args (argc, argv);
_gfortran_set_max_subrecord_length (8);
return 0;
- }
+ }
\ No newline at end of file
Fortran language standards compliance (see :ref:`standards`), or contributing
to the implementation of extensions such as OpenMP (see :ref:`openmp`) or
OpenACC (see :ref:`openacc`) that are under active development. Again,
- contributing test cases for these features is useful too!
+ contributing test cases for these features is useful too!
\ No newline at end of file
runtime/gfortranconvertunit
runtime/gfortranerrorbacktrace
runtime/gfortranformattedbuffersize
- runtime/gfortranunformattedbuffersize
+ runtime/gfortranunformattedbuffersize
\ No newline at end of file
The values specified via the GFORTRAN_CONVERT_UNIT
environment variable will override the CONVERT specifier in the
open statement*. This is to give control over data formats to
- users who do not have the source code of their program available.
+ users who do not have the source code of their program available.
\ No newline at end of file
backtrace is printed when a serious run-time error occurs. To disable
the backtracing, set the variable to :samp:`n`, :samp:`N`, :samp:`0`.
Default is to print a backtrace unless the :option:`-fno-backtrace`
-compile option was used.
+compile option was used.
\ No newline at end of file
The :envvar:`GFORTRAN_FORMATTED_BUFFER_SIZE` environment variable
specifies buffer size in bytes to be used for formatted output.
-The default value is 8192.
+The default value is 8192.
\ No newline at end of file
$ GFORTRAN_LIST_SEPARATOR=' , ' ./a.out
when :command:`a.out` is the compiled Fortran program that you want to run.
-Default is a single space.
+Default is a single space.
\ No newline at end of file
a plus sign is printed
where permitted by the Fortran standard. If the first letter
is :samp:`n`, :samp:`N` or :samp:`0`, a plus sign is not printed
-in most cases. Default is not to print plus signs.
+in most cases. Default is not to print plus signs.
\ No newline at end of file
If the first letter is :samp:`y`, :samp:`Y` or :samp:`1`, filename and
line numbers for runtime errors are printed. If the first letter is
:samp:`n`, :samp:`N` or :samp:`0`, do not print filename and line numbers
-for runtime errors. The default is to print the location.
+for runtime errors. The default is to print the location.
\ No newline at end of file
This environment variable can be used to select the unit number
preconnected to standard error. This must be a positive integer.
-The default value is 0.
+The default value is 0.
\ No newline at end of file
This environment variable can be used to select the unit number
preconnected to standard input. This must be a positive integer.
-The default value is 5.
+The default value is 5.
\ No newline at end of file
This environment variable can be used to select the unit number
preconnected to standard output. This must be a positive integer.
-The default value is 6.
+The default value is 6.
\ No newline at end of file
the first letter is :samp:`y`, :samp:`Y` or :samp:`1`, all I/O is
unbuffered. This will slow down small sequential reads and writes. If
the first letter is :samp:`n`, :samp:`N` or :samp:`0`, I/O is buffered.
-This is the default.
+This is the default.
\ No newline at end of file
whether I/O on a preconnected unit (i.e. STDOUT or STDERR) is unbuffered. If
the first letter is :samp:`y`, :samp:`Y` or :samp:`1`, I/O is unbuffered. This
will slow down small sequential reads and writes. If the first letter
-is :samp:`n`, :samp:`N` or :samp:`0`, I/O is buffered. This is the default.
+is :samp:`n`, :samp:`N` or :samp:`0`, I/O is buffered. This is the default.
\ No newline at end of file
The :envvar:`GFORTRAN_UNFORMATTED_BUFFER_SIZE` environment variable
specifies buffer size in bytes to be used for unformatted output.
-The default value is 131072.
+The default value is 131072.
\ No newline at end of file
:envvar:`TEMP` environment variables, if they exist, in that order.
* The ``P_tmpdir`` macro if it is defined, otherwise the directory
- :samp:`/tmp`.
+ :samp:`/tmp`.
\ No newline at end of file
``implicit-none-spec-list``.
* The behavior of the ``INQUIRE`` statement with the ``RECL=``
- specifier now conforms to Fortran 2018.
+ specifier now conforms to Fortran 2018.
\ No newline at end of file
^^^^^^^^^^
Opaque pointer to represent a team-handle. This type is a stand-in for the
-future implementation of teams. It is about to change without further notice.
+future implementation of teams. It is about to change without further notice.
\ No newline at end of file
:maxdepth: 2
c-type-interoperability
- function-names
+ function-names
\ No newline at end of file
program will fail. When passing a pointer from Go to C, the Go
function must retain a visible copy of it in some Go variable.
Otherwise the Go garbage collector may delete the pointer while the C
-function is still using it.
+function is still using it.
\ No newline at end of file
``//go:noinline``
The ``//go:noinline`` directive specifies that the next function
- defined in the file may not be inlined.
+ defined in the file may not be inlined.
\ No newline at end of file
You have freedom to copy and modify this GNU Manual, like GNU
software. Copies published by the Free Software Foundation raise
- funds for GNU development.
+ funds for GNU development.
\ No newline at end of file
.. code-block:: c++
- extern int go_function(int) __asm__ ("mypkgpath.Function");
+ extern int go_function(int) __asm__ ("mypkgpath.Function");
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../doc/gpl-3.0.rst
+.. include:: ../../../doc/gpl-3.0.rst
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../../doc/gnu_free_documentation_license.rst
+.. include:: ../../../doc/gnu_free_documentation_license.rst
\ No newline at end of file
At link time you must explicitly tell :command:`gccgo` which files to
link together into the executable, as is usual with :command:`gcc`.
-This is different from the behavior of other Go compilers.
+This is different from the behavior of other Go compilers.
\ No newline at end of file
c-interoperability
general-public-license-3
gnu-free-documentation-license
- indices-and-tables
+ indices-and-tables
\ No newline at end of file
-.. include:: ../../../doc/indices-and-tables.rst
+.. include:: ../../../doc/indices-and-tables.rst
\ No newline at end of file
the Go programming language. This manual is specifically about
:command:`gccgo`. For more information about the Go programming
language in general, including language specifications and standard
-package documentation, see http://golang.org/.
+package documentation, see http://golang.org/.
\ No newline at end of file
.. only:: man
- .. include:: copyright.rst
+ .. include:: copyright.rst
\ No newline at end of file
* I/O within OpenMP target regions and OpenACC parallel/kernels is supported
using the C library ``printf`` functions and the Fortran
- ``print`` / ``write`` statements.
+ ``print`` / ``write`` statements.
\ No newline at end of file
You have freedom to copy and modify this GNU Manual, like GNU
software. Copies published by the Free Software Foundation raise
- funds for GNU development.
+ funds for GNU development.
\ No newline at end of file
-
.. [#f1] See "Stream Management" in "CUDA Driver API",
- TRM-06703-001, Version 5.5, for additional information
+ TRM-06703-001, Version 5.5, for additional information
\ No newline at end of file
A complete description of all OpenACC directives accepted may be found in
the `OpenACC <https://www.openacc.org>`_ Application Programming
-Interface manual, version 2.6.
+Interface manual, version 2.6.
\ No newline at end of file
A complete description of all OpenMP directives may be found in the
`OpenMP Application Program Interface <https://www.openmp.org>`_ manuals.
-See also :ref:`openmp-implementation-status`.
+See also :ref:`openmp-implementation-status`.
\ No newline at end of file
}
/* Initialize OpenACC library and use device 'dev' */
- acc_set_device_num(dev, acc_device_nvidia);
+ acc_set_device_num(dev, acc_device_nvidia);
\ No newline at end of file
}
/* Copy the results from the device */
- acc_memcpy_from_device(&h_Y1[0], d_Y, N * sizeof (float));
+ acc_memcpy_from_device(&h_Y1[0], d_Y, N * sizeof (float));
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../doc/funding.rst
+.. include:: ../../doc/funding.rst
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../doc/gpl-3.0.rst
+.. include:: ../../doc/gpl-3.0.rst
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../doc/gnu_free_documentation_license.rst
+.. include:: ../../doc/gnu_free_documentation_license.rst
\ No newline at end of file
* ``acc_memcpy_to_device``, ``acc_memcpy_to_device_async``
-* ``acc_memcpy_from_device``, ``acc_memcpy_from_device_async``
+* ``acc_memcpy_from_device``, ``acc_memcpy_from_device_async``
\ No newline at end of file
gnu-free-documentation-license
funding
- indices-and-tables
+ indices-and-tables
\ No newline at end of file
-.. include:: ../../doc/indices-and-tables.rst
+.. include:: ../../doc/indices-and-tables.rst
\ No newline at end of file
Originally, libgomp implemented the GNU OpenMP Runtime Library. Based
on this, support for OpenACC and offloading (both OpenACC and OpenMP
4's target construct) has been added later on, and the library's name
-changed to GNU Offloading and Multi Processing Runtime Library.
+changed to GNU Offloading and Multi Processing Runtime Library.
\ No newline at end of file
.. -
Offload-Target Specifics
- -
+ -
\ No newline at end of file
.. -
The libgomp ABI
- -
+ -
\ No newline at end of file
:maxdepth: 2
amd-radeon-gcn
- nvptx
+ nvptx
\ No newline at end of file
openacc-environment-variables/accdevicetype
openacc-environment-variables/accdevicenum
openacc-environment-variables/accproflib
- openacc-environment-variables/gccaccnotify
+ openacc-environment-variables/gccaccnotify
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 4.2.
+ 4.2.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 4.1.
+ 4.1.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 4.3.
+ 4.3.
\ No newline at end of file
**************
Description:
- Print debug information pertaining to the accelerator.
+ Print debug information pertaining to the accelerator.
\ No newline at end of file
"Interactions with the CUDA Driver API" in
"CUDA Runtime API", Version 5.5, and section 2.27, "VDPAU
Interoperability", in "CUDA Driver API", TRM-06703-001, Version 5.5,
- for additional information on library interoperability.
+ for additional information on library interoperability.
\ No newline at end of file
.. [#f1] More complete information
about :envvar:`ACC_DEVICE_TYPE` and :envvar:`ACC_DEVICE_NUM` can be found in
sections 4.1 and 4.2 of the `OpenACC <https://www.openacc.org>`_
- Application Programming Interface”, Version 2.6.
+ Application Programming Interface”, Version 2.6.
\ No newline at end of file
openacc-introduction
first-invocation-nvidia-cublas-library-api
first-invocation-openacc-library-api
- openacc-library-and-environment-variables
+ openacc-library-and-environment-variables
\ No newline at end of file
.. toctree::
:maxdepth: 2
- implementation-status-and-implementation-defined-behavior
+ implementation-status-and-implementation-defined-behavior
\ No newline at end of file
openacc-runtime-library-routines/accprofregister
openacc-runtime-library-routines/accprofunregister
openacc-runtime-library-routines/accproflookup
- openacc-runtime-library-routines/accregisterlibrary
+ openacc-runtime-library-routines/accregisterlibrary
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.9.
+ 3.2.9.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.10.
+ 3.2.10.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.34.
+ 3.2.34.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.20.
+ 3.2.20.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.22.
+ 3.2.22.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.21.
+ 3.2.21.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.23.
+ 3.2.23.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.35.
+ 3.2.35.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.28.
+ 3.2.28.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.19.
+ 3.2.19.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- A.2.1.3.
+ A.2.1.3.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- A.2.1.2.
+ A.2.1.2.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- A.2.1.1.
+ A.2.1.1.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.5.
+ 3.2.5.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.3.
+ 3.2.3.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.1.
+ 3.2.1.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.6.
+ 3.2.6.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.29.
+ 3.2.29.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.7.
+ 3.2.7.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.30.
+ 3.2.30.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.18.
+ 3.2.18.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.26.
+ 3.2.26.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.32.
+ 3.2.32.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.31.
+ 3.2.31.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.17.
+ 3.2.17.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.20.
+ 3.2.20.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.21.
+ 3.2.21.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 5.3.
+ 5.3.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 5.3.
+ 5.3.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 5.3.
+ 5.3.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 5.3.
+ 5.3.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- A.2.1.4.
+ A.2.1.4.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.4.
+ 3.2.4.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.2.
+ 3.2.2.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.8.
+ 3.2.8.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.27.
+ 3.2.27.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.24.
+ 3.2.24.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.25.
+ 3.2.25.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.11.
+ 3.2.11.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.13.
+ 3.2.13.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.14.
+ 3.2.14.
\ No newline at end of file
Reference:
:openacc:`2.6`, section
- 3.2.12.
+ 3.2.12.
\ No newline at end of file
- See ``-march=`` in :ref:`gcc:amd-gcn-options`
* - ``nvptx``
- ``gpu``
- - See ``-march=`` in :ref:`gcc:nvidia-ptx-options`
+ - See ``-march=`` in :ref:`gcc:nvidia-ptx-options`
\ No newline at end of file
openmp-environment-variables/gompdebug
openmp-environment-variables/gompstacksize
openmp-environment-variables/gompspincount
- openmp-environment-variables/gomprtemsthreadpools
+ openmp-environment-variables/gomprtemsthreadpools
\ No newline at end of file
``FALSE``, the host system will handle the assignment of threads to CPUs.
See also:
- :ref:`OMP_PLACES`, :ref:`OMP_PROC_BIND`
+ :ref:`OMP_PLACES`, :ref:`OMP_PROC_BIND`
\ No newline at end of file
(disabled, also the default if not set), or ``1`` (enabled).
If enabled, some debugging output will be printed during execution.
- This is currently not specified in more detail, and subject to change.
+ This is currently not specified in more detail, and subject to change.
\ No newline at end of file
one thread pool available. Since no priority is specified for this scheduler
instance, the worker thread inherits the priority of the OpenMP primary thread
that created it. In the scheduler instance ``WRK1`` there are three thread
- pools available and their worker threads run at priority four.
+ pools available and their worker threads run at priority four.
\ No newline at end of file
or :envvar:`OMP_WAIT_POLICY` is ``PASSIVE``.
See also:
- :ref:`OMP_WAIT_POLICY`
+ :ref:`OMP_WAIT_POLICY`
\ No newline at end of file
Reference:
`GCC Patches Mailinglist <https://gcc.gnu.org/ml/gcc-patches/2006-06/msg00493.html>`_,
- `GCC Patches Mailinglist (2) <https://gcc.gnu.org/ml/gcc-patches/2006-06/msg00496.html>`_
+ `GCC Patches Mailinglist (2) <https://gcc.gnu.org/ml/gcc-patches/2006-06/msg00496.html>`_
\ No newline at end of file
:ref:`omp_get_cancellation`
Reference:
- :openmp:`4.5`, Section 4.11
+ :openmp:`4.5`, Section 4.11
\ No newline at end of file
:ref:`omp_get_default_device`, :ref:`omp_set_default_device`,
Reference:
- :openmp:`4.5`, Section 4.13
+ :openmp:`4.5`, Section 4.13
\ No newline at end of file
this information will not be shown.
Reference:
- :openmp:`4.5`, Section 4.12
+ :openmp:`4.5`, Section 4.12
\ No newline at end of file
:ref:`omp_set_dynamic`
Reference:
- :openmp:`4.5`, Section 4.3
+ :openmp:`4.5`, Section 4.3
\ No newline at end of file
:ref:`omp_set_max_active_levels`, :ref:`OMP_NESTED`
Reference:
- :openmp:`4.5`, Section 4.9
+ :openmp:`4.5`, Section 4.9
\ No newline at end of file
:ref:`omp_get_max_task_priority`
Reference:
- :openmp:`4.5`, Section 4.14
+ :openmp:`4.5`, Section 4.14
\ No newline at end of file
:ref:`omp_set_max_active_levels`, :ref:`omp_set_nested`
Reference:
- :openmp:`4.5`, Section 4.6
+ :openmp:`4.5`, Section 4.6
\ No newline at end of file
:ref:`omp_set_num_teams`
Reference:
- :openmp:`5.1`, Section 6.23
+ :openmp:`5.1`, Section 6.23
\ No newline at end of file
:ref:`omp_set_num_threads`, :ref:`OMP_NESTED`
Reference:
- :openmp:`4.5`, Section 4.2
+ :openmp:`4.5`, Section 4.2
\ No newline at end of file
:ref:`OMP_DISPLAY_ENV`
Reference:
- :openmp:`4.5`, Section 4.5
+ :openmp:`4.5`, Section 4.5
\ No newline at end of file
:ref:`OMP_NESTED`, :ref:`OMP_PLACES`
Reference:
- :openmp:`4.5`, Section 4.4
+ :openmp:`4.5`, Section 4.4
\ No newline at end of file
:ref:`omp_set_schedule`
Reference:
- :openmp:`4.5`, Sections 2.7.1.1 and 4.1
+ :openmp:`4.5`, Sections 2.7.1.1 and 4.1
\ No newline at end of file
dependent.
Reference:
- :openmp:`4.5`, Section 4.7
+ :openmp:`4.5`, Section 4.7
\ No newline at end of file
If undefined, then the program will behave as if ``DEFAULT`` was set.
Reference:
- :openmp:`5.0`, Section 6.17
+ :openmp:`5.0`, Section 6.17
\ No newline at end of file
:ref:`OMP_THREAD_LIMIT`, :ref:`omp_set_teams_thread_limit`
Reference:
- :openmp:`5.1`, Section 6.24
+ :openmp:`5.1`, Section 6.24
\ No newline at end of file
:ref:`OMP_NUM_THREADS`, :ref:`omp_get_thread_limit`
Reference:
- :openmp:`4.5`, Section 4.10
+ :openmp:`4.5`, Section 4.10
\ No newline at end of file
:ref:`GOMP_SPINCOUNT`
Reference:
- :openmp:`4.5`, Section 4.8
+ :openmp:`4.5`, Section 4.8
\ No newline at end of file
:maxdepth: 2
openmp-context-selectors
- memory-allocation-with-libmemkind
+ memory-allocation-with-libmemkind
\ No newline at end of file
openmp-implementation-status/openmp-45
openmp-implementation-status/openmp-50
openmp-implementation-status/openmp-51
- openmp-implementation-status/openmp-52
+ openmp-implementation-status/openmp-52
\ No newline at end of file
OpenMP 4.5
**********
-The OpenMP 4.5 specification is fully supported.
+The OpenMP 4.5 specification is fully supported.
\ No newline at end of file
* - Supporting C++'s range-based for loop
- Y
- -
+ -
\ No newline at end of file
-
* - For Fortran, diagnose placing declarative before/between ``USE``, ``IMPORT``, and ``IMPLICIT`` as invalid
- N
- -
+ -
\ No newline at end of file
.. -
OpenMP Runtime Library Routines
- -
+ -
\ No newline at end of file
.. toctree::
:maxdepth: 2
- openmp-runtime-library-routines/ompfulfillevent
+ openmp-runtime-library-routines/ompfulfillevent
\ No newline at end of file
:ref:`omp_init_lock`
Reference:
- :openmp:`4.5`, Section 3.3.3.
+ :openmp:`4.5`, Section 3.3.3.
\ No newline at end of file
:ref:`omp_init_lock`
Reference:
- :openmp:`4.5`, Section 3.3.3.
+ :openmp:`4.5`, Section 3.3.3.
\ No newline at end of file
- ``integer (kind=omp_event_handle_kind) :: event``
Reference:
- :openmp:`5.0`, Section 3.5.1.
+ :openmp:`5.0`, Section 3.5.1.
\ No newline at end of file
:ref:`omp_get_level`, :ref:`omp_get_max_active_levels`, :ref:`omp_set_max_active_levels`
Reference:
- :openmp:`4.5`, Section 3.2.20.
+ :openmp:`4.5`, Section 3.2.20.
\ No newline at end of file
:ref:`omp_get_level`, :ref:`omp_get_thread_num`, :ref:`omp_get_team_size`
Reference:
- :openmp:`4.5`, Section 3.2.18.
+ :openmp:`4.5`, Section 3.2.18.
\ No newline at end of file
:ref:`OMP_CANCELLATION`
Reference:
- :openmp:`4.5`, Section 3.2.9.
+ :openmp:`4.5`, Section 3.2.9.
\ No newline at end of file
:ref:`OMP_DEFAULT_DEVICE`, :ref:`omp_set_default_device`
Reference:
- :openmp:`4.5`, Section 3.2.30.
+ :openmp:`4.5`, Section 3.2.30.
\ No newline at end of file
:ref:`omp_get_initial_device`
Reference:
- :openmp:`5.0`, Section 3.2.37.
+ :openmp:`5.0`, Section 3.2.37.
\ No newline at end of file
:ref:`omp_set_dynamic`, :ref:`OMP_DYNAMIC`
Reference:
- :openmp:`4.5`, Section 3.2.8.
+ :openmp:`4.5`, Section 3.2.8.
\ No newline at end of file
:ref:`omp_get_num_devices`
Reference:
- :openmp:`4.5`, Section 3.2.35.
+ :openmp:`4.5`, Section 3.2.35.
\ No newline at end of file
:ref:`omp_get_active_level`
Reference:
- :openmp:`4.5`, Section 3.2.17.
+ :openmp:`4.5`, Section 3.2.17.
\ No newline at end of file
:ref:`omp_set_max_active_levels`, :ref:`omp_get_active_level`
Reference:
- :openmp:`4.5`, Section 3.2.16.
+ :openmp:`4.5`, Section 3.2.16.
\ No newline at end of file
- ``integer function omp_get_max_task_priority()``
Reference:
- :openmp:`4.5`, Section 3.2.29.
+ :openmp:`4.5`, Section 3.2.29.
\ No newline at end of file
:ref:`omp_set_num_teams`, :ref:`omp_get_num_teams`
Reference:
- :openmp:`5.1`, Section 3.4.4.
+ :openmp:`5.1`, Section 3.4.4.
\ No newline at end of file
:ref:`omp_set_num_threads`, :ref:`omp_set_dynamic`, :ref:`omp_get_thread_limit`
Reference:
- :openmp:`4.5`, Section 3.2.3.
+ :openmp:`4.5`, Section 3.2.3.
\ No newline at end of file
:ref:`OMP_MAX_ACTIVE_LEVELS`, :ref:`OMP_NESTED`
Reference:
- :openmp:`4.5`, Section 3.2.11.
+ :openmp:`4.5`, Section 3.2.11.
\ No newline at end of file
- ``integer function omp_get_num_devices()``
Reference:
- :openmp:`4.5`, Section 3.2.31.
+ :openmp:`4.5`, Section 3.2.31.
\ No newline at end of file
- ``integer function omp_get_num_procs()``
Reference:
- :openmp:`4.5`, Section 3.2.5.
+ :openmp:`4.5`, Section 3.2.5.
\ No newline at end of file
- ``integer function omp_get_num_teams()``
Reference:
- :openmp:`4.5`, Section 3.2.32.
+ :openmp:`4.5`, Section 3.2.32.
\ No newline at end of file
:ref:`omp_get_max_threads`, :ref:`omp_set_num_threads`, :ref:`OMP_NUM_THREADS`
Reference:
- :openmp:`4.5`, Section 3.2.2.
+ :openmp:`4.5`, Section 3.2.2.
\ No newline at end of file
:ref:`OMP_PROC_BIND`, :ref:`OMP_PLACES`, :ref:`GOMP_CPU_AFFINITY`,
Reference:
- :openmp:`4.5`, Section 3.2.22.
+ :openmp:`4.5`, Section 3.2.22.
\ No newline at end of file
:ref:`omp_set_schedule`, :ref:`OMP_SCHEDULE`
Reference:
- :openmp:`4.5`, Section 3.2.13.
+ :openmp:`4.5`, Section 3.2.13.
\ No newline at end of file
:ref:`omp_get_max_active_levels`, :ref:`omp_set_max_active_levels`
Reference:
- :openmp:`5.0`, Section 3.2.15.
+ :openmp:`5.0`, Section 3.2.15.
\ No newline at end of file
- ``integer function omp_get_team_num()``
Reference:
- :openmp:`4.5`, Section 3.2.33.
+ :openmp:`4.5`, Section 3.2.33.
\ No newline at end of file
:ref:`omp_get_num_threads`, :ref:`omp_get_level`, :ref:`omp_get_ancestor_thread_num`
Reference:
- :openmp:`4.5`, Section 3.2.19.
+ :openmp:`4.5`, Section 3.2.19.
\ No newline at end of file
:ref:`omp_set_teams_thread_limit`, :ref:`OMP_TEAMS_THREAD_LIMIT`
Reference:
- :openmp:`5.1`, Section 3.4.6.
+ :openmp:`5.1`, Section 3.4.6.
\ No newline at end of file
:ref:`omp_get_max_threads`, :ref:`OMP_THREAD_LIMIT`
Reference:
- :openmp:`4.5`, Section 3.2.14.
+ :openmp:`4.5`, Section 3.2.14.
\ No newline at end of file
:ref:`omp_get_num_threads`, :ref:`omp_get_ancestor_thread_num`
Reference:
- :openmp:`4.5`, Section 3.2.4.
+ :openmp:`4.5`, Section 3.2.4.
\ No newline at end of file
:ref:`omp_get_wtime`
Reference:
- :openmp:`4.5`, Section 3.4.2.
+ :openmp:`4.5`, Section 3.4.2.
\ No newline at end of file
:ref:`omp_get_wtick`
Reference:
- :openmp:`4.5`, Section 3.4.1.
+ :openmp:`4.5`, Section 3.4.1.
\ No newline at end of file
- ``logical function omp_in_final()``
Reference:
- :openmp:`4.5`, Section 3.2.21.
+ :openmp:`4.5`, Section 3.2.21.
\ No newline at end of file
:ref:`omp_destroy_lock`
Reference:
- :openmp:`4.5`, Section 3.3.1.
+ :openmp:`4.5`, Section 3.3.1.
\ No newline at end of file
:ref:`omp_destroy_nest_lock`
Reference:
- :openmp:`4.5`, Section 3.3.1.
+ :openmp:`4.5`, Section 3.3.1.
\ No newline at end of file
- ``logical function omp_in_parallel()``
Reference:
- :openmp:`4.5`, Section 3.2.6.
+ :openmp:`4.5`, Section 3.2.6.
\ No newline at end of file
- ``logical function omp_is_initial_device()``
Reference:
- :openmp:`4.5`, Section 3.2.34.
+ :openmp:`4.5`, Section 3.2.34.
\ No newline at end of file
:ref:`OMP_DEFAULT_DEVICE`, :ref:`omp_get_default_device`
Reference:
- :openmp:`4.5`, Section 3.2.29.
+ :openmp:`4.5`, Section 3.2.29.
\ No newline at end of file
:ref:`OMP_DYNAMIC`, :ref:`omp_get_dynamic`
Reference:
- :openmp:`4.5`, Section 3.2.7.
+ :openmp:`4.5`, Section 3.2.7.
\ No newline at end of file
:ref:`omp_init_lock`, :ref:`omp_test_lock`, :ref:`omp_unset_lock`
Reference:
- :openmp:`4.5`, Section 3.3.4.
+ :openmp:`4.5`, Section 3.3.4.
\ No newline at end of file
:ref:`omp_get_supported_active_levels`
Reference:
- :openmp:`4.5`, Section 3.2.15.
+ :openmp:`4.5`, Section 3.2.15.
\ No newline at end of file
:ref:`OMP_MAX_ACTIVE_LEVELS`, :ref:`OMP_NESTED`
Reference:
- :openmp:`4.5`, Section 3.2.10.
+ :openmp:`4.5`, Section 3.2.10.
\ No newline at end of file
:ref:`omp_init_nest_lock`, :ref:`omp_unset_nest_lock`
Reference:
- :openmp:`4.5`, Section 3.3.4.
+ :openmp:`4.5`, Section 3.3.4.
\ No newline at end of file
:ref:`OMP_NUM_TEAMS`, :ref:`omp_get_num_teams`, :ref:`omp_get_max_teams`
Reference:
- :openmp:`5.1`, Section 3.4.3.
+ :openmp:`5.1`, Section 3.4.3.
\ No newline at end of file
:ref:`OMP_NUM_THREADS`, :ref:`omp_get_num_threads`, :ref:`omp_get_max_threads`
Reference:
- :openmp:`4.5`, Section 3.2.1.
+ :openmp:`4.5`, Section 3.2.1.
\ No newline at end of file
:ref:`OMP_SCHEDULE`
Reference:
- :openmp:`4.5`, Section 3.2.12.
+ :openmp:`4.5`, Section 3.2.12.
\ No newline at end of file
:ref:`OMP_TEAMS_THREAD_LIMIT`, :ref:`omp_get_teams_thread_limit`, :ref:`omp_get_thread_limit`
Reference:
- :openmp:`5.1`, Section 3.4.5.
+ :openmp:`5.1`, Section 3.4.5.
\ No newline at end of file
:ref:`omp_init_lock`, :ref:`omp_set_lock`, :ref:`omp_set_lock`
Reference:
- :openmp:`4.5`, Section 3.3.6.
+ :openmp:`4.5`, Section 3.3.6.
\ No newline at end of file
:ref:`omp_init_lock`, :ref:`omp_set_lock`, :ref:`omp_set_lock`
Reference:
- :openmp:`4.5`, Section 3.3.6.
+ :openmp:`4.5`, Section 3.3.6.
\ No newline at end of file
:ref:`omp_set_lock`, :ref:`omp_test_lock`
Reference:
- :openmp:`4.5`, Section 3.3.5.
+ :openmp:`4.5`, Section 3.3.5.
\ No newline at end of file
:ref:`omp_set_nest_lock`
Reference:
- :openmp:`4.5`, Section 3.3.5.
+ :openmp:`4.5`, Section 3.3.5.
\ No newline at end of file
Bugs in the GNU Offloading and Multi Processing Runtime Library should
be reported via `Bugzilla <https://gcc.gnu.org/bugzilla/>`_. Please add
"openacc", or "openmp", or both to the keywords field in the bug
-report, as appropriate.
+report, as appropriate.
\ No newline at end of file
the-libgomp-abi/implementing-ordered-construct
the-libgomp-abi/implementing-sections-construct
the-libgomp-abi/implementing-single-construct
- the-libgomp-abi/implementing-openaccs-parallel-construct
+ the-libgomp-abi/implementing-openaccs-parallel-construct
\ No newline at end of file
void GOMP_atomic_exit (void)
which reuses the regular lock code, but with yet another lock
-object private to the library.
+object private to the library.
\ No newline at end of file
.. code-block:: c++
- void GOMP_barrier (void)
+ void GOMP_barrier (void)
\ No newline at end of file
Ideally the ABI would specify that all zero is a valid unlocked
state, and so we wouldn't need to initialize this at
-startup.
+startup.
\ No newline at end of file
x and y are global variables.
COPYPRIVATE would work the same way, except the structure
-broadcast would have to happen via SINGLE machinery instead.
+broadcast would have to happen via SINGLE machinery instead.
\ No newline at end of file
Implementing FLUSH construct
****************************
-Expands to the ``__sync_synchronize`` builtin.
+Expands to the ``__sync_synchronize`` builtin.
\ No newline at end of file
of these routines.
There are separate routines for handling loops with an ORDERED
-clause. Bookkeeping for that is non-trivial...
+clause. Bookkeeping for that is non-trivial...
\ No newline at end of file
Alternately, we generate two copies of the parallel subfunction
and only include this in the version run by the primary thread.
-Surely this is not worthwhile though...
+Surely this is not worthwhile though...
\ No newline at end of file
.. code-block:: c++
- void GOACC_parallel ()
+ void GOACC_parallel ()
\ No newline at end of file
.. code-block:: c++
void GOMP_ordered_start (void)
- void GOMP_ordered_end (void)
+ void GOMP_ordered_end (void)
\ No newline at end of file
void GOMP_parallel_end (void)
-Tears down the team and returns us to the previous ``omp_in_parallel()`` state.
+Tears down the team and returns us to the previous ``omp_in_parallel()`` state.
\ No newline at end of file
In association with FOR or SECTIONS blocks, create a new
automatic variable within the current function. This preserves
-the semantic of new variable creation.
+the semantic of new variable creation.
\ No newline at end of file
a pointer to an array of the type of the variable, indexed by the
thread's :samp:`{team_id}`. The thread stores its final value into the
array, and after the barrier, the primary thread iterates over the
-array to collect the values.
+array to collect the values.
\ No newline at end of file
stmt3;
break;
}
- GOMP_barrier ();
+ GOMP_barrier ();
\ No newline at end of file
}
else
x = datap->x;
- GOMP_barrier ();
+ GOMP_barrier ();
\ No newline at end of file
Even more ideally, this ctor feature is handled by extensions
to the main pthreads library. Failing that, we can have a set
-of entry points to register ctor functions to be called.
+of entry points to register ctor functions to be called.
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../doc/bsd.rst
+.. include:: ../../doc/bsd.rst
\ No newline at end of file
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with no
Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
-A copy of the license is in the :ref:`gnu_fdl`.
+A copy of the license is in the :ref:`gnu_fdl`.
\ No newline at end of file
.. function:: void *obstack_next_free (struct obstack *obstack_ptr)
Address just after the end of the currently growing object.
- See :ref:`status-of-an-obstack`.
+ See :ref:`status-of-an-obstack`.
\ No newline at end of file
Print to allocated string without fail. If ``xvasprintf`` fails,
this will print a message to ``stderr`` (using the name set by
- ``xmalloc_set_program_name``, if any) and then call ``xexit``.
+ ``xmalloc_set_program_name``, if any) and then call ``xexit``.
\ No newline at end of file
lesser-general-public-license-2.1
bsd
- indices-and-tables
+ indices-and-tables
\ No newline at end of file
-.. include:: ../../doc/indices-and-tables.rst
+.. include:: ../../doc/indices-and-tables.rst
\ No newline at end of file
The ``libiberty`` library is a collection of subroutines used by various
GNU programs. It is available under the Library General Public
-License; for more information, see Library Copying.
+License; for more information, see Library Copying.
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../doc/lgpl-2.1.rst
+.. include:: ../../doc/lgpl-2.1.rst
\ No newline at end of file
replacement-functions
- extensions
+ extensions
\ No newline at end of file
These are a set of routines to facilitate programming with the system
``errno`` interface. The ``libiberty`` source file :samp:`strerror.c`
-contains a good deal of documentation for these functions.
+contains a good deal of documentation for these functions.
\ No newline at end of file
in :samp:`{foo}.c` but not declared in any ``libiberty`` header file; more
comments and caveats for each function's implementation are often
available in the source file. Generally, the function can simply
-be declared as ``extern``.
+be declared as ``extern``.
\ No newline at end of file
Making use of ``libiberty`` code usually requires that you include one or more
header files from the ``libiberty`` distribution. (They will be named as
necessary in the function descriptions.) At link time, you will need to
-add :option:`-liberty` to your link command invocation.
+add :option:`-liberty` to your link command invocation.
\ No newline at end of file
using a single global lock as a guard for all transactions. Note that like
other synchronization constructs in C/C++, transactions rely on a
data-race-free program (e.g., a nontransactional write that is concurrent
-with a transactional read to the same memory location is a data race).
+with a transactional read to the same memory location is a data race).
\ No newline at end of file
under the terms of the GNU Free Documentation License, Version 1.2 or
any later version published by the Free Software Foundation; with no
Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
-A copy of the license is included in the section entitled :ref:`gnu_fdl`.
+A copy of the license is included in the section entitled :ref:`gnu_fdl`.
\ No newline at end of file
To activate support for TM in C/C++, the compile-time flag :option:`-fgnu-tm`
must be specified. This enables TM language-level constructs such as
-transaction statements (e.g., ``__transaction_atomic``, see :ref:`c-c++-language-constructs-for-tm` for details).
+transaction statements (e.g., ``__transaction_atomic``, see :ref:`c-c++-language-constructs-for-tm` for details).
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../doc/gnu_free_documentation_license.rst
+.. include:: ../../doc/gnu_free_documentation_license.rst
\ No newline at end of file
the-libitm-abi
internals
gnu-free-documentation-license
- indices-and-tables
+ indices-and-tables
\ No newline at end of file
-.. include:: ../../doc/indices-and-tables.rst
+.. include:: ../../doc/indices-and-tables.rst
\ No newline at end of file
tm-methods-and-method-groups
nesting-flat-vs-closed
- locking-conventions
+ locking-conventions
\ No newline at end of file
have threads with different priorities will likely also require lower latency
or higher throughput for high-priority threads. Therefore, it probably makes
not that much sense (except for eventual progress guarantees) to use
-priority inheritance until the TM has priority-aware contention management.
+priority inheritance until the TM has priority-aware contention management.
\ No newline at end of file
nesting. User-controlled aborts will correctly abort the innermost enclosing
transaction, whereas the whole (i.e., outermost) transaction will be restarted
otherwise (e.g., when a transaction encounters data conflicts during
-optimistic execution).
+optimistic execution).
\ No newline at end of file
the-libitm-abi/function-list
the-libitm-abi/future-enhancements-to-the-abi
the-libitm-abi/sample-code
- the-libitm-abi/memory-model
+ the-libitm-abi/memory-model
\ No newline at end of file
libitm also provides transactional clones of C++ memory management functions
such as global operator new and delete. They are part of libitm for historic
-reasons but do not need to be part of this ABI.
+reasons but do not need to be part of this ABI.
\ No newline at end of file
For copying conditions, see the copyright.rst file.
[No changes] Future Enhancements to the ABI
-*******************************************
+*******************************************
\ No newline at end of file
Function pointer encryption
^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Currently, this is not implemented.
+Currently, this is not implemented.
\ No newline at end of file
For example, if a transactional load is ordered before another load/store, then
the TM runtime must also ensure this ordering when accessing shared state. If
not, this might break the kind of publication safety used in the C++ TM
-specification. Likewise, the TM runtime must ensure privatization safety.
+specification. Likewise, the TM runtime must ensure privatization safety.
\ No newline at end of file
For copying conditions, see the copyright.rst file.
[No changes] Non-objectives
-***************************
+***************************
\ No newline at end of file
For copying conditions, see the copyright.rst file.
[No changes] Objectives
-***********************
+***********************
\ No newline at end of file
************
The code examples might not be correct w.r.t. the current version of the ABI,
-especially everything related to exception handling.
+especially everything related to exception handling.
\ No newline at end of file
*********************
``_ITM_codeProperties`` has changed, see :ref:`txn-code-properties`.
-``_ITM_srcLocation`` is not used.
+``_ITM_srcLocation`` is not used.
\ No newline at end of file
``GTM::dispatch_serialirr()``).
Note that this environment variable is only a hint for libitm and might not
-be supported in the future.
+be supported in the future.
\ No newline at end of file
(a) The FSF's Back-Cover Text is:
- You have the freedom to copy and modify this GNU manual.
+ You have the freedom to copy and modify this GNU manual.
\ No newline at end of file
This is part of the GCC manual.
For copying conditions, see the copyright.rst file.
-.. include:: ../../doc/gnu_free_documentation_license.rst
+.. include:: ../../doc/gnu_free_documentation_license.rst
\ No newline at end of file
:maxdepth: 2
strtoflt128
- quadmathsnprintf
+ quadmathsnprintf
\ No newline at end of file
gnu-free-documentation-license
reporting-bugs
- indices-and-tables
+ indices-and-tables
\ No newline at end of file
-.. include:: ../../doc/indices-and-tables.rst
+.. include:: ../../doc/indices-and-tables.rst
\ No newline at end of file
.. index:: Introduction
This manual documents the usage of libquadmath, the GCC Quad-Precision
-Math Library Application Programming Interface (API).
+Math Library Application Programming Interface (API).
\ No newline at end of file
* :samp:`{csinhq}`: complex hyperbolic sine function
* :samp:`{csqrtq}`: complex square root
* :samp:`{ctanq}`: complex tangent function
-* :samp:`{ctanhq}`: complex hyperbolic tangent function
+* :samp:`{ctanhq}`: complex hyperbolic tangent function
\ No newline at end of file
free (str);
}
return 0;
- }
+ }
\ No newline at end of file
--------------
Bugs in the GCC Quad-Precision Math Library implementation should be
-reported via |bugurl|.
+reported via |bugurl|.
\ No newline at end of file
r = strtoflt128 ("1.2345678", NULL);
return 0;
- }
+ }
\ No newline at end of file
* :samp:`{M_2_PIq}`: one over two pi
* :samp:`{M_2_SQRTPIq}`: two over square root of pi
* :samp:`{M_SQRT2q}`: square root of 2
-* :samp:`{M_SQRT1_2q}`: one over square root of 2
+* :samp:`{M_SQRT1_2q}`: one over square root of 2
\ No newline at end of file
projects / platform / upstream / gcc.git / commitdiff