1GFORTRAN(1) GNU GFORTRAN(1)
2
3
4
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
18 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
25 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
30 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
38 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
50 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
56 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
66 Debugging Options
67 -fbacktrace -fdump-fortran-optimized -fdump-fortran-original
68 -fdump-parse-tree -ffpe-trap=list -ffpe-summary=list
69
70 Directory Options
71 -Idir -Jdir -fintrinsic-modules-path dir
72
73 Link Options
74 -static-libgfortran
75
76 Runtime Options
77 -fconvert=conversion -fmax-subrecord-length=length
78 -frecord-marker=length -fsign-zero
79
80 Interoperability Options
81 -fc-prototypes
82
83 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
97 Options controlling Fortran dialect
98 The following options control the details of the Fortran dialect
99 accepted by the compiler:
100
101 -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
108 -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
117 -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
125 -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
132 Other flags enabled by this switch are: -fdollar-ok -fcray-pointer
133 -fdec-structure -fdec-intrinsic-ints -fdec-static -fdec-math
134
135 If -fd-lines-as-code/-fd-lines-as-comments are unset, then -fdec
136 also sets -fd-lines-as-comments.
137
138 -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
144 -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
149 -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
154 -fdec-static
155 Enable DEC-style STATIC and AUTOMATIC attributes to explicitly
156 specify the storage of variables and other objects.
157
158 -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
164 -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
176 -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
181 -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
186 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
194 -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
200 -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
204 -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
209 -fcray-pointer
210 Enable the Cray pointer extension, which provides C-like pointer
211 functionality.
212
213 -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
220 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
224 -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
232 -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
244 -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
250 -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
258 -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
266 -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
274 -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
283 -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
293 -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
309 -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
328 -ftest-forall-temp
329 Enhance test coverage by forcing most forall assignments to use
330 temporary.
331
332 Enable and customize preprocessing
333 Preprocessor related options. See section Preprocessing and conditional
334 compilation for more detailed information on preprocessing in gfortran.
335
336 -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
343 To disable preprocessing of files with any of the above listed
344 extensions, use the negative form: -nocpp.
345
346 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
351 -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
357 touch foo.f90; gfortran -cpp -E -dM foo.f90
358
359 will show all the predefined macros.
360
361 -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
366 -dN Like -dD, but emit only the macro names, not their expansions.
367
368 -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
374 -dI Output '#include' directives in addition to the result of
375 preprocessing.
376
377 -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
391 -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
398 -imultilib dir
399 Use dir as a subdirectory of the directory containing target-
400 specific C++ headers.
401
402 -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
407 -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
411 -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
418 -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
426 -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
431 -undef
432 Do not predefine any system-specific or GCC-specific macros. The
433 standard predefined macros remain defined.
434
435 -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
441 -A-predicate=answer
442 Cancel an assertion with the predicate predicate and answer answer.
443
444 -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
448 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
455 Warning: this currently handles C-Style comments only. The
456 preprocessor does not yet recognize Fortran-style comments.
457
458 -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
462 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
468 Warning: this currently handles C- and C++-Style comments only. The
469 preprocessor does not yet recognize Fortran-style comments.
470
471 -Dname
472 Predefine name as a macro, with definition 1.
473
474 -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
480 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
484 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
490 -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
494 -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
498 -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
503 -Uname
504 Cancel any previous definition of name, either built in or provided
505 with a -D option.
506
507 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
514 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
519 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
525 These options control the amount and kinds of errors and warnings
526 produced by GNU Fortran:
527
528 -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
534 -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
539 -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
546 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
551 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
556 This should be used in conjunction with -std=f95, -std=f2003,
557 -std=f2008 or -std=f2018.
558
559 -pedantic-errors
560 Like -pedantic, except that errors are produced rather than
561 warnings.
562
563 -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
572 -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
578 The following example will trigger the warning.
579
580 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
588 call bar(a,a)
589
590 -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
598 -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
603 -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
608 -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
615 -Wcharacter-truncation
616 Warn when a character assignment will truncate the assigned string.
617
618 -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
624 -Wconversion
625 Warn about implicit conversions that are likely to change the value
626 of the expression after conversion. Implied by -Wall.
627
628 -Wconversion-extra
629 Warn about implicit conversions between different types and kinds.
630 This option does not imply -Wconversion.
631
632 -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
637 -Wfrontend-loop-interchange
638 Enable warning for loop interchanges performed by the
639 -ffrontend-loop-interchange option.
640
641 -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
647 -Wimplicit-procedure
648 Warn if a procedure is called that has neither an explicit
649 interface nor has been declared as "EXTERNAL".
650
651 -Winteger-division
652 Warn if a constant integer division truncates it result. As an
653 example, 3/5 evaluates to 0.
654
655 -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
662 -Wreal-q-constant
663 Produce a warning if a real-literal-constant contains a "q"
664 exponent-letter.
665
666 -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
671 This currently produces a warning under the following
672 circumstances:
673
674 * An INTEGER SELECT construct has a CASE that can never be
675 matched as its lower value is greater than its upper value.
676
677 * A LOGICAL SELECT construct has three CASE statements.
678
679 * A TRANSFER specifies a source that is shorter than the
680 destination.
681
682 * 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
686 * A "CHARACTER" variable is declared with negative length.
687
688 -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
696 -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
701 -Wunderflow
702 Produce a warning when numerical constant expressions are
703 encountered, which yield an UNDERFLOW during compilation. Enabled
704 by default.
705
706 -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
713 -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
717 -Wunused-dummy-argument
718 Warn about unused dummy arguments. This option is implied by -Wall.
719
720 -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
727 -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
732 -Wfunction-elimination
733 Warn if any calls to functions are eliminated by the optimizations
734 enabled by the -ffrontend-optimize option.
735
736 -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
748 -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
753 -Wcompare-reals
754 Warn when comparing real or complex types for equality or
755 inequality. This option is implied by -Wextra.
756
757 -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
761 -Wzerotrip
762 Warn if a "DO" loop is known to execute zero times at compile time.
763 This option is implied by -Wall.
764
765 -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
770 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
777 This option is implied by -Wextra.
778
779 -Werror
780 Turns all warnings into errors.
781
782 Some of these have no effect when compiling programs written in
783 Fortran.
784
785 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
789 -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
797 -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
804 -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
812 -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
827 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
832 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
836 By default no exception traps are enabled.
837
838 -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
845 By default, a summary for all exceptions but inexact is shown.
846
847 -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
856 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
861 It also affects the search paths used by cpp when used to preprocess
862 Fortran source.
863
864 -Idir
865 These affect interpretation of the "INCLUDE" directive (as well as
866 of the "#include" directive of the cpp preprocessor).
867
868 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
872 This path is also used to search for .mod files when previously
873 compiled modules are required by a "USE" statement.
874
875 -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
880 The default is the current directory.
881
882 -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
887 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
892 -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
898 Influencing runtime behavior
899 These options affect the runtime behavior of programs compiled with GNU
900 Fortran.
901
902 -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
909 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
913 -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
921 -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
926 -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
935 Options for code generation conventions
936 These machine-independent options control the interface conventions
937 used in code generation.
938
939 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
944 -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
954 -ff2c
955 Generate code designed to be compatible with code generated by g77
956 and f2c.
957
958 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
970 This does not affect the generation of code that interfaces with
971 the libgfortran library.
972
973 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
979 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
983 -fno-underscoring
984 Do not transform names of entities specified in the Fortran source
985 file by appending underscores to them.
986
987 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
991 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
996 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
1001 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
1005 I = J() + MAX_COUNT (MY_VAR, LVAR)
1006
1007 is implemented as something akin to:
1008
1009 i = j_() + max_count__(&my_var__, &lvar);
1010
1011 With -fno-underscoring, the same statement is implemented as:
1012
1013 i = j() + max_count(&my_var, &lvar);
1014
1015 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
1019 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
1029 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
1036 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
1042 -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
1050 This option has no effect if -fno-underscoring is in effect. It is
1051 implied by the -ff2c option.
1052
1053 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
1059 -fcoarray=<keyword>
1060 none
1061 Disable coarray support; using coarray declarations and image-
1062 control statements will produce a compile-time error. (Default)
1063
1064 single
1065 Single-image mode, i.e. "num_images()" is always one.
1066
1067 lib Library-based coarray parallelization; a suitable GNU Fortran
1068 coarray library needs to be linked.
1069
1070 -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
1076 all Enable all run-time test of -fcheck.
1077
1078 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
1084 Note: The warning is only printed once per location.
1085
1086 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
1094 Some checks require that -fcheck=bounds is set for the
1095 compilation of the main program.
1096
1097 Note: In the future this may also include other forms of
1098 checking, e.g., checking substring references.
1099
1100 do Enable generation of run-time checks for invalid modification
1101 of loop iteration variables.
1102
1103 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
1107 pointer
1108 Enable generation of run-time checks for pointers and
1109 allocatables.
1110
1111 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
1118 Example: Assuming you have a file foo.f90, the command
1119
1120 gfortran -fcheck=all,no-array-temps foo.f90
1121
1122 will compile the file with all checks enabled as specified above
1123 except warnings for generated array temporaries.
1124
1125 -fbounds-check
1126 Deprecated alias for -fcheck=bounds.
1127
1128 -fcheck-array-temporaries
1129 Deprecated alias for -fcheck=array-temps.
1130
1131 -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
1136 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
1144 Caution: This option can lead to long compile times and
1145 excessively large object files.
1146
1147 The default value for n is 65535.
1148
1149 -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
1157 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
1161 The default value for n is 32768.
1162
1163 -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
1171 -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
1177 -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
1183 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
1187 -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
1193 -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
1201 -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
1210 The default value for n is 30.
1211
1212 -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
1223 The default value for n is 30. The "-fblas-matmul-limit" can be
1224 used to change this value.
1225
1226 -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
1231 -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
1246 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
1251 These options do not initialize
1252
1253 * objects with the POINTER attribute
1254
1255 * allocatable arrays
1256
1257 * variables that appear in an "EQUIVALENCE" statement.
1258
1259 (These limitations may be removed in future releases).
1260
1261 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
1267 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
1271 -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
1282 -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
1291 -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
1297 -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
1302 a = f(b,c) + f(b,c)
1303
1304 there will only be a single call to "f". This option only works if
1305 -ffrontend-optimize is in effect.
1306
1307 -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
1316 -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
1343 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
1350 (a) The FSF's Front-Cover Text is:
1351
1352 A GNU Manual
1353
1354 (b) The FSF's Back-Cover Text is:
1355
1356 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.
1359
1360
1361
1362gcc-8.3.0 2019-02-22 GFORTRAN(1)