1GFORTRAN(1)                           GNU                          GFORTRAN(1)
2
3
4

NAME

6       gfortran - GNU Fortran compiler
7

SYNOPSIS

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

DESCRIPTION

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

OPTIONS

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

ENVIRONMENT

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

BUGS

1328       For instructions on reporting bugs, see
1329       <http://bugzilla.redhat.com/bugzilla>.
1330

SEE ALSO

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

AUTHOR

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)
Impressum