1GFORTRAN(1) GNU GFORTRAN(1)
2
6 gfortran - GNU Fortran compiler
7
9 gfortran [-c|-S|-E]
10 [-g] [-pg] [-Olevel]
11 [-Wwarn...] [-pedantic]
12 [-Idir...] [-Ldir...]
13 [-Dmacro[=defn]...] [-Umacro]
14 [-foption...]
15 [-mmachine-option...]
16 [-o outfile] infile...
17 Only the most useful options are listed here; see below for the
19 remainder.
20
22 The gfortran command supports all the options supported by the gcc
23 command. Only options specific to GNU Fortran are documented here.
24 All GCC and GNU Fortran options are accepted both by gfortran and by
26 gcc (as well as any other drivers built at the same time, such as g++),
27 since adding GNU Fortran to the GCC distribution enables acceptance of
28 GNU Fortran options by all of the relevant drivers.
29 In some cases, options have positive and negative forms; the negative
31 form of -ffoo would be -fno-foo. This manual documents only one of
32 these two forms, whichever one is not the default.
33
35 Here is a summary of all the options specific to GNU Fortran, grouped
36 by type. Explanations are in the following sections.
37 Fortran Language Options
39 -fall-intrinsics -fbackslash -fcray-pointer -fd-lines-as-code
40 -fd-lines-as-comments -fdec -fdec-structure -fdec-intrinsic-ints
41 -fdec-static -fdec-math -fdefault-double-8 -fdefault-integer-8
42 -fdefault-real-8 -fdefault-real-10 -fdefault-real-16 -fdollar-ok
43 -ffixed-line-length-n -ffixed-line-length-none -ffree-form
44 -ffree-line-length-n -ffree-line-length-none -fimplicit-none
45 -finteger-4-integer-8 -fmax-identifier-length -fmodule-private
46 -ffixed-form -fno-range-check -fopenacc -fopenmp -freal-4-real-10
47 -freal-4-real-16 -freal-4-real-8 -freal-8-real-10 -freal-8-real-16
48 -freal-8-real-4 -std=std -ftest-forall-temp
49 Preprocessing Options
51 -A-question[=answer] -Aquestion=answer -C -CC -Dmacro[=defn] -H -P
52 -Umacro -cpp -dD -dI -dM -dN -dU -fworking-directory -imultilib dir
53 -iprefix file -iquote -isysroot dir -isystem dir -nocpp -nostdinc
54 -undef
55 Error and Warning Options
57 -Waliasing -Wall -Wampersand -Wargument-mismatch -Warray-bounds
58 -Wc-binding-type -Wcharacter-truncation -Wconversion -Wdo-subscript
59 -Wfunction-elimination -Wimplicit-interface -Wimplicit-procedure
60 -Wintrinsic-shadow -Wuse-without-only -Wintrinsics-std
61 -Wline-truncation -Wno-align-commons -Wno-tabs -Wreal-q-constant
62 -Wsurprising -Wunderflow -Wunused-parameter -Wrealloc-lhs
63 -Wrealloc-lhs-all -Wfrontend-loop-interchange -Wtarget-lifetime
64 -fmax-errors=n -fsyntax-only -pedantic -pedantic-errors
65 Debugging Options
67 -fbacktrace -fdump-fortran-optimized -fdump-fortran-original
68 -fdump-parse-tree -ffpe-trap=list -ffpe-summary=list
69 Directory Options
71 -Idir -Jdir -fintrinsic-modules-path dir
72 Link Options
74 -static-libgfortran
75 Runtime Options
77 -fconvert=conversion -fmax-subrecord-length=length
78 -frecord-marker=length -fsign-zero
79 Interoperability Options
81 -fc-prototypes
82 Code Generation Options
84 -faggressive-function-elimination -fblas-matmul-limit=n
85 -fbounds-check -fcheck-array-temporaries
86 -fcheck=<all|array-temps|bounds|do|mem|pointer|recursion>
87 -fcoarray=<none|single|lib> -fexternal-blas -ff2c
88 -ffrontend-loop-interchange -ffrontend-optimize -finit-character=n
89 -finit-integer=n -finit-local-zero -finit-derived
90 -finit-logical=<true|false> -finit-real=<zero|inf|-inf|nan|snan>
91 -finline-matmul-limit=n -fmax-array-constructor=n
92 -fmax-stack-var-size=n -fno-align-commons -fno-automatic
93 -fno-protect-parens -fno-underscoring -fsecond-underscore
94 -fpack-derived -frealloc-lhs -frecursive -frepack-arrays
95 -fshort-enums -fstack-arrays
96 Options controlling Fortran dialect
98 The following options control the details of the Fortran dialect
99 accepted by the compiler:
100 -ffree-form
102 -ffixed-form
103 Specify the layout used by the source file. The free form layout
104 was introduced in Fortran 90. Fixed form was traditionally used in
105 older Fortran programs. When neither option is specified, the
106 source form is determined by the file extension.
107 -fall-intrinsics
109 This option causes all intrinsic procedures (including the GNU-
110 specific extensions) to be accepted. This can be useful with
111 -std=f95 to force standard-compliance but get access to the full
112 range of intrinsics available with gfortran. As a consequence,
113 -Wintrinsics-std will be ignored and no user-defined procedure with
114 the same name as any intrinsic will be called except when it is
115 explicitly declared "EXTERNAL".
116 -fd-lines-as-code
118 -fd-lines-as-comments
119 Enable special treatment for lines beginning with "d" or "D" in
120 fixed form sources. If the -fd-lines-as-code option is given they
121 are treated as if the first column contained a blank. If the
122 -fd-lines-as-comments option is given, they are treated as comment
123 lines.
124 -fdec
126 DEC compatibility mode. Enables extensions and other features that
127 mimic the default behavior of older compilers (such as DEC). These
128 features are non-standard and should be avoided at all costs. For
129 details on GNU Fortran's implementation of these extensions see the
130 full documentation.
131 Other flags enabled by this switch are: -fdollar-ok -fcray-pointer
133 -fdec-structure -fdec-intrinsic-ints -fdec-static -fdec-math
134 If -fd-lines-as-code/-fd-lines-as-comments are unset, then -fdec
136 also sets -fd-lines-as-comments.
137 -fdec-structure
139 Enable DEC "STRUCTURE" and "RECORD" as well as "UNION", "MAP", and
140 dot ('.') as a member separator (in addition to '%'). This is
141 provided for compatibility only; Fortran 90 derived types should be
142 used instead where possible.
143 -fdec-intrinsic-ints
145 Enable B/I/J/K kind variants of existing integer functions (e.g.
146 BIAND, IIAND, JIAND, etc...). For a complete list of intrinsics see
147 the full documentation.
148 -fdec-math
150 Enable legacy math intrinsics such as COTAN and degree-valued
151 trigonometric functions (e.g. TAND, ATAND, etc...) for
152 compatability with older code.
153 -fdec-static
155 Enable DEC-style STATIC and AUTOMATIC attributes to explicitly
156 specify the storage of variables and other objects.
157 -fdollar-ok
159 Allow $ as a valid non-first character in a symbol name. Symbols
160 that start with $ are rejected since it is unclear which rules to
161 apply to implicit typing as different vendors implement different
162 rules. Using $ in "IMPLICIT" statements is also rejected.
163 -fbackslash
165 Change the interpretation of backslashes in string literals from a
166 single backslash character to "C-style" escape characters. The
167 following combinations are expanded "\a", "\b", "\f", "\n", "\r",
168 "\t", "\v", "\\", and "\0" to the ASCII characters alert,
169 backspace, form feed, newline, carriage return, horizontal tab,
170 vertical tab, backslash, and NUL, respectively. Additionally,
171 "\x"nn, "\u"nnnn and "\U"nnnnnnnn (where each n is a hexadecimal
172 digit) are translated into the Unicode characters corresponding to
173 the specified code points. All other combinations of a character
174 preceded by \ are unexpanded.
175 -fmodule-private
177 Set the default accessibility of module entities to "PRIVATE".
178 Use-associated entities will not be accessible unless they are
179 explicitly declared as "PUBLIC".
180 -ffixed-line-length-n
182 Set column after which characters are ignored in typical fixed-form
183 lines in the source file, and through which spaces are assumed (as
184 if padded to that length) after the ends of short fixed-form lines.
185 Popular values for n include 72 (the standard and the default), 80
187 (card image), and 132 (corresponding to "extended-source" options
188 in some popular compilers). n may also be none, meaning that the
189 entire line is meaningful and that continued character constants
190 never have implicit spaces appended to them to fill out the line.
191 -ffixed-line-length-0 means the same thing as
192 -ffixed-line-length-none.
193 -ffree-line-length-n
195 Set column after which characters are ignored in typical free-form
196 lines in the source file. The default value is 132. n may be none,
197 meaning that the entire line is meaningful. -ffree-line-length-0
198 means the same thing as -ffree-line-length-none.
199 -fmax-identifier-length=n
201 Specify the maximum allowed identifier length. Typical values are
202 31 (Fortran 95) and 63 (Fortran 2003 and Fortran 2008).
203 -fimplicit-none
205 Specify that no implicit typing is allowed, unless overridden by
206 explicit "IMPLICIT" statements. This is the equivalent of adding
207 "implicit none" to the start of every procedure.
208 -fcray-pointer
210 Enable the Cray pointer extension, which provides C-like pointer
211 functionality.
212 -fopenacc
214 Enable the OpenACC extensions. This includes OpenACC "!$acc"
215 directives in free form and "c$acc", *$acc and "!$acc" directives
216 in fixed form, "!$" conditional compilation sentinels in free form
217 and "c$", "*$" and "!$" sentinels in fixed form, and when linking
218 arranges for the OpenACC runtime library to be linked in.
219 Note that this is an experimental feature, incomplete, and subject
221 to change in future versions of GCC. See
222 <https://gcc.gnu.org/wiki/OpenACC> for more information.
223 -fopenmp
225 Enable the OpenMP extensions. This includes OpenMP "!$omp"
226 directives in free form and "c$omp", *$omp and "!$omp" directives
227 in fixed form, "!$" conditional compilation sentinels in free form
228 and "c$", "*$" and "!$" sentinels in fixed form, and when linking
229 arranges for the OpenMP runtime library to be linked in. The
230 option -fopenmp implies -frecursive.
231 -fno-range-check
233 Disable range checking on results of simplification of constant
234 expressions during compilation. For example, GNU Fortran will give
235 an error at compile time when simplifying "a = 1. / 0". With this
236 option, no error will be given and "a" will be assigned the value
237 "+Infinity". If an expression evaluates to a value outside of the
238 relevant range of ["-HUGE()":"HUGE()"], then the expression will be
239 replaced by "-Inf" or "+Inf" as appropriate. Similarly, "DATA
240 i/Z'FFFFFFFF'/" will result in an integer overflow on most systems,
241 but with -fno-range-check the value will "wrap around" and "i" will
242 be initialized to -1 instead.
243 -fdefault-integer-8
245 Set the default integer and logical types to an 8 byte wide type.
246 This option also affects the kind of integer constants like 42.
247 Unlike -finteger-4-integer-8, it does not promote variables with
248 explicit kind declaration.
249 -fdefault-real-8
251 Set the default real type to an 8 byte wide type. This option also
252 affects the kind of non-double real constants like 1.0, and does
253 promote the default width of "DOUBLE PRECISION" to 16 bytes if
254 possible, unless "-fdefault-double-8" is given, too. Unlike
255 -freal-4-real-8, it does not promote variables with explicit kind
256 declaration.
257 -fdefault-real-10
259 Set the default real type to a 10 byte wide type. This option also
260 affects the kind of non-double real constants like 1.0, and does
261 promote the default width of "DOUBLE PRECISION" to 16 bytes if
262 possible, unless "-fdefault-double-8" is given. Unlike
263 -freal-4-real-10, it does not promote variables with explicit kind
264 declaration.
265 -fdefault-real-16
267 Set the default real type to a 16 byte wide type. This option also
268 affects the kind of non-double real constants like 1.0, and does
269 promote the default width of "DOUBLE PRECISION" to 16 bytes if
270 possible, unless "-fdefault-double-8" is given. Unlike
271 -freal-4-real-16, it does not promote variables with explicit kind
272 declaration.
273 -fdefault-double-8
275 Set the "DOUBLE PRECISION" type to an 8 byte wide type. Do nothing
276 if this is already the default. If -fdefault-real-8 is given,
277 "DOUBLE PRECISION" would instead be promoted to 16 bytes if
278 possible, and -fdefault-double-8 can be used to prevent this. The
279 kind of real constants like "1.d0" will not be changed by
280 -fdefault-real-8 though, so also -fdefault-double-8 does not affect
281 it.
282 -finteger-4-integer-8
284 Promote all "INTEGER(KIND=4)" entities to an "INTEGER(KIND=8)"
285 entities. If "KIND=8" is unavailable, then an error will be
286 issued. This option should be used with care and may not be
287 suitable for your codes. Areas of possible concern include calls
288 to external procedures, alignment in "EQUIVALENCE" and/or "COMMON",
289 generic interfaces, BOZ literal constant conversion, and I/O.
290 Inspection of the intermediate representation of the translated
291 Fortran code, produced by -fdump-tree-original, is suggested.
292 -freal-4-real-8
294 -freal-4-real-10
295 -freal-4-real-16
296 -freal-8-real-4
297 -freal-8-real-10
298 -freal-8-real-16
299 Promote all "REAL(KIND=M)" entities to "REAL(KIND=N)" entities. If
300 "REAL(KIND=N)" is unavailable, then an error will be issued. All
301 other real kind types are unaffected by this option. These options
302 should be used with care and may not be suitable for your codes.
303 Areas of possible concern include calls to external procedures,
304 alignment in "EQUIVALENCE" and/or "COMMON", generic interfaces, BOZ
305 literal constant conversion, and I/O. Inspection of the
306 intermediate representation of the translated Fortran code,
307 produced by -fdump-tree-original, is suggested.
308 -std=std
310 Specify the standard to which the program is expected to conform,
311 which may be one of f95, f2003, f2008, f2018, gnu, or legacy. The
312 default value for std is gnu, which specifies a superset of the
313 latest Fortran standard that includes all of the extensions
314 supported by GNU Fortran, although warnings will be given for
315 obsolete extensions not recommended for use in new code. The
316 legacy value is equivalent but without the warnings for obsolete
317 extensions, and may be useful for old non-standard programs. The
318 f95, f2003, f2008, and f2018 values specify strict conformance to
319 the Fortran 95, Fortran 2003, Fortran 2008 and Fortran 2018
320 standards, respectively; errors are given for all extensions beyond
321 the relevant language standard, and warnings are given for the
322 Fortran 77 features that are permitted but obsolescent in later
323 standards. -std=f2008ts allows the Fortran 2008 standard including
324 the additions of the Technical Specification (TS) 29113 on Further
325 Interoperability of Fortran with C and TS 18508 on Additional
326 Parallel Features in Fortran.
327 -ftest-forall-temp
329 Enhance test coverage by forcing most forall assignments to use
330 temporary.
331 Enable and customize preprocessing
333 Preprocessor related options. See section Preprocessing and conditional
334 compilation for more detailed information on preprocessing in gfortran.
335 -cpp
337 -nocpp
338 Enable preprocessing. The preprocessor is automatically invoked if
339 the file extension is .fpp, .FPP, .F, .FOR, .FTN, .F90, .F95, .F03
340 or .F08. Use this option to manually enable preprocessing of any
341 kind of Fortran file.
342 To disable preprocessing of files with any of the above listed
344 extensions, use the negative form: -nocpp.
345 The preprocessor is run in traditional mode. Any restrictions of
347 the file-format, especially the limits on line length, apply for
348 preprocessed output as well, so it might be advisable to use the
349 -ffree-line-length-none or -ffixed-line-length-none options.
350 -dM Instead of the normal output, generate a list of '#define'
352 directives for all the macros defined during the execution of the
353 preprocessor, including predefined macros. This gives you a way of
354 finding out what is predefined in your version of the preprocessor.
355 Assuming you have no file foo.f90, the command
356 touch foo.f90; gfortran -cpp -E -dM foo.f90
358 will show all the predefined macros.
360 -dD Like -dM except in two respects: it does not include the predefined
362 macros, and it outputs both the "#define" directives and the result
363 of preprocessing. Both kinds of output go to the standard output
364 file.
365 -dN Like -dD, but emit only the macro names, not their expansions.
367 -dU Like dD except that only macros that are expanded, or whose
369 definedness is tested in preprocessor directives, are output; the
370 output is delayed until the use or test of the macro; and '#undef'
371 directives are also output for macros tested but undefined at the
372 time.
373 -dI Output '#include' directives in addition to the result of
375 preprocessing.
376 -fworking-directory
378 Enable generation of linemarkers in the preprocessor output that
379 will let the compiler know the current working directory at the
380 time of preprocessing. When this option is enabled, the
381 preprocessor will emit, after the initial linemarker, a second
382 linemarker with the current working directory followed by two
383 slashes. GCC will use this directory, when it is present in the
384 preprocessed input, as the directory emitted as the current working
385 directory in some debugging information formats. This option is
386 implicitly enabled if debugging information is enabled, but this
387 can be inhibited with the negated form -fno-working-directory. If
388 the -P flag is present in the command line, this option has no
389 effect, since no "#line" directives are emitted whatsoever.
390 -idirafter dir
392 Search dir for include files, but do it after all directories
393 specified with -I and the standard system directories have been
394 exhausted. dir is treated as a system include directory. If dir
395 begins with "=", then the "=" will be replaced by the sysroot
396 prefix; see --sysroot and -isysroot.
397 -imultilib dir
399 Use dir as a subdirectory of the directory containing target-
400 specific C++ headers.
401 -iprefix prefix
403 Specify prefix as the prefix for subsequent -iwithprefix options.
404 If the prefix represents a directory, you should include the final
405 '/'.
406 -isysroot dir
408 This option is like the --sysroot option, but applies only to
409 header files. See the --sysroot option for more information.
410 -iquote dir
412 Search dir only for header files requested with "#include "file"";
413 they are not searched for "#include <file>", before all directories
414 specified by -I and before the standard system directories. If dir
415 begins with "=", then the "=" will be replaced by the sysroot
416 prefix; see --sysroot and -isysroot.
417 -isystem dir
419 Search dir for header files, after all directories specified by -I
420 but before the standard system directories. Mark it as a system
421 directory, so that it gets the same special treatment as is applied
422 to the standard system directories. If dir begins with "=", then
423 the "=" will be replaced by the sysroot prefix; see --sysroot and
424 -isysroot.
425 -nostdinc
427 Do not search the standard system directories for header files.
428 Only the directories you have specified with -I options (and the
429 directory of the current file, if appropriate) are searched.
430 -undef
432 Do not predefine any system-specific or GCC-specific macros. The
433 standard predefined macros remain defined.
434 -Apredicate=answer
436 Make an assertion with the predicate predicate and answer answer.
437 This form is preferred to the older form -A predicate(answer),
438 which is still supported, because it does not use shell special
439 characters.
440 -A-predicate=answer
442 Cancel an assertion with the predicate predicate and answer answer.
443 -C Do not discard comments. All comments are passed through to the
445 output file, except for comments in processed directives, which are
446 deleted along with the directive.
447 You should be prepared for side effects when using -C; it causes
449 the preprocessor to treat comments as tokens in their own right.
450 For example, comments appearing at the start of what would be a
451 directive line have the effect of turning that line into an
452 ordinary source line, since the first token on the line is no
453 longer a '#'.
454 Warning: this currently handles C-Style comments only. The
456 preprocessor does not yet recognize Fortran-style comments.
457 -CC Do not discard comments, including during macro expansion. This is
459 like -C, except that comments contained within macros are also
460 passed through to the output file where the macro is expanded.
461 In addition to the side-effects of the -C option, the -CC option
463 causes all C++-style comments inside a macro to be converted to
464 C-style comments. This is to prevent later use of that macro from
465 inadvertently commenting out the remainder of the source line. The
466 -CC option is generally used to support lint comments.
467 Warning: this currently handles C- and C++-Style comments only. The
469 preprocessor does not yet recognize Fortran-style comments.
470 -Dname
472 Predefine name as a macro, with definition 1.
473 -Dname=definition
475 The contents of definition are tokenized and processed as if they
476 appeared during translation phase three in a '#define' directive.
477 In particular, the definition will be truncated by embedded newline
478 characters.
479 If you are invoking the preprocessor from a shell or shell-like
481 program you may need to use the shell's quoting syntax to protect
482 characters such as spaces that have a meaning in the shell syntax.
483 If you wish to define a function-like macro on the command line,
485 write its argument list with surrounding parentheses before the
486 equals sign (if any). Parentheses are meaningful to most shells, so
487 you will need to quote the option. With sh and csh,
488 "-D'name(args...)=definition'" works.
489 -D and -U options are processed in the order they are given on the
491 command line. All -imacros file and -include file options are
492 processed after all -D and -U options.
493 -H Print the name of each header file used, in addition to other
495 normal activities. Each name is indented to show how deep in the
496 '#include' stack it is.
497 -P Inhibit generation of linemarkers in the output from the
499 preprocessor. This might be useful when running the preprocessor
500 on something that is not C code, and will be sent to a program
501 which might be confused by the linemarkers.
502 -Uname
504 Cancel any previous definition of name, either built in or provided
505 with a -D option.
506 Options to request or suppress errors and warnings
508 Errors are diagnostic messages that report that the GNU Fortran
509 compiler cannot compile the relevant piece of source code. The
510 compiler will continue to process the program in an attempt to report
511 further errors to aid in debugging, but will not produce any compiled
512 output.
513 Warnings are diagnostic messages that report constructions which are
515 not inherently erroneous but which are risky or suggest there is likely
516 to be a bug in the program. Unless -Werror is specified, they do not
517 prevent compilation of the program.
518 You can request many specific warnings with options beginning -W, for
520 example -Wimplicit to request warnings on implicit declarations. Each
521 of these specific warning options also has a negative form beginning
522 -Wno- to turn off warnings; for example, -Wno-implicit. This manual
523 lists only one of the two forms, whichever is not the default.
524 These options control the amount and kinds of errors and warnings
526 produced by GNU Fortran:
527 -fmax-errors=n
529 Limits the maximum number of error messages to n, at which point
530 GNU Fortran bails out rather than attempting to continue processing
531 the source code. If n is 0, there is no limit on the number of
532 error messages produced.
533 -fsyntax-only
535 Check the code for syntax errors, but do not actually compile it.
536 This will generate module files for each module present in the
537 code, but no other output file.
538 -Wpedantic
540 -pedantic
541 Issue warnings for uses of extensions to Fortran. -pedantic also
542 applies to C-language constructs where they occur in GNU Fortran
543 source files, such as use of \e in a character constant within a
544 directive like "#include".
545 Valid Fortran programs should compile properly with or without this
547 option. However, without this option, certain GNU extensions and
548 traditional Fortran features are supported as well. With this
549 option, many of them are rejected.
550 Some users try to use -pedantic to check programs for conformance.
552 They soon find that it does not do quite what they want---it finds
553 some nonstandard practices, but not all. However, improvements to
554 GNU Fortran in this area are welcome.
555 This should be used in conjunction with -std=f95, -std=f2003,
557 -std=f2008 or -std=f2018.
558 -pedantic-errors
560 Like -pedantic, except that errors are produced rather than
561 warnings.
562 -Wall
564 Enables commonly used warning options pertaining to usage that we
565 recommend avoiding and that we believe are easy to avoid. This
566 currently includes -Waliasing, -Wampersand, -Wconversion,
567 -Wsurprising, -Wc-binding-type, -Wintrinsics-std, -Wtabs,
568 -Wintrinsic-shadow, -Wline-truncation, -Wtarget-lifetime,
569 -Winteger-division, -Wreal-q-constant, -Wunused and
570 -Wundefined-do-loop.
571 -Waliasing
573 Warn about possible aliasing of dummy arguments. Specifically, it
574 warns if the same actual argument is associated with a dummy
575 argument with "INTENT(IN)" and a dummy argument with "INTENT(OUT)"
576 in a call with an explicit interface.
577 The following example will trigger the warning.
579 interface
581 subroutine bar(a,b)
582 integer, intent(in) :: a
583 integer, intent(out) :: b
584 end subroutine
585 end interface
586 integer :: a
587 call bar(a,a)
589 -Wampersand
591 Warn about missing ampersand in continued character constants. The
592 warning is given with -Wampersand, -pedantic, -std=f95, -std=f2003,
593 -std=f2008 and -std=f2018. Note: With no ampersand given in a
594 continued character constant, GNU Fortran assumes continuation at
595 the first non-comment, non-whitespace character after the ampersand
596 that initiated the continuation.
597 -Wargument-mismatch
599 Warn about type, rank, and other mismatches between formal
600 parameters and actual arguments to functions and subroutines.
601 These warnings are recommended and thus enabled by default.
602 -Warray-temporaries
604 Warn about array temporaries generated by the compiler. The
605 information generated by this warning is sometimes useful in
606 optimization, in order to avoid such temporaries.
607 -Wc-binding-type
609 Warn if the a variable might not be C interoperable. In
610 particular, warn if the variable has been declared using an
611 intrinsic type with default kind instead of using a kind parameter
612 defined for C interoperability in the intrinsic "ISO_C_Binding"
613 module. This option is implied by -Wall.
614 -Wcharacter-truncation
616 Warn when a character assignment will truncate the assigned string.
617 -Wline-truncation
619 Warn when a source code line will be truncated. This option is
620 implied by -Wall. For free-form source code, the default is
621 -Werror=line-truncation such that truncations are reported as
622 error.
623 -Wconversion
625 Warn about implicit conversions that are likely to change the value
626 of the expression after conversion. Implied by -Wall.
627 -Wconversion-extra
629 Warn about implicit conversions between different types and kinds.
630 This option does not imply -Wconversion.
631 -Wextra
633 Enables some warning options for usages of language features which
634 may be problematic. This currently includes -Wcompare-reals,
635 -Wunused-parameter and -Wdo-subscript.
636 -Wfrontend-loop-interchange
638 Enable warning for loop interchanges performed by the
639 -ffrontend-loop-interchange option.
640 -Wimplicit-interface
642 Warn if a procedure is called without an explicit interface. Note
643 this only checks that an explicit interface is present. It does
644 not check that the declared interfaces are consistent across
645 program units.
646 -Wimplicit-procedure
648 Warn if a procedure is called that has neither an explicit
649 interface nor has been declared as "EXTERNAL".
650 -Winteger-division
652 Warn if a constant integer division truncates it result. As an
653 example, 3/5 evaluates to 0.
654 -Wintrinsics-std
656 Warn if gfortran finds a procedure named like an intrinsic not
657 available in the currently selected standard (with -std) and treats
658 it as "EXTERNAL" procedure because of this. -fall-intrinsics can
659 be used to never trigger this behavior and always link to the
660 intrinsic regardless of the selected standard.
661 -Wreal-q-constant
663 Produce a warning if a real-literal-constant contains a "q"
664 exponent-letter.
665 -Wsurprising
667 Produce a warning when "suspicious" code constructs are
668 encountered. While technically legal these usually indicate that
669 an error has been made.
670 This currently produces a warning under the following
672 circumstances:
673 * An INTEGER SELECT construct has a CASE that can never be
675 matched as its lower value is greater than its upper value.
676 * A LOGICAL SELECT construct has three CASE statements.
678 * A TRANSFER specifies a source that is shorter than the
680 destination.
681 * The type of a function result is declared more than once with
683 the same type. If -pedantic or standard-conforming mode is
684 enabled, this is an error.
685 * A "CHARACTER" variable is declared with negative length.
687 -Wtabs
689 By default, tabs are accepted as whitespace, but tabs are not
690 members of the Fortran Character Set. For continuation lines, a
691 tab followed by a digit between 1 and 9 is supported. -Wtabs will
692 cause a warning to be issued if a tab is encountered. Note, -Wtabs
693 is active for -pedantic, -std=f95, -std=f2003, -std=f2008,
694 -std=f2008ts, -std=f2018 and -Wall.
695 -Wundefined-do-loop
697 Warn if a DO loop with step either 1 or -1 yields an underflow or
698 an overflow during iteration of an induction variable of the loop.
699 This option is implied by -Wall.
700 -Wunderflow
702 Produce a warning when numerical constant expressions are
703 encountered, which yield an UNDERFLOW during compilation. Enabled
704 by default.
705 -Wintrinsic-shadow
707 Warn if a user-defined procedure or module procedure has the same
708 name as an intrinsic; in this case, an explicit interface or
709 "EXTERNAL" or "INTRINSIC" declaration might be needed to get calls
710 later resolved to the desired intrinsic/procedure. This option is
711 implied by -Wall.
712 -Wuse-without-only
714 Warn if a "USE" statement has no "ONLY" qualifier and thus
715 implicitly imports all public entities of the used module.
716 -Wunused-dummy-argument
718 Warn about unused dummy arguments. This option is implied by -Wall.
719 -Wunused-parameter
721 Contrary to gcc's meaning of -Wunused-parameter, gfortran's
722 implementation of this option does not warn about unused dummy
723 arguments (see -Wunused-dummy-argument), but about unused
724 "PARAMETER" values. -Wunused-parameter is implied by -Wextra if
725 also -Wunused or -Wall is used.
726 -Walign-commons
728 By default, gfortran warns about any occasion of variables being
729 padded for proper alignment inside a "COMMON" block. This warning
730 can be turned off via -Wno-align-commons. See also -falign-commons.
731 -Wfunction-elimination
733 Warn if any calls to functions are eliminated by the optimizations
734 enabled by the -ffrontend-optimize option.
735 -Wrealloc-lhs
737 Warn when the compiler might insert code to for allocation or
738 reallocation of an allocatable array variable of intrinsic type in
739 intrinsic assignments. In hot loops, the Fortran 2003 reallocation
740 feature may reduce the performance. If the array is already
741 allocated with the correct shape, consider using a whole-array
742 array-spec (e.g. "(:,:,:)") for the variable on the left-hand side
743 to prevent the reallocation check. Note that in some cases the
744 warning is shown, even if the compiler will optimize reallocation
745 checks away. For instance, when the right-hand side contains the
746 same variable multiplied by a scalar. See also -frealloc-lhs.
747 -Wrealloc-lhs-all
749 Warn when the compiler inserts code to for allocation or
750 reallocation of an allocatable variable; this includes scalars and
751 derived types.
752 -Wcompare-reals
754 Warn when comparing real or complex types for equality or
755 inequality. This option is implied by -Wextra.
756 -Wtarget-lifetime
758 Warn if the pointer in a pointer assignment might be longer than
759 the its target. This option is implied by -Wall.
760 -Wzerotrip
762 Warn if a "DO" loop is known to execute zero times at compile time.
763 This option is implied by -Wall.
764 -Wdo-subscript
766 Warn if an array subscript inside a DO loop could lead to an out-
767 of-bounds access even if the compiler can not prove that the
768 statement is actually executed, in cases like
769 real a(3)
771 do i=1,4
772 if (condition(i)) then
773 a(i) = 1.2
774 end if
775 end do
776 This option is implied by -Wextra.
778 -Werror
780 Turns all warnings into errors.
781 Some of these have no effect when compiling programs written in
783 Fortran.
784 Options for debugging your program or GNU Fortran
786 GNU Fortran has various special options that are used for debugging
787 either your program or the GNU Fortran compiler.
788 -fdump-fortran-original
790 Output the internal parse tree after translating the source program
791 into internal representation. This option is mostly useful for
792 debugging the GNU Fortran compiler itself. The output generated by
793 this option might change between releases. This option may also
794 generate internal compiler errors for features which have only
795 recently been added.
796 -fdump-fortran-optimized
798 Output the parse tree after front-end optimization. Mostly useful
799 for debugging the GNU Fortran compiler itself. The output generated
800 by this option might change between releases. This option may also
801 generate internal compiler errors for features which have only
802 recently been added.
803 -fdump-parse-tree
805 Output the internal parse tree after translating the source program
806 into internal representation. Mostly useful for debugging the GNU
807 Fortran compiler itself. The output generated by this option might
808 change between releases. This option may also generate internal
809 compiler errors for features which have only recently been added.
810 This option is deprecated; use "-fdump-fortran-original" instead.
811 -ffpe-trap=list
813 Specify a list of floating point exception traps to enable. On
814 most systems, if a floating point exception occurs and the trap for
815 that exception is enabled, a SIGFPE signal will be sent and the
816 program being aborted, producing a core file useful for debugging.
817 list is a (possibly empty) comma-separated list of the following
818 exceptions: invalid (invalid floating point operation, such as
819 "SQRT(-1.0)"), zero (division by zero), overflow (overflow in a
820 floating point operation), underflow (underflow in a floating point
821 operation), inexact (loss of precision during operation), and
822 denormal (operation performed on a denormal value). The first five
823 exceptions correspond to the five IEEE 754 exceptions, whereas the
824 last one (denormal) is not part of the IEEE 754 standard but is
825 available on some common architectures such as x86.
826 The first three exceptions (invalid, zero, and overflow) often
828 indicate serious errors, and unless the program has provisions for
829 dealing with these exceptions, enabling traps for these three
830 exceptions is probably a good idea.
831 Many, if not most, floating point operations incur loss of
833 precision due to rounding, and hence the "ffpe-trap=inexact" is
834 likely to be uninteresting in practice.
835 By default no exception traps are enabled.
837 -ffpe-summary=list
839 Specify a list of floating-point exceptions, whose flag status is
840 printed to "ERROR_UNIT" when invoking "STOP" and "ERROR STOP".
841 list can be either none, all or a comma-separated list of the
842 following exceptions: invalid, zero, overflow, underflow, inexact
843 and denormal. (See -ffpe-trap for a description of the exceptions.)
844 By default, a summary for all exceptions but inexact is shown.
846 -fno-backtrace
848 When a serious runtime error is encountered or a deadly signal is
849 emitted (segmentation fault, illegal instruction, bus error,
850 floating-point exception, and the other POSIX signals that have the
851 action core), the Fortran runtime library tries to output a
852 backtrace of the error. "-fno-backtrace" disables the backtrace
853 generation. This option only has influence for compilation of the
854 Fortran main program.
855 Options for directory search
857 These options affect how GNU Fortran searches for files specified by
858 the "INCLUDE" directive and where it searches for previously compiled
859 modules.
860 It also affects the search paths used by cpp when used to preprocess
862 Fortran source.
863 -Idir
865 These affect interpretation of the "INCLUDE" directive (as well as
866 of the "#include" directive of the cpp preprocessor).
867 Also note that the general behavior of -I and "INCLUDE" is pretty
869 much the same as of -I with "#include" in the cpp preprocessor,
870 with regard to looking for header.gcc files and other such things.
871 This path is also used to search for .mod files when previously
873 compiled modules are required by a "USE" statement.
874 -Jdir
876 This option specifies where to put .mod files for compiled modules.
877 It is also added to the list of directories to searched by an "USE"
878 statement.
879 The default is the current directory.
881 -fintrinsic-modules-path dir
883 This option specifies the location of pre-compiled intrinsic
884 modules, if they are not in the default location expected by the
885 compiler.
886 Influencing the linking step
888 These options come into play when the compiler links object files into
889 an executable output file. They are meaningless if the compiler is not
890 doing a link step.
891 -static-libgfortran
893 On systems that provide libgfortran as a shared and a static
894 library, this option forces the use of the static version. If no
895 shared version of libgfortran was built when the compiler was
896 configured, this option has no effect.
897 Influencing runtime behavior
899 These options affect the runtime behavior of programs compiled with GNU
900 Fortran.
901 -fconvert=conversion
903 Specify the representation of data for unformatted files. Valid
904 values for conversion are: native, the default; swap, swap between
905 big- and little-endian; big-endian, use big-endian representation
906 for unformatted files; little-endian, use little-endian
907 representation for unformatted files.
908 This option has an effect only when used in the main program. The
910 "CONVERT" specifier and the GFORTRAN_CONVERT_UNIT environment
911 variable override the default specified by -fconvert.
912 -frecord-marker=length
914 Specify the length of record markers for unformatted files. Valid
915 values for length are 4 and 8. Default is 4. This is different
916 from previous versions of gfortran, which specified a default
917 record marker length of 8 on most systems. If you want to read or
918 write files compatible with earlier versions of gfortran, use
919 -frecord-marker=8.
920 -fmax-subrecord-length=length
922 Specify the maximum length for a subrecord. The maximum permitted
923 value for length is 2147483639, which is also the default. Only
924 really useful for use by the gfortran testsuite.
925 -fsign-zero
927 When enabled, floating point numbers of value zero with the sign
928 bit set are written as negative number in formatted output and
929 treated as negative in the "SIGN" intrinsic. -fno-sign-zero does
930 not print the negative sign of zero values (or values rounded to
931 zero for I/O) and regards zero as positive number in the "SIGN"
932 intrinsic for compatibility with Fortran 77. The default is
933 -fsign-zero.
934 Options for code generation conventions
936 These machine-independent options control the interface conventions
937 used in code generation.
938 Most of them have both positive and negative forms; the negative form
940 of -ffoo would be -fno-foo. In the table below, only one of the forms
941 is listed---the one which is not the default. You can figure out the
942 other form by either removing no- or adding it.
943 -fno-automatic
945 Treat each program unit (except those marked as RECURSIVE) as if
946 the "SAVE" statement were specified for every local variable and
947 array referenced in it. Does not affect common blocks. (Some
948 Fortran compilers provide this option under the name -static or
949 -save.) The default, which is -fautomatic, uses the stack for
950 local variables smaller than the value given by
951 -fmax-stack-var-size. Use the option -frecursive to use no static
952 memory.
953 -ff2c
955 Generate code designed to be compatible with code generated by g77
956 and f2c.
957 The calling conventions used by g77 (originally implemented in f2c)
959 require functions that return type default "REAL" to actually
960 return the C type "double", and functions that return type
961 "COMPLEX" to return the values via an extra argument in the calling
962 sequence that points to where to store the return value. Under the
963 default GNU calling conventions, such functions simply return their
964 results as they would in GNU C---default "REAL" functions return
965 the C type "float", and "COMPLEX" functions return the GNU C type
966 "complex". Additionally, this option implies the
967 -fsecond-underscore option, unless -fno-second-underscore is
968 explicitly requested.
969 This does not affect the generation of code that interfaces with
971 the libgfortran library.
972 Caution: It is not a good idea to mix Fortran code compiled with
974 -ff2c with code compiled with the default -fno-f2c calling
975 conventions as, calling "COMPLEX" or default "REAL" functions
976 between program parts which were compiled with different calling
977 conventions will break at execution time.
978 Caution: This will break code which passes intrinsic functions of
980 type default "REAL" or "COMPLEX" as actual arguments, as the
981 library implementations use the -fno-f2c calling conventions.
982 -fno-underscoring
984 Do not transform names of entities specified in the Fortran source
985 file by appending underscores to them.
986 With -funderscoring in effect, GNU Fortran appends one underscore
988 to external names with no underscores. This is done to ensure
989 compatibility with code produced by many UNIX Fortran compilers.
990 Caution: The default behavior of GNU Fortran is incompatible with
992 f2c and g77, please use the -ff2c option if you want object files
993 compiled with GNU Fortran to be compatible with object code created
994 with these tools.
995 Use of -fno-underscoring is not recommended unless you are
997 experimenting with issues such as integration of GNU Fortran into
998 existing system environments (vis-a-vis existing libraries, tools,
999 and so on).
1000 For example, with -funderscoring, and assuming that "j()" and
1002 "max_count()" are external functions while "my_var" and "lvar" are
1003 local variables, a statement like
1004 I = J() + MAX_COUNT (MY_VAR, LVAR)
1006 is implemented as something akin to:
1008 i = j_() + max_count__(&my_var__, &lvar);
1010 With -fno-underscoring, the same statement is implemented as:
1012 i = j() + max_count(&my_var, &lvar);
1014 Use of -fno-underscoring allows direct specification of user-
1016 defined names while debugging and when interfacing GNU Fortran code
1017 with other languages.
1018 Note that just because the names match does not mean that the
1020 interface implemented by GNU Fortran for an external name matches
1021 the interface implemented by some other language for that same
1022 name. That is, getting code produced by GNU Fortran to link to
1023 code produced by some other compiler using this or any other method
1024 can be only a small part of the overall solution---getting the code
1025 generated by both compilers to agree on issues other than naming
1026 can require significant effort, and, unlike naming disagreements,
1027 linkers normally cannot detect disagreements in these other areas.
1028 Also, note that with -fno-underscoring, the lack of appended
1030 underscores introduces the very real possibility that a user-
1031 defined external name will conflict with a name in a system
1032 library, which could make finding unresolved-reference bugs quite
1033 difficult in some cases---they might occur at program run time, and
1034 show up only as buggy behavior at run time.
1035 In future versions of GNU Fortran we hope to improve naming and
1037 linking issues so that debugging always involves using the names as
1038 they appear in the source, even if the names as seen by the linker
1039 are mangled to prevent accidental linking between procedures with
1040 incompatible interfaces.
1041 -fsecond-underscore
1043 By default, GNU Fortran appends an underscore to external names.
1044 If this option is used GNU Fortran appends two underscores to names
1045 with underscores and one underscore to external names with no
1046 underscores. GNU Fortran also appends two underscores to internal
1047 names with underscores to avoid naming collisions with external
1048 names.
1049 This option has no effect if -fno-underscoring is in effect. It is
1051 implied by the -ff2c option.
1052 Otherwise, with this option, an external name such as "MAX_COUNT"
1054 is implemented as a reference to the link-time external symbol
1055 "max_count__", instead of "max_count_". This is required for
1056 compatibility with g77 and f2c, and is implied by use of the -ff2c
1057 option.
1058 -fcoarray=<keyword>
1060 none
1061 Disable coarray support; using coarray declarations and image-
1062 control statements will produce a compile-time error. (Default)
1063 single
1065 Single-image mode, i.e. "num_images()" is always one.
1066 lib Library-based coarray parallelization; a suitable GNU Fortran
1068 coarray library needs to be linked.
1069 -fcheck=<keyword>
1071 Enable the generation of run-time checks; the argument shall be a
1072 comma-delimited list of the following keywords. Prefixing a check
1073 with no- disables it if it was activated by a previous
1074 specification.
1075 all Enable all run-time test of -fcheck.
1077 array-temps
1079 Warns at run time when for passing an actual argument a
1080 temporary array had to be generated. The information generated
1081 by this warning is sometimes useful in optimization, in order
1082 to avoid such temporaries.
1083 Note: The warning is only printed once per location.
1085 bounds
1087 Enable generation of run-time checks for array subscripts and
1088 against the declared minimum and maximum values. It also
1089 checks array indices for assumed and deferred shape arrays
1090 against the actual allocated bounds and ensures that all string
1091 lengths are equal for character array constructors without an
1092 explicit typespec.
1093 Some checks require that -fcheck=bounds is set for the
1095 compilation of the main program.
1096 Note: In the future this may also include other forms of
1098 checking, e.g., checking substring references.
1099 do Enable generation of run-time checks for invalid modification
1101 of loop iteration variables.
1102 mem Enable generation of run-time checks for memory allocation.
1104 Note: This option does not affect explicit allocations using
1105 the "ALLOCATE" statement, which will be always checked.
1106 pointer
1108 Enable generation of run-time checks for pointers and
1109 allocatables.
1110 recursion
1112 Enable generation of run-time checks for recursively called
1113 subroutines and functions which are not marked as recursive.
1114 See also -frecursive. Note: This check does not work for
1115 OpenMP programs and is disabled if used together with
1116 -frecursive and -fopenmp.
1117 Example: Assuming you have a file foo.f90, the command
1119 gfortran -fcheck=all,no-array-temps foo.f90
1121 will compile the file with all checks enabled as specified above
1123 except warnings for generated array temporaries.
1124 -fbounds-check
1126 Deprecated alias for -fcheck=bounds.
1127 -fcheck-array-temporaries
1129 Deprecated alias for -fcheck=array-temps.
1130 -fmax-array-constructor=n
1132 This option can be used to increase the upper limit permitted in
1133 array constructors. The code below requires this option to expand
1134 the array at compile time.
1135 program test
1137 implicit none
1138 integer j
1139 integer, parameter :: n = 100000
1140 integer, parameter :: i(n) = (/ (2*j, j = 1, n) /)
1141 print '(10(I0,1X))', i
1142 end program test
1143 Caution: This option can lead to long compile times and
1145 excessively large object files.
1146 The default value for n is 65535.
1148 -fmax-stack-var-size=n
1150 This option specifies the size in bytes of the largest array that
1151 will be put on the stack; if the size is exceeded static memory is
1152 used (except in procedures marked as RECURSIVE). Use the option
1153 -frecursive to allow for recursive procedures which do not have a
1154 RECURSIVE attribute or for parallel programs. Use -fno-automatic to
1155 never use the stack.
1156 This option currently only affects local arrays declared with
1158 constant bounds, and may not apply to all character variables.
1159 Future versions of GNU Fortran may improve this behavior.
1160 The default value for n is 32768.
1162 -fstack-arrays
1164 Adding this option will make the Fortran compiler put all arrays of
1165 unknown size and array temporaries onto stack memory. If your
1166 program uses very large local arrays it is possible that you will
1167 have to extend your runtime limits for stack memory on some
1168 operating systems. This flag is enabled by default at optimization
1169 level -Ofast unless -fmax-stack-var-size is specified.
1170 -fpack-derived
1172 This option tells GNU Fortran to pack derived type members as
1173 closely as possible. Code compiled with this option is likely to
1174 be incompatible with code compiled without this option, and may
1175 execute slower.
1176 -frepack-arrays
1178 In some circumstances GNU Fortran may pass assumed shape array
1179 sections via a descriptor describing a noncontiguous area of
1180 memory. This option adds code to the function prologue to repack
1181 the data into a contiguous block at runtime.
1182 This should result in faster accesses to the array. However it can
1184 introduce significant overhead to the function call, especially
1185 when the passed data is noncontiguous.
1186 -fshort-enums
1188 This option is provided for interoperability with C code that was
1189 compiled with the -fshort-enums option. It will make GNU Fortran
1190 choose the smallest "INTEGER" kind a given enumerator set will fit
1191 in, and give all its enumerators this kind.
1192 -fexternal-blas
1194 This option will make gfortran generate calls to BLAS functions for
1195 some matrix operations like "MATMUL", instead of using our own
1196 algorithms, if the size of the matrices involved is larger than a
1197 given limit (see -fblas-matmul-limit). This may be profitable if
1198 an optimized vendor BLAS library is available. The BLAS library
1199 will have to be specified at link time.
1200 -fblas-matmul-limit=n
1202 Only significant when -fexternal-blas is in effect. Matrix
1203 multiplication of matrices with size larger than (or equal to) n
1204 will be performed by calls to BLAS functions, while others will be
1205 handled by gfortran internal algorithms. If the matrices involved
1206 are not square, the size comparison is performed using the
1207 geometric mean of the dimensions of the argument and result
1208 matrices.
1209 The default value for n is 30.
1211 -finline-matmul-limit=n
1213 When front-end optimiztion is active, some calls to the "MATMUL"
1214 intrinsic function will be inlined. This may result in code size
1215 increase if the size of the matrix cannot be determined at compile
1216 time, as code for both cases is generated. Setting
1217 "-finline-matmul-limit=0" will disable inlining in all cases.
1218 Setting this option with a value of n will produce inline code for
1219 matrices with size up to n. If the matrices involved are not
1220 square, the size comparison is performed using the geometric mean
1221 of the dimensions of the argument and result matrices.
1222 The default value for n is 30. The "-fblas-matmul-limit" can be
1224 used to change this value.
1225 -frecursive
1227 Allow indirect recursion by forcing all local arrays to be
1228 allocated on the stack. This flag cannot be used together with
1229 -fmax-stack-var-size= or -fno-automatic.
1230 -finit-local-zero
1232 -finit-derived
1233 -finit-integer=n
1234 -finit-real=<zero|inf|-inf|nan|snan>
1235 -finit-logical=<true|false>
1236 -finit-character=n
1237 The -finit-local-zero option instructs the compiler to initialize
1238 local "INTEGER", "REAL", and "COMPLEX" variables to zero, "LOGICAL"
1239 variables to false, and "CHARACTER" variables to a string of null
1240 bytes. Finer-grained initialization options are provided by the
1241 -finit-integer=n, -finit-real=<zero|inf|-inf|nan|snan> (which also
1242 initializes the real and imaginary parts of local "COMPLEX"
1243 variables), -finit-logical=<true|false>, and -finit-character=n
1244 (where n is an ASCII character value) options.
1245 With -finit-derived, components of derived type variables will be
1247 initialized according to these flags. Components whose type is not
1248 covered by an explicit -finit-* flag will be treated as described
1249 above with -finit-local-zero.
1250 These options do not initialize
1252 * objects with the POINTER attribute
1254 * allocatable arrays
1256 * variables that appear in an "EQUIVALENCE" statement.
1258 (These limitations may be removed in future releases).
1260 Note that the -finit-real=nan option initializes "REAL" and
1262 "COMPLEX" variables with a quiet NaN. For a signalling NaN use
1263 -finit-real=snan; note, however, that compile-time optimizations
1264 may convert them into quiet NaN and that trapping needs to be
1265 enabled (e.g. via -ffpe-trap).
1266 Finally, note that enabling any of the -finit-* options will
1268 silence warnings that would have been emitted by -Wuninitialized
1269 for the affected local variables.
1270 -falign-commons
1272 By default, gfortran enforces proper alignment of all variables in
1273 a "COMMON" block by padding them as needed. On certain platforms
1274 this is mandatory, on others it increases performance. If a
1275 "COMMON" block is not declared with consistent data types
1276 everywhere, this padding can cause trouble, and -fno-align-commons
1277 can be used to disable automatic alignment. The same form of this
1278 option should be used for all files that share a "COMMON" block.
1279 To avoid potential alignment issues in "COMMON" blocks, it is
1280 recommended to order objects from largest to smallest.
1281 -fno-protect-parens
1283 By default the parentheses in expression are honored for all
1284 optimization levels such that the compiler does not do any re-
1285 association. Using -fno-protect-parens allows the compiler to
1286 reorder "REAL" and "COMPLEX" expressions to produce faster code.
1287 Note that for the re-association optimization -fno-signed-zeros and
1288 -fno-trapping-math need to be in effect. The parentheses protection
1289 is enabled by default, unless -Ofast is given.
1290 -frealloc-lhs
1292 An allocatable left-hand side of an intrinsic assignment is
1293 automatically (re)allocated if it is either unallocated or has a
1294 different shape. The option is enabled by default except when
1295 -std=f95 is given. See also -Wrealloc-lhs.
1296 -faggressive-function-elimination
1298 Functions with identical argument lists are eliminated within
1299 statements, regardless of whether these functions are marked "PURE"
1300 or not. For example, in
1301 a = f(b,c) + f(b,c)
1303 there will only be a single call to "f". This option only works if
1305 -ffrontend-optimize is in effect.
1306 -ffrontend-optimize
1308 This option performs front-end optimization, based on manipulating
1309 parts the Fortran parse tree. Enabled by default by any -O option.
1310 Optimizations enabled by this option include inlining calls to
1311 "MATMUL", elimination of identical function calls within
1312 expressions, removing unnecessary calls to "TRIM" in comparisons
1313 and assignments and replacing TRIM(a) with "a(1:LEN_TRIM(a))". It
1314 can be deselected by specifying -fno-frontend-optimize.
1315 -ffrontend-loop-interchange
1317 Attempt to interchange loops in the Fortran front end where
1318 profitable. Enabled by default by any -O option. At the moment,
1319 this option only affects "FORALL" and "DO CONCURRENT" statements
1320 with several forall triplets.
1321
1323 The gfortran compiler currently does not make use of any environment
1324 variables to control its operation above and beyond those that affect
1325 the operation of gcc.
1326
1328 For instructions on reporting bugs, see
1329 <http://bugzilla.redhat.com/bugzilla>.
1330
1332 gpl(7), gfdl(7), fsf-funding(7), cpp(1), gcov(1), gcc(1), as(1), ld(1),
1333 gdb(1), dbx(1) and the Info entries for gcc, cpp, gfortran, as, ld,
1334 binutils and gdb.
1335
1337 See the Info entry for gfortran for contributors to GCC and GNU
1338 Fortran.
1339
1341 Copyright (c) 2004-2018 Free Software Foundation, Inc.
1342 Permission is granted to copy, distribute and/or modify this document
1344 under the terms of the GNU Free Documentation License, Version 1.3 or
1345 any later version published by the Free Software Foundation; with the
1346 Invariant Sections being "Funding Free Software", the Front-Cover Texts
1347 being (a) (see below), and with the Back-Cover Texts being (b) (see
1348 below). A copy of the license is included in the gfdl(7) man page.
1349 (a) The FSF's Front-Cover Text is:
1351 A GNU Manual
1353 (b) The FSF's Back-Cover Text is:
1355 You have freedom to copy and modify this GNU Manual, like GNU
1357 software. Copies published by the Free Software Foundation raise
1358 funds for GNU development.
1359gcc-8 2018-09-05 GFORTRAN(1)