1 @c Copyright (C) 2004-2021 Free Software Foundation, Inc.
2 @c This is part of the GNU Fortran manual.
3 @c For copying conditions, see the file gfortran.texi.
7 Copyright @copyright{} 2004-2021 Free Software Foundation, Inc.
9 Permission is granted to copy, distribute and/or modify this document
10 under the terms of the GNU Free Documentation License, Version 1.3 or
11 any later version published by the Free Software Foundation; with the
12 Invariant Sections being ``Funding Free Software'', the Front-Cover
13 Texts being (a) (see below), and with the Back-Cover Texts being (b)
14 (see below). A copy of the license is included in the gfdl(7) man page.
16 (a) The FSF's Front-Cover Text is:
20 (b) The FSF's Back-Cover Text is:
22 You have freedom to copy and modify this GNU Manual, like GNU
23 software. Copies published by the Free Software Foundation raise
24 funds for GNU development.
26 @c Set file name and title for the man page.
28 @settitle GNU Fortran compiler.
30 gfortran [@option{-c}|@option{-S}|@option{-E}]
31 [@option{-g}] [@option{-pg}] [@option{-O}@var{level}]
32 [@option{-W}@var{warn}@dots{}] [@option{-pedantic}]
33 [@option{-I}@var{dir}@dots{}] [@option{-L}@var{dir}@dots{}]
34 [@option{-D}@var{macro}[=@var{defn}]@dots{}] [@option{-U}@var{macro}]
35 [@option{-f}@var{option}@dots{}]
36 [@option{-m}@var{machine-option}@dots{}]
37 [@option{-o} @var{outfile}] @var{infile}@dots{}
39 Only the most useful options are listed here; see below for the
43 gpl(7), gfdl(7), fsf-funding(7),
44 cpp(1), gcov(1), gcc(1), as(1), ld(1), gdb(1), dbx(1)
45 and the Info entries for @file{gcc}, @file{cpp}, @file{gfortran}, @file{as},
46 @file{ld}, @file{binutils} and @file{gdb}.
49 For instructions on reporting bugs, see
53 See the Info entry for @command{gfortran} for contributors to GCC and
58 @node Invoking GNU Fortran
59 @chapter GNU Fortran Command Options
60 @cindex GNU Fortran command options
61 @cindex command options
62 @cindex options, @command{gfortran} command
64 @c man begin DESCRIPTION
66 The @command{gfortran} command supports all the options supported by the
67 @command{gcc} command. Only options specific to GNU Fortran are documented
70 @xref{Invoking GCC,,GCC Command Options,gcc,Using the GNU Compiler
71 Collection (GCC)}, for information
72 on the non-Fortran-specific aspects of the @command{gcc} command (and,
73 therefore, the @command{gfortran} command).
75 @cindex options, negative forms
76 All GCC and GNU Fortran options
77 are accepted both by @command{gfortran} and by @command{gcc}
78 (as well as any other drivers built at the same time,
79 such as @command{g++}),
80 since adding GNU Fortran to the GCC distribution
81 enables acceptance of GNU Fortran options
82 by all of the relevant drivers.
84 In some cases, options have positive and negative forms;
85 the negative form of @option{-ffoo} would be @option{-fno-foo}.
86 This manual documents only one of these two forms, whichever
87 one is not the default.
91 * Option Summary:: Brief list of all @command{gfortran} options,
93 * Fortran Dialect Options:: Controlling the variant of Fortran language
95 * Preprocessing Options:: Enable and customize preprocessing.
96 * Error and Warning Options:: How picky should the compiler be?
97 * Debugging Options:: Symbol tables, measurements, and debugging dumps.
98 * Directory Options:: Where to find module files
99 * Link Options :: Influencing the linking step
100 * Runtime Options:: Influencing runtime behavior
101 * Code Gen Options:: Specifying conventions for function calls, data layout
103 * Interoperability Options:: Options for interoperability with other
105 * Environment Variables:: Environment variables that affect @command{gfortran}.
109 @section Option summary
113 Here is a summary of all the options specific to GNU Fortran, grouped
114 by type. Explanations are in the following sections.
117 @item Fortran Language Options
118 @xref{Fortran Dialect Options,,Options controlling Fortran dialect}.
119 @gccoptlist{-fall-intrinsics -fallow-argument-mismatch -fallow-invalid-boz @gol
120 -fbackslash -fcray-pointer -fd-lines-as-code -fd-lines-as-comments @gol
121 -fdec -fdec-char-conversions -fdec-structure -fdec-intrinsic-ints @gol
122 -fdec-static -fdec-math -fdec-include -fdec-format-defaults @gol
123 -fdec-blank-format-item -fdefault-double-8 -fdefault-integer-8 @gol
124 -fdefault-real-8 -fdefault-real-10 -fdefault-real-16 -fdollar-ok @gol
125 -ffixed-line-length-@var{n} -ffixed-line-length-none -fpad-source @gol
126 -ffree-form -ffree-line-length-@var{n} -ffree-line-length-none @gol
127 -fimplicit-none -finteger-4-integer-8 -fmax-identifier-length @gol
128 -fmodule-private -ffixed-form -fno-range-check -fopenacc -fopenmp @gol
129 -freal-4-real-10 -freal-4-real-16 -freal-4-real-8 -freal-8-real-10 @gol
130 -freal-8-real-16 -freal-8-real-4 -std=@var{std} -ftest-forall-temp
133 @item Preprocessing Options
134 @xref{Preprocessing Options,,Enable and customize preprocessing}.
135 @gccoptlist{-A-@var{question}@r{[}=@var{answer}@r{]}
136 -A@var{question}=@var{answer} -C -CC -D@var{macro}@r{[}=@var{defn}@r{]}
138 -U@var{macro} -cpp -dD -dI -dM -dN -dU -fworking-directory
139 -imultilib @var{dir} @gol
140 -iprefix @var{file} -iquote -isysroot @var{dir} -isystem @var{dir} -nocpp
145 @item Error and Warning Options
146 @xref{Error and Warning Options,,Options to request or suppress errors
148 @gccoptlist{-Waliasing -Wall -Wampersand -Warray-bounds @gol
149 -Wc-binding-type -Wcharacter-truncation -Wconversion @gol
150 -Wdo-subscript -Wfunction-elimination -Wimplicit-interface @gol
151 -Wimplicit-procedure -Wintrinsic-shadow -Wuse-without-only @gol
152 -Wintrinsics-std -Wline-truncation -Wno-align-commons @gol
153 -Wno-overwrite-recursive -Wno-tabs -Wreal-q-constant -Wsurprising @gol
154 -Wunderflow -Wunused-parameter -Wrealloc-lhs -Wrealloc-lhs-all @gol
155 -Wfrontend-loop-interchange -Wtarget-lifetime -fmax-errors=@var{n} @gol
156 -fsyntax-only -pedantic @gol
157 -pedantic-errors @gol
160 @item Debugging Options
161 @xref{Debugging Options,,Options for debugging your program or GNU Fortran}.
162 @gccoptlist{-fbacktrace -fdump-fortran-optimized -fdump-fortran-original @gol
163 -fdebug-aux-vars -fdump-fortran-global -fdump-parse-tree -ffpe-trap=@var{list} @gol
164 -ffpe-summary=@var{list}
167 @item Directory Options
168 @xref{Directory Options,,Options for directory search}.
169 @gccoptlist{-I@var{dir} -J@var{dir} -fintrinsic-modules-path @var{dir}}
172 @xref{Link Options,,Options for influencing the linking step}.
173 @gccoptlist{-static-libgfortran}
175 @item Runtime Options
176 @xref{Runtime Options,,Options for influencing runtime behavior}.
177 @gccoptlist{-fconvert=@var{conversion} -fmax-subrecord-length=@var{length} @gol
178 -frecord-marker=@var{length} -fsign-zero
181 @item Interoperability Options
182 @xref{Interoperability Options,,Options for interoperability}.
183 @gccoptlist{-fc-prototypes -fc-prototypes-external}
185 @item Code Generation Options
186 @xref{Code Gen Options,,Options for code generation conventions}.
187 @gccoptlist{-faggressive-function-elimination -fblas-matmul-limit=@var{n} @gol
188 -fbounds-check -ftail-call-workaround -ftail-call-workaround=@var{n} @gol
189 -fcheck-array-temporaries @gol
190 -fcheck=@var{<all|array-temps|bits|bounds|do|mem|pointer|recursion>} @gol
191 -fcoarray=@var{<none|single|lib>} -fexternal-blas -ff2c @gol
192 -ffrontend-loop-interchange -ffrontend-optimize @gol
193 -finit-character=@var{n} -finit-integer=@var{n} -finit-local-zero @gol
194 -finit-derived -finit-logical=@var{<true|false>} @gol
195 -finit-real=@var{<zero|inf|-inf|nan|snan>}
196 -finline-matmul-limit=@var{n} @gol
197 -finline-arg-packing -fmax-array-constructor=@var{n} @gol
198 -fmax-stack-var-size=@var{n} -fno-align-commons -fno-automatic @gol
199 -fno-protect-parens -fno-underscoring -fsecond-underscore @gol
200 -fpack-derived -frealloc-lhs -frecursive -frepack-arrays @gol
201 -fshort-enums -fstack-arrays
205 @node Fortran Dialect Options
206 @section Options controlling Fortran dialect
207 @cindex dialect options
208 @cindex language, dialect options
209 @cindex options, dialect
211 The following options control the details of the Fortran dialect
212 accepted by the compiler:
217 @opindex @code{ffree-form}
218 @opindex @code{ffixed-form}
219 @cindex options, Fortran dialect
220 @cindex file format, free
221 @cindex file format, fixed
222 Specify the layout used by the source file. The free form layout
223 was introduced in Fortran 90. Fixed form was traditionally used in
224 older Fortran programs. When neither option is specified, the source
225 form is determined by the file extension.
227 @item -fall-intrinsics
228 @opindex @code{fall-intrinsics}
229 This option causes all intrinsic procedures (including the GNU-specific
230 extensions) to be accepted. This can be useful with @option{-std=f95} to
231 force standard-compliance but get access to the full range of intrinsics
232 available with @command{gfortran}. As a consequence, @option{-Wintrinsics-std}
233 will be ignored and no user-defined procedure with the same name as any
234 intrinsic will be called except when it is explicitly declared @code{EXTERNAL}.
236 @item -fallow-argument-mismatch
237 @opindex @code{fallow-argument-mismatch}
238 Some code contains calls to external procedures with mismatches
239 between the calls and the procedure definition, or with mismatches
240 between different calls. Such code is non-conforming, and will usually
241 be flagged with an error. This options degrades the error to a
242 warning, which can only be disabled by disabling all warnings via
243 @option{-w}. Only a single occurrence per argument is flagged by this
244 warning. @option{-fallow-argument-mismatch} is implied by
245 @option{-std=legacy}.
247 Using this option is @emph{strongly} discouraged. It is possible to
248 provide standard-conforming code which allows different types of
249 arguments by using an explicit interface and @code{TYPE(*)}.
251 @item -fallow-invalid-boz
252 @opindex @code{allow-invalid-boz}
253 A BOZ literal constant can occur in a limited number of contexts in
254 standard conforming Fortran. This option degrades an error condition
255 to a warning, and allows a BOZ literal constant to appear where the
256 Fortran standard would otherwise prohibit its use.
258 @item -fd-lines-as-code
259 @itemx -fd-lines-as-comments
260 @opindex @code{fd-lines-as-code}
261 @opindex @code{fd-lines-as-comments}
262 Enable special treatment for lines beginning with @code{d} or @code{D}
263 in fixed form sources. If the @option{-fd-lines-as-code} option is
264 given they are treated as if the first column contained a blank. If the
265 @option{-fd-lines-as-comments} option is given, they are treated as
270 DEC compatibility mode. Enables extensions and other features that mimic
271 the default behavior of older compilers (such as DEC).
272 These features are non-standard and should be avoided at all costs.
273 For details on GNU Fortran's implementation of these extensions see the
276 Other flags enabled by this switch are:
277 @option{-fdollar-ok} @option{-fcray-pointer} @option{-fdec-char-conversions}
278 @option{-fdec-structure} @option{-fdec-intrinsic-ints} @option{-fdec-static}
279 @option{-fdec-math} @option{-fdec-include} @option{-fdec-blank-format-item}
280 @option{-fdec-format-defaults}
282 If @option{-fd-lines-as-code}/@option{-fd-lines-as-comments} are unset, then
283 @option{-fdec} also sets @option{-fd-lines-as-comments}.
285 @item -fdec-char-conversions
286 @opindex @code{fdec-char-conversions}
287 Enable the use of character literals in assignments and @code{DATA} statements
288 for non-character variables.
290 @item -fdec-structure
291 @opindex @code{fdec-structure}
292 Enable DEC @code{STRUCTURE} and @code{RECORD} as well as @code{UNION},
293 @code{MAP}, and dot ('.') as a member separator (in addition to '%'). This is
294 provided for compatibility only; Fortran 90 derived types should be used
295 instead where possible.
297 @item -fdec-intrinsic-ints
298 @opindex @code{fdec-intrinsic-ints}
299 Enable B/I/J/K kind variants of existing integer functions (e.g. BIAND, IIAND,
300 JIAND, etc...). For a complete list of intrinsics see the full documentation.
303 @opindex @code{fdec-math}
304 Enable legacy math intrinsics such as COTAN and degree-valued trigonometric
305 functions (e.g. TAND, ATAND, etc...) for compatability with older code.
308 @opindex @code{fdec-static}
309 Enable DEC-style STATIC and AUTOMATIC attributes to explicitly specify
310 the storage of variables and other objects.
313 @opindex @code{fdec-include}
314 Enable parsing of INCLUDE as a statement in addition to parsing it as
315 INCLUDE line. When parsed as INCLUDE statement, INCLUDE does not have to
316 be on a single line and can use line continuations.
318 @item -fdec-format-defaults
319 @opindex @code{fdec-format-defaults}
320 Enable format specifiers F, G and I to be used without width specifiers,
321 default widths will be used instead.
323 @item -fdec-blank-format-item
324 @opindex @code{fdec-blank-format-item}
325 Enable a blank format item at the end of a format specification i.e. nothing
326 following the final comma.
329 @opindex @code{fdollar-ok}
332 @cindex character set
333 Allow @samp{$} as a valid non-first character in a symbol name. Symbols
334 that start with @samp{$} are rejected since it is unclear which rules to
335 apply to implicit typing as different vendors implement different rules.
336 Using @samp{$} in @code{IMPLICIT} statements is also rejected.
339 @opindex @code{backslash}
341 @cindex escape characters
342 Change the interpretation of backslashes in string literals from a single
343 backslash character to ``C-style'' escape characters. The following
344 combinations are expanded @code{\a}, @code{\b}, @code{\f}, @code{\n},
345 @code{\r}, @code{\t}, @code{\v}, @code{\\}, and @code{\0} to the ASCII
346 characters alert, backspace, form feed, newline, carriage return,
347 horizontal tab, vertical tab, backslash, and NUL, respectively.
348 Additionally, @code{\x}@var{nn}, @code{\u}@var{nnnn} and
349 @code{\U}@var{nnnnnnnn} (where each @var{n} is a hexadecimal digit) are
350 translated into the Unicode characters corresponding to the specified code
351 points. All other combinations of a character preceded by \ are
354 @item -fmodule-private
355 @opindex @code{fmodule-private}
356 @cindex module entities
358 Set the default accessibility of module entities to @code{PRIVATE}.
359 Use-associated entities will not be accessible unless they are explicitly
360 declared as @code{PUBLIC}.
362 @item -ffixed-line-length-@var{n}
363 @opindex @code{ffixed-line-length-}@var{n}
364 @cindex file format, fixed
365 Set column after which characters are ignored in typical fixed-form
366 lines in the source file, and, unless @code{-fno-pad-source}, through which
367 spaces are assumed (as if padded to that length) after the ends of short
370 Popular values for @var{n} include 72 (the
371 standard and the default), 80 (card image), and 132 (corresponding
372 to ``extended-source'' options in some popular compilers).
373 @var{n} may also be @samp{none}, meaning that the entire line is meaningful
374 and that continued character constants never have implicit spaces appended
375 to them to fill out the line.
376 @option{-ffixed-line-length-0} means the same thing as
377 @option{-ffixed-line-length-none}.
379 @item -fno-pad-source
380 @opindex @code{fpad-source}
381 By default fixed-form lines have spaces assumed (as if padded to that length)
382 after the ends of short fixed-form lines. This is not done either if
383 @option{-ffixed-line-length-0}, @option{-ffixed-line-length-none} or
384 if @option{-fno-pad-source} option is used. With any of those options
385 continued character constants never have implicit spaces appended
386 to them to fill out the line.
388 @item -ffree-line-length-@var{n}
389 @opindex @code{ffree-line-length-}@var{n}
390 @cindex file format, free
391 Set column after which characters are ignored in typical free-form
392 lines in the source file. The default value is 132.
393 @var{n} may be @samp{none}, meaning that the entire line is meaningful.
394 @option{-ffree-line-length-0} means the same thing as
395 @option{-ffree-line-length-none}.
397 @item -fmax-identifier-length=@var{n}
398 @opindex @code{fmax-identifier-length=}@var{n}
399 Specify the maximum allowed identifier length. Typical values are
400 31 (Fortran 95) and 63 (Fortran 2003 and Fortran 2008).
402 @item -fimplicit-none
403 @opindex @code{fimplicit-none}
404 Specify that no implicit typing is allowed, unless overridden by explicit
405 @code{IMPLICIT} statements. This is the equivalent of adding
406 @code{implicit none} to the start of every procedure.
409 @opindex @code{fcray-pointer}
410 Enable the Cray pointer extension, which provides C-like pointer
414 @opindex @code{fopenacc}
416 Enable the OpenACC extensions. This includes OpenACC @code{!$acc}
417 directives in free form and @code{c$acc}, @code{*$acc} and
418 @code{!$acc} directives in fixed form, @code{!$} conditional
419 compilation sentinels in free form and @code{c$}, @code{*$} and
420 @code{!$} sentinels in fixed form, and when linking arranges for the
421 OpenACC runtime library to be linked in.
424 @opindex @code{fopenmp}
426 Enable the OpenMP extensions. This includes OpenMP @code{!$omp} directives
428 and @code{c$omp}, @code{*$omp} and @code{!$omp} directives in fixed form,
429 @code{!$} conditional compilation sentinels in free form
430 and @code{c$}, @code{*$} and @code{!$} sentinels in fixed form,
431 and when linking arranges for the OpenMP runtime library to be linked
432 in. The option @option{-fopenmp} implies @option{-frecursive}.
434 @item -fno-range-check
435 @opindex @code{frange-check}
436 Disable range checking on results of simplification of constant
437 expressions during compilation. For example, GNU Fortran will give
438 an error at compile time when simplifying @code{a = 1. / 0}.
439 With this option, no error will be given and @code{a} will be assigned
440 the value @code{+Infinity}. If an expression evaluates to a value
441 outside of the relevant range of [@code{-HUGE()}:@code{HUGE()}],
442 then the expression will be replaced by @code{-Inf} or @code{+Inf}
444 Similarly, @code{DATA i/Z'FFFFFFFF'/} will result in an integer overflow
445 on most systems, but with @option{-fno-range-check} the value will
446 ``wrap around'' and @code{i} will be initialized to @math{-1} instead.
448 @item -fdefault-integer-8
449 @opindex @code{fdefault-integer-8}
450 Set the default integer and logical types to an 8 byte wide type. This option
451 also affects the kind of integer constants like @code{42}. Unlike
452 @option{-finteger-4-integer-8}, it does not promote variables with explicit
455 @item -fdefault-real-8
456 @opindex @code{fdefault-real-8}
457 Set the default real type to an 8 byte wide type. This option also affects
458 the kind of non-double real constants like @code{1.0}. This option promotes
459 the default width of @code{DOUBLE PRECISION} and double real constants
460 like @code{1.d0} to 16 bytes if possible. If @code{-fdefault-double-8}
461 is given along with @code{fdefault-real-8}, @code{DOUBLE PRECISION}
462 and double real constants are not promoted. Unlike @option{-freal-4-real-8},
463 @code{fdefault-real-8} does not promote variables with explicit kind
466 @item -fdefault-real-10
467 @opindex @code{fdefault-real-10}
468 Set the default real type to an 10 byte wide type. This option also affects
469 the kind of non-double real constants like @code{1.0}. This option promotes
470 the default width of @code{DOUBLE PRECISION} and double real constants
471 like @code{1.d0} to 16 bytes if possible. If @code{-fdefault-double-8}
472 is given along with @code{fdefault-real-10}, @code{DOUBLE PRECISION}
473 and double real constants are not promoted. Unlike @option{-freal-4-real-10},
474 @code{fdefault-real-10} does not promote variables with explicit kind
477 @item -fdefault-real-16
478 @opindex @code{fdefault-real-16}
479 Set the default real type to an 16 byte wide type. This option also affects
480 the kind of non-double real constants like @code{1.0}. This option promotes
481 the default width of @code{DOUBLE PRECISION} and double real constants
482 like @code{1.d0} to 16 bytes if possible. If @code{-fdefault-double-8}
483 is given along with @code{fdefault-real-16}, @code{DOUBLE PRECISION}
484 and double real constants are not promoted. Unlike @option{-freal-4-real-16},
485 @code{fdefault-real-16} does not promote variables with explicit kind
488 @item -fdefault-double-8
489 @opindex @code{fdefault-double-8}
490 Set the @code{DOUBLE PRECISION} type and double real constants
491 like @code{1.d0} to an 8 byte wide type. Do nothing if this
492 is already the default. This option prevents @option{-fdefault-real-8},
493 @option{-fdefault-real-10}, and @option{-fdefault-real-16},
494 from promoting @code{DOUBLE PRECISION} and double real constants like
495 @code{1.d0} to 16 bytes.
497 @item -finteger-4-integer-8
498 @opindex @code{finteger-4-integer-8}
499 Promote all @code{INTEGER(KIND=4)} entities to an @code{INTEGER(KIND=8)}
500 entities. If @code{KIND=8} is unavailable, then an error will be issued.
501 This option should be used with care and may not be suitable for your codes.
502 Areas of possible concern include calls to external procedures,
503 alignment in @code{EQUIVALENCE} and/or @code{COMMON}, generic interfaces,
504 BOZ literal constant conversion, and I/O. Inspection of the intermediate
505 representation of the translated Fortran code, produced by
506 @option{-fdump-tree-original}, is suggested.
508 @item -freal-4-real-8
509 @itemx -freal-4-real-10
510 @itemx -freal-4-real-16
511 @itemx -freal-8-real-4
512 @itemx -freal-8-real-10
513 @itemx -freal-8-real-16
514 @opindex @code{freal-4-real-8}
515 @opindex @code{freal-4-real-10}
516 @opindex @code{freal-4-real-16}
517 @opindex @code{freal-8-real-4}
518 @opindex @code{freal-8-real-10}
519 @opindex @code{freal-8-real-16}
520 @cindex options, real kind type promotion
521 Promote all @code{REAL(KIND=M)} entities to @code{REAL(KIND=N)} entities.
522 If @code{REAL(KIND=N)} is unavailable, then an error will be issued.
523 All other real kind types are unaffected by this option.
524 These options should be used with care and may not be suitable for your
525 codes. Areas of possible concern include calls to external procedures,
526 alignment in @code{EQUIVALENCE} and/or @code{COMMON}, generic interfaces,
527 BOZ literal constant conversion, and I/O. Inspection of the intermediate
528 representation of the translated Fortran code, produced by
529 @option{-fdump-tree-original}, is suggested.
532 @opindex @code{std=}@var{std} option
533 Specify the standard to which the program is expected to conform,
534 which may be one of @samp{f95}, @samp{f2003}, @samp{f2008},
535 @samp{f2018}, @samp{gnu}, or @samp{legacy}. The default value for
536 @var{std} is @samp{gnu}, which specifies a superset of the latest
537 Fortran standard that includes all of the extensions supported by GNU
538 Fortran, although warnings will be given for obsolete extensions not
539 recommended for use in new code. The @samp{legacy} value is
540 equivalent but without the warnings for obsolete extensions, and may
541 be useful for old non-standard programs. The @samp{f95},
542 @samp{f2003}, @samp{f2008}, and @samp{f2018} values specify strict
543 conformance to the Fortran 95, Fortran 2003, Fortran 2008 and Fortran
544 2018 standards, respectively; errors are given for all extensions
545 beyond the relevant language standard, and warnings are given for the
546 Fortran 77 features that are permitted but obsolescent in later
547 standards. The deprecated option @samp{-std=f2008ts} acts as an alias for
548 @samp{-std=f2018}. It is only present for backwards compatibility with
549 earlier gfortran versions and should not be used any more.
551 @item -ftest-forall-temp
552 @opindex @code{ftest-forall-temp}
553 Enhance test coverage by forcing most forall assignments to use temporary.
557 @node Preprocessing Options
558 @section Enable and customize preprocessing
560 @cindex options, preprocessor
563 Preprocessor related options. See section
564 @ref{Preprocessing and conditional compilation} for more detailed
565 information on preprocessing in @command{gfortran}.
572 @cindex preprocessor, enable
573 @cindex preprocessor, disable
574 Enable preprocessing. The preprocessor is automatically invoked if
575 the file extension is @file{.fpp}, @file{.FPP}, @file{.F}, @file{.FOR},
576 @file{.FTN}, @file{.F90}, @file{.F95}, @file{.F03} or @file{.F08}. Use
577 this option to manually enable preprocessing of any kind of Fortran file.
579 To disable preprocessing of files with any of the above listed extensions,
580 use the negative form: @option{-nocpp}.
582 The preprocessor is run in traditional mode. Any restrictions of the
583 file-format, especially the limits on line length, apply for
584 preprocessed output as well, so it might be advisable to use the
585 @option{-ffree-line-length-none} or @option{-ffixed-line-length-none}
590 @cindex preprocessor, debugging
591 @cindex debugging, preprocessor
592 Instead of the normal output, generate a list of @code{'#define'}
593 directives for all the macros defined during the execution of the
594 preprocessor, including predefined macros. This gives you a way
595 of finding out what is predefined in your version of the preprocessor.
596 Assuming you have no file @file{foo.f90}, the command
598 touch foo.f90; gfortran -cpp -E -dM foo.f90
600 will show all the predefined macros.
604 @cindex preprocessor, debugging
605 @cindex debugging, preprocessor
606 Like @option{-dM} except in two respects: it does not include the
607 predefined macros, and it outputs both the @code{#define} directives
608 and the result of preprocessing. Both kinds of output go to the
609 standard output file.
613 @cindex preprocessor, debugging
614 @cindex debugging, preprocessor
615 Like @option{-dD}, but emit only the macro names, not their expansions.
619 @cindex preprocessor, debugging
620 @cindex debugging, preprocessor
621 Like @option{dD} except that only macros that are expanded, or whose
622 definedness is tested in preprocessor directives, are output; the
623 output is delayed until the use or test of the macro; and @code{'#undef'}
624 directives are also output for macros tested but undefined at the time.
628 @cindex preprocessor, debugging
629 @cindex debugging, preprocessor
630 Output @code{'#include'} directives in addition to the result
633 @item -fworking-directory
634 @opindex @code{fworking-directory}
635 @cindex preprocessor, working directory
636 Enable generation of linemarkers in the preprocessor output that will
637 let the compiler know the current working directory at the time of
638 preprocessing. When this option is enabled, the preprocessor will emit,
639 after the initial linemarker, a second linemarker with the current
640 working directory followed by two slashes. GCC will use this directory,
641 when it is present in the preprocessed input, as the directory emitted
642 as the current working directory in some debugging information formats.
643 This option is implicitly enabled if debugging information is enabled,
644 but this can be inhibited with the negated form
645 @option{-fno-working-directory}. If the @option{-P} flag is present
646 in the command line, this option has no effect, since no @code{#line}
647 directives are emitted whatsoever.
649 @item -idirafter @var{dir}
650 @opindex @code{idirafter @var{dir}}
651 @cindex preprocessing, include path
652 Search @var{dir} for include files, but do it after all directories
653 specified with @option{-I} and the standard system directories have
654 been exhausted. @var{dir} is treated as a system include directory.
655 If dir begins with @code{=}, then the @code{=} will be replaced by
656 the sysroot prefix; see @option{--sysroot} and @option{-isysroot}.
658 @item -imultilib @var{dir}
659 @opindex @code{imultilib @var{dir}}
660 @cindex preprocessing, include path
661 Use @var{dir} as a subdirectory of the directory containing target-specific
664 @item -iprefix @var{prefix}
665 @opindex @code{iprefix @var{prefix}}
666 @cindex preprocessing, include path
667 Specify @var{prefix} as the prefix for subsequent @option{-iwithprefix}
668 options. If the @var{prefix} represents a directory, you should include
669 the final @code{'/'}.
671 @item -isysroot @var{dir}
672 @opindex @code{isysroot @var{dir}}
673 @cindex preprocessing, include path
674 This option is like the @option{--sysroot} option, but applies only to
675 header files. See the @option{--sysroot} option for more information.
677 @item -iquote @var{dir}
678 @opindex @code{iquote @var{dir}}
679 @cindex preprocessing, include path
680 Search @var{dir} only for header files requested with @code{#include "file"};
681 they are not searched for @code{#include <file>}, before all directories
682 specified by @option{-I} and before the standard system directories. If
683 @var{dir} begins with @code{=}, then the @code{=} will be replaced by the
684 sysroot prefix; see @option{--sysroot} and @option{-isysroot}.
686 @item -isystem @var{dir}
687 @opindex @code{isystem @var{dir}}
688 @cindex preprocessing, include path
689 Search @var{dir} for header files, after all directories specified by
690 @option{-I} but before the standard system directories. Mark it as a
691 system directory, so that it gets the same special treatment as is
692 applied to the standard system directories. If @var{dir} begins with
693 @code{=}, then the @code{=} will be replaced by the sysroot prefix;
694 see @option{--sysroot} and @option{-isysroot}.
697 @opindex @code{nostdinc}
698 Do not search the standard system directories for header files. Only
699 the directories you have specified with @option{-I} options (and the
700 directory of the current file, if appropriate) are searched.
703 @opindex @code{undef}
704 Do not predefine any system-specific or GCC-specific macros.
705 The standard predefined macros remain defined.
707 @item -A@var{predicate}=@var{answer}
708 @opindex @code{A@var{predicate}=@var{answer}}
709 @cindex preprocessing, assertion
710 Make an assertion with the predicate @var{predicate} and answer @var{answer}.
711 This form is preferred to the older form -A predicate(answer), which is still
712 supported, because it does not use shell special characters.
714 @item -A-@var{predicate}=@var{answer}
715 @opindex @code{A-@var{predicate}=@var{answer}}
716 @cindex preprocessing, assertion
717 Cancel an assertion with the predicate @var{predicate} and answer @var{answer}.
721 @cindex preprocessing, keep comments
722 Do not discard comments. All comments are passed through to the output
723 file, except for comments in processed directives, which are deleted
724 along with the directive.
726 You should be prepared for side effects when using @option{-C}; it causes
727 the preprocessor to treat comments as tokens in their own right. For example,
728 comments appearing at the start of what would be a directive line have the
729 effect of turning that line into an ordinary source line, since the first
730 token on the line is no longer a @code{'#'}.
732 Warning: this currently handles C-Style comments only. The preprocessor
733 does not yet recognize Fortran-style comments.
737 @cindex preprocessing, keep comments
738 Do not discard comments, including during macro expansion. This is like
739 @option{-C}, except that comments contained within macros are also passed
740 through to the output file where the macro is expanded.
742 In addition to the side-effects of the @option{-C} option, the @option{-CC}
743 option causes all C++-style comments inside a macro to be converted to C-style
744 comments. This is to prevent later use of that macro from inadvertently
745 commenting out the remainder of the source line. The @option{-CC} option
746 is generally used to support lint comments.
748 Warning: this currently handles C- and C++-Style comments only. The
749 preprocessor does not yet recognize Fortran-style comments.
752 @opindex @code{D@var{name}}
753 @cindex preprocessing, define macros
754 Predefine name as a macro, with definition @code{1}.
756 @item -D@var{name}=@var{definition}
757 @opindex @code{D@var{name}=@var{definition}}
758 @cindex preprocessing, define macros
759 The contents of @var{definition} are tokenized and processed as if they
760 appeared during translation phase three in a @code{'#define'} directive.
761 In particular, the definition will be truncated by embedded newline
764 If you are invoking the preprocessor from a shell or shell-like program
765 you may need to use the shell's quoting syntax to protect characters such
766 as spaces that have a meaning in the shell syntax.
768 If you wish to define a function-like macro on the command line, write
769 its argument list with surrounding parentheses before the equals sign
770 (if any). Parentheses are meaningful to most shells, so you will need
771 to quote the option. With sh and csh, @code{-D'name(args...)=definition'}
774 @option{-D} and @option{-U} options are processed in the order they are
775 given on the command line. All -imacros file and -include file options
776 are processed after all -D and -U options.
780 Print the name of each header file used, in addition to other normal
781 activities. Each name is indented to show how deep in the @code{'#include'}
786 @cindex preprocessing, no linemarkers
787 Inhibit generation of linemarkers in the output from the preprocessor.
788 This might be useful when running the preprocessor on something that
789 is not C code, and will be sent to a program which might be confused
793 @opindex @code{U@var{name}}
794 @cindex preprocessing, undefine macros
795 Cancel any previous definition of @var{name}, either built in or provided
796 with a @option{-D} option.
800 @node Error and Warning Options
801 @section Options to request or suppress errors and warnings
802 @cindex options, warnings
803 @cindex options, errors
804 @cindex warnings, suppressing
805 @cindex messages, error
806 @cindex messages, warning
807 @cindex suppressing warnings
809 Errors are diagnostic messages that report that the GNU Fortran compiler
810 cannot compile the relevant piece of source code. The compiler will
811 continue to process the program in an attempt to report further errors
812 to aid in debugging, but will not produce any compiled output.
814 Warnings are diagnostic messages that report constructions which
815 are not inherently erroneous but which are risky or suggest there is
816 likely to be a bug in the program. Unless @option{-Werror} is specified,
817 they do not prevent compilation of the program.
819 You can request many specific warnings with options beginning @option{-W},
820 for example @option{-Wimplicit} to request warnings on implicit
821 declarations. Each of these specific warning options also has a
822 negative form beginning @option{-Wno-} to turn off warnings;
823 for example, @option{-Wno-implicit}. This manual lists only one of the
824 two forms, whichever is not the default.
826 These options control the amount and kinds of errors and warnings produced
830 @item -fmax-errors=@var{n}
831 @opindex @code{fmax-errors=}@var{n}
832 @cindex errors, limiting
833 Limits the maximum number of error messages to @var{n}, at which point
834 GNU Fortran bails out rather than attempting to continue processing the
835 source code. If @var{n} is 0, there is no limit on the number of error
839 @opindex @code{fsyntax-only}
840 @cindex syntax checking
841 Check the code for syntax errors, but do not actually compile it. This
842 will generate module files for each module present in the code, but no
847 @opindex @code{pedantic}
848 @opindex @code{Wpedantic}
849 Issue warnings for uses of extensions to Fortran.
850 @option{-pedantic} also applies to C-language constructs where they
851 occur in GNU Fortran source files, such as use of @samp{\e} in a
852 character constant within a directive like @code{#include}.
854 Valid Fortran programs should compile properly with or without
856 However, without this option, certain GNU extensions and traditional
857 Fortran features are supported as well.
858 With this option, many of them are rejected.
860 Some users try to use @option{-pedantic} to check programs for conformance.
861 They soon find that it does not do quite what they want---it finds some
862 nonstandard practices, but not all.
863 However, improvements to GNU Fortran in this area are welcome.
865 This should be used in conjunction with @option{-std=f95},
866 @option{-std=f2003}, @option{-std=f2008} or @option{-std=f2018}.
868 @item -pedantic-errors
869 @opindex @code{pedantic-errors}
870 Like @option{-pedantic}, except that errors are produced rather than
876 @cindex warnings, all
877 Enables commonly used warning options pertaining to usage that
878 we recommend avoiding and that we believe are easy to avoid.
879 This currently includes @option{-Waliasing}, @option{-Wampersand},
880 @option{-Wconversion}, @option{-Wsurprising}, @option{-Wc-binding-type},
881 @option{-Wintrinsics-std}, @option{-Wtabs}, @option{-Wintrinsic-shadow},
882 @option{-Wline-truncation}, @option{-Wtarget-lifetime},
883 @option{-Winteger-division}, @option{-Wreal-q-constant}, @option{-Wunused}
884 and @option{-Wundefined-do-loop}.
887 @opindex @code{Waliasing}
889 @cindex warnings, aliasing
890 Warn about possible aliasing of dummy arguments. Specifically, it warns
891 if the same actual argument is associated with a dummy argument with
892 @code{INTENT(IN)} and a dummy argument with @code{INTENT(OUT)} in a call
893 with an explicit interface.
895 The following example will trigger the warning.
899 integer, intent(in) :: a
900 integer, intent(out) :: b
909 @opindex @code{Wampersand}
910 @cindex warnings, ampersand
912 Warn about missing ampersand in continued character constants. The
913 warning is given with @option{-Wampersand}, @option{-pedantic},
914 @option{-std=f95}, @option{-std=f2003}, @option{-std=f2008} and
915 @option{-std=f2018}. Note: With no ampersand given in a continued
916 character constant, GNU Fortran assumes continuation at the first
917 non-comment, non-whitespace character after the ampersand that
918 initiated the continuation.
920 @item -Warray-temporaries
921 @opindex @code{Warray-temporaries}
922 @cindex warnings, array temporaries
923 Warn about array temporaries generated by the compiler. The information
924 generated by this warning is sometimes useful in optimization, in order to
925 avoid such temporaries.
927 @item -Wc-binding-type
928 @opindex @code{Wc-binding-type}
929 @cindex warning, C binding type
930 Warn if the a variable might not be C interoperable. In particular, warn if
931 the variable has been declared using an intrinsic type with default kind
932 instead of using a kind parameter defined for C interoperability in the
933 intrinsic @code{ISO_C_Binding} module. This option is implied by
936 @item -Wcharacter-truncation
937 @opindex @code{Wcharacter-truncation}
938 @cindex warnings, character truncation
939 Warn when a character assignment will truncate the assigned string.
941 @item -Wline-truncation
942 @opindex @code{Wline-truncation}
943 @cindex warnings, line truncation
944 Warn when a source code line will be truncated. This option is
945 implied by @option{-Wall}. For free-form source code, the default is
946 @option{-Werror=line-truncation} such that truncations are reported as
950 @opindex @code{Wconversion}
951 @cindex warnings, conversion
953 Warn about implicit conversions that are likely to change the value of
954 the expression after conversion. Implied by @option{-Wall}.
956 @item -Wconversion-extra
957 @opindex @code{Wconversion-extra}
958 @cindex warnings, conversion
960 Warn about implicit conversions between different types and kinds. This
961 option does @emph{not} imply @option{-Wconversion}.
964 @opindex @code{Wextra}
965 @cindex extra warnings
966 @cindex warnings, extra
967 Enables some warning options for usages of language features which
968 may be problematic. This currently includes @option{-Wcompare-reals},
969 @option{-Wunused-parameter} and @option{-Wdo-subscript}.
971 @item -Wfrontend-loop-interchange
972 @opindex @code{Wfrontend-loop-interchange}
973 @cindex warnings, loop interchange
974 @cindex loop interchange, warning
975 Warn when using @option{-ffrontend-loop-interchange} for performing loop
978 @item -Wimplicit-interface
979 @opindex @code{Wimplicit-interface}
980 @cindex warnings, implicit interface
981 Warn if a procedure is called without an explicit interface.
982 Note this only checks that an explicit interface is present. It does not
983 check that the declared interfaces are consistent across program units.
985 @item -Wimplicit-procedure
986 @opindex @code{Wimplicit-procedure}
987 @cindex warnings, implicit procedure
988 Warn if a procedure is called that has neither an explicit interface
989 nor has been declared as @code{EXTERNAL}.
991 @item -Winteger-division
992 @opindex @code{Winteger-division}
993 @cindex warnings, integer division
994 @cindex warnings, division of integers
995 Warn if a constant integer division truncates its result.
996 As an example, 3/5 evaluates to 0.
998 @item -Wintrinsics-std
999 @opindex @code{Wintrinsics-std}
1000 @cindex warnings, non-standard intrinsics
1001 @cindex warnings, intrinsics of other standards
1002 Warn if @command{gfortran} finds a procedure named like an intrinsic not
1003 available in the currently selected standard (with @option{-std}) and treats
1004 it as @code{EXTERNAL} procedure because of this. @option{-fall-intrinsics} can
1005 be used to never trigger this behavior and always link to the intrinsic
1006 regardless of the selected standard.
1008 @item -Wno-overwrite-recursive
1009 @opindex @code{Woverwrite-recursive}
1010 @cindex warnings, overwrite recursive
1011 Do not warn when @option{-fno-automatic} is used with @option{-frecursive}. Recursion
1012 will be broken if the relevant local variables do not have the attribute
1013 @code{AUTOMATIC} explicitly declared. This option can be used to suppress the warning
1014 when it is known that recursion is not broken. Useful for build environments that use
1017 @item -Wreal-q-constant
1018 @opindex @code{Wreal-q-constant}
1019 @cindex warnings, @code{q} exponent-letter
1020 Produce a warning if a real-literal-constant contains a @code{q}
1024 @opindex @code{Wsurprising}
1025 @cindex warnings, suspicious code
1026 Produce a warning when ``suspicious'' code constructs are encountered.
1027 While technically legal these usually indicate that an error has been made.
1029 This currently produces a warning under the following circumstances:
1033 An INTEGER SELECT construct has a CASE that can never be matched as its
1034 lower value is greater than its upper value.
1037 A LOGICAL SELECT construct has three CASE statements.
1040 A TRANSFER specifies a source that is shorter than the destination.
1043 The type of a function result is declared more than once with the same type. If
1044 @option{-pedantic} or standard-conforming mode is enabled, this is an error.
1047 A @code{CHARACTER} variable is declared with negative length.
1051 @opindex @code{Wtabs}
1052 @cindex warnings, tabs
1054 By default, tabs are accepted as whitespace, but tabs are not members
1055 of the Fortran Character Set. For continuation lines, a tab followed
1056 by a digit between 1 and 9 is supported. @option{-Wtabs} will cause a
1057 warning to be issued if a tab is encountered. Note, @option{-Wtabs} is
1058 active for @option{-pedantic}, @option{-std=f95}, @option{-std=f2003},
1059 @option{-std=f2008}, @option{-std=f2018} and
1062 @item -Wundefined-do-loop
1063 @opindex @code{Wundefined-do-loop}
1064 @cindex warnings, undefined do loop
1065 Warn if a DO loop with step either 1 or -1 yields an underflow or an overflow
1066 during iteration of an induction variable of the loop.
1067 This option is implied by @option{-Wall}.
1070 @opindex @code{Wunderflow}
1071 @cindex warnings, underflow
1073 Produce a warning when numerical constant expressions are
1074 encountered, which yield an UNDERFLOW during compilation. Enabled by default.
1076 @item -Wintrinsic-shadow
1077 @opindex @code{Wintrinsic-shadow}
1078 @cindex warnings, intrinsic
1080 Warn if a user-defined procedure or module procedure has the same name as an
1081 intrinsic; in this case, an explicit interface or @code{EXTERNAL} or
1082 @code{INTRINSIC} declaration might be needed to get calls later resolved to
1083 the desired intrinsic/procedure. This option is implied by @option{-Wall}.
1085 @item -Wuse-without-only
1086 @opindex @code{Wuse-without-only}
1087 @cindex warnings, use statements
1089 Warn if a @code{USE} statement has no @code{ONLY} qualifier and
1090 thus implicitly imports all public entities of the used module.
1092 @item -Wunused-dummy-argument
1093 @opindex @code{Wunused-dummy-argument}
1094 @cindex warnings, unused dummy argument
1095 @cindex unused dummy argument
1096 @cindex dummy argument, unused
1097 Warn about unused dummy arguments. This option is implied by @option{-Wall}.
1099 @item -Wunused-parameter
1100 @opindex @code{Wunused-parameter}
1101 @cindex warnings, unused parameter
1102 @cindex unused parameter
1103 Contrary to @command{gcc}'s meaning of @option{-Wunused-parameter},
1104 @command{gfortran}'s implementation of this option does not warn
1105 about unused dummy arguments (see @option{-Wunused-dummy-argument}),
1106 but about unused @code{PARAMETER} values. @option{-Wunused-parameter}
1107 is implied by @option{-Wextra} if also @option{-Wunused} or
1108 @option{-Wall} is used.
1110 @item -Walign-commons
1111 @opindex @code{Walign-commons}
1112 @cindex warnings, alignment of @code{COMMON} blocks
1113 @cindex alignment of @code{COMMON} blocks
1114 By default, @command{gfortran} warns about any occasion of variables being
1115 padded for proper alignment inside a @code{COMMON} block. This warning can be turned
1116 off via @option{-Wno-align-commons}. See also @option{-falign-commons}.
1118 @item -Wfunction-elimination
1119 @opindex @code{Wfunction-elimination}
1120 @cindex function elimination
1121 @cindex warnings, function elimination
1122 Warn if any calls to impure functions are eliminated by the optimizations
1123 enabled by the @option{-ffrontend-optimize} option.
1124 This option is implied by @option{-Wextra}.
1127 @opindex @code{Wrealloc-lhs}
1128 @cindex Reallocate the LHS in assignments, notification
1129 Warn when the compiler might insert code to for allocation or reallocation of
1130 an allocatable array variable of intrinsic type in intrinsic assignments. In
1131 hot loops, the Fortran 2003 reallocation feature may reduce the performance.
1132 If the array is already allocated with the correct shape, consider using a
1133 whole-array array-spec (e.g. @code{(:,:,:)}) for the variable on the left-hand
1134 side to prevent the reallocation check. Note that in some cases the warning
1135 is shown, even if the compiler will optimize reallocation checks away. For
1136 instance, when the right-hand side contains the same variable multiplied by
1137 a scalar. See also @option{-frealloc-lhs}.
1139 @item -Wrealloc-lhs-all
1140 @opindex @code{Wrealloc-lhs-all}
1141 Warn when the compiler inserts code to for allocation or reallocation of an
1142 allocatable variable; this includes scalars and derived types.
1144 @item -Wcompare-reals
1145 @opindex @code{Wcompare-reals}
1146 Warn when comparing real or complex types for equality or inequality.
1147 This option is implied by @option{-Wextra}.
1149 @item -Wtarget-lifetime
1150 @opindex @code{Wtargt-lifetime}
1151 Warn if the pointer in a pointer assignment might be longer than the its
1152 target. This option is implied by @option{-Wall}.
1155 @opindex @code{Wzerotrip}
1156 Warn if a @code{DO} loop is known to execute zero times at compile
1157 time. This option is implied by @option{-Wall}.
1159 @item -Wdo-subscript
1160 @opindex @code{Wdo-subscript}
1161 Warn if an array subscript inside a DO loop could lead to an
1162 out-of-bounds access even if the compiler cannot prove that the
1163 statement is actually executed, in cases like
1167 if (condition(i)) then
1172 This option is implied by @option{-Wextra}.
1175 @opindex @code{Werror}
1176 @cindex warnings, to errors
1177 Turns all warnings into errors.
1180 @xref{Warning Options,,Options to Request or Suppress Errors and
1181 Warnings, gcc,Using the GNU Compiler Collection (GCC)}, for information on
1182 more options offered by the GBE shared by @command{gfortran}, @command{gcc}
1183 and other GNU compilers.
1185 Some of these have no effect when compiling programs written in Fortran.
1187 @node Debugging Options
1188 @section Options for debugging your program or GNU Fortran
1189 @cindex options, debugging
1190 @cindex debugging information options
1192 GNU Fortran has various special options that are used for debugging
1193 either your program or the GNU Fortran compiler.
1196 @item -fdump-fortran-original
1197 @opindex @code{fdump-fortran-original}
1198 Output the internal parse tree after translating the source program
1199 into internal representation. This option is mostly useful for
1200 debugging the GNU Fortran compiler itself. The output generated by
1201 this option might change between releases. This option may also
1202 generate internal compiler errors for features which have only
1203 recently been added.
1205 @item -fdump-fortran-optimized
1206 @opindex @code{fdump-fortran-optimized}
1207 Output the parse tree after front-end optimization. Mostly useful for
1208 debugging the GNU Fortran compiler itself. The output generated by
1209 this option might change between releases. This option may also
1210 generate internal compiler errors for features which have only
1211 recently been added.
1213 @item -fdump-parse-tree
1214 @opindex @code{fdump-parse-tree}
1215 Output the internal parse tree after translating the source program
1216 into internal representation. Mostly useful for debugging the GNU
1217 Fortran compiler itself. The output generated by this option might
1218 change between releases. This option may also generate internal
1219 compiler errors for features which have only recently been added. This
1220 option is deprecated; use @code{-fdump-fortran-original} instead.
1222 @item -fdebug-aux-vars
1223 @opindex @code{fdebug-aux-vars}
1224 Renames internal variables created by the gfortran front end and makes
1225 them accessible to a debugger. The name of the internal variables then
1226 start with upper-case letters followed by an underscore. This option is
1227 useful for debugging the compiler's code generation together with
1228 @code{-fdump-tree-original} and enabling debugging of the executable
1229 program by using @code{-g} or @code{-ggdb3}.
1231 @item -fdump-fortran-global
1232 @opindex @code{fdump-fortran-global}
1233 Output a list of the global identifiers after translating into
1234 middle-end representation. Mostly useful for debugging the GNU Fortran
1235 compiler itself. The output generated by this option might change
1236 between releases. This option may also generate internal compiler
1237 errors for features which have only recently been added.
1239 @item -ffpe-trap=@var{list}
1240 @opindex @code{ffpe-trap=}@var{list}
1241 Specify a list of floating point exception traps to enable. On most
1242 systems, if a floating point exception occurs and the trap for that
1243 exception is enabled, a SIGFPE signal will be sent and the program
1244 being aborted, producing a core file useful for debugging. @var{list}
1245 is a (possibly empty) comma-separated list of the following
1246 exceptions: @samp{invalid} (invalid floating point operation, such as
1247 @code{SQRT(-1.0)}), @samp{zero} (division by zero), @samp{overflow}
1248 (overflow in a floating point operation), @samp{underflow} (underflow
1249 in a floating point operation), @samp{inexact} (loss of precision
1250 during operation), and @samp{denormal} (operation performed on a
1251 denormal value). The first five exceptions correspond to the five
1252 IEEE 754 exceptions, whereas the last one (@samp{denormal}) is not
1253 part of the IEEE 754 standard but is available on some common
1254 architectures such as x86.
1256 The first three exceptions (@samp{invalid}, @samp{zero}, and
1257 @samp{overflow}) often indicate serious errors, and unless the program
1258 has provisions for dealing with these exceptions, enabling traps for
1259 these three exceptions is probably a good idea.
1261 If the option is used more than once in the command line, the lists will
1262 be joined: '@code{ffpe-trap=}@var{list1} @code{ffpe-trap=}@var{list2}'
1263 is equivalent to @code{ffpe-trap=}@var{list1},@var{list2}.
1265 Note that once enabled an exception cannot be disabled (no negative form).
1267 Many, if not most, floating point operations incur loss of precision
1268 due to rounding, and hence the @code{ffpe-trap=inexact} is likely to
1269 be uninteresting in practice.
1271 By default no exception traps are enabled.
1273 @item -ffpe-summary=@var{list}
1274 @opindex @code{ffpe-summary=}@var{list}
1275 Specify a list of floating-point exceptions, whose flag status is printed
1276 to @code{ERROR_UNIT} when invoking @code{STOP} and @code{ERROR STOP}.
1277 @var{list} can be either @samp{none}, @samp{all} or a comma-separated list
1278 of the following exceptions: @samp{invalid}, @samp{zero}, @samp{overflow},
1279 @samp{underflow}, @samp{inexact} and @samp{denormal}. (See
1280 @option{-ffpe-trap} for a description of the exceptions.)
1282 If the option is used more than once in the command line, only the
1283 last one will be used.
1285 By default, a summary for all exceptions but @samp{inexact} is shown.
1287 @item -fno-backtrace
1288 @opindex @code{fno-backtrace}
1291 When a serious runtime error is encountered or a deadly signal is
1292 emitted (segmentation fault, illegal instruction, bus error,
1293 floating-point exception, and the other POSIX signals that have the
1294 action @samp{core}), the Fortran runtime library tries to output a
1295 backtrace of the error. @code{-fno-backtrace} disables the backtrace
1296 generation. This option only has influence for compilation of the
1297 Fortran main program.
1301 @xref{Debugging Options,,Options for Debugging Your Program or GCC,
1302 gcc,Using the GNU Compiler Collection (GCC)}, for more information on
1305 @node Directory Options
1306 @section Options for directory search
1307 @cindex directory, options
1308 @cindex options, directory search
1310 @cindex @code{INCLUDE} directive
1311 @cindex directive, @code{INCLUDE}
1312 These options affect how GNU Fortran searches
1313 for files specified by the @code{INCLUDE} directive and where it searches
1314 for previously compiled modules.
1316 It also affects the search paths used by @command{cpp} when used to preprocess
1321 @opindex @code{I}@var{dir}
1322 @cindex directory, search paths for inclusion
1323 @cindex inclusion, directory search paths for
1324 @cindex search paths, for included files
1325 @cindex paths, search
1326 @cindex module search path
1327 These affect interpretation of the @code{INCLUDE} directive
1328 (as well as of the @code{#include} directive of the @command{cpp}
1331 Also note that the general behavior of @option{-I} and
1332 @code{INCLUDE} is pretty much the same as of @option{-I} with
1333 @code{#include} in the @command{cpp} preprocessor, with regard to
1334 looking for @file{header.gcc} files and other such things.
1336 This path is also used to search for @file{.mod} files when previously
1337 compiled modules are required by a @code{USE} statement.
1339 @xref{Directory Options,,Options for Directory Search,
1340 gcc,Using the GNU Compiler Collection (GCC)}, for information on the
1344 @opindex @code{J}@var{dir}
1345 @opindex @code{M}@var{dir}
1346 @cindex paths, search
1347 @cindex module search path
1348 This option specifies where to put @file{.mod} files for compiled modules.
1349 It is also added to the list of directories to searched by an @code{USE}
1352 The default is the current directory.
1354 @item -fintrinsic-modules-path @var{dir}
1355 @opindex @code{fintrinsic-modules-path} @var{dir}
1356 @cindex paths, search
1357 @cindex module search path
1358 This option specifies the location of pre-compiled intrinsic modules, if
1359 they are not in the default location expected by the compiler.
1363 @section Influencing the linking step
1364 @cindex options, linking
1365 @cindex linking, static
1367 These options come into play when the compiler links object files into an
1368 executable output file. They are meaningless if the compiler is not doing
1372 @item -static-libgfortran
1373 @opindex @code{static-libgfortran}
1374 On systems that provide @file{libgfortran} as a shared and a static
1375 library, this option forces the use of the static version. If no
1376 shared version of @file{libgfortran} was built when the compiler was
1377 configured, this option has no effect.
1381 @node Runtime Options
1382 @section Influencing runtime behavior
1383 @cindex options, runtime
1385 These options affect the runtime behavior of programs compiled with GNU Fortran.
1388 @item -fconvert=@var{conversion}
1389 @opindex @code{fconvert=}@var{conversion}
1390 Specify the representation of data for unformatted files. Valid
1391 values for conversion are: @samp{native}, the default; @samp{swap},
1392 swap between big- and little-endian; @samp{big-endian}, use big-endian
1393 representation for unformatted files; @samp{little-endian}, use little-endian
1394 representation for unformatted files.
1396 @emph{This option has an effect only when used in the main program.
1397 The @code{CONVERT} specifier and the GFORTRAN_CONVERT_UNIT environment
1398 variable override the default specified by @option{-fconvert}.}
1400 @item -frecord-marker=@var{length}
1401 @opindex @code{frecord-marker=}@var{length}
1402 Specify the length of record markers for unformatted files.
1403 Valid values for @var{length} are 4 and 8. Default is 4.
1404 @emph{This is different from previous versions of @command{gfortran}},
1405 which specified a default record marker length of 8 on most
1406 systems. If you want to read or write files compatible
1407 with earlier versions of @command{gfortran}, use @option{-frecord-marker=8}.
1409 @item -fmax-subrecord-length=@var{length}
1410 @opindex @code{fmax-subrecord-length=}@var{length}
1411 Specify the maximum length for a subrecord. The maximum permitted
1412 value for length is 2147483639, which is also the default. Only
1413 really useful for use by the gfortran testsuite.
1416 @opindex @code{fsign-zero}
1417 When enabled, floating point numbers of value zero with the sign bit set
1418 are written as negative number in formatted output and treated as
1419 negative in the @code{SIGN} intrinsic. @option{-fno-sign-zero} does not
1420 print the negative sign of zero values (or values rounded to zero for I/O)
1421 and regards zero as positive number in the @code{SIGN} intrinsic for
1422 compatibility with Fortran 77. The default is @option{-fsign-zero}.
1425 @node Code Gen Options
1426 @section Options for code generation conventions
1427 @cindex code generation, conventions
1428 @cindex options, code generation
1429 @cindex options, run-time
1431 These machine-independent options control the interface conventions
1432 used in code generation.
1434 Most of them have both positive and negative forms; the negative form
1435 of @option{-ffoo} would be @option{-fno-foo}. In the table below, only
1436 one of the forms is listed---the one which is not the default. You
1437 can figure out the other form by either removing @option{no-} or adding
1441 @item -fno-automatic
1442 @opindex @code{fno-automatic}
1443 @cindex @code{SAVE} statement
1444 @cindex statement, @code{SAVE}
1445 Treat each program unit (except those marked as RECURSIVE) as if the
1446 @code{SAVE} statement were specified for every local variable and array
1447 referenced in it. Does not affect common blocks. (Some Fortran compilers
1448 provide this option under the name @option{-static} or @option{-save}.)
1449 The default, which is @option{-fautomatic}, uses the stack for local
1450 variables smaller than the value given by @option{-fmax-stack-var-size}.
1451 Use the option @option{-frecursive} to use no static memory.
1453 Local variables or arrays having an explicit @code{SAVE} attribute are
1454 silently ignored unless the @option{-pedantic} option is added.
1458 @cindex calling convention
1459 @cindex @command{f2c} calling convention
1460 @cindex @command{g77} calling convention
1461 @cindex libf2c calling convention
1462 Generate code designed to be compatible with code generated
1463 by @command{g77} and @command{f2c}.
1465 The calling conventions used by @command{g77} (originally implemented
1466 in @command{f2c}) require functions that return type
1467 default @code{REAL} to actually return the C type @code{double}, and
1468 functions that return type @code{COMPLEX} to return the values via an
1469 extra argument in the calling sequence that points to where to
1470 store the return value. Under the default GNU calling conventions, such
1471 functions simply return their results as they would in GNU
1472 C---default @code{REAL} functions return the C type @code{float}, and
1473 @code{COMPLEX} functions return the GNU C type @code{complex}.
1474 Additionally, this option implies the @option{-fsecond-underscore}
1475 option, unless @option{-fno-second-underscore} is explicitly requested.
1477 This does not affect the generation of code that interfaces with
1478 the @command{libgfortran} library.
1480 @emph{Caution:} It is not a good idea to mix Fortran code compiled with
1481 @option{-ff2c} with code compiled with the default @option{-fno-f2c}
1482 calling conventions as, calling @code{COMPLEX} or default @code{REAL}
1483 functions between program parts which were compiled with different
1484 calling conventions will break at execution time.
1486 @emph{Caution:} This will break code which passes intrinsic functions
1487 of type default @code{REAL} or @code{COMPLEX} as actual arguments, as
1488 the library implementations use the @option{-fno-f2c} calling conventions.
1490 @item -fno-underscoring
1491 @opindex @code{fno-underscoring}
1493 @cindex symbol names, underscores
1494 @cindex transforming symbol names
1495 @cindex symbol names, transforming
1496 Do not transform names of entities specified in the Fortran
1497 source file by appending underscores to them.
1499 With @option{-funderscoring} in effect, GNU Fortran appends one
1500 underscore to external names with no underscores. This is done to ensure
1501 compatibility with code produced by many UNIX Fortran compilers.
1503 @emph{Caution}: The default behavior of GNU Fortran is
1504 incompatible with @command{f2c} and @command{g77}, please use the
1505 @option{-ff2c} option if you want object files compiled with
1506 GNU Fortran to be compatible with object code created with these
1509 Use of @option{-fno-underscoring} is not recommended unless you are
1510 experimenting with issues such as integration of GNU Fortran into
1511 existing system environments (vis-@`{a}-vis existing libraries, tools,
1514 For example, with @option{-funderscoring}, and assuming that @code{j()} and
1515 @code{max_count()} are external functions while @code{my_var} and
1516 @code{lvar} are local variables, a statement like
1518 I = J() + MAX_COUNT (MY_VAR, LVAR)
1521 is implemented as something akin to:
1523 i = j_() + max_count__(&my_var__, &lvar);
1526 With @option{-fno-underscoring}, the same statement is implemented as:
1529 i = j() + max_count(&my_var, &lvar);
1532 Use of @option{-fno-underscoring} allows direct specification of
1533 user-defined names while debugging and when interfacing GNU Fortran
1534 code with other languages.
1536 Note that just because the names match does @emph{not} mean that the
1537 interface implemented by GNU Fortran for an external name matches the
1538 interface implemented by some other language for that same name.
1539 That is, getting code produced by GNU Fortran to link to code produced
1540 by some other compiler using this or any other method can be only a
1541 small part of the overall solution---getting the code generated by
1542 both compilers to agree on issues other than naming can require
1543 significant effort, and, unlike naming disagreements, linkers normally
1544 cannot detect disagreements in these other areas.
1546 Also, note that with @option{-fno-underscoring}, the lack of appended
1547 underscores introduces the very real possibility that a user-defined
1548 external name will conflict with a name in a system library, which
1549 could make finding unresolved-reference bugs quite difficult in some
1550 cases---they might occur at program run time, and show up only as
1551 buggy behavior at run time.
1553 In future versions of GNU Fortran we hope to improve naming and linking
1554 issues so that debugging always involves using the names as they appear
1555 in the source, even if the names as seen by the linker are mangled to
1556 prevent accidental linking between procedures with incompatible
1559 @item -fsecond-underscore
1560 @opindex @code{fsecond-underscore}
1562 @cindex symbol names, underscores
1563 @cindex transforming symbol names
1564 @cindex symbol names, transforming
1565 @cindex @command{f2c} calling convention
1566 @cindex @command{g77} calling convention
1567 @cindex libf2c calling convention
1568 By default, GNU Fortran appends an underscore to external
1569 names. If this option is used GNU Fortran appends two
1570 underscores to names with underscores and one underscore to external names
1571 with no underscores. GNU Fortran also appends two underscores to
1572 internal names with underscores to avoid naming collisions with external
1575 This option has no effect if @option{-fno-underscoring} is
1576 in effect. It is implied by the @option{-ff2c} option.
1578 Otherwise, with this option, an external name such as @code{MAX_COUNT}
1579 is implemented as a reference to the link-time external symbol
1580 @code{max_count__}, instead of @code{max_count_}. This is required
1581 for compatibility with @command{g77} and @command{f2c}, and is implied
1582 by use of the @option{-ff2c} option.
1584 @item -fcoarray=@var{<keyword>}
1585 @opindex @code{fcoarray}
1590 Disable coarray support; using coarray declarations and image-control
1591 statements will produce a compile-time error. (Default)
1594 Single-image mode, i.e. @code{num_images()} is always one.
1597 Library-based coarray parallelization; a suitable GNU Fortran coarray
1598 library needs to be linked.
1602 @item -fcheck=@var{<keyword>}
1603 @opindex @code{fcheck}
1604 @cindex array, bounds checking
1605 @cindex bit intrinsics checking
1606 @cindex bounds checking
1607 @cindex pointer checking
1608 @cindex memory checking
1609 @cindex range checking
1610 @cindex subscript checking
1611 @cindex checking subscripts
1612 @cindex run-time checking
1613 @cindex checking array temporaries
1615 Enable the generation of run-time checks; the argument shall be
1616 a comma-delimited list of the following keywords. Prefixing a check with
1617 @option{no-} disables it if it was activated by a previous specification.
1621 Enable all run-time test of @option{-fcheck}.
1623 @item @samp{array-temps}
1624 Warns at run time when for passing an actual argument a temporary array
1625 had to be generated. The information generated by this warning is
1626 sometimes useful in optimization, in order to avoid such temporaries.
1628 Note: The warning is only printed once per location.
1631 Enable generation of run-time checks for invalid arguments to the bit
1632 manipulation intrinsics.
1635 Enable generation of run-time checks for array subscripts
1636 and against the declared minimum and maximum values. It also
1637 checks array indices for assumed and deferred
1638 shape arrays against the actual allocated bounds and ensures that all string
1639 lengths are equal for character array constructors without an explicit
1642 Some checks require that @option{-fcheck=bounds} is set for
1643 the compilation of the main program.
1645 Note: In the future this may also include other forms of checking, e.g.,
1646 checking substring references.
1649 Enable generation of run-time checks for invalid modification of loop
1650 iteration variables.
1653 Enable generation of run-time checks for memory allocation.
1654 Note: This option does not affect explicit allocations using the
1655 @code{ALLOCATE} statement, which will be always checked.
1657 @item @samp{pointer}
1658 Enable generation of run-time checks for pointers and allocatables.
1660 @item @samp{recursion}
1661 Enable generation of run-time checks for recursively called subroutines and
1662 functions which are not marked as recursive. See also @option{-frecursive}.
1663 Note: This check does not work for OpenMP programs and is disabled if used
1664 together with @option{-frecursive} and @option{-fopenmp}.
1667 Example: Assuming you have a file @file{foo.f90}, the command
1669 gfortran -fcheck=all,no-array-temps foo.f90
1671 will compile the file with all checks enabled as specified above except
1672 warnings for generated array temporaries.
1675 @item -fbounds-check
1676 @opindex @code{fbounds-check}
1677 @c Note: This option is also referred in gcc's manpage
1678 Deprecated alias for @option{-fcheck=bounds}.
1680 @item -ftail-call-workaround
1681 @itemx -ftail-call-workaround=@var{n}
1682 @opindex @code{tail-call-workaround}
1683 Some C interfaces to Fortran codes violate the gfortran ABI by
1684 omitting the hidden character length arguments as described in
1685 @xref{Argument passing conventions}. This can lead to crashes
1686 because pushing arguments for tail calls can overflow the stack.
1688 To provide a workaround for existing binary packages, this option
1689 disables tail call optimization for gfortran procedures with character
1690 arguments. With @option{-ftail-call-workaround=2} tail call optimization
1691 is disabled in all gfortran procedures with character arguments,
1692 with @option{-ftail-call-workaround=1} or equivalent
1693 @option{-ftail-call-workaround} only in gfortran procedures with character
1694 arguments that call implicitly prototyped procedures.
1696 Using this option can lead to problems including crashes due to
1697 insufficient stack space.
1699 It is @emph{very strongly} recommended to fix the code in question.
1700 The @option{-fc-prototypes-external} option can be used to generate
1701 prototypes which conform to gfortran's ABI, for inclusion in the
1704 Support for this option will likely be withdrawn in a future release
1707 The negative form, @option{-fno-tail-call-workaround} or equivalent
1708 @option{-ftail-call-workaround=0}, can be used to disable this option.
1710 Default is currently @option{-ftail-call-workaround}, this will change
1713 @item -fcheck-array-temporaries
1714 @opindex @code{fcheck-array-temporaries}
1715 Deprecated alias for @option{-fcheck=array-temps}.
1717 @item -fmax-array-constructor=@var{n}
1718 @opindex @code{fmax-array-constructor}
1719 This option can be used to increase the upper limit permitted in
1720 array constructors. The code below requires this option to expand
1721 the array at compile time.
1727 integer, parameter :: n = 100000
1728 integer, parameter :: i(n) = (/ (2*j, j = 1, n) /)
1729 print '(10(I0,1X))', i
1733 @emph{Caution: This option can lead to long compile times and excessively
1734 large object files.}
1736 The default value for @var{n} is 65535.
1739 @item -fmax-stack-var-size=@var{n}
1740 @opindex @code{fmax-stack-var-size}
1741 This option specifies the size in bytes of the largest array that will be put
1742 on the stack; if the size is exceeded static memory is used (except in
1743 procedures marked as RECURSIVE). Use the option @option{-frecursive} to
1744 allow for recursive procedures which do not have a RECURSIVE attribute or
1745 for parallel programs. Use @option{-fno-automatic} to never use the stack.
1747 This option currently only affects local arrays declared with constant
1748 bounds, and may not apply to all character variables.
1749 Future versions of GNU Fortran may improve this behavior.
1751 The default value for @var{n} is 65536.
1753 @item -fstack-arrays
1754 @opindex @code{fstack-arrays}
1755 Adding this option will make the Fortran compiler put all arrays of
1756 unknown size and array temporaries onto stack memory. If your program uses very
1757 large local arrays it is possible that you will have to extend your runtime
1758 limits for stack memory on some operating systems. This flag is enabled
1759 by default at optimization level @option{-Ofast} unless
1760 @option{-fmax-stack-var-size} is specified.
1762 @item -fpack-derived
1763 @opindex @code{fpack-derived}
1764 @cindex structure packing
1765 This option tells GNU Fortran to pack derived type members as closely as
1766 possible. Code compiled with this option is likely to be incompatible
1767 with code compiled without this option, and may execute slower.
1769 @item -frepack-arrays
1770 @opindex @code{frepack-arrays}
1771 @cindex repacking arrays
1772 In some circumstances GNU Fortran may pass assumed shape array
1773 sections via a descriptor describing a noncontiguous area of memory.
1774 This option adds code to the function prologue to repack the data into
1775 a contiguous block at runtime.
1777 This should result in faster accesses to the array. However it can introduce
1778 significant overhead to the function call, especially when the passed data
1782 @opindex @code{fshort-enums}
1783 This option is provided for interoperability with C code that was
1784 compiled with the @option{-fshort-enums} option. It will make
1785 GNU Fortran choose the smallest @code{INTEGER} kind a given
1786 enumerator set will fit in, and give all its enumerators this kind.
1788 @item -finline-arg-packing
1789 @opindex @code{finline-arg-packing}
1790 When passing an assumed-shape argument of a procedure as actual
1791 argument to an assumed-size or explicit size or as argument to a
1792 procedure that does not have an explicit interface, the argument may
1793 have to be packed, that is put into contiguous memory. An example is
1794 the call to @code{foo} in
1797 real, dimension(*) :: a
1800 real, dimension(:) :: b
1805 When @option{-finline-arg-packing} is in effect, this packing will be
1806 performed by inline code. This allows for more optimization while
1807 increasing code size.
1809 @option{-finline-arg-packing} is implied by any of the @option{-O} options
1810 except when optimizing for size via @option{-Os}. If the code
1811 contains a very large number of argument that have to be packed, code
1812 size and also compilation time may become excessive. If that is the
1813 case, it may be better to disable this option. Instances of packing
1814 can be found by using by using @option{-Warray-temporaries}.
1816 @item -fexternal-blas
1817 @opindex @code{fexternal-blas}
1818 This option will make @command{gfortran} generate calls to BLAS functions
1819 for some matrix operations like @code{MATMUL}, instead of using our own
1820 algorithms, if the size of the matrices involved is larger than a given
1821 limit (see @option{-fblas-matmul-limit}). This may be profitable if an
1822 optimized vendor BLAS library is available. The BLAS library will have
1823 to be specified at link time.
1825 @item -fblas-matmul-limit=@var{n}
1826 @opindex @code{fblas-matmul-limit}
1827 Only significant when @option{-fexternal-blas} is in effect.
1828 Matrix multiplication of matrices with size larger than (or equal to) @var{n}
1829 will be performed by calls to BLAS functions, while others will be
1830 handled by @command{gfortran} internal algorithms. If the matrices
1831 involved are not square, the size comparison is performed using the
1832 geometric mean of the dimensions of the argument and result matrices.
1834 The default value for @var{n} is 30.
1836 @item -finline-matmul-limit=@var{n}
1837 @opindex @code{finline-matmul-limit}
1838 When front-end optimization is active, some calls to the @code{MATMUL}
1839 intrinsic function will be inlined. This may result in code size
1840 increase if the size of the matrix cannot be determined at compile
1841 time, as code for both cases is generated. Setting
1842 @code{-finline-matmul-limit=0} will disable inlining in all cases.
1843 Setting this option with a value of @var{n} will produce inline code
1844 for matrices with size up to @var{n}. If the matrices involved are not
1845 square, the size comparison is performed using the geometric mean of
1846 the dimensions of the argument and result matrices.
1848 The default value for @var{n} is 30. The @code{-fblas-matmul-limit}
1849 can be used to change this value.
1852 @opindex @code{frecursive}
1853 Allow indirect recursion by forcing all local arrays to be allocated
1854 on the stack. This flag cannot be used together with
1855 @option{-fmax-stack-var-size=} or @option{-fno-automatic}.
1857 @item -finit-local-zero
1858 @itemx -finit-derived
1859 @itemx -finit-integer=@var{n}
1860 @itemx -finit-real=@var{<zero|inf|-inf|nan|snan>}
1861 @itemx -finit-logical=@var{<true|false>}
1862 @itemx -finit-character=@var{n}
1863 @opindex @code{finit-local-zero}
1864 @opindex @code{finit-derived}
1865 @opindex @code{finit-integer}
1866 @opindex @code{finit-real}
1867 @opindex @code{finit-logical}
1868 @opindex @code{finit-character}
1869 The @option{-finit-local-zero} option instructs the compiler to
1870 initialize local @code{INTEGER}, @code{REAL}, and @code{COMPLEX}
1871 variables to zero, @code{LOGICAL} variables to false, and
1872 @code{CHARACTER} variables to a string of null bytes. Finer-grained
1873 initialization options are provided by the
1874 @option{-finit-integer=@var{n}},
1875 @option{-finit-real=@var{<zero|inf|-inf|nan|snan>}} (which also initializes
1876 the real and imaginary parts of local @code{COMPLEX} variables),
1877 @option{-finit-logical=@var{<true|false>}}, and
1878 @option{-finit-character=@var{n}} (where @var{n} is an ASCII character
1881 With @option{-finit-derived}, components of derived type variables will be
1882 initialized according to these flags. Components whose type is not covered by
1883 an explicit @option{-finit-*} flag will be treated as described above with
1884 @option{-finit-local-zero}.
1886 These options do not initialize
1889 objects with the POINTER attribute
1893 variables that appear in an @code{EQUIVALENCE} statement.
1895 (These limitations may be removed in future releases).
1897 Note that the @option{-finit-real=nan} option initializes @code{REAL}
1898 and @code{COMPLEX} variables with a quiet NaN. For a signalling NaN
1899 use @option{-finit-real=snan}; note, however, that compile-time
1900 optimizations may convert them into quiet NaN and that trapping
1901 needs to be enabled (e.g. via @option{-ffpe-trap}).
1903 The @option{-finit-integer} option will parse the value into an
1904 integer of type @code{INTEGER(kind=C_LONG)} on the host. Said value
1905 is then assigned to the integer variables in the Fortran code, which
1906 might result in wraparound if the value is too large for the kind.
1908 Finally, note that enabling any of the @option{-finit-*} options will
1909 silence warnings that would have been emitted by @option{-Wuninitialized}
1910 for the affected local variables.
1912 @item -falign-commons
1913 @opindex @code{falign-commons}
1914 @cindex alignment of @code{COMMON} blocks
1915 By default, @command{gfortran} enforces proper alignment of all variables in a
1916 @code{COMMON} block by padding them as needed. On certain platforms this is mandatory,
1917 on others it increases performance. If a @code{COMMON} block is not declared with
1918 consistent data types everywhere, this padding can cause trouble, and
1919 @option{-fno-align-commons} can be used to disable automatic alignment. The
1920 same form of this option should be used for all files that share a @code{COMMON} block.
1921 To avoid potential alignment issues in @code{COMMON} blocks, it is recommended to order
1922 objects from largest to smallest.
1924 @item -fno-protect-parens
1925 @opindex @code{fno-protect-parens}
1926 @cindex re-association of parenthesized expressions
1927 By default the parentheses in expression are honored for all optimization
1928 levels such that the compiler does not do any re-association. Using
1929 @option{-fno-protect-parens} allows the compiler to reorder @code{REAL} and
1930 @code{COMPLEX} expressions to produce faster code. Note that for the re-association
1931 optimization @option{-fno-signed-zeros} and @option{-fno-trapping-math}
1932 need to be in effect. The parentheses protection is enabled by default, unless
1933 @option{-Ofast} is given.
1936 @opindex @code{frealloc-lhs}
1937 @cindex Reallocate the LHS in assignments
1938 An allocatable left-hand side of an intrinsic assignment is automatically
1939 (re)allocated if it is either unallocated or has a different shape. The
1940 option is enabled by default except when @option{-std=f95} is given. See
1941 also @option{-Wrealloc-lhs}.
1943 @item -faggressive-function-elimination
1944 @opindex @code{faggressive-function-elimination}
1945 @cindex Elimination of functions with identical argument lists
1946 Functions with identical argument lists are eliminated within
1947 statements, regardless of whether these functions are marked
1948 @code{PURE} or not. For example, in
1952 there will only be a single call to @code{f}. This option only works
1953 if @option{-ffrontend-optimize} is in effect.
1955 @item -ffrontend-optimize
1956 @opindex @code{frontend-optimize}
1957 @cindex Front-end optimization
1958 This option performs front-end optimization, based on manipulating
1959 parts the Fortran parse tree. Enabled by default by any @option{-O} option
1960 except @option{-O0} and @option{-Og}. Optimizations enabled by this option
1963 @item inlining calls to @code{MATMUL},
1964 @item elimination of identical function calls within expressions,
1965 @item removing unnecessary calls to @code{TRIM} in comparisons and assignments,
1966 @item replacing @code{TRIM(a)} with @code{a(1:LEN_TRIM(a))} and
1967 @item short-circuiting of logical operators (@code{.AND.} and @code{.OR.}).
1969 It can be deselected by specifying @option{-fno-frontend-optimize}.
1971 @item -ffrontend-loop-interchange
1972 @opindex @code{frontend-loop-interchange}
1973 @cindex loop interchange, Fortran
1974 Attempt to interchange loops in the Fortran front end where
1975 profitable. Enabled by default by any @option{-O} option.
1976 At the moment, this option only affects @code{FORALL} and
1977 @code{DO CONCURRENT} statements with several forall triplets.
1980 @xref{Code Gen Options,,Options for Code Generation Conventions,
1981 gcc,Using the GNU Compiler Collection (GCC)}, for information on more options
1983 shared by @command{gfortran}, @command{gcc}, and other GNU compilers.
1987 @node Interoperability Options
1988 @section Options for interoperability with other languages
1992 @item -fc-prototypes
1993 @opindex @code{c-prototypes}
1994 @cindex Generating C prototypes from Fortran BIND(C) enteties
1995 This option will generate C prototypes from @code{BIND(C)} variable
1996 declarations, types and procedure interfaces and writes them to
1997 standard output. @code{ENUM} is not yet supported.
1999 The generated prototypes may need inclusion of an appropriate header,
2000 such as @code{<stdint.h>} or @code{<stdlib.h>}. For types which are
2001 not specified using the appropriate kind from the @code{iso_c_binding}
2002 module, a warning is added as a comment to the code.
2004 For function pointers, a pointer to a function returning @code{int}
2005 without an explicit argument list is generated.
2009 $ gfortran -fc-prototypes -fsyntax-only foo.f90 > foo.h
2011 where the C code intended for interoperating with the Fortran code
2012 then uses @code{#include "foo.h"}.
2014 @item -fc-prototypes-external
2015 @opindex @code{c-prototypes-external}
2016 @cindex Generating C prototypes from external procedures
2017 This option will generate C prototypes from external functions and
2018 subroutines and write them to standard output. This may be useful for
2019 making sure that C bindings to Fortran code are correct. This option
2020 does not generate prototypes for @code{BIND(C)} procedures, use
2021 @option{-fc-prototypes} for that.
2023 The generated prototypes may need inclusion of an appropriate
2024 header, such as as @code{<stdint.h>} or @code{<stdlib.h>}.
2026 This is primarily meant for legacy code to ensure that existing C
2027 bindings match what @command{gfortran} emits. The generated C
2028 prototypes should be correct for the current version of the compiler,
2029 but may not match what other compilers or earlier versions of
2030 @command{gfortran} need. For new developments, use of the
2031 @code{BIND(C)} features is recommended.
2035 $ gfortran -fc-prototypes-external -fsyntax-only foo.f > foo.h
2037 where the C code intended for interoperating with the Fortran code
2038 then uses @code{#include "foo.h"}.
2041 @node Environment Variables
2042 @section Environment variables affecting @command{gfortran}
2043 @cindex environment variable
2045 @c man begin ENVIRONMENT
2047 The @command{gfortran} compiler currently does not make use of any environment
2048 variables to control its operation above and beyond those
2049 that affect the operation of @command{gcc}.
2051 @xref{Environment Variables,,Environment Variables Affecting GCC,
2052 gcc,Using the GNU Compiler Collection (GCC)}, for information on environment
2055 @xref{Runtime}, for environment variables that affect the
2056 run-time behavior of programs compiled with GNU Fortran.