| @c Copyright (C) 2004-2022 Free Software Foundation, Inc. |
| @c This is part of the GNU Fortran manual. |
| @c For copying conditions, see the file gfortran.texi. |
| |
| @ignore |
| @c man begin COPYRIGHT |
| Copyright @copyright{} 2004-2022 Free Software Foundation, Inc. |
| |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.3 or |
| any later version published by the Free Software Foundation; with the |
| Invariant Sections being ``Funding Free Software'', the Front-Cover |
| Texts being (a) (see below), and with the Back-Cover Texts being (b) |
| (see below). A copy of the license is included in the gfdl(7) man page. |
| |
| (a) The FSF's Front-Cover Text is: |
| |
| A GNU Manual |
| |
| (b) The FSF's Back-Cover Text is: |
| |
| 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. |
| @c man end |
| @c Set file name and title for the man page. |
| @setfilename gfortran |
| @settitle GNU Fortran compiler. |
| @c man begin SYNOPSIS |
| gfortran [@option{-c}|@option{-S}|@option{-E}] |
| [@option{-g}] [@option{-pg}] [@option{-O}@var{level}] |
| [@option{-W}@var{warn}@dots{}] [@option{-pedantic}] |
| [@option{-I}@var{dir}@dots{}] [@option{-L}@var{dir}@dots{}] |
| [@option{-D}@var{macro}[=@var{defn}]@dots{}] [@option{-U}@var{macro}] |
| [@option{-f}@var{option}@dots{}] |
| [@option{-m}@var{machine-option}@dots{}] |
| [@option{-o} @var{outfile}] @var{infile}@dots{} |
| |
| Only the most useful options are listed here; see below for the |
| remainder. |
| @c man end |
| @c man begin SEEALSO |
| gpl(7), gfdl(7), fsf-funding(7), |
| cpp(1), gcov(1), gcc(1), as(1), ld(1), gdb(1), dbx(1) |
| and the Info entries for @file{gcc}, @file{cpp}, @file{gfortran}, @file{as}, |
| @file{ld}, @file{binutils} and @file{gdb}. |
| @c man end |
| @c man begin BUGS |
| For instructions on reporting bugs, see |
| @w{@value{BUGURL}}. |
| @c man end |
| @c man begin AUTHOR |
| See the Info entry for @command{gfortran} for contributors to GCC and |
| GNU Fortran. |
| @c man end |
| @end ignore |
| |
| @node Invoking GNU Fortran |
| @chapter GNU Fortran Command Options |
| @cindex GNU Fortran command options |
| @cindex command options |
| @cindex options, @command{gfortran} command |
| |
| @c man begin DESCRIPTION |
| |
| The @command{gfortran} command supports all the options supported by the |
| @command{gcc} command. Only options specific to GNU Fortran are documented |
| here. |
| |
| @xref{Invoking GCC,,GCC Command Options,gcc,Using the GNU Compiler |
| Collection (GCC)}, for information |
| on the non-Fortran-specific aspects of the @command{gcc} command (and, |
| therefore, the @command{gfortran} command). |
| |
| @cindex options, negative forms |
| All GCC and GNU Fortran options |
| are accepted both by @command{gfortran} and by @command{gcc} |
| (as well as any other drivers built at the same time, |
| such as @command{g++}), |
| since adding GNU Fortran to the GCC distribution |
| enables acceptance of GNU Fortran options |
| by all of the relevant drivers. |
| |
| In some cases, options have positive and negative forms; |
| the negative form of @option{-ffoo} would be @option{-fno-foo}. |
| This manual documents only one of these two forms, whichever |
| one is not the default. |
| @c man end |
| |
| @menu |
| * Option Summary:: Brief list of all @command{gfortran} options, |
| without explanations. |
| * Fortran Dialect Options:: Controlling the variant of Fortran language |
| compiled. |
| * Preprocessing Options:: Enable and customize preprocessing. |
| * Error and Warning Options:: How picky should the compiler be? |
| * Debugging Options:: Symbol tables, measurements, and debugging dumps. |
| * Directory Options:: Where to find module files |
| * Link Options :: Influencing the linking step |
| * Runtime Options:: Influencing runtime behavior |
| * Code Gen Options:: Specifying conventions for function calls, data layout |
| and register usage. |
| * Interoperability Options:: Options for interoperability with other |
| languages. |
| * Environment Variables:: Environment variables that affect @command{gfortran}. |
| @end menu |
| |
| @node Option Summary |
| @section Option summary |
| |
| @c man begin OPTIONS |
| |
| Here is a summary of all the options specific to GNU Fortran, grouped |
| by type. Explanations are in the following sections. |
| |
| @table @emph |
| @item Fortran Language Options |
| @xref{Fortran Dialect Options,,Options controlling Fortran dialect}. |
| @gccoptlist{-fall-intrinsics -fallow-argument-mismatch -fallow-invalid-boz @gol |
| -fbackslash -fcray-pointer -fd-lines-as-code -fd-lines-as-comments @gol |
| -fdec -fdec-char-conversions -fdec-structure -fdec-intrinsic-ints @gol |
| -fdec-static -fdec-math -fdec-include -fdec-format-defaults @gol |
| -fdec-blank-format-item -fdefault-double-8 -fdefault-integer-8 @gol |
| -fdefault-real-8 -fdefault-real-10 -fdefault-real-16 -fdollar-ok @gol |
| -ffixed-line-length-@var{n} -ffixed-line-length-none -fpad-source @gol |
| -ffree-form -ffree-line-length-@var{n} -ffree-line-length-none @gol |
| -fimplicit-none -finteger-4-integer-8 -fmax-identifier-length @gol |
| -fmodule-private -ffixed-form -fno-range-check -fopenacc -fopenmp @gol |
| -freal-4-real-10 -freal-4-real-16 -freal-4-real-8 -freal-8-real-10 @gol |
| -freal-8-real-16 -freal-8-real-4 -std=@var{std} -ftest-forall-temp |
| } |
| |
| @item Preprocessing Options |
| @xref{Preprocessing Options,,Enable and customize preprocessing}. |
| @gccoptlist{-A-@var{question}@r{[}=@var{answer}@r{]} |
| -A@var{question}=@var{answer} -C -CC -D@var{macro}@r{[}=@var{defn}@r{]} |
| -H -P @gol |
| -U@var{macro} -cpp -dD -dI -dM -dN -dU -fworking-directory |
| -imultilib @var{dir} @gol |
| -iprefix @var{file} -iquote -isysroot @var{dir} -isystem @var{dir} -nocpp |
| -nostdinc @gol |
| -undef |
| } |
| |
| @item Error and Warning Options |
| @xref{Error and Warning Options,,Options to request or suppress errors |
| and warnings}. |
| @gccoptlist{-Waliasing -Wall -Wampersand -Warray-bounds @gol |
| -Wc-binding-type -Wcharacter-truncation -Wconversion @gol |
| -Wdo-subscript -Wfunction-elimination -Wimplicit-interface @gol |
| -Wimplicit-procedure -Wintrinsic-shadow -Wuse-without-only @gol |
| -Wintrinsics-std -Wline-truncation -Wno-align-commons @gol |
| -Wno-overwrite-recursive -Wno-tabs -Wreal-q-constant -Wsurprising @gol |
| -Wunderflow -Wunused-parameter -Wrealloc-lhs -Wrealloc-lhs-all @gol |
| -Wfrontend-loop-interchange -Wtarget-lifetime -fmax-errors=@var{n} @gol |
| -fsyntax-only -pedantic @gol |
| -pedantic-errors @gol |
| } |
| |
| @item Debugging Options |
| @xref{Debugging Options,,Options for debugging your program or GNU Fortran}. |
| @gccoptlist{-fbacktrace -fdump-fortran-optimized -fdump-fortran-original @gol |
| -fdebug-aux-vars -fdump-fortran-global -fdump-parse-tree -ffpe-trap=@var{list} @gol |
| -ffpe-summary=@var{list} |
| } |
| |
| @item Directory Options |
| @xref{Directory Options,,Options for directory search}. |
| @gccoptlist{-I@var{dir} -J@var{dir} -fintrinsic-modules-path @var{dir}} |
| |
| @item Link Options |
| @xref{Link Options,,Options for influencing the linking step}. |
| @gccoptlist{-static-libgfortran} |
| |
| @item Runtime Options |
| @xref{Runtime Options,,Options for influencing runtime behavior}. |
| @gccoptlist{-fconvert=@var{conversion} -fmax-subrecord-length=@var{length} @gol |
| -frecord-marker=@var{length} -fsign-zero |
| } |
| |
| @item Interoperability Options |
| @xref{Interoperability Options,,Options for interoperability}. |
| @gccoptlist{-fc-prototypes -fc-prototypes-external} |
| |
| @item Code Generation Options |
| @xref{Code Gen Options,,Options for code generation conventions}. |
| @gccoptlist{-faggressive-function-elimination -fblas-matmul-limit=@var{n} @gol |
| -fbounds-check -ftail-call-workaround -ftail-call-workaround=@var{n} @gol |
| -fcheck-array-temporaries @gol |
| -fcheck=@var{<all|array-temps|bits|bounds|do|mem|pointer|recursion>} @gol |
| -fcoarray=@var{<none|single|lib>} -fexternal-blas -ff2c @gol |
| -ffrontend-loop-interchange -ffrontend-optimize @gol |
| -finit-character=@var{n} -finit-integer=@var{n} -finit-local-zero @gol |
| -finit-derived -finit-logical=@var{<true|false>} @gol |
| -finit-real=@var{<zero|inf|-inf|nan|snan>} |
| -finline-matmul-limit=@var{n} @gol |
| -finline-arg-packing -fmax-array-constructor=@var{n} @gol |
| -fmax-stack-var-size=@var{n} -fno-align-commons -fno-automatic @gol |
| -fno-protect-parens -fno-underscoring -fsecond-underscore @gol |
| -fpack-derived -frealloc-lhs -frecursive -frepack-arrays @gol |
| -fshort-enums -fstack-arrays |
| } |
| @end table |
| |
| @node Fortran Dialect Options |
| @section Options controlling Fortran dialect |
| @cindex dialect options |
| @cindex language, dialect options |
| @cindex options, dialect |
| |
| The following options control the details of the Fortran dialect |
| accepted by the compiler: |
| |
| @table @gcctabopt |
| @item -ffree-form |
| @itemx -ffixed-form |
| @opindex @code{ffree-form} |
| @opindex @code{ffixed-form} |
| @cindex options, Fortran dialect |
| @cindex file format, free |
| @cindex file format, fixed |
| Specify the layout used by the source file. The free form layout |
| was introduced in Fortran 90. Fixed form was traditionally used in |
| older Fortran programs. When neither option is specified, the source |
| form is determined by the file extension. |
| |
| @item -fall-intrinsics |
| @opindex @code{fall-intrinsics} |
| This option causes all intrinsic procedures (including the GNU-specific |
| extensions) to be accepted. This can be useful with @option{-std=} to |
| force standard-compliance but get access to the full range of intrinsics |
| available with @command{gfortran}. As a consequence, @option{-Wintrinsics-std} |
| will be ignored and no user-defined procedure with the same name as any |
| intrinsic will be called except when it is explicitly declared @code{EXTERNAL}. |
| |
| @item -fallow-argument-mismatch |
| @opindex @code{fallow-argument-mismatch} |
| Some code contains calls to external procedures with mismatches |
| between the calls and the procedure definition, or with mismatches |
| between different calls. Such code is non-conforming, and will usually |
| be flagged with an error. This options degrades the error to a |
| warning, which can only be disabled by disabling all warnings via |
| @option{-w}. Only a single occurrence per argument is flagged by this |
| warning. @option{-fallow-argument-mismatch} is implied by |
| @option{-std=legacy}. |
| |
| Using this option is @emph{strongly} discouraged. It is possible to |
| provide standard-conforming code which allows different types of |
| arguments by using an explicit interface and @code{TYPE(*)}. |
| |
| @item -fallow-invalid-boz |
| @opindex @code{allow-invalid-boz} |
| A BOZ literal constant can occur in a limited number of contexts in |
| standard conforming Fortran. This option degrades an error condition |
| to a warning, and allows a BOZ literal constant to appear where the |
| Fortran standard would otherwise prohibit its use. |
| |
| @item -fd-lines-as-code |
| @itemx -fd-lines-as-comments |
| @opindex @code{fd-lines-as-code} |
| @opindex @code{fd-lines-as-comments} |
| Enable special treatment for lines beginning with @code{d} or @code{D} |
| in fixed form sources. If the @option{-fd-lines-as-code} option is |
| given they are treated as if the first column contained a blank. If the |
| @option{-fd-lines-as-comments} option is given, they are treated as |
| comment lines. |
| |
| @item -fdec |
| @opindex @code{fdec} |
| DEC compatibility mode. Enables extensions and other features that mimic |
| the default behavior of older compilers (such as DEC). |
| These features are non-standard and should be avoided at all costs. |
| For details on GNU Fortran's implementation of these extensions see the |
| full documentation. |
| |
| Other flags enabled by this switch are: |
| @option{-fdollar-ok} @option{-fcray-pointer} @option{-fdec-char-conversions} |
| @option{-fdec-structure} @option{-fdec-intrinsic-ints} @option{-fdec-static} |
| @option{-fdec-math} @option{-fdec-include} @option{-fdec-blank-format-item} |
| @option{-fdec-format-defaults} |
| |
| If @option{-fd-lines-as-code}/@option{-fd-lines-as-comments} are unset, then |
| @option{-fdec} also sets @option{-fd-lines-as-comments}. |
| |
| @item -fdec-char-conversions |
| @opindex @code{fdec-char-conversions} |
| Enable the use of character literals in assignments and @code{DATA} statements |
| for non-character variables. |
| |
| @item -fdec-structure |
| @opindex @code{fdec-structure} |
| Enable DEC @code{STRUCTURE} and @code{RECORD} as well as @code{UNION}, |
| @code{MAP}, and dot ('.') as a member separator (in addition to '%'). This is |
| provided for compatibility only; Fortran 90 derived types should be used |
| instead where possible. |
| |
| @item -fdec-intrinsic-ints |
| @opindex @code{fdec-intrinsic-ints} |
| Enable B/I/J/K kind variants of existing integer functions (e.g. BIAND, IIAND, |
| JIAND, etc...). For a complete list of intrinsics see the full documentation. |
| |
| @item -fdec-math |
| @opindex @code{fdec-math} |
| Enable legacy math intrinsics such as COTAN and degree-valued trigonometric |
| functions (e.g. TAND, ATAND, etc...) for compatability with older code. |
| |
| @item -fdec-static |
| @opindex @code{fdec-static} |
| Enable DEC-style STATIC and AUTOMATIC attributes to explicitly specify |
| the storage of variables and other objects. |
| |
| @item -fdec-include |
| @opindex @code{fdec-include} |
| Enable parsing of INCLUDE as a statement in addition to parsing it as |
| INCLUDE line. When parsed as INCLUDE statement, INCLUDE does not have to |
| be on a single line and can use line continuations. |
| |
| @item -fdec-format-defaults |
| @opindex @code{fdec-format-defaults} |
| Enable format specifiers F, G and I to be used without width specifiers, |
| default widths will be used instead. |
| |
| @item -fdec-blank-format-item |
| @opindex @code{fdec-blank-format-item} |
| Enable a blank format item at the end of a format specification i.e. nothing |
| following the final comma. |
| |
| @item -fdollar-ok |
| @opindex @code{fdollar-ok} |
| @cindex @code{$} |
| @cindex symbol names |
| @cindex character set |
| Allow @samp{$} as a valid non-first character in a symbol name. Symbols |
| that start with @samp{$} are rejected since it is unclear which rules to |
| apply to implicit typing as different vendors implement different rules. |
| Using @samp{$} in @code{IMPLICIT} statements is also rejected. |
| |
| @item -fbackslash |
| @opindex @code{backslash} |
| @cindex backslash |
| @cindex escape characters |
| Change the interpretation of backslashes in string literals from a single |
| backslash character to ``C-style'' escape characters. The following |
| combinations are expanded @code{\a}, @code{\b}, @code{\f}, @code{\n}, |
| @code{\r}, @code{\t}, @code{\v}, @code{\\}, and @code{\0} to the ASCII |
| characters alert, backspace, form feed, newline, carriage return, |
| horizontal tab, vertical tab, backslash, and NUL, respectively. |
| Additionally, @code{\x}@var{nn}, @code{\u}@var{nnnn} and |
| @code{\U}@var{nnnnnnnn} (where each @var{n} is a hexadecimal digit) are |
| translated into the Unicode characters corresponding to the specified code |
| points. All other combinations of a character preceded by \ are |
| unexpanded. |
| |
| @item -fmodule-private |
| @opindex @code{fmodule-private} |
| @cindex module entities |
| @cindex private |
| Set the default accessibility of module entities to @code{PRIVATE}. |
| Use-associated entities will not be accessible unless they are explicitly |
| declared as @code{PUBLIC}. |
| |
| @item -ffixed-line-length-@var{n} |
| @opindex @code{ffixed-line-length-}@var{n} |
| @cindex file format, fixed |
| Set column after which characters are ignored in typical fixed-form |
| lines in the source file, and, unless @code{-fno-pad-source}, through which |
| spaces are assumed (as if padded to that length) after the ends of short |
| fixed-form lines. |
| |
| Popular values for @var{n} include 72 (the |
| standard and the default), 80 (card image), and 132 (corresponding |
| to ``extended-source'' options in some popular compilers). |
| @var{n} may also be @samp{none}, meaning that the entire line is meaningful |
| and that continued character constants never have implicit spaces appended |
| to them to fill out the line. |
| @option{-ffixed-line-length-0} means the same thing as |
| @option{-ffixed-line-length-none}. |
| |
| @item -fno-pad-source |
| @opindex @code{fpad-source} |
| By default fixed-form lines have spaces assumed (as if padded to that length) |
| after the ends of short fixed-form lines. This is not done either if |
| @option{-ffixed-line-length-0}, @option{-ffixed-line-length-none} or |
| if @option{-fno-pad-source} option is used. With any of those options |
| continued character constants never have implicit spaces appended |
| to them to fill out the line. |
| |
| @item -ffree-line-length-@var{n} |
| @opindex @code{ffree-line-length-}@var{n} |
| @cindex file format, free |
| Set column after which characters are ignored in typical free-form |
| lines in the source file. The default value is 132. |
| @var{n} may be @samp{none}, meaning that the entire line is meaningful. |
| @option{-ffree-line-length-0} means the same thing as |
| @option{-ffree-line-length-none}. |
| |
| @item -fmax-identifier-length=@var{n} |
| @opindex @code{fmax-identifier-length=}@var{n} |
| Specify the maximum allowed identifier length. Typical values are |
| 31 (Fortran 95) and 63 (Fortran 2003 and later). |
| |
| @item -fimplicit-none |
| @opindex @code{fimplicit-none} |
| Specify that no implicit typing is allowed, unless overridden by explicit |
| @code{IMPLICIT} statements. This is the equivalent of adding |
| @code{implicit none} to the start of every procedure. |
| |
| @item -fcray-pointer |
| @opindex @code{fcray-pointer} |
| Enable the Cray pointer extension, which provides C-like pointer |
| functionality. |
| |
| @item -fopenacc |
| @opindex @code{fopenacc} |
| @cindex OpenACC |
| Enable the OpenACC extensions. This includes OpenACC @code{!$acc} |
| directives in free form and @code{c$acc}, @code{*$acc} and |
| @code{!$acc} directives in fixed form, @code{!$} conditional |
| compilation sentinels in free form and @code{c$}, @code{*$} and |
| @code{!$} sentinels in fixed form, and when linking arranges for the |
| OpenACC runtime library to be linked in. |
| |
| @item -fopenmp |
| @opindex @code{fopenmp} |
| @cindex OpenMP |
| Enable the OpenMP extensions. This includes OpenMP @code{!$omp} directives |
| in free form |
| and @code{c$omp}, @code{*$omp} and @code{!$omp} directives in fixed form, |
| @code{!$} conditional compilation sentinels in free form |
| and @code{c$}, @code{*$} and @code{!$} sentinels in fixed form, |
| and when linking arranges for the OpenMP runtime library to be linked |
| in. The option @option{-fopenmp} implies @option{-frecursive}. |
| |
| @item -fno-range-check |
| @opindex @code{frange-check} |
| Disable range checking on results of simplification of constant |
| expressions during compilation. For example, GNU Fortran will give |
| an error at compile time when simplifying @code{a = 1. / 0}. |
| With this option, no error will be given and @code{a} will be assigned |
| the value @code{+Infinity}. If an expression evaluates to a value |
| outside of the relevant range of [@code{-HUGE()}:@code{HUGE()}], |
| then the expression will be replaced by @code{-Inf} or @code{+Inf} |
| as appropriate. |
| Similarly, @code{DATA i/Z'FFFFFFFF'/} will result in an integer overflow |
| on most systems, but with @option{-fno-range-check} the value will |
| ``wrap around'' and @code{i} will be initialized to @math{-1} instead. |
| |
| @item -fdefault-integer-8 |
| @opindex @code{fdefault-integer-8} |
| Set the default integer and logical types to an 8 byte wide type. This option |
| also affects the kind of integer constants like @code{42}. Unlike |
| @option{-finteger-4-integer-8}, it does not promote variables with explicit |
| kind declaration. |
| |
| @item -fdefault-real-8 |
| @opindex @code{fdefault-real-8} |
| Set the default real type to an 8 byte wide type. This option also affects |
| the kind of non-double real constants like @code{1.0}. This option promotes |
| the default width of @code{DOUBLE PRECISION} and double real constants |
| like @code{1.d0} to 16 bytes if possible. If @code{-fdefault-double-8} |
| is given along with @code{fdefault-real-8}, @code{DOUBLE PRECISION} |
| and double real constants are not promoted. Unlike @option{-freal-4-real-8}, |
| @code{fdefault-real-8} does not promote variables with explicit kind |
| declarations. |
| |
| @item -fdefault-real-10 |
| @opindex @code{fdefault-real-10} |
| Set the default real type to an 10 byte wide type. This option also affects |
| the kind of non-double real constants like @code{1.0}. This option promotes |
| the default width of @code{DOUBLE PRECISION} and double real constants |
| like @code{1.d0} to 16 bytes if possible. If @code{-fdefault-double-8} |
| is given along with @code{fdefault-real-10}, @code{DOUBLE PRECISION} |
| and double real constants are not promoted. Unlike @option{-freal-4-real-10}, |
| @code{fdefault-real-10} does not promote variables with explicit kind |
| declarations. |
| |
| @item -fdefault-real-16 |
| @opindex @code{fdefault-real-16} |
| Set the default real type to an 16 byte wide type. This option also affects |
| the kind of non-double real constants like @code{1.0}. This option promotes |
| the default width of @code{DOUBLE PRECISION} and double real constants |
| like @code{1.d0} to 16 bytes if possible. If @code{-fdefault-double-8} |
| is given along with @code{fdefault-real-16}, @code{DOUBLE PRECISION} |
| and double real constants are not promoted. Unlike @option{-freal-4-real-16}, |
| @code{fdefault-real-16} does not promote variables with explicit kind |
| declarations. |
| |
| @item -fdefault-double-8 |
| @opindex @code{fdefault-double-8} |
| Set the @code{DOUBLE PRECISION} type and double real constants |
| like @code{1.d0} to an 8 byte wide type. Do nothing if this |
| is already the default. This option prevents @option{-fdefault-real-8}, |
| @option{-fdefault-real-10}, and @option{-fdefault-real-16}, |
| from promoting @code{DOUBLE PRECISION} and double real constants like |
| @code{1.d0} to 16 bytes. |
| |
| @item -finteger-4-integer-8 |
| @opindex @code{finteger-4-integer-8} |
| Promote all @code{INTEGER(KIND=4)} entities to an @code{INTEGER(KIND=8)} |
| entities. If @code{KIND=8} is unavailable, then an error will be issued. |
| This option should be used with care and may not be suitable for your codes. |
| Areas of possible concern include calls to external procedures, |
| alignment in @code{EQUIVALENCE} and/or @code{COMMON}, generic interfaces, |
| BOZ literal constant conversion, and I/O. Inspection of the intermediate |
| representation of the translated Fortran code, produced by |
| @option{-fdump-tree-original}, is suggested. |
| |
| @item -freal-4-real-8 |
| @itemx -freal-4-real-10 |
| @itemx -freal-4-real-16 |
| @itemx -freal-8-real-4 |
| @itemx -freal-8-real-10 |
| @itemx -freal-8-real-16 |
| @opindex @code{freal-4-real-8} |
| @opindex @code{freal-4-real-10} |
| @opindex @code{freal-4-real-16} |
| @opindex @code{freal-8-real-4} |
| @opindex @code{freal-8-real-10} |
| @opindex @code{freal-8-real-16} |
| @cindex options, real kind type promotion |
| Promote all @code{REAL(KIND=M)} entities to @code{REAL(KIND=N)} entities. |
| If @code{REAL(KIND=N)} is unavailable, then an error will be issued. |
| The @code{-freal-4-} flags also affect the default real kind and the |
| @code{-freal-8-} flags also the double-precision real kind. All other |
| real-kind types are unaffected by this option. The promotion is also |
| applied to real literal constants of default and double-precision kind |
| and a specified kind number of 4 or 8, respectively. |
| However, @code{-fdefault-real-8}, @code{-fdefault-real-10}, |
| @code{-fdefault-real-10}, and @code{-fdefault-double-8} take precedence |
| for the default and double-precision real kinds, both for real literal |
| constants and for declarations without a kind number. |
| Note that for @code{REAL(KIND=KIND(1.0))} the literal may get promoted and |
| then the result may get promoted again. |
| These options should be used with care and may not be suitable for your |
| codes. Areas of possible concern include calls to external procedures, |
| alignment in @code{EQUIVALENCE} and/or @code{COMMON}, generic interfaces, |
| BOZ literal constant conversion, and I/O and calls to intrinsic procedures |
| when passing a value to the @code{kind=} dummy argument. Inspection of the |
| intermediate representation of the translated Fortran code, produced by |
| @option{-fdump-fortran-original} or @option{-fdump-tree-original}, is suggested. |
| |
| @item -std=@var{std} |
| @opindex @code{std=}@var{std} option |
| Specify the standard to which the program is expected to conform, |
| which may be one of @samp{f95}, @samp{f2003}, @samp{f2008}, |
| @samp{f2018}, @samp{gnu}, or @samp{legacy}. The default value for |
| @var{std} is @samp{gnu}, which specifies a superset of the latest |
| Fortran standard that includes all of the extensions supported by GNU |
| Fortran, although warnings will be given for obsolete extensions not |
| recommended for use in new code. The @samp{legacy} value is |
| equivalent but without the warnings for obsolete extensions, and may |
| be useful for old non-standard programs. The @samp{f95}, |
| @samp{f2003}, @samp{f2008}, and @samp{f2018} values specify strict |
| conformance to the Fortran 95, Fortran 2003, Fortran 2008 and Fortran |
| 2018 standards, respectively; errors are given for all extensions |
| beyond the relevant language standard, and warnings are given for the |
| Fortran 77 features that are permitted but obsolescent in later |
| standards. The deprecated option @samp{-std=f2008ts} acts as an alias for |
| @samp{-std=f2018}. It is only present for backwards compatibility with |
| earlier gfortran versions and should not be used any more. |
| |
| @item -ftest-forall-temp |
| @opindex @code{ftest-forall-temp} |
| Enhance test coverage by forcing most forall assignments to use temporary. |
| |
| @end table |
| |
| @node Preprocessing Options |
| @section Enable and customize preprocessing |
| @cindex preprocessor |
| @cindex options, preprocessor |
| @cindex CPP |
| @cindex FPP |
| @cindex Conditional compilation |
| @cindex Preprocessing |
| @cindex preprocessor, include file handling |
| |
| Many Fortran compilers including GNU Fortran allow passing the source code |
| through a C preprocessor (CPP; sometimes also called the Fortran preprocessor, |
| FPP) to allow for conditional compilation. In the case of GNU Fortran, |
| this is the GNU C Preprocessor in the traditional mode. On systems with |
| case-preserving file names, the preprocessor is automatically invoked if the |
| filename extension is @file{.F}, @file{.FOR}, @file{.FTN}, @file{.fpp}, |
| @file{.FPP}, @file{.F90}, @file{.F95}, @file{.F03} or @file{.F08}. To manually |
| invoke the preprocessor on any file, use @option{-cpp}, to disable |
| preprocessing on files where the preprocessor is run automatically, use |
| @option{-nocpp}. |
| |
| If a preprocessed file includes another file with the Fortran @code{INCLUDE} |
| statement, the included file is not preprocessed. To preprocess included |
| files, use the equivalent preprocessor statement @code{#include}. |
| |
| If GNU Fortran invokes the preprocessor, @code{__GFORTRAN__} |
| is defined. The macros @code{__GNUC__}, @code{__GNUC_MINOR__} and |
| @code{__GNUC_PATCHLEVEL__} can be used to determine the version of the |
| compiler. See @ref{Top,,Overview,cpp,The C Preprocessor} for details. |
| |
| GNU Fortran supports a number of @code{INTEGER} and @code{REAL} kind types |
| in additional to the kind types required by the Fortran standard. |
| The availability of any given kind type is architecture dependent. The |
| following pre-defined preprocessor macros can be used to conditionally |
| include code for these additional kind types: @code{__GFC_INT_1__}, |
| @code{__GFC_INT_2__}, @code{__GFC_INT_8__}, @code{__GFC_INT_16__}, |
| @code{__GFC_REAL_10__}, and @code{__GFC_REAL_16__}. |
| |
| While CPP is the de-facto standard for preprocessing Fortran code, |
| Part 3 of the Fortran 95 standard (ISO/IEC 1539-3:1998) defines |
| Conditional Compilation, which is not widely used and not directly |
| supported by the GNU Fortran compiler. You can use the program coco |
| to preprocess such files (@uref{http://www.daniellnagle.com/coco.html}). |
| |
| The following options control preprocessing of Fortran code: |
| |
| @table @gcctabopt |
| @item -cpp |
| @itemx -nocpp |
| @opindex @code{cpp} |
| @opindex @code{fpp} |
| @cindex preprocessor, enable |
| @cindex preprocessor, disable |
| Enable preprocessing. The preprocessor is automatically invoked if |
| the file extension is @file{.fpp}, @file{.FPP}, @file{.F}, @file{.FOR}, |
| @file{.FTN}, @file{.F90}, @file{.F95}, @file{.F03} or @file{.F08}. Use |
| this option to manually enable preprocessing of any kind of Fortran file. |
| |
| To disable preprocessing of files with any of the above listed extensions, |
| use the negative form: @option{-nocpp}. |
| |
| The preprocessor is run in traditional mode. Any restrictions of the |
| file-format, especially the limits on line length, apply for |
| preprocessed output as well, so it might be advisable to use the |
| @option{-ffree-line-length-none} or @option{-ffixed-line-length-none} |
| options. |
| |
| @item -dM |
| @opindex @code{dM} |
| @cindex preprocessor, debugging |
| @cindex debugging, preprocessor |
| Instead of the normal output, generate a list of @code{'#define'} |
| directives for all the macros defined during the execution of the |
| preprocessor, including predefined macros. This gives you a way |
| of finding out what is predefined in your version of the preprocessor. |
| Assuming you have no file @file{foo.f90}, the command |
| @smallexample |
| touch foo.f90; gfortran -cpp -E -dM foo.f90 |
| @end smallexample |
| will show all the predefined macros. |
| |
| @item -dD |
| @opindex @code{dD} |
| @cindex preprocessor, debugging |
| @cindex debugging, preprocessor |
| Like @option{-dM} except in two respects: it does not include the |
| predefined macros, and it outputs both the @code{#define} directives |
| and the result of preprocessing. Both kinds of output go to the |
| standard output file. |
| |
| @item -dN |
| @opindex @code{dN} |
| @cindex preprocessor, debugging |
| @cindex debugging, preprocessor |
| Like @option{-dD}, but emit only the macro names, not their expansions. |
| |
| @item -dU |
| @opindex @code{dU} |
| @cindex preprocessor, debugging |
| @cindex debugging, preprocessor |
| Like @option{dD} except that only macros that are expanded, or whose |
| definedness is tested in preprocessor directives, are output; the |
| output is delayed until the use or test of the macro; and @code{'#undef'} |
| directives are also output for macros tested but undefined at the time. |
| |
| @item -dI |
| @opindex @code{dI} |
| @cindex preprocessor, debugging |
| @cindex debugging, preprocessor |
| Output @code{'#include'} directives in addition to the result |
| of preprocessing. |
| |
| @item -fworking-directory |
| @opindex @code{fworking-directory} |
| @cindex preprocessor, working directory |
| Enable generation of linemarkers in the preprocessor output that will |
| let the compiler know the current working directory at the time of |
| preprocessing. When this option is enabled, the preprocessor will emit, |
| after the initial linemarker, a second linemarker with the current |
| working directory followed by two slashes. GCC will use this directory, |
| when it is present in the preprocessed input, as the directory emitted |
| as the current working directory in some debugging information formats. |
| This option is implicitly enabled if debugging information is enabled, |
| but this can be inhibited with the negated form |
| @option{-fno-working-directory}. If the @option{-P} flag is present |
| in the command line, this option has no effect, since no @code{#line} |
| directives are emitted whatsoever. |
| |
| @item -idirafter @var{dir} |
| @opindex @code{idirafter @var{dir}} |
| @cindex preprocessing, include path |
| Search @var{dir} for include files, but do it after all directories |
| specified with @option{-I} and the standard system directories have |
| been exhausted. @var{dir} is treated as a system include directory. |
| If dir begins with @code{=}, then the @code{=} will be replaced by |
| the sysroot prefix; see @option{--sysroot} and @option{-isysroot}. |
| |
| @item -imultilib @var{dir} |
| @opindex @code{imultilib @var{dir}} |
| @cindex preprocessing, include path |
| Use @var{dir} as a subdirectory of the directory containing target-specific |
| C++ headers. |
| |
| @item -iprefix @var{prefix} |
| @opindex @code{iprefix @var{prefix}} |
| @cindex preprocessing, include path |
| Specify @var{prefix} as the prefix for subsequent @option{-iwithprefix} |
| options. If the @var{prefix} represents a directory, you should include |
| the final @code{'/'}. |
| |
| @item -isysroot @var{dir} |
| @opindex @code{isysroot @var{dir}} |
| @cindex preprocessing, include path |
| This option is like the @option{--sysroot} option, but applies only to |
| header files. See the @option{--sysroot} option for more information. |
| |
| @item -iquote @var{dir} |
| @opindex @code{iquote @var{dir}} |
| @cindex preprocessing, include path |
| Search @var{dir} only for header files requested with @code{#include "file"}; |
| they are not searched for @code{#include <file>}, before all directories |
| specified by @option{-I} and before the standard system directories. If |
| @var{dir} begins with @code{=}, then the @code{=} will be replaced by the |
| sysroot prefix; see @option{--sysroot} and @option{-isysroot}. |
| |
| @item -isystem @var{dir} |
| @opindex @code{isystem @var{dir}} |
| @cindex preprocessing, include path |
| Search @var{dir} for header files, after all directories specified by |
| @option{-I} but before the standard system directories. Mark it as a |
| system directory, so that it gets the same special treatment as is |
| applied to the standard system directories. If @var{dir} begins with |
| @code{=}, then the @code{=} will be replaced by the sysroot prefix; |
| see @option{--sysroot} and @option{-isysroot}. |
| |
| @item -nostdinc |
| @opindex @code{nostdinc} |
| Do not search the standard system directories for header files. Only |
| the directories you have specified with @option{-I} options (and the |
| directory of the current file, if appropriate) are searched. |
| |
| @item -undef |
| @opindex @code{undef} |
| Do not predefine any system-specific or GCC-specific macros. |
| The standard predefined macros remain defined. |
| |
| @item -A@var{predicate}=@var{answer} |
| @opindex @code{A@var{predicate}=@var{answer}} |
| @cindex preprocessing, assertion |
| Make an assertion with the predicate @var{predicate} and answer @var{answer}. |
| This form is preferred to the older form -A predicate(answer), which is still |
| supported, because it does not use shell special characters. |
| |
| @item -A-@var{predicate}=@var{answer} |
| @opindex @code{A-@var{predicate}=@var{answer}} |
| @cindex preprocessing, assertion |
| Cancel an assertion with the predicate @var{predicate} and answer @var{answer}. |
| |
| @item -C |
| @opindex @code{C} |
| @cindex preprocessing, keep comments |
| Do not discard comments. All comments are passed through to the output |
| file, except for comments in processed directives, which are deleted |
| along with the directive. |
| |
| You should be prepared for side effects when using @option{-C}; it causes |
| the preprocessor to treat comments as tokens in their own right. For example, |
| comments appearing at the start of what would be a directive line have the |
| effect of turning that line into an ordinary source line, since the first |
| token on the line is no longer a @code{'#'}. |
| |
| Warning: this currently handles C-Style comments only. The preprocessor |
| does not yet recognize Fortran-style comments. |
| |
| @item -CC |
| @opindex @code{CC} |
| @cindex preprocessing, keep comments |
| Do not discard comments, including during macro expansion. This is like |
| @option{-C}, except that comments contained within macros are also passed |
| through to the output file where the macro is expanded. |
| |
| In addition to the side-effects of the @option{-C} option, the @option{-CC} |
| option causes all C++-style comments inside a macro to be converted to C-style |
| comments. This is to prevent later use of that macro from inadvertently |
| commenting out the remainder of the source line. The @option{-CC} option |
| is generally used to support lint comments. |
| |
| Warning: this currently handles C- and C++-Style comments only. The |
| preprocessor does not yet recognize Fortran-style comments. |
| |
| @item -D@var{name} |
| @opindex @code{D@var{name}} |
| @cindex preprocessing, define macros |
| Predefine name as a macro, with definition @code{1}. |
| |
| @item -D@var{name}=@var{definition} |
| @opindex @code{D@var{name}=@var{definition}} |
| @cindex preprocessing, define macros |
| The contents of @var{definition} are tokenized and processed as if they |
| appeared during translation phase three in a @code{'#define'} directive. |
| In particular, the definition will be truncated by embedded newline |
| characters. |
| |
| If you are invoking the preprocessor from a shell or shell-like program |
| you may need to use the shell's quoting syntax to protect characters such |
| as spaces that have a meaning in the shell syntax. |
| |
| If you wish to define a function-like macro on the command line, write |
| its argument list with surrounding parentheses before the equals sign |
| (if any). Parentheses are meaningful to most shells, so you will need |
| to quote the option. With sh and csh, @code{-D'name(args...)=definition'} |
| works. |
| |
| @option{-D} and @option{-U} options are processed in the order they are |
| given on the command line. All -imacros file and -include file options |
| are processed after all -D and -U options. |
| |
| @item -H |
| @opindex @code{H} |
| Print the name of each header file used, in addition to other normal |
| activities. Each name is indented to show how deep in the @code{'#include'} |
| stack it is. |
| |
| @item -P |
| @opindex @code{P} |
| @cindex preprocessing, no linemarkers |
| Inhibit generation of linemarkers in the output from the preprocessor. |
| This might be useful when running the preprocessor on something that |
| is not C code, and will be sent to a program which might be confused |
| by the linemarkers. |
| |
| @item -U@var{name} |
| @opindex @code{U@var{name}} |
| @cindex preprocessing, undefine macros |
| Cancel any previous definition of @var{name}, either built in or provided |
| with a @option{-D} option. |
| @end table |
| |
| |
| @node Error and Warning Options |
| @section Options to request or suppress errors and warnings |
| @cindex options, warnings |
| @cindex options, errors |
| @cindex warnings, suppressing |
| @cindex messages, error |
| @cindex messages, warning |
| @cindex suppressing warnings |
| |
| Errors are diagnostic messages that report that the GNU Fortran compiler |
| cannot compile the relevant piece of source code. The compiler will |
| continue to process the program in an attempt to report further errors |
| to aid in debugging, but will not produce any compiled output. |
| |
| Warnings are diagnostic messages that report constructions which |
| are not inherently erroneous but which are risky or suggest there is |
| likely to be a bug in the program. Unless @option{-Werror} is specified, |
| they do not prevent compilation of the program. |
| |
| You can request many specific warnings with options beginning @option{-W}, |
| for example @option{-Wimplicit} to request warnings on implicit |
| declarations. Each of these specific warning options also has a |
| negative form beginning @option{-Wno-} to turn off warnings; |
| for example, @option{-Wno-implicit}. This manual lists only one of the |
| two forms, whichever is not the default. |
| |
| These options control the amount and kinds of errors and warnings produced |
| by GNU Fortran: |
| |
| @table @gcctabopt |
| @item -fmax-errors=@var{n} |
| @opindex @code{fmax-errors=}@var{n} |
| @cindex errors, limiting |
| Limits the maximum number of error messages to @var{n}, at which point |
| GNU Fortran bails out rather than attempting to continue processing the |
| source code. If @var{n} is 0, there is no limit on the number of error |
| messages produced. |
| |
| @item -fsyntax-only |
| @opindex @code{fsyntax-only} |
| @cindex syntax checking |
| Check the code for syntax errors, but do not actually compile it. This |
| will generate module files for each module present in the code, but no |
| other output file. |
| |
| @item -Wpedantic |
| @itemx -pedantic |
| @opindex @code{pedantic} |
| @opindex @code{Wpedantic} |
| Issue warnings for uses of extensions to Fortran. |
| @option{-pedantic} also applies to C-language constructs where they |
| occur in GNU Fortran source files, such as use of @samp{\e} in a |
| character constant within a directive like @code{#include}. |
| |
| Valid Fortran programs should compile properly with or without |
| this option. |
| However, without this option, certain GNU extensions and traditional |
| Fortran features are supported as well. |
| With this option, many of them are rejected. |
| |
| Some users try to use @option{-pedantic} to check programs for conformance. |
| They soon find that it does not do quite what they want---it finds some |
| nonstandard practices, but not all. |
| However, improvements to GNU Fortran in this area are welcome. |
| |
| This should be used in conjunction with @option{-std=f95}, |
| @option{-std=f2003}, @option{-std=f2008} or @option{-std=f2018}. |
| |
| @item -pedantic-errors |
| @opindex @code{pedantic-errors} |
| Like @option{-pedantic}, except that errors are produced rather than |
| warnings. |
| |
| @item -Wall |
| @opindex @code{Wall} |
| @cindex all warnings |
| @cindex warnings, all |
| Enables commonly used warning options pertaining to usage that |
| we recommend avoiding and that we believe are easy to avoid. |
| This currently includes @option{-Waliasing}, @option{-Wampersand}, |
| @option{-Wconversion}, @option{-Wsurprising}, @option{-Wc-binding-type}, |
| @option{-Wintrinsics-std}, @option{-Wtabs}, @option{-Wintrinsic-shadow}, |
| @option{-Wline-truncation}, @option{-Wtarget-lifetime}, |
| @option{-Winteger-division}, @option{-Wreal-q-constant}, @option{-Wunused} |
| and @option{-Wundefined-do-loop}. |
| |
| @item -Waliasing |
| @opindex @code{Waliasing} |
| @cindex aliasing |
| @cindex warnings, aliasing |
| Warn about possible aliasing of dummy arguments. Specifically, it warns |
| if the same actual argument is associated with a dummy argument with |
| @code{INTENT(IN)} and a dummy argument with @code{INTENT(OUT)} in a call |
| with an explicit interface. |
| |
| The following example will trigger the warning. |
| @smallexample |
| interface |
| subroutine bar(a,b) |
| integer, intent(in) :: a |
| integer, intent(out) :: b |
| end subroutine |
| end interface |
| integer :: a |
| |
| call bar(a,a) |
| @end smallexample |
| |
| @item -Wampersand |
| @opindex @code{Wampersand} |
| @cindex warnings, ampersand |
| @cindex @code{&} |
| Warn about missing ampersand in continued character constants. The |
| warning is given with @option{-Wampersand}, @option{-pedantic}, |
| @option{-std=f95}, @option{-std=f2003}, @option{-std=f2008} and |
| @option{-std=f2018}. Note: With no ampersand given in a continued |
| character constant, GNU Fortran assumes continuation at the first |
| non-comment, non-whitespace character after the ampersand that |
| initiated the continuation. |
| |
| @item -Warray-temporaries |
| @opindex @code{Warray-temporaries} |
| @cindex warnings, array temporaries |
| Warn about array temporaries generated by the compiler. The information |
| generated by this warning is sometimes useful in optimization, in order to |
| avoid such temporaries. |
| |
| @item -Wc-binding-type |
| @opindex @code{Wc-binding-type} |
| @cindex warning, C binding type |
| Warn if the a variable might not be C interoperable. In particular, warn if |
| the variable has been declared using an intrinsic type with default kind |
| instead of using a kind parameter defined for C interoperability in the |
| intrinsic @code{ISO_C_Binding} module. This option is implied by |
| @option{-Wall}. |
| |
| @item -Wcharacter-truncation |
| @opindex @code{Wcharacter-truncation} |
| @cindex warnings, character truncation |
| Warn when a character assignment will truncate the assigned string. |
| |
| @item -Wline-truncation |
| @opindex @code{Wline-truncation} |
| @cindex warnings, line truncation |
| Warn when a source code line will be truncated. This option is |
| implied by @option{-Wall}. For free-form source code, the default is |
| @option{-Werror=line-truncation} such that truncations are reported as |
| error. |
| |
| @item -Wconversion |
| @opindex @code{Wconversion} |
| @cindex warnings, conversion |
| @cindex conversion |
| Warn about implicit conversions that are likely to change the value of |
| the expression after conversion. Implied by @option{-Wall}. |
| |
| @item -Wconversion-extra |
| @opindex @code{Wconversion-extra} |
| @cindex warnings, conversion |
| @cindex conversion |
| Warn about implicit conversions between different types and kinds. This |
| option does @emph{not} imply @option{-Wconversion}. |
| |
| @item -Wextra |
| @opindex @code{Wextra} |
| @cindex extra warnings |
| @cindex warnings, extra |
| Enables some warning options for usages of language features which |
| may be problematic. This currently includes @option{-Wcompare-reals}, |
| @option{-Wunused-parameter} and @option{-Wdo-subscript}. |
| |
| @item -Wfrontend-loop-interchange |
| @opindex @code{Wfrontend-loop-interchange} |
| @cindex warnings, loop interchange |
| @cindex loop interchange, warning |
| Warn when using @option{-ffrontend-loop-interchange} for performing loop |
| interchanges. |
| |
| @item -Wimplicit-interface |
| @opindex @code{Wimplicit-interface} |
| @cindex warnings, implicit interface |
| Warn if a procedure is called without an explicit interface. |
| Note this only checks that an explicit interface is present. It does not |
| check that the declared interfaces are consistent across program units. |
| |
| @item -Wimplicit-procedure |
| @opindex @code{Wimplicit-procedure} |
| @cindex warnings, implicit procedure |
| Warn if a procedure is called that has neither an explicit interface |
| nor has been declared as @code{EXTERNAL}. |
| |
| @item -Winteger-division |
| @opindex @code{Winteger-division} |
| @cindex warnings, integer division |
| @cindex warnings, division of integers |
| Warn if a constant integer division truncates its result. |
| As an example, 3/5 evaluates to 0. |
| |
| @item -Wintrinsics-std |
| @opindex @code{Wintrinsics-std} |
| @cindex warnings, non-standard intrinsics |
| @cindex warnings, intrinsics of other standards |
| Warn if @command{gfortran} finds a procedure named like an intrinsic not |
| available in the currently selected standard (with @option{-std}) and treats |
| it as @code{EXTERNAL} procedure because of this. @option{-fall-intrinsics} can |
| be used to never trigger this behavior and always link to the intrinsic |
| regardless of the selected standard. |
| |
| @item -Wno-overwrite-recursive |
| @opindex @code{Woverwrite-recursive} |
| @cindex warnings, overwrite recursive |
| Do not warn when @option{-fno-automatic} is used with @option{-frecursive}. Recursion |
| will be broken if the relevant local variables do not have the attribute |
| @code{AUTOMATIC} explicitly declared. This option can be used to suppress the warning |
| when it is known that recursion is not broken. Useful for build environments that use |
| @option{-Werror}. |
| |
| @item -Wreal-q-constant |
| @opindex @code{Wreal-q-constant} |
| @cindex warnings, @code{q} exponent-letter |
| Produce a warning if a real-literal-constant contains a @code{q} |
| exponent-letter. |
| |
| @item -Wsurprising |
| @opindex @code{Wsurprising} |
| @cindex warnings, suspicious code |
| Produce a warning when ``suspicious'' code constructs are encountered. |
| While technically legal these usually indicate that an error has been made. |
| |
| This currently produces a warning under the following circumstances: |
| |
| @itemize @bullet |
| @item |
| An INTEGER SELECT construct has a CASE that can never be matched as its |
| lower value is greater than its upper value. |
| |
| @item |
| A LOGICAL SELECT construct has three CASE statements. |
| |
| @item |
| A TRANSFER specifies a source that is shorter than the destination. |
| |
| @item |
| The type of a function result is declared more than once with the same type. If |
| @option{-pedantic} or standard-conforming mode is enabled, this is an error. |
| |
| @item |
| A @code{CHARACTER} variable is declared with negative length. |
| @end itemize |
| |
| @item -Wtabs |
| @opindex @code{Wtabs} |
| @cindex warnings, tabs |
| @cindex tabulators |
| By default, tabs are accepted as whitespace, but tabs are not members |
| of the Fortran Character Set. For continuation lines, a tab followed |
| by a digit between 1 and 9 is supported. @option{-Wtabs} will cause a |
| warning to be issued if a tab is encountered. Note, @option{-Wtabs} is |
| active for @option{-pedantic}, @option{-std=f95}, @option{-std=f2003}, |
| @option{-std=f2008}, @option{-std=f2018} and |
| @option{-Wall}. |
| |
| @item -Wundefined-do-loop |
| @opindex @code{Wundefined-do-loop} |
| @cindex warnings, undefined do loop |
| Warn if a DO loop with step either 1 or -1 yields an underflow or an overflow |
| during iteration of an induction variable of the loop. |
| This option is implied by @option{-Wall}. |
| |
| @item -Wunderflow |
| @opindex @code{Wunderflow} |
| @cindex warnings, underflow |
| @cindex underflow |
| Produce a warning when numerical constant expressions are |
| encountered, which yield an UNDERFLOW during compilation. Enabled by default. |
| |
| @item -Wintrinsic-shadow |
| @opindex @code{Wintrinsic-shadow} |
| @cindex warnings, intrinsic |
| @cindex intrinsic |
| Warn if a user-defined procedure or module procedure has the same name as an |
| intrinsic; in this case, an explicit interface or @code{EXTERNAL} or |
| @code{INTRINSIC} declaration might be needed to get calls later resolved to |
| the desired intrinsic/procedure. This option is implied by @option{-Wall}. |
| |
| @item -Wuse-without-only |
| @opindex @code{Wuse-without-only} |
| @cindex warnings, use statements |
| @cindex intrinsic |
| Warn if a @code{USE} statement has no @code{ONLY} qualifier and |
| thus implicitly imports all public entities of the used module. |
| |
| @item -Wunused-dummy-argument |
| @opindex @code{Wunused-dummy-argument} |
| @cindex warnings, unused dummy argument |
| @cindex unused dummy argument |
| @cindex dummy argument, unused |
| Warn about unused dummy arguments. This option is implied by @option{-Wall}. |
| |
| @item -Wunused-parameter |
| @opindex @code{Wunused-parameter} |
| @cindex warnings, unused parameter |
| @cindex unused parameter |
| Contrary to @command{gcc}'s meaning of @option{-Wunused-parameter}, |
| @command{gfortran}'s implementation of this option does not warn |
| about unused dummy arguments (see @option{-Wunused-dummy-argument}), |
| but about unused @code{PARAMETER} values. @option{-Wunused-parameter} |
| is implied by @option{-Wextra} if also @option{-Wunused} or |
| @option{-Wall} is used. |
| |
| @item -Walign-commons |
| @opindex @code{Walign-commons} |
| @cindex warnings, alignment of @code{COMMON} blocks |
| @cindex alignment of @code{COMMON} blocks |
| By default, @command{gfortran} warns about any occasion of variables being |
| padded for proper alignment inside a @code{COMMON} block. This warning can be turned |
| off via @option{-Wno-align-commons}. See also @option{-falign-commons}. |
| |
| @item -Wfunction-elimination |
| @opindex @code{Wfunction-elimination} |
| @cindex function elimination |
| @cindex warnings, function elimination |
| Warn if any calls to impure functions are eliminated by the optimizations |
| enabled by the @option{-ffrontend-optimize} option. |
| This option is implied by @option{-Wextra}. |
| |
| @item -Wrealloc-lhs |
| @opindex @code{Wrealloc-lhs} |
| @cindex Reallocate the LHS in assignments, notification |
| Warn when the compiler might insert code to for allocation or reallocation of |
| an allocatable array variable of intrinsic type in intrinsic assignments. In |
| hot loops, the Fortran 2003 reallocation feature may reduce the performance. |
| If the array is already allocated with the correct shape, consider using a |
| whole-array array-spec (e.g. @code{(:,:,:)}) for the variable on the left-hand |
| side to prevent the reallocation check. Note that in some cases the warning |
| is shown, even if the compiler will optimize reallocation checks away. For |
| instance, when the right-hand side contains the same variable multiplied by |
| a scalar. See also @option{-frealloc-lhs}. |
| |
| @item -Wrealloc-lhs-all |
| @opindex @code{Wrealloc-lhs-all} |
| Warn when the compiler inserts code to for allocation or reallocation of an |
| allocatable variable; this includes scalars and derived types. |
| |
| @item -Wcompare-reals |
| @opindex @code{Wcompare-reals} |
| Warn when comparing real or complex types for equality or inequality. |
| This option is implied by @option{-Wextra}. |
| |
| @item -Wtarget-lifetime |
| @opindex @code{Wtargt-lifetime} |
| Warn if the pointer in a pointer assignment might be longer than the its |
| target. This option is implied by @option{-Wall}. |
| |
| @item -Wzerotrip |
| @opindex @code{Wzerotrip} |
| Warn if a @code{DO} loop is known to execute zero times at compile |
| time. This option is implied by @option{-Wall}. |
| |
| @item -Wdo-subscript |
| @opindex @code{Wdo-subscript} |
| Warn if an array subscript inside a DO loop could lead to an |
| out-of-bounds access even if the compiler cannot prove that the |
| statement is actually executed, in cases like |
| @smallexample |
| real a(3) |
| do i=1,4 |
| if (condition(i)) then |
| a(i) = 1.2 |
| end if |
| end do |
| @end smallexample |
| This option is implied by @option{-Wextra}. |
| |
| @item -Werror |
| @opindex @code{Werror} |
| @cindex warnings, to errors |
| Turns all warnings into errors. |
| @end table |
| |
| @xref{Warning Options,,Options to Request or Suppress Errors and |
| Warnings, gcc,Using the GNU Compiler Collection (GCC)}, for information on |
| 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. |
| |
| @node Debugging Options |
| @section Options for debugging your program or GNU Fortran |
| @cindex options, debugging |
| @cindex debugging information options |
| |
| GNU Fortran has various special options that are used for debugging |
| either your program or the GNU Fortran compiler. |
| |
| @table @gcctabopt |
| @item -fdump-fortran-original |
| @opindex @code{fdump-fortran-original} |
| Output the internal parse tree after translating the source program |
| into internal representation. This option is mostly useful for |
| debugging the GNU Fortran compiler itself. The output generated by |
| this option might change between releases. This option may also |
| generate internal compiler errors for features which have only |
| recently been added. |
| |
| @item -fdump-fortran-optimized |
| @opindex @code{fdump-fortran-optimized} |
| Output the parse tree after front-end optimization. Mostly useful for |
| debugging the GNU Fortran compiler itself. The output generated by |
| this option might change between releases. This option may also |
| generate internal compiler errors for features which have only |
| recently been added. |
| |
| @item -fdump-parse-tree |
| @opindex @code{fdump-parse-tree} |
| Output the internal parse tree after translating the source program |
| into internal representation. Mostly useful for debugging the GNU |
| Fortran compiler itself. The output generated by this option might |
| change between releases. This option may also generate internal |
| compiler errors for features which have only recently been added. This |
| option is deprecated; use @code{-fdump-fortran-original} instead. |
| |
| @item -fdebug-aux-vars |
| @opindex @code{fdebug-aux-vars} |
| Renames internal variables created by the gfortran front end and makes |
| them accessible to a debugger. The name of the internal variables then |
| start with upper-case letters followed by an underscore. This option is |
| useful for debugging the compiler's code generation together with |
| @code{-fdump-tree-original} and enabling debugging of the executable |
| program by using @code{-g} or @code{-ggdb3}. |
| |
| @item -fdump-fortran-global |
| @opindex @code{fdump-fortran-global} |
| Output a list of the global identifiers after translating into |
| middle-end representation. Mostly useful for debugging the GNU Fortran |
| compiler itself. The output generated by this option might change |
| between releases. This option may also generate internal compiler |
| errors for features which have only recently been added. |
| |
| @item -ffpe-trap=@var{list} |
| @opindex @code{ffpe-trap=}@var{list} |
| Specify a list of floating point exception traps to enable. On most |
| systems, if a floating point exception occurs and the trap for that |
| exception is enabled, a SIGFPE signal will be sent and the program |
| being aborted, producing a core file useful for debugging. @var{list} |
| is a (possibly empty) comma-separated list of the following |
| exceptions: @samp{invalid} (invalid floating point operation, such as |
| @code{SQRT(-1.0)}), @samp{zero} (division by zero), @samp{overflow} |
| (overflow in a floating point operation), @samp{underflow} (underflow |
| in a floating point operation), @samp{inexact} (loss of precision |
| during operation), and @samp{denormal} (operation performed on a |
| denormal value). The first five exceptions correspond to the five |
| IEEE 754 exceptions, whereas the last one (@samp{denormal}) is not |
| part of the IEEE 754 standard but is available on some common |
| architectures such as x86. |
| |
| The first three exceptions (@samp{invalid}, @samp{zero}, and |
| @samp{overflow}) often indicate serious errors, and unless the program |
| has provisions for dealing with these exceptions, enabling traps for |
| these three exceptions is probably a good idea. |
| |
| If the option is used more than once in the command line, the lists will |
| be joined: '@code{ffpe-trap=}@var{list1} @code{ffpe-trap=}@var{list2}' |
| is equivalent to @code{ffpe-trap=}@var{list1},@var{list2}. |
| |
| Note that once enabled an exception cannot be disabled (no negative form). |
| |
| Many, if not most, floating point operations incur loss of precision |
| due to rounding, and hence the @code{ffpe-trap=inexact} is likely to |
| be uninteresting in practice. |
| |
| By default no exception traps are enabled. |
| |
| @item -ffpe-summary=@var{list} |
| @opindex @code{ffpe-summary=}@var{list} |
| Specify a list of floating-point exceptions, whose flag status is printed |
| to @code{ERROR_UNIT} when invoking @code{STOP} and @code{ERROR STOP}. |
| @var{list} can be either @samp{none}, @samp{all} or a comma-separated list |
| of the following exceptions: @samp{invalid}, @samp{zero}, @samp{overflow}, |
| @samp{underflow}, @samp{inexact} and @samp{denormal}. (See |
| @option{-ffpe-trap} for a description of the exceptions.) |
| |
| If the option is used more than once in the command line, only the |
| last one will be used. |
| |
| By default, a summary for all exceptions but @samp{inexact} is shown. |
| |
| @item -fno-backtrace |
| @opindex @code{fno-backtrace} |
| @cindex backtrace |
| @cindex trace |
| When a serious runtime error is encountered or a deadly signal is |
| emitted (segmentation fault, illegal instruction, bus error, |
| floating-point exception, and the other POSIX signals that have the |
| action @samp{core}), the Fortran runtime library tries to output a |
| backtrace of the error. @code{-fno-backtrace} disables the backtrace |
| generation. This option only has influence for compilation of the |
| Fortran main program. |
| |
| @end table |
| |
| @xref{Debugging Options,,Options for Debugging Your Program or GCC, |
| gcc,Using the GNU Compiler Collection (GCC)}, for more information on |
| debugging options. |
| |
| @node Directory Options |
| @section Options for directory search |
| @cindex directory, options |
| @cindex options, directory search |
| @cindex search path |
| @cindex @code{INCLUDE} directive |
| @cindex directive, @code{INCLUDE} |
| These options affect how GNU Fortran searches |
| for files specified by the @code{INCLUDE} directive and where it searches |
| for previously compiled modules. |
| |
| It also affects the search paths used by @command{cpp} when used to preprocess |
| Fortran source. |
| |
| @table @gcctabopt |
| @item -I@var{dir} |
| @opindex @code{I}@var{dir} |
| @cindex directory, search paths for inclusion |
| @cindex inclusion, directory search paths for |
| @cindex search paths, for included files |
| @cindex paths, search |
| @cindex module search path |
| These affect interpretation of the @code{INCLUDE} directive |
| (as well as of the @code{#include} directive of the @command{cpp} |
| preprocessor). |
| |
| Also note that the general behavior of @option{-I} and |
| @code{INCLUDE} is pretty much the same as of @option{-I} with |
| @code{#include} in the @command{cpp} preprocessor, with regard to |
| looking for @file{header.gcc} files and other such things. |
| |
| This path is also used to search for @file{.mod} files when previously |
| compiled modules are required by a @code{USE} statement. |
| |
| @xref{Directory Options,,Options for Directory Search, |
| gcc,Using the GNU Compiler Collection (GCC)}, for information on the |
| @option{-I} option. |
| |
| @item -J@var{dir} |
| @opindex @code{J}@var{dir} |
| @opindex @code{M}@var{dir} |
| @cindex paths, search |
| @cindex module search path |
| This option specifies where to put @file{.mod} files for compiled modules. |
| It is also added to the list of directories to searched by an @code{USE} |
| statement. |
| |
| The default is the current directory. |
| |
| @item -fintrinsic-modules-path @var{dir} |
| @opindex @code{fintrinsic-modules-path} @var{dir} |
| @cindex paths, search |
| @cindex module search path |
| This option specifies the location of pre-compiled intrinsic modules, if |
| they are not in the default location expected by the compiler. |
| @end table |
| |
| @node Link Options |
| @section Influencing the linking step |
| @cindex options, linking |
| @cindex linking, static |
| |
| These options come into play when the compiler links object files into an |
| executable output file. They are meaningless if the compiler is not doing |
| a link step. |
| |
| @table @gcctabopt |
| @item -static-libgfortran |
| @opindex @code{static-libgfortran} |
| On systems that provide @file{libgfortran} as a shared and a static |
| library, this option forces the use of the static version. If no |
| shared version of @file{libgfortran} was built when the compiler was |
| configured, this option has no effect. |
| @end table |
| |
| |
| @node Runtime Options |
| @section Influencing runtime behavior |
| @cindex options, runtime |
| |
| These options affect the runtime behavior of programs compiled with GNU Fortran. |
| |
| @table @gcctabopt |
| @item -fconvert=@var{conversion} |
| @opindex @code{fconvert=}@var{conversion} |
| Specify the representation of data for unformatted files. Valid |
| values for conversion are: @samp{native}, the default; @samp{swap}, |
| swap between big- and little-endian; @samp{big-endian}, use big-endian |
| representation for unformatted files; @samp{little-endian}, use little-endian |
| representation for unformatted files. |
| |
| @emph{This option has an effect only when used in the main program. |
| The @code{CONVERT} specifier and the GFORTRAN_CONVERT_UNIT environment |
| variable override the default specified by @option{-fconvert}.} |
| |
| @item -frecord-marker=@var{length} |
| @opindex @code{frecord-marker=}@var{length} |
| Specify the length of record markers for unformatted files. |
| Valid values for @var{length} are 4 and 8. Default is 4. |
| @emph{This is different from previous versions of @command{gfortran}}, |
| which specified a default record marker length of 8 on most |
| systems. If you want to read or write files compatible |
| with earlier versions of @command{gfortran}, use @option{-frecord-marker=8}. |
| |
| @item -fmax-subrecord-length=@var{length} |
| @opindex @code{fmax-subrecord-length=}@var{length} |
| Specify the maximum length for a subrecord. The maximum permitted |
| value for length is 2147483639, which is also the default. Only |
| really useful for use by the gfortran testsuite. |
| |
| @item -fsign-zero |
| @opindex @code{fsign-zero} |
| When enabled, floating point numbers of value zero with the sign bit set |
| are written as negative number in formatted output and treated as |
| negative in the @code{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 @code{SIGN} intrinsic for |
| compatibility with Fortran 77. The default is @option{-fsign-zero}. |
| @end table |
| |
| @node Code Gen Options |
| @section Options for code generation conventions |
| @cindex code generation, conventions |
| @cindex options, code generation |
| @cindex options, run-time |
| |
| These machine-independent options control the interface conventions |
| used in code generation. |
| |
| Most of them have both positive and negative forms; the negative form |
| of @option{-ffoo} would be @option{-fno-foo}. In the table below, only |
| one of the forms is listed---the one which is not the default. You |
| can figure out the other form by either removing @option{no-} or adding |
| it. |
| |
| @table @gcctabopt |
| @item -fno-automatic |
| @opindex @code{fno-automatic} |
| @cindex @code{SAVE} statement |
| @cindex statement, @code{SAVE} |
| Treat each program unit (except those marked as RECURSIVE) as if the |
| @code{SAVE} statement were specified for every local variable and array |
| referenced in it. Does not affect common blocks. (Some Fortran compilers |
| provide this option under the name @option{-static} or @option{-save}.) |
| The default, which is @option{-fautomatic}, uses the stack for local |
| variables smaller than the value given by @option{-fmax-stack-var-size}. |
| Use the option @option{-frecursive} to use no static memory. |
| |
| Local variables or arrays having an explicit @code{SAVE} attribute are |
| silently ignored unless the @option{-pedantic} option is added. |
| |
| @item -ff2c |
| @opindex ff2c |
| @cindex calling convention |
| @cindex @command{f2c} calling convention |
| @cindex @command{g77} calling convention |
| @cindex libf2c calling convention |
| Generate code designed to be compatible with code generated |
| by @command{g77} and @command{f2c}. |
| |
| The calling conventions used by @command{g77} (originally implemented |
| in @command{f2c}) require functions that return type |
| default @code{REAL} to actually return the C type @code{double}, and |
| functions that return type @code{COMPLEX} to return the values via an |
| extra argument in the calling sequence that points to where to |
| store the return value. Under the default GNU calling conventions, such |
| functions simply return their results as they would in GNU |
| C---default @code{REAL} functions return the C type @code{float}, and |
| @code{COMPLEX} functions return the GNU C type @code{complex}. |
| Additionally, this option implies the @option{-fsecond-underscore} |
| option, unless @option{-fno-second-underscore} is explicitly requested. |
| |
| This does not affect the generation of code that interfaces with |
| the @command{libgfortran} library. |
| |
| @emph{Caution:} It is not a good idea to mix Fortran code compiled with |
| @option{-ff2c} with code compiled with the default @option{-fno-f2c} |
| calling conventions as, calling @code{COMPLEX} or default @code{REAL} |
| functions between program parts which were compiled with different |
| calling conventions will break at execution time. |
| |
| @emph{Caution:} This will break code which passes intrinsic functions |
| of type default @code{REAL} or @code{COMPLEX} as actual arguments, as |
| the library implementations use the @option{-fno-f2c} calling conventions. |
| |
| @item -fno-underscoring |
| @opindex @code{fno-underscoring} |
| @cindex underscore |
| @cindex symbol names, underscores |
| @cindex transforming symbol names |
| @cindex symbol names, transforming |
| Do not transform names of entities specified in the Fortran |
| source file by appending underscores to them. |
| |
| With @option{-funderscoring} in effect, GNU Fortran appends one |
| underscore to external names with no underscores. This is done to ensure |
| compatibility with code produced by many UNIX Fortran compilers. |
| |
| @emph{Caution}: The default behavior of GNU Fortran is |
| incompatible with @command{f2c} and @command{g77}, please use the |
| @option{-ff2c} option if you want object files compiled with |
| GNU Fortran to be compatible with object code created with these |
| tools. |
| |
| Use of @option{-fno-underscoring} is not recommended unless you are |
| experimenting with issues such as integration of GNU Fortran into |
| existing system environments (vis-@`{a}-vis existing libraries, tools, |
| and so on). |
| |
| For example, with @option{-funderscoring}, and assuming that @code{j()} and |
| @code{max_count()} are external functions while @code{my_var} and |
| @code{lvar} are local variables, a statement like |
| @smallexample |
| I = J() + MAX_COUNT (MY_VAR, LVAR) |
| @end smallexample |
| @noindent |
| is implemented as something akin to: |
| @smallexample |
| i = j_() + max_count__(&my_var__, &lvar); |
| @end smallexample |
| |
| With @option{-fno-underscoring}, the same statement is implemented as: |
| |
| @smallexample |
| i = j() + max_count(&my_var, &lvar); |
| @end smallexample |
| |
| Use of @option{-fno-underscoring} allows direct specification of |
| user-defined names while debugging and when interfacing GNU Fortran |
| code with other languages. |
| |
| Note that just because the names match does @emph{not} mean that the |
| interface implemented by GNU Fortran for an external name matches the |
| interface implemented by some other language for that same name. |
| That is, getting code produced by GNU Fortran to link to code produced |
| by some other compiler using this or any other method can be only a |
| small part of the overall solution---getting the code generated by |
| both compilers to agree on issues other than naming can require |
| significant effort, and, unlike naming disagreements, linkers normally |
| cannot detect disagreements in these other areas. |
| |
| Also, note that with @option{-fno-underscoring}, the lack of appended |
| underscores introduces the very real possibility that a user-defined |
| external name will conflict with a name in a system library, which |
| could make finding unresolved-reference bugs quite difficult in some |
| cases---they might occur at program run time, and show up only as |
| buggy behavior at run time. |
| |
| In future versions of GNU Fortran we hope to improve naming and linking |
| issues so that debugging always involves using the names as they appear |
| in the source, even if the names as seen by the linker are mangled to |
| prevent accidental linking between procedures with incompatible |
| interfaces. |
| |
| @item -fsecond-underscore |
| @opindex @code{fsecond-underscore} |
| @cindex underscore |
| @cindex symbol names, underscores |
| @cindex transforming symbol names |
| @cindex symbol names, transforming |
| @cindex @command{f2c} calling convention |
| @cindex @command{g77} calling convention |
| @cindex libf2c calling convention |
| By default, GNU Fortran appends an underscore to external |
| names. If this option is used GNU Fortran appends two |
| underscores to names with underscores and one underscore to external names |
| with no underscores. GNU Fortran also appends two underscores to |
| internal names with underscores to avoid naming collisions with external |
| names. |
| |
| This option has no effect if @option{-fno-underscoring} is |
| in effect. It is implied by the @option{-ff2c} option. |
| |
| Otherwise, with this option, an external name such as @code{MAX_COUNT} |
| is implemented as a reference to the link-time external symbol |
| @code{max_count__}, instead of @code{max_count_}. This is required |
| for compatibility with @command{g77} and @command{f2c}, and is implied |
| by use of the @option{-ff2c} option. |
| |
| @item -fcoarray=@var{<keyword>} |
| @opindex @code{fcoarray} |
| @cindex coarrays |
| |
| @table @asis |
| @item @samp{none} |
| Disable coarray support; using coarray declarations and image-control |
| statements will produce a compile-time error. (Default) |
| |
| @item @samp{single} |
| Single-image mode, i.e. @code{num_images()} is always one. |
| |
| @item @samp{lib} |
| Library-based coarray parallelization; a suitable GNU Fortran coarray |
| library needs to be linked. |
| @end table |
| |
| |
| @item -fcheck=@var{<keyword>} |
| @opindex @code{fcheck} |
| @cindex array, bounds checking |
| @cindex bit intrinsics checking |
| @cindex bounds checking |
| @cindex pointer checking |
| @cindex memory checking |
| @cindex range checking |
| @cindex subscript checking |
| @cindex checking subscripts |
| @cindex run-time checking |
| @cindex checking array temporaries |
| |
| Enable the generation of run-time checks; the argument shall be |
| a comma-delimited list of the following keywords. Prefixing a check with |
| @option{no-} disables it if it was activated by a previous specification. |
| |
| @table @asis |
| @item @samp{all} |
| Enable all run-time test of @option{-fcheck}. |
| |
| @item @samp{array-temps} |
| Warns at run time when for passing an actual argument a temporary array |
| had to be generated. The information generated by this warning is |
| sometimes useful in optimization, in order to avoid such temporaries. |
| |
| Note: The warning is only printed once per location. |
| |
| @item @samp{bits} |
| Enable generation of run-time checks for invalid arguments to the bit |
| manipulation intrinsics. |
| |
| @item @samp{bounds} |
| Enable generation of run-time checks for array subscripts |
| and against the declared minimum and maximum values. It also |
| checks array indices for assumed and deferred |
| shape arrays against the actual allocated bounds and ensures that all string |
| lengths are equal for character array constructors without an explicit |
| typespec. |
| |
| Some checks require that @option{-fcheck=bounds} is set for |
| the compilation of the main program. |
| |
| Note: In the future this may also include other forms of checking, e.g., |
| checking substring references. |
| |
| @item @samp{do} |
| Enable generation of run-time checks for invalid modification of loop |
| iteration variables. |
| |
| @item @samp{mem} |
| Enable generation of run-time checks for memory allocation. |
| Note: This option does not affect explicit allocations using the |
| @code{ALLOCATE} statement, which will be always checked. |
| |
| @item @samp{pointer} |
| Enable generation of run-time checks for pointers and allocatables. |
| |
| @item @samp{recursion} |
| Enable generation of run-time checks for recursively called subroutines and |
| functions which are not marked as recursive. See also @option{-frecursive}. |
| Note: This check does not work for OpenMP programs and is disabled if used |
| together with @option{-frecursive} and @option{-fopenmp}. |
| @end table |
| |
| Example: Assuming you have a file @file{foo.f90}, the command |
| @smallexample |
| gfortran -fcheck=all,no-array-temps foo.f90 |
| @end smallexample |
| will compile the file with all checks enabled as specified above except |
| warnings for generated array temporaries. |
| |
| |
| @item -fbounds-check |
| @opindex @code{fbounds-check} |
| @c Note: This option is also referred in gcc's manpage |
| Deprecated alias for @option{-fcheck=bounds}. |
| |
| @item -ftail-call-workaround |
| @itemx -ftail-call-workaround=@var{n} |
| @opindex @code{tail-call-workaround} |
| Some C interfaces to Fortran codes violate the gfortran ABI by |
| omitting the hidden character length arguments as described in |
| @xref{Argument passing conventions}. This can lead to crashes |
| because pushing arguments for tail calls can overflow the stack. |
| |
| To provide a workaround for existing binary packages, this option |
| disables tail call optimization for gfortran procedures with character |
| arguments. With @option{-ftail-call-workaround=2} tail call optimization |
| is disabled in all gfortran procedures with character arguments, |
| with @option{-ftail-call-workaround=1} or equivalent |
| @option{-ftail-call-workaround} only in gfortran procedures with character |
| arguments that call implicitly prototyped procedures. |
| |
| Using this option can lead to problems including crashes due to |
| insufficient stack space. |
| |
| It is @emph{very strongly} recommended to fix the code in question. |
| The @option{-fc-prototypes-external} option can be used to generate |
| prototypes which conform to gfortran's ABI, for inclusion in the |
| source code. |
| |
| Support for this option will likely be withdrawn in a future release |
| of gfortran. |
| |
| The negative form, @option{-fno-tail-call-workaround} or equivalent |
| @option{-ftail-call-workaround=0}, can be used to disable this option. |
| |
| Default is currently @option{-ftail-call-workaround}, this will change |
| in future releases. |
| |
| @item -fcheck-array-temporaries |
| @opindex @code{fcheck-array-temporaries} |
| Deprecated alias for @option{-fcheck=array-temps}. |
| |
| @item -fmax-array-constructor=@var{n} |
| @opindex @code{fmax-array-constructor} |
| This option can be used to increase the upper limit permitted in |
| array constructors. The code below requires this option to expand |
| the array at compile time. |
| |
| @smallexample |
| program test |
| implicit none |
| integer j |
| integer, parameter :: n = 100000 |
| integer, parameter :: i(n) = (/ (2*j, j = 1, n) /) |
| print '(10(I0,1X))', i |
| end program test |
| @end smallexample |
| |
| @emph{Caution: This option can lead to long compile times and excessively |
| large object files.} |
| |
| The default value for @var{n} is 65535. |
| |
| |
| @item -fmax-stack-var-size=@var{n} |
| @opindex @code{fmax-stack-var-size} |
| This option specifies the size in bytes of the largest array that will be put |
| on the stack; if the size is exceeded static memory is used (except in |
| procedures marked as RECURSIVE). Use the option @option{-frecursive} to |
| allow for recursive procedures which do not have a RECURSIVE attribute or |
| for parallel programs. Use @option{-fno-automatic} to never use the stack. |
| |
| This option currently only affects local arrays declared with constant |
| bounds, and may not apply to all character variables. |
| Future versions of GNU Fortran may improve this behavior. |
| |
| The default value for @var{n} is 65536. |
| |
| @item -fstack-arrays |
| @opindex @code{fstack-arrays} |
| Adding this option will make the Fortran compiler put all arrays of |
| unknown size and array temporaries onto stack memory. If your program uses very |
| large local arrays it is possible that you will have to extend your runtime |
| limits for stack memory on some operating systems. This flag is enabled |
| by default at optimization level @option{-Ofast} unless |
| @option{-fmax-stack-var-size} is specified. |
| |
| @item -fpack-derived |
| @opindex @code{fpack-derived} |
| @cindex structure packing |
| This option tells GNU Fortran to pack derived type members as closely as |
| possible. Code compiled with this option is likely to be incompatible |
| with code compiled without this option, and may execute slower. |
| |
| @item -frepack-arrays |
| @opindex @code{frepack-arrays} |
| @cindex repacking arrays |
| In some circumstances GNU Fortran may pass assumed shape array |
| sections via a descriptor describing a noncontiguous area of memory. |
| This option adds code to the function prologue to repack the data into |
| a contiguous block at runtime. |
| |
| This should result in faster accesses to the array. However it can introduce |
| significant overhead to the function call, especially when the passed data |
| is noncontiguous. |
| |
| @item -fshort-enums |
| @opindex @code{fshort-enums} |
| This option is provided for interoperability with C code that was |
| compiled with the @option{-fshort-enums} option. It will make |
| GNU Fortran choose the smallest @code{INTEGER} kind a given |
| enumerator set will fit in, and give all its enumerators this kind. |
| |
| @item -finline-arg-packing |
| @opindex @code{finline-arg-packing} |
| When passing an assumed-shape argument of a procedure as actual |
| argument to an assumed-size or explicit size or as argument to a |
| procedure that does not have an explicit interface, the argument may |
| have to be packed, that is put into contiguous memory. An example is |
| the call to @code{foo} in |
| @smallexample |
| subroutine foo(a) |
| real, dimension(*) :: a |
| end subroutine foo |
| subroutine bar(b) |
| real, dimension(:) :: b |
| call foo(b) |
| end subroutine bar |
| @end smallexample |
| |
| When @option{-finline-arg-packing} is in effect, this packing will be |
| performed by inline code. This allows for more optimization while |
| increasing code size. |
| |
| @option{-finline-arg-packing} is implied by any of the @option{-O} options |
| except when optimizing for size via @option{-Os}. If the code |
| contains a very large number of argument that have to be packed, code |
| size and also compilation time may become excessive. If that is the |
| case, it may be better to disable this option. Instances of packing |
| can be found by using @option{-Warray-temporaries}. |
| |
| @item -fexternal-blas |
| @opindex @code{fexternal-blas} |
| This option will make @command{gfortran} generate calls to BLAS functions |
| for some matrix operations like @code{MATMUL}, instead of using our own |
| algorithms, if the size of the matrices involved is larger than a given |
| limit (see @option{-fblas-matmul-limit}). This may be profitable if an |
| optimized vendor BLAS library is available. The BLAS library will have |
| to be specified at link time. |
| |
| @item -fblas-matmul-limit=@var{n} |
| @opindex @code{fblas-matmul-limit} |
| Only significant when @option{-fexternal-blas} is in effect. |
| Matrix multiplication of matrices with size larger than (or equal to) @var{n} |
| will be performed by calls to BLAS functions, while others will be |
| handled by @command{gfortran} internal algorithms. If the matrices |
| involved are not square, the size comparison is performed using the |
| geometric mean of the dimensions of the argument and result matrices. |
| |
| The default value for @var{n} is 30. |
| |
| @item -finline-matmul-limit=@var{n} |
| @opindex @code{finline-matmul-limit} |
| When front-end optimization is active, some calls to the @code{MATMUL} |
| intrinsic function will be inlined. This may result in code size |
| increase if the size of the matrix cannot be determined at compile |
| time, as code for both cases is generated. Setting |
| @code{-finline-matmul-limit=0} will disable inlining in all cases. |
| Setting this option with a value of @var{n} will produce inline code |
| for matrices with size up to @var{n}. If the matrices involved are not |
| square, the size comparison is performed using the geometric mean of |
| the dimensions of the argument and result matrices. |
| |
| The default value for @var{n} is 30. The @code{-fblas-matmul-limit} |
| can be used to change this value. |
| |
| @item -frecursive |
| @opindex @code{frecursive} |
| Allow indirect recursion by forcing all local arrays to be allocated |
| on the stack. This flag cannot be used together with |
| @option{-fmax-stack-var-size=} or @option{-fno-automatic}. |
| |
| @item -finit-local-zero |
| @itemx -finit-derived |
| @itemx -finit-integer=@var{n} |
| @itemx -finit-real=@var{<zero|inf|-inf|nan|snan>} |
| @itemx -finit-logical=@var{<true|false>} |
| @itemx -finit-character=@var{n} |
| @opindex @code{finit-local-zero} |
| @opindex @code{finit-derived} |
| @opindex @code{finit-integer} |
| @opindex @code{finit-real} |
| @opindex @code{finit-logical} |
| @opindex @code{finit-character} |
| The @option{-finit-local-zero} option instructs the compiler to |
| initialize local @code{INTEGER}, @code{REAL}, and @code{COMPLEX} |
| variables to zero, @code{LOGICAL} variables to false, and |
| @code{CHARACTER} variables to a string of null bytes. Finer-grained |
| initialization options are provided by the |
| @option{-finit-integer=@var{n}}, |
| @option{-finit-real=@var{<zero|inf|-inf|nan|snan>}} (which also initializes |
| the real and imaginary parts of local @code{COMPLEX} variables), |
| @option{-finit-logical=@var{<true|false>}}, and |
| @option{-finit-character=@var{n}} (where @var{n} is an ASCII character |
| value) options. |
| |
| With @option{-finit-derived}, components of derived type variables will be |
| initialized according to these flags. Components whose type is not covered by |
| an explicit @option{-finit-*} flag will be treated as described above with |
| @option{-finit-local-zero}. |
| |
| These options do not initialize |
| @itemize @bullet |
| @item |
| objects with the POINTER attribute |
| @item |
| allocatable arrays |
| @item |
| variables that appear in an @code{EQUIVALENCE} statement. |
| @end itemize |
| (These limitations may be removed in future releases). |
| |
| Note that the @option{-finit-real=nan} option initializes @code{REAL} |
| and @code{COMPLEX} variables with a quiet NaN. For a signalling NaN |
| use @option{-finit-real=snan}; note, however, that compile-time |
| optimizations may convert them into quiet NaN and that trapping |
| needs to be enabled (e.g. via @option{-ffpe-trap}). |
| |
| The @option{-finit-integer} option will parse the value into an |
| integer of type @code{INTEGER(kind=C_LONG)} on the host. Said value |
| is then assigned to the integer variables in the Fortran code, which |
| might result in wraparound if the value is too large for the kind. |
| |
| Finally, note that enabling any of the @option{-finit-*} options will |
| silence warnings that would have been emitted by @option{-Wuninitialized} |
| for the affected local variables. |
| |
| @item -falign-commons |
| @opindex @code{falign-commons} |
| @cindex alignment of @code{COMMON} blocks |
| By default, @command{gfortran} enforces proper alignment of all variables in a |
| @code{COMMON} block by padding them as needed. On certain platforms this is mandatory, |
| on others it increases performance. If a @code{COMMON} block is not declared with |
| consistent data types everywhere, this padding can cause trouble, and |
| @option{-fno-align-commons} can be used to disable automatic alignment. The |
| same form of this option should be used for all files that share a @code{COMMON} block. |
| To avoid potential alignment issues in @code{COMMON} blocks, it is recommended to order |
| objects from largest to smallest. |
| |
| @item -fno-protect-parens |
| @opindex @code{fno-protect-parens} |
| @cindex re-association of parenthesized expressions |
| By default the parentheses in expression are honored for all optimization |
| levels such that the compiler does not do any re-association. Using |
| @option{-fno-protect-parens} allows the compiler to reorder @code{REAL} and |
| @code{COMPLEX} expressions to produce faster code. Note that for the re-association |
| optimization @option{-fno-signed-zeros} and @option{-fno-trapping-math} |
| need to be in effect. The parentheses protection is enabled by default, unless |
| @option{-Ofast} is given. |
| |
| @item -frealloc-lhs |
| @opindex @code{frealloc-lhs} |
| @cindex Reallocate the LHS in assignments |
| An allocatable left-hand side of an intrinsic assignment is automatically |
| (re)allocated if it is either unallocated or has a different shape. The |
| option is enabled by default except when @option{-std=f95} is given. See |
| also @option{-Wrealloc-lhs}. |
| |
| @item -faggressive-function-elimination |
| @opindex @code{faggressive-function-elimination} |
| @cindex Elimination of functions with identical argument lists |
| Functions with identical argument lists are eliminated within |
| statements, regardless of whether these functions are marked |
| @code{PURE} or not. For example, in |
| @smallexample |
| a = f(b,c) + f(b,c) |
| @end smallexample |
| there will only be a single call to @code{f}. This option only works |
| if @option{-ffrontend-optimize} is in effect. |
| |
| @item -ffrontend-optimize |
| @opindex @code{frontend-optimize} |
| @cindex Front-end optimization |
| This option performs front-end optimization, based on manipulating |
| parts the Fortran parse tree. Enabled by default by any @option{-O} option |
| except @option{-O0} and @option{-Og}. Optimizations enabled by this option |
| include: |
| @itemize @bullet |
| @item inlining calls to @code{MATMUL}, |
| @item elimination of identical function calls within expressions, |
| @item removing unnecessary calls to @code{TRIM} in comparisons and assignments, |
| @item replacing @code{TRIM(a)} with @code{a(1:LEN_TRIM(a))} and |
| @item short-circuiting of logical operators (@code{.AND.} and @code{.OR.}). |
| @end itemize |
| It can be deselected by specifying @option{-fno-frontend-optimize}. |
| |
| @item -ffrontend-loop-interchange |
| @opindex @code{frontend-loop-interchange} |
| @cindex loop interchange, Fortran |
| Attempt to interchange loops in the Fortran front end where |
| profitable. Enabled by default by any @option{-O} option. |
| At the moment, this option only affects @code{FORALL} and |
| @code{DO CONCURRENT} statements with several forall triplets. |
| @end table |
| |
| @xref{Code Gen Options,,Options for Code Generation Conventions, |
| gcc,Using the GNU Compiler Collection (GCC)}, for information on more options |
| offered by the GBE |
| shared by @command{gfortran}, @command{gcc}, and other GNU compilers. |
| |
| @c man end |
| |
| @node Interoperability Options |
| @section Options for interoperability with other languages |
| |
| @table @asis |
| |
| @item -fc-prototypes |
| @opindex @code{c-prototypes} |
| @cindex Generating C prototypes from Fortran BIND(C) enteties |
| This option will generate C prototypes from @code{BIND(C)} variable |
| declarations, types and procedure interfaces and writes them to |
| standard output. @code{ENUM} is not yet supported. |
| |
| The generated prototypes may need inclusion of an appropriate header, |
| such as @code{<stdint.h>} or @code{<stdlib.h>}. For types which are |
| not specified using the appropriate kind from the @code{iso_c_binding} |
| module, a warning is added as a comment to the code. |
| |
| For function pointers, a pointer to a function returning @code{int} |
| without an explicit argument list is generated. |
| |
| Example of use: |
| @smallexample |
| $ gfortran -fc-prototypes -fsyntax-only foo.f90 > foo.h |
| @end smallexample |
| where the C code intended for interoperating with the Fortran code |
| then uses @code{#include "foo.h"}. |
| |
| @item -fc-prototypes-external |
| @opindex @code{c-prototypes-external} |
| @cindex Generating C prototypes from external procedures |
| This option will generate C prototypes from external functions and |
| subroutines and write them to standard output. This may be useful for |
| making sure that C bindings to Fortran code are correct. This option |
| does not generate prototypes for @code{BIND(C)} procedures, use |
| @option{-fc-prototypes} for that. |
| |
| The generated prototypes may need inclusion of an appropriate |
| header, such as @code{<stdint.h>} or @code{<stdlib.h>}. |
| |
| This is primarily meant for legacy code to ensure that existing C |
| bindings match what @command{gfortran} emits. The generated C |
| prototypes should be correct for the current version of the compiler, |
| but may not match what other compilers or earlier versions of |
| @command{gfortran} need. For new developments, use of the |
| @code{BIND(C)} features is recommended. |
| |
| Example of use: |
| @smallexample |
| $ gfortran -fc-prototypes-external -fsyntax-only foo.f > foo.h |
| @end smallexample |
| where the C code intended for interoperating with the Fortran code |
| then uses @code{#include "foo.h"}. |
| @end table |
| |
| @node Environment Variables |
| @section Environment variables affecting @command{gfortran} |
| @cindex environment variable |
| |
| @c man begin ENVIRONMENT |
| |
| The @command{gfortran} compiler currently does not make use of any environment |
| variables to control its operation above and beyond those |
| that affect the operation of @command{gcc}. |
| |
| @xref{Environment Variables,,Environment Variables Affecting GCC, |
| gcc,Using the GNU Compiler Collection (GCC)}, for information on environment |
| variables. |
| |
| @xref{Runtime}, for environment variables that affect the |
| run-time behavior of programs compiled with GNU Fortran. |
| @c man end |