GFORTRAN(1)

📦
version 9.5.0 · 2 versions
, in ubuntu noble

💖 GFORTRAN(1) · GNU Manual ✨

✨ NAME ✨

gfortran - the GNU Fortran compiler 🧚

🎀 SYNOPSIS 🎀

gfortran [-c|-S|-E]
         [-g] [-pg] [-Olevel]
         [-Wwarn...] [-pedantic]
         [-Idir...] [-Ldir...]
         [-Dmacro[=defn]...] [-Umacro]
         [-foption...]
         [-mmachine-option...]
         [-o outfile] infile...

Okay so this is only the most useful stuff, bestie. The rest is further down 👀

💅 DESCRIPTION 💅

Okay so gfortran supports every option that gcc supports, no cap. This page only covers the options that are specific to GNU Fortran, so you're not drowning in extra stuff 🫶

Every GCC and GNU Fortran option works with both gfortran and gcc, and also with any other drivers that were built at the same time (like g++). Adding GNU Fortran to the GCC distribution means all the relevant drivers accept GNU Fortran options. It's giving teamwork 🌈

Some options come in positive and negative forms. The negative form of -ffoo is -fno-foo. This manual only documents one of the two, whichever one isn't the default. So don't be confused when you only see one version 🙈

👑 OPTIONS 👑

Here's the cheat sheet of every option specific to GNU Fortran, sorted into groups by type. The explanations come after the groups ✨

🦋 Fortran Language Options

-fall-intrinsics -fbackslash -fcray-pointer -fd-lines-as-code
-fd-lines-as-comments -fdec -fdec-structure -fdec-intrinsic-ints
-fdec-static -fdec-math -fdec-include -fdefault-double-8
-fdefault-integer-8 -fdefault-real-8 -fdefault-real-10
-fdefault-real-16 -fdollar-ok -ffixed-line-length-n
-ffixed-line-length-none -fpad-source -ffree-form
-ffree-line-length-n -ffree-line-length-none -fimplicit-none
-finteger-4-integer-8 -fmax-identifier-length -fmodule-private
-ffixed-form -fno-range-check -fopenacc -fopenmp -freal-4-real-10
-freal-4-real-16 -freal-4-real-8 -freal-8-real-10 -freal-8-real-16
-freal-8-real-4 -std=std -ftest-forall-temp

🌈 Preprocessing Options

-A-question[=answer] -Aquestion=answer -C -CC -Dmacro[=defn] -H -P
-Umacro -cpp -dD -dI -dM -dN -dU -fworking-directory -imultilib dir
-iprefix file -iquote -isysroot dir -isystem dir -nocpp -nostdinc
-undef

🌸 Error and Warning Options

-Waliasing -Wall -Wampersand -Wargument-mismatch -Warray-bounds
-Wc-binding-type -Wcharacter-truncation -Wconversion -Wdo-subscript
-Wfunction-elimination -Wimplicit-interface -Wimplicit-procedure
-Wintrinsic-shadow -Wuse-without-only -Wintrinsics-std
-Wline-truncation -Wno-align-commons -Wno-tabs -Wreal-q-constant
-Wsurprising -Wunderflow -Wunused-parameter -Wrealloc-lhs
-Wrealloc-lhs-all -Wfrontend-loop-interchange -Wtarget-lifetime
-fmax-errors=n -fsyntax-only -pedantic -pedantic-errors

🔥 Debugging Options

-fbacktrace -fdump-fortran-optimized -fdump-fortran-original
-fdump-fortran-global -fdump-parse-tree -ffpe-trap=list
-ffpe-summary=list

🧚 Directory Options

-Idir  -Jdir -fintrinsic-modules-path dir
-static-libgfortran

🍓 Runtime Options

-fconvert=conversion -fmax-subrecord-length=length
-frecord-marker=length -fsign-zero

🫧 Interoperability Options

-fc-prototypes -fc-prototypes-external

💻 Code Generation Options

-faggressive-function-elimination -fblas-matmul-limit=n
-fbounds-check -ftail-call-workaround -ftail-call-workaround=n
-fcheck-array-temporaries
-fcheck=<all|array-temps|bounds|do|mem|pointer|recursion>
-fcoarray=<none|single|lib> -fexternal-blas -ff2c
-ffrontend-loop-interchange -ffrontend-optimize -finit-character=n
-finit-integer=n -finit-local-zero -finit-derived
-finit-logical=<true|false> -finit-real=<zero|inf|-inf|nan|snan>
-finline-matmul-limit=n -fmax-array-constructor=n
-fmax-stack-var-size=n -fno-align-commons -fno-automatic
-fno-protect-parens -fno-underscoring -fsecond-underscore
-fpack-derived -frealloc-lhs -frecursive -frepack-arrays
-fshort-enums -fstack-arrays

🌸 Options controlling Fortran dialect

These options control the details of the Fortran dialect the compiler accepts. Here they are, one by one 💅

  • -ffree-form, -ffixed-form — These pick the layout of the source file. Free form came in with Fortran 90, while fixed form was the old-school way older Fortran programs were written. If you don't specify either one, the compiler figures out the source form from the file extension 📝
  • -fall-intrinsics — This makes every intrinsic procedure work, including GNU's own extensions. It's super handy alongside -std=f95 if you want standard compliance but still want the full set of gfortran intrinsics. The catch is that -Wintrinsics-std gets ignored, and no user-defined procedure that shares a name with an intrinsic will get called, unless it's explicitly declared EXTERNAL 🙃
  • -fd-lines-as-code, -fd-lines-as-comments — These give special treatment to lines starting with d or D in fixed form sources. With -fd-lines-as-code, they're treated as if the first column had a blank in it. With -fd-lines-as-comments, they're treated as comment lines 💬
  • -fdec — This turns on DEC compatibility mode, which enables extensions and other features that copy the default behavior of older compilers (like DEC's). Fair warning:
These features are non-standard, so avoid them at all costs. For the nitty-gritty on how GNU Fortran implements these extensions, check the full documentation.

Turning this on also flips on -fdollar-ok, -fcray-pointer, -fdec-structure, -fdec-intrinsic-ints, -fdec-static, and -fdec-math. And if -fd-lines-as-code or -fd-lines-as-comments aren't set, then -fdec also sets -fd-lines-as-comments 🫠

  • -fdec-structure — This enables DEC "STRUCTURE" and "RECORD", plus "UNION", "MAP", and the dot ('.') as a member separator (on top of '%'). It's here for compatibility only. Fortran 90 derived types are the better choice wherever you can use them 🌷
  • -fdec-intrinsic-ints — This enables the B/I/J/K kind variants of existing integer functions, like BIAND, IIAND, JIAND, and so on. For the full list of intrinsics, check the full documentation 🔢
  • -fdec-math — This enables legacy math intrinsics like COTAN and the degree-valued trig functions (like TAND, ATAND, and so on) so older code keeps working 📐
  • -fdec-static — This enables DEC-style STATIC and AUTOMATIC attributes, which let you explicitly set the storage of variables and other objects 🧱
  • -fdec-include — This lets INCLUDE be parsed as a statement, as well as the regular INCLUDE line. When it's parsed as a statement, INCLUDE doesn't have to sit on a single line and can use line continuations ✂️
  • -fdollar-ok — This lets $ show up as a valid non-first character in a symbol name. Symbols that start with $ still get rejected, because it's unclear which implicit typing rules should apply, since different vendors do it differently. Using $ in IMPLICIT statements is also rejected 🚫
  • -fbackslash — This changes how backslashes work in string literals. Instead of being a single backslash character, they become "C-style" escape characters. These get expanded: "\a", "\b", "\f", "\n", "\r", "\t", "\v", "\\", and "\0" become the ASCII alert, backspace, form feed, newline, carriage return, horizontal tab, vertical tab, backslash, and NUL characters, in that order. On top of that, "\x"nn, "\u"nnnn, and "\U"nnnnnnnn (where each n is a hexadecimal digit) get translated into the Unicode characters for those code points. Any other combination of a character preceded by \ stays unexpanded 🌈
  • -fmodule-private — This sets the default accessibility of module entities to PRIVATE. Use-associated entities won't be accessible unless they're explicitly declared PUBLIC 🔒
  • -ffixed-line-length-n — This sets the column after which characters get ignored in typical fixed-form lines in the source file. Unless you use -fno-pad-source, it also decides how far spaces are assumed (as if the line were padded out to that length) after the ends of short fixed-form lines. Popular values for n are 72 (the standard and the default), 80 (card image), and 132 (matching the "extended-source" options in some popular compilers). n can also be none, which means the entire line is meaningful and continued character constants never get implicit spaces tacked on to fill out the line. -ffixed-line-length-0 does the exact same thing as -ffixed-line-length-none 📏
  • -fno-pad-source — Normally, fixed-form lines have spaces assumed (as if padded to that length) after the ends of short fixed-form lines. That doesn't happen if you use -ffixed-line-length-0, -ffixed-line-length-none, or -fno-pad-source. With any of those, continued character constants never get implicit spaces appended to fill out the line 🙅‍♀️
  • -ffree-line-length-n — This sets the column after which characters get ignored in typical free-form lines in the source file. The default is 132. n can be none, meaning the entire line is meaningful. -ffree-line-length-0 means the same thing as -ffree-line-length-none 📐
  • -fmax-identifier-length=n — This sets the maximum allowed identifier length. Typical values are 31 (Fortran 95) and 63 (Fortran 2003 and Fortran 2008) 🏷️
  • -fimplicit-none — This says no implicit typing is allowed, unless an explicit IMPLICIT statement overrides it. It's the same as adding implicit none to the start of every procedure 🤐
  • -fcray-pointer — This enables the Cray pointer extension, which gives you C-like pointer functionality 👉
  • -fopenacc — This enables the OpenACC extensions. That includes OpenACC !$acc directives in free form, c$acc, *$acc, and !$acc directives in fixed form, !$ conditional compilation sentinels in free form, and c$, *$, and !$ sentinels in fixed form. When linking, it also makes sure the OpenACC runtime library gets linked in.
This is an experimental feature, so it's incomplete and subject to change in future versions of GCC. For more info, check https://gcc.gnu.org/wiki/OpenACC 🧪
  • -fopenmp — This enables the OpenMP extensions. That includes OpenMP !$omp directives in free form, c$omp, *$omp, and !$omp directives in fixed form, !$ conditional compilation sentinels in free form, and c$, *$, and !$ sentinels in fixed form. When linking, it also makes sure the OpenMP runtime library gets linked in. And heads up, -fopenmp implies -frecursive 🧵
  • -fno-range-check — okay so this one turns OFF the range checks when gfortran is folding constant expressions at compile time 🙈. Normally it'll yell at you for a = 1. / 0, but with this flag no error shows up and a just gets +Infinity ✨. If a value lands outside the range of ["-HUGE()":HUGE()], it gets swapped for -Inf or +Inf, whichever fits. The DATA i/Z'FFFFFFFF'/ example is iconic: it'd normally overflow on most systems, but with -fno-range-check it wraps around and i ends up as -1 🔥
  • -fdefault-integer-8 — sets the default integer and logical types to an 8 byte wide type 💖. It also changes the kind of integer constants like 42. Unlike -finteger-4-integer-8, it does not promote variables that already have an explicit kind declaration, so those stay as they are 🫶
  • -fdefault-real-8 — sets the default real type to an 8 byte wide type 🌸. It also changes the kind of non-double real constants like 1.0. This one bumps the default width of DOUBLE PRECISION and double real constants like 1.d0 up to 16 bytes if that's possible. If you also pass -fdefault-double-8, then DOUBLE PRECISION and double real constants won't get promoted. Unlike -freal-4-real-8, -fdefault-real-8 doesn't touch variables with explicit kind declarations 💅
  • -fdefault-real-10 — same energy as -fdefault-real-8, but the default real type becomes a 10 byte wide type 🦋. It changes non-double real constants like 1.0, and it bumps DOUBLE PRECISION and double real constants like 1.d0 up to 16 bytes if possible. Passing -fdefault-double-8 along with it keeps DOUBLE PRECISION and double real constants from being promoted. And just like before, it won't mess with variables that have explicit kind declarations, unlike -freal-4-real-10 🧚
  • -fdefault-real-16 — sets the default real type to a 16 byte wide type 👑. It changes the kind of non-double real constants like 1.0, and bumps DOUBLE PRECISION and double real constants like 1.d0 up to 16 bytes if possible. With -fdefault-double-8 added, DOUBLE PRECISION and double real constants stay put. Explicitly kinded variables are left alone, unlike with -freal-4-real-16 ✨
  • -fdefault-double-8 — sets DOUBLE PRECISION and double real constants like 1.d0 to an 8 byte wide type 🍓. If that's already the default, it does nothing. This option stops -fdefault-real-8, -fdefault-real-10, and -fdefault-real-16 from promoting DOUBLE PRECISION and double real constants like 1.d0 to 16 bytes, so it's the one to reach for when you want those to stay small 💜
  • -finteger-4-integer-8 — promotes all INTEGER(KIND=4) entities to INTEGER(KIND=8) entities 😭. If KIND=8 isn't available, you'll get an error. Be careful with this one, bestie, because it may not suit your codes ⚠️. The areas to watch are calls to external procedures, alignment in EQUIVALENCE and/or COMMON, generic interfaces, BOZ literal constant conversion, and I/O. It's suggested that you inspect the intermediate representation of the translated Fortran code, which you can produce with -fdump-tree-original 🔍
  • -freal-4-real-8, -freal-4-real-10, -freal-4-real-16, -freal-8-real-4, -freal-8-real-10, -freal-8-real-16 — these all promote every REAL(KIND=M) entity to REAL(KIND=N) 🌈. If REAL(KIND=N) isn't available, you'll get an error. Every other real kind is unaffected. Same warning as before, babe: these may not suit your codes 💀. Watch out for calls to external procedures, alignment in EQUIVALENCE and/or COMMON, generic interfaces, BOZ literal constant conversion, and I/O. Again, inspecting the intermediate representation from -fdump-tree-original is suggested 🫶
  • -std=std — tell gfortran which standard your program is supposed to follow 📜. You can pick f95, f2003, f2008, f2018, gnu, or legacy. The default is gnu, which is a superset of the latest Fortran standard that includes every GNU Fortran extension, though you'll get warnings for obsolete extensions that aren't recommended in new code 🙄. The legacy value is basically the same but without those obsolete-extension warnings, which is useful for old non-standard programs 🧓. The f95, f2003, f2008, and f2018 values enforce strict conformance to Fortran 95, Fortran 2003, Fortran 2008, and Fortran 2018 respectively. Anything beyond that standard gets an error, and Fortran 77 features that are allowed but obsolescent in later standards get warnings 🚫. The deprecated -std=f2008ts is an alias for -std=f2018. It's only there for backwards compatibility with earlier gfortran versions, so please don't use it anymore 🥀
  • -ftest-forall-temp — boosts test coverage by forcing most forall assignments to use a temporary 🧪

✨ Enable and customize preprocessing ✨

Okay, these are all the preprocessor options 🎀. Check out the section Preprocessing and conditional compilation for the deeper dive on preprocessing in gfortran 📖

  • -cpp, -nocpp — -cpp turns preprocessing on 🌟. The preprocessor gets called automatically if your file extension is .fpp, .FPP, .F, .FOR, .FTN, .F90, .F95, .F03, or .F08. Use -cpp to manually enable preprocessing for any kind of Fortran file 💖.

To turn preprocessing OFF for files with any of those extensions, use the negative form, -nocpp 🙅‍♀️.

The preprocessor runs in traditional mode 🕰️. Any file-format restrictions, especially the line length limits, still apply to the preprocessed output, so it might be a good idea to use -ffree-line-length-none or -ffixed-line-length-none 📏

  • -dM — instead of the normal output, you get a list of #define directives for every macro defined while the preprocessor runs, predefined ones included 🧚. It's a super handy way to see what's predefined in your version of the preprocessor 👀. If you don't have a file called foo.f90, this command will show all the predefined macros:
touch foo.f90; gfortran -cpp -E -dM foo.f90
  • -dD — like -dM, but with two differences 💅. It leaves out the predefined macros, and it outputs both the #define directives AND the result of preprocessing. Both kinds of output go to the standard output file 📤
  • -dN — like -dD, but it only emits the macro names and not their expansions 🦋
  • -dU — like -dD except only macros that get expanded, or whose definedness gets tested in preprocessor directives, are output 🎯. The output is delayed until the macro is used or tested. #undef directives are also output for macros that were tested but were undefined at that time 🙈
  • -dI — outputs #include directives alongside the result of preprocessing 🌸
  • -fworking-directory — turns on generating linemarkers in the preprocessor output so the compiler knows the current working directory at preprocessing time 🗺️. With this on, the preprocessor emits a second linemarker after the initial one, containing the current working directory followed by two slashes. If the directory is present in the preprocessed input, GCC uses it as the current working directory in some debugging information formats 🐛. This is implicitly enabled when debugging information is on, but you can block that with the negated form, -fno-working-directory 🚫. Heads up: if the -P flag is in the command line, this option does nothing at all, because no #line directives get emitted whatsoever 😭
  • -idirafter dir — searches dir for include files, but only AFTER all the directories given with -I and the standard system directories have been exhausted 🏁. dir gets treated as a system include directory. If dir begins with =, then the = gets replaced by the sysroot prefix (see --sysroot and -isysroot) 🌿
  • -imultilib dir — uses dir as a subdirectory of the directory containing target-specific C++ headers 📚
  • -iprefix prefix — sets prefix as the prefix for subsequent -iwithprefix options 🏷️. If the prefix is a directory, include the final / 💅
  • -isysroot dir — this one's like --sysroot, but it only applies to header files 📂. Check the --sysroot option for more deets 👑
  • -iquote dir — searches dir ONLY for header files requested with #include "file" 💌. They're not searched for #include <file>. This happens before all the -I directories and before the standard system directories 🥇. If dir begins with =, then the = gets replaced by the sysroot prefix (see --sysroot and -isysroot) 🌿
  • -isystem dir — searches dir for header files, AFTER all the -I directories but BEFORE the standard system directories 🏛️. It gets marked as a system directory, so it gets the same special treatment as the standard system directories ✨. If dir begins with =, then the = gets replaced by the sysroot prefix (see --sysroot and -isysroot) 🌿
  • -nostdinc — don't search the standard system directories for header files 🙅‍♀️. Only the directories you specified with -I options (plus the directory of the current file, if appropriate) get searched 🔎
  • -undef — don't predefine any system-specific or GCC-specific macros 🧼. The standard predefined macros stay defined 💜
  • -Apredicate=answer — makes an assertion with the predicate predicate and the answer answer 🧠. This form is preferred over the older -A predicate(answer) form, which is still supported, because it doesn't use shell special characters 🐚
  • -A-predicate=answer — cancels an assertion with the predicate predicate and the answer answer ❌
  • -C — don't discard comments 💬. All comments get passed through to the output file, EXCEPT for comments inside processed directives, which get deleted along with the directive 🗑️

Okay so the -C option has some side effects, bestie 🚨 It makes the preprocessor treat comments as real tokens in their own right. A comment sitting at the start of what would be a directive line turns that line into an ordinary source line, because the first token on it is no longer a #. Chaotic, I know 💀

Warning: this currently handles C-style comments only 😭 The preprocessor does not yet recognize Fortran-style comments.
  • -CC — don't discard comments, not even during macro expansion 💖 It's like -C, except comments inside macros also get passed through to the output file wherever that macro gets expanded.

On top of the -C side effects, -CC converts all C++-style comments inside a macro into C-style comments 🙈 Why? So a later use of that macro can't accidentally comment out the rest of the source line. It's generally used to support lint comments 🫶

Warning: this currently handles C- and C++-style comments only. The preprocessor does not yet recognize Fortran-style comments.
  • -Dname — predefines name as a macro, with the definition 1 🌸
  • -Dname=definition — the contents of definition get tokenized and processed as if they showed up during translation phase three in a #define directive 🧚 The big catch: embedded newline characters will truncate the definition.

If you're invoking the preprocessor from a shell (or something shell-like), you might need the shell's quoting syntax to protect characters like spaces that have a meaning in shell syntax 🐚

Want a function-like macro on the command line? Write its argument list with surrounding parentheses before the equals sign (if any). Parentheses mean stuff to most shells, so you'll need to quote the option. With sh and csh, "-D'name(args...)=definition'" works 💅

-D and -U options are processed in the order you give them on the command line. All -imacros file and -include file options get processed after all the -D and -U options ✨

  • -H — prints the name of each header file used, along with all the other normal activities 📚 Each name is indented to show how deep it sits in the #include stack.
  • -P — inhibits generation of linemarkers in the preprocessor output 🦋 This might be useful when you're running the preprocessor on something that isn't C code and will be sent to a program that might get confused by the linemarkers.
  • -Uname — cancels any previous definition of name, whether it was built in or provided with a -D option 🧹

✨ Options to request or suppress errors and warnings ✨

Errors are diagnostic messages reporting that GNU Fortran cannot compile the relevant piece of source code 🙅 The compiler keeps going to try to report further errors so you can debug, but it won't produce any compiled output.

Warnings are diagnostic messages about constructions that aren't inherently erroneous but are risky or suggest there's likely a bug in the program 👀 Unless -Werror is specified, they don't prevent your program from compiling.

You can request lots of specific warnings with options beginning -W, for example -Wimplicit to get warnings on implicit declarations. Each of these specific warning options also has a negative form beginning -Wno- to turn warnings off, for example -Wno-implicit. This manual only lists one of the two forms, whichever is not the default 🧠

These options control the amount and kinds of errors and warnings GNU Fortran produces:

  • -fmax-errors=n — caps the number of error messages at n, at which point GNU Fortran bails out instead of trying to keep going 🛑 If n is 0, there is no limit on the number of error messages produced.
  • -fsyntax-only — checks the code for syntax errors but doesn't actually compile it 🧐 This will generate module files for each module present in the code, but no other output file.
  • -Wpedantic, -pedantic — issues warnings for uses of extensions to Fortran 📏 -pedantic also applies to C-language constructs where they occur in GNU Fortran source files, such as use of \e in a character constant within a directive like "#include".

Valid Fortran programs should compile properly with or without this option. Without it, though, certain GNU extensions and traditional Fortran features are supported too. With this option, many of them get rejected 🙃

Some users try to use -pedantic to check programs for conformance. They soon find it doesn't do quite what they want—it finds some nonstandard practices, but not all. However, improvements to GNU Fortran in this area are welcome 🙏

This should be used in conjunction with -std=f95, -std=f2003, -std=f2008 or -std=f2018.

  • -pedantic-errors — like -pedantic, except that errors are produced rather than warnings 🚫
  • -Wall — enables commonly used warning options pertaining to usage we recommend avoiding and that we believe are easy to avoid 🌈 This currently includes -Waliasing, -Wampersand, -Wconversion, -Wsurprising, -Wc-binding-type, -Wintrinsics-std, -Wtabs, -Wintrinsic-shadow, -Wline-truncation, -Wtarget-lifetime, -Winteger-division, -Wreal-q-constant, -Wunused and -Wundefined-do-loop.
  • -Waliasing — warns about possible aliasing of dummy arguments 👯 Specifically, it warns if the same actual argument is associated with a dummy argument with INTENT(IN) and a dummy argument with INTENT(OUT) in a call with an explicit interface.

The following example will trigger the warning:

interface
  subroutine bar(a,b)
    integer, intent(in) :: a
    integer, intent(out) :: b
  end subroutine
end interface
integer :: a

call bar(a,a)
  • -Wampersand — warns about a missing ampersand in continued character constants 💅 The warning is given with -Wampersand, -pedantic, -std=f95, -std=f2003, -std=f2008 and -std=f2018.

Note: With no ampersand given in a continued character constant, GNU Fortran assumes continuation at the first non-comment, non-whitespace character after the ampersand that initiated the continuation.

  • -Wargument-mismatch — warns about type, rank, and other mismatches between formal parameters and actual arguments to functions and subroutines 🧩 These warnings are recommended and thus enabled by default.
  • -Warray-temporaries — warns about array temporaries generated by the compiler 🗑️ The information from this warning is sometimes useful in optimization, so you can avoid such temporaries.
  • -Wc-binding-type — warns if a variable might not be C interoperable 🔗 In particular, it warns if the variable has been declared using an intrinsic type with default kind instead of using a kind parameter defined for C interoperability in the intrinsic ISO_C_Binding module. This option is implied by -Wall.
  • -Wcharacter-truncation — warns when a character assignment will truncate the assigned string ✂️
  • -Wline-truncation — warns when a source code line will be truncated 📏 This option is implied by -Wall. For free-form source code, the default is -Werror=line-truncation, so truncations are reported as errors.
  • -Wconversion — warns about implicit conversions that are likely to change the value of the expression after conversion 🔄 Implied by -Wall.
  • -Wconversion-extra — warns about implicit conversions between different types and kinds 🧪 This option does not imply -Wconversion.
  • -Wextra — enables some warning options for usages of language features which may be problematic 🍬 This currently includes -Wcompare-reals, -Wunused-parameter and -Wdo-subscript.
  • -Wfrontend-loop-interchange — enables warnings for loop interchanges performed by the -ffrontend-loop-interchange option 🔁
  • -Wimplicit-interface — warns if a procedure is called without an explicit interface 🕵️ Note this only checks that an explicit interface is present. It does not check that the declared interfaces are consistent across program units.
  • -Wimplicit-procedure — warns if a procedure is called that has neither an explicit interface nor has been declared as "EXTERNAL" 🫠
  • -Winteger-division — warns if a constant integer division truncates its result 🍕 As an example, 3/5 evaluates to 0.
  • -Wintrinsics-std — warns if gfortran finds a procedure named like an intrinsic that isn't available in the currently selected standard (with -std) and treats it as an "EXTERNAL" procedure because of this 🧐 -fall-intrinsics can be used to never trigger this behavior and always link to the intrinsic regardless of the selected standard.
  • -Wreal-q-constant — produces a warning if a real-literal-constant contains a "q" exponent-letter 🔢
  • -Wsurprising — produces a warning when "suspicious" code constructs are encountered 🫢 While technically legal, these usually indicate that an error has been made. This currently produces a warning under the following circumstances:
    • An INTEGER SELECT construct has a CASE that can never be matched as its lower value is greater than its upper value.
    • A LOGICAL SELECT construct has three CASE statements.
    • A TRANSFER specifies a source that is shorter than the destination.
    • The type of a function result is declared more than once with the same type. If -pedantic or standard-conforming mode is enabled, this is an error.
    • A "CHARACTER" variable is declared with negative length.
  • -Wtabs — tabs are accepted as whitespace by default, but tabs are not members of the Fortran Character Set ⚠️ For continuation lines, a tab followed by a digit between 1 and 9 is supported. -Wtabs will cause a warning to be issued if a tab is encountered. Note, -Wtabs is active for -pedantic, -std=f95, -std=f2003, -std=f2008, -std=f2018 and -Wall.
  • -Wundefined-do-loop — warns if a DO loop with step either 1 or -1 yields an underflow or an overflow during iteration of an induction variable of the loop 🔁 This option is implied by -Wall.
  • -Wunderflow — produces a warning when numerical constant expressions are encountered which yield an UNDERFLOW during compilation 🌊 Enabled by default.
  • -Wintrinsic-shadow: okay so this one warns if your own procedure or module procedure has the same name as an intrinsic 👀. Calls might not resolve to the one you actually meant, so you may need an explicit interface or an EXTERNAL or INTRINSIC declaration to get things back on track 🎀. This is implied by -Wall 💅.
  • -Wuse-without-only: warns if a USE statement has no ONLY qualifier, which means it quietly imports every public entity from the module 🫣.
  • -Wunused-dummy-argument: warns about unused dummy arguments 🧹. This is implied by -Wall.
  • -Wunused-parameter: this one is a plot twist 🌀. Unlike gcc, gfortran doesn't use it for unused dummy arguments (that's -Wunused-dummy-argument). Instead it warns about unused PARAMETER values. It's implied by -Wextra if -Wunused or -Wall is also used.
  • -Walign-commons: by default gfortran warns whenever variables inside a COMMON block get padded for proper alignment 📏. You can silence it with -Wno-align-commons, and see also -falign-commons.
  • -Wfunction-elimination: warns if calls to impure functions get eliminated by the optimizations turned on by -ffrontend-optimize 🫠. This is implied by -Wextra.
  • -Wrealloc-lhs: warns when the compiler might insert allocation or reallocation code for an allocatable array of intrinsic type in an intrinsic assignment 🔁. In hot loops, the Fortran 2003 reallocation feature can hurt performance 🥲. If the array is already allocated with the correct shape, consider a whole-array array-spec like (:,:,:) on the left-hand side so the reallocation check gets skipped ✨. Heads up, the warning can show up even when the compiler would optimize the check away anyway, like when the right-hand side has the same variable multiplied by a scalar. See also -frealloc-lhs.
  • -Wrealloc-lhs-all: warns whenever the compiler inserts allocation or reallocation code for any allocatable variable, and that includes scalars and derived types 🧩.
  • -Wcompare-reals: warns when you compare real or complex values for equality or inequality 🙈. This is implied by -Wextra.
  • -Wtarget-lifetime: warns if the pointer in a pointer assignment might outlive its target ⏳. This is implied by -Wall.
  • -Wzerotrip: warns if a DO loop is known at compile time to run zero times 🔄. This is implied by -Wall.
  • -Wdo-subscript: this one catches sneaky out-of-bounds vibes 👀. It warns if an array subscript inside a DO loop could go out of bounds, even when the compiler can't prove the statement actually runs. Something like this:
real a(3)
do i=1,4
  if (condition(i)) then
    a(i) = 1.2
  end if
end do

This is implied by -Wextra.

  • -Werror: turns every warning into an error 🚫.

Some of these have no effect when compiling programs written in Fortran 🤷‍♀️.

🐛 Options for debugging your program or GNU Fortran 🔍

GNU Fortran has a bunch of special options for debugging either your program or the GNU Fortran compiler itself 🧚. Hot tip: most of these are mainly for compiler nerds 🤓.

  • -fdump-fortran-original: outputs the internal parse tree right after the source program gets translated into internal representation 🌳. It's mostly useful for debugging the GNU Fortran compiler itself. The output might change between releases, and it may also throw internal compiler errors for features that were only added recently 😭.
  • -fdump-fortran-optimized: outputs the parse tree after front-end optimization 🪄. Mostly useful for debugging the GNU Fortran compiler itself. The output might change between releases, and it may also cause internal compiler errors for brand-new features 💀.
  • -fdump-parse-tree: outputs the internal parse tree right after the source program gets translated into internal representation 🌲. It's mostly for debugging the compiler itself, the output can change between releases, and it may also cause internal compiler errors for recently added features.
This option is deprecated! Use -fdump-fortran-original instead 🚨.
  • -fdump-fortran-global: outputs a list of the global identifiers after translating into middle-end representation 📜. Mostly useful for debugging the GNU Fortran compiler itself. The output might change between releases, and it may also trigger internal compiler errors for features that were only recently added 🫨.
  • -ffpe-trap=list: lets you turn on floating-point exception traps 💥. On most systems, when a floating-point exception happens and its trap is enabled, a SIGFPE signal gets sent and the program is aborted, leaving behind a core file that's super useful for debugging 🔥. The list is a comma-separated list (it can be empty) of these exceptions:
    • invalid: an invalid floating-point operation, like SQRT(-1.0) 🙅‍♀️
    • zero: division by zero ➗
    • overflow: overflow in a floating-point operation 📈
    • underflow: underflow in a floating-point operation 📉
    • inexact: loss of precision during an operation 🌫️
    • denormal: an operation performed on a denormal value 🤏

The first five exceptions match the five IEEE 754 exceptions. The last one, denormal, isn't part of IEEE 754, but it's available on some common architectures like x86 🖥️.

The first three exceptions (invalid, zero, and overflow) often point to serious errors. Unless your program has a plan for handling them, turning on traps for those three is probably a good idea 🫶.

If you use the option more than once on the command line, the lists get joined together. So '"ffpe-trap="list1 "ffpe-trap="list2' is the same as "ffpe-trap="list1,list2 🧩.

Once you enable an exception, you can't disable it. There's no negative form, so choose wisely 🔒.

Lots of floating-point operations lose precision because of rounding, so ffpe-trap=inexact is probably not very interesting in practice 🥱.

By default, no exception traps are enabled 🕊️.

  • -ffpe-summary=list: lets you pick which floating-point exceptions get their flag status printed to ERROR_UNIT whenever STOP or ERROR STOP gets invoked 📋. The list can be none, all, or a comma-separated list of invalid, zero, overflow, underflow, inexact, and denormal. (Check -ffpe-trap for what each of those exceptions means 👀.)

If you use the option more than once on the command line, only the last one counts 🫵.

By default, a summary for all exceptions except inexact gets shown 📝.

  • -fno-backtrace: when a serious runtime error pops up or a deadly signal gets emitted (segmentation fault, illegal instruction, bus error, floating-point exception, and any other POSIX signal whose action is core), the Fortran runtime library tries to print a backtrace of the error 🪵. -fno-backtrace turns that backtrace generation off 🙅‍♀️. This option only matters when compiling the Fortran main program.

These options control how GNU Fortran looks for files pulled in by the INCLUDE directive, and where it looks for previously compiled modules 🧭.

They also affect the search paths cpp uses when it preprocesses Fortran source 🌸.

  • -Idir: affects how the INCLUDE directive gets interpreted (and the #include directive of the cpp preprocessor too) 🗺️.

Also, the general behavior of -I and INCLUDE is pretty much the same as -I with #include in the cpp preprocessor, when it comes to looking for header.gcc files and other stuff like that 💅.

This path is also used to search for .mod files when a USE statement needs previously compiled modules 📦.

  • -Jdir: specifies where to put .mod files for compiled modules 🗃️. It also gets added to the list of directories that a USE statement searches.

The default is the current directory 📍.

  • -fintrinsic-modules-path dir: specifies where the pre-compiled intrinsic modules live, if they aren't in the default location the compiler expects 🏠.

🔗 Influencing the linking step ⛓️

These options kick in when the compiler links object files into an executable output file 🧩. They're meaningless if the compiler isn't doing a link step 🤷‍♀️.

  • -static-libgfortran: on systems that provide libgfortran as both a shared and a static library, this forces the static version 🪨. If no shared version of libgfortran was built when the compiler was configured, this option does nothing 😶.

🏃‍♀️ Influencing runtime behavior 🌈

These options change how programs compiled with GNU Fortran behave at runtime 🎬.

  • -fconvert=conversion: sets how data is represented in unformatted files 🧃. Valid values for conversion are native (the default), swap (swaps between big- and little-endian), big-endian (uses big-endian representation for unformatted files), and little-endian (uses little-endian representation for unformatted files) 🔀.

This option only has an effect when it's used in the main program 👑. The CONVERT specifier and the GFORTRAN_CONVERT_UNIT environment variable both override the default set by -fconvert 🫡.

  • -frecord-marker=length: sets the length of record markers for unformatted files 📏. Valid values for length are 4 and 8, and the default is 4 💖. This is different from earlier gfortran versions, which used a default record marker length of 8 on most systems 🕰️. If you want to read or write files that work with earlier versions of gfortran, use -frecord-marker=8 🔁.
  • -fmax-subrecord-length=length: sets the maximum length for a subrecord 📐. The maximum permitted value for length is 2147483639, which is also the default 💯. It's only really useful for the gfortran testsuite 🧪.
  • -fsign-zero — okay bestie, when this is on 💖, floating point zeros that have the sign bit set get written out as negative numbers in formatted output, and the SIGN intrinsic treats them as negative too 🦋. -fno-sign-zero is the chill version 🌸. It doesn't print the negative sign of zero values (or values rounded to zero for I/O), and it treats zero as positive in the SIGN intrinsic, which keeps things compatible with Fortran 77 🎀. The default is -fsign-zero ✨.

✨ Options for code generation conventions ✨

okay so these are machine-independent options that control the interface conventions used in code generation 🧚. They're giving main character energy in the build process 💅.

Most of them come in positive and negative forms. The negative form of -ffoo is -fno-foo. Below, only the non-default form is listed, so you figure out the other one by either removing no- or adding it 🌈.

  • -fno-automatic — treat each program unit (except those marked RECURSIVE) as if the SAVE statement were specified for every local variable and array referenced in it. It doesn't affect common blocks. (Some Fortran compilers call this option -static or -save.) The default, -fautomatic, uses the stack for local variables smaller than the value given by -fmax-stack-var-size. If you want no static memory at all, use -frecursive 💜.
    • Local variables or arrays with an explicit SAVE attribute are silently ignored unless you add the -pedantic option 🙈.
  • -ff2c — generate code that's compatible with code generated by g77 and f2c 🫶. The g77 calling conventions (originally implemented in f2c) make functions that return default REAL actually return the C type double. Functions that return COMPLEX send their value back through an extra argument in the calling sequence, which points to where the return value gets stored. Under the default GNU calling conventions, those functions just return their results like GNU C would. Default REAL functions return the C type float, and COMPLEX functions return the GNU C type complex ✨. This option also implies -fsecond-underscore, unless you explicitly ask for -fno-second-underscore 🔥.
    • This does not affect the generation of code that interfaces with the libgfortran library.
Caution: It is not a good idea to mix Fortran code compiled with -ff2c with code compiled with the default -fno-f2c calling conventions 💀. Calling COMPLEX or default REAL functions between program parts compiled with different calling conventions will break at execution time 😭.
Caution: This will break code that passes intrinsic functions of type default REAL or COMPLEX as actual arguments, because the library implementations use the -fno-f2c calling conventions 🙈.
  • -fno-underscoring — do not transform the names of entities in the Fortran source file by appending underscores to them 🎀.
    • With -funderscoring in effect, GNU Fortran appends one underscore to external names with no underscores. This is done to stay compatible with code produced by many UNIX Fortran compilers 🦋.
    • Using -fno-underscoring is not recommended unless you're experimenting with things like integrating GNU Fortran into existing system environments (vis-à-vis existing libraries, tools, and so on) 🧐.

For example, with -funderscoring, and assuming that j() and max_count() are external functions while my_var and lvar are local variables, a statement like this:

I = J() + MAX_COUNT (MY_VAR, LVAR)

is implemented as something akin to:

i = j_() + max_count__(&my_var__, &lvar);

With -fno-underscoring, the same statement is implemented as:

i = j() + max_count(&my_var, &lvar);
  • Using -fno-underscoring lets you specify user-defined names directly while debugging and when interfacing GNU Fortran code with other languages 🔍.
  • Just because the names match doesn't mean the interface GNU Fortran implements for an external name matches the interface another language implements for that same name 🫠. Getting code from GNU Fortran to link with code from another compiler using this or any other method can be only a small part of the solution. Getting the code from both compilers to agree on things other than naming can take serious effort, and unlike naming disagreements, linkers normally can't detect disagreements in those other areas 💀.
  • With -fno-underscoring, the lack of appended underscores introduces a very real possibility that a user-defined external name will conflict with a name in a system library. That could make finding unresolved-reference bugs quite difficult in some cases, since they might occur at program run time and only show up as buggy behavior then 😭.
  • In future versions of GNU Fortran, the hope is to improve naming and linking so that debugging always involves using the names as they appear in the source. The names as seen by the linker may still be mangled to prevent accidental linking between procedures with incompatible interfaces ✨.
  • -fsecond-underscore — by default, GNU Fortran appends an underscore to external names. With this option, GNU Fortran appends two underscores to names that contain underscores, and one underscore to external names with no underscores. It also appends two underscores to internal names with underscores, to avoid naming collisions with external names 💜.
    • This option has no effect if -fno-underscoring is in effect. It is implied by the -ff2c option 🌸.
    • With this option, an external name such as MAX_COUNT is implemented as a reference to the link-time external symbol max_count__, instead of max_count_. This is required for compatibility with g77 and f2c, and it's implied by using the -ff2c option 🫶.
  • -fcoarray=<keyword> — pick how coarray support works 🌈.
    • none — disable coarray support. Using coarray declarations and image-control statements will produce a compile-time error. (Default) 🚫
    • single — single-image mode, i.e. num_images() is always one 🧚.
    • lib — library-based coarray parallelization. A suitable GNU Fortran coarray library needs to be linked 🔥.
  • -fcheck=<keyword> — enable the generation of run-time checks 🛡️. The argument should be a comma-delimited list of the keywords below. Prefixing a check with no- disables it if it was activated by a previous specification 💅.
    • all — enable all run-time tests of -fcheck ✨.
    • array-temps — warns at run time when, to pass an actual argument, a temporary array had to be generated. The info from this warning is sometimes useful for optimization, so you can avoid those temporaries 🦋.
      • Note: The warning is only printed once per location.
    • bounds — enable generation of run-time checks for array subscripts and against the declared minimum and maximum values. It also checks array indices for assumed and deferred shape arrays against the actual allocated bounds, and it makes sure all string lengths are equal for character array constructors without an explicit typespec 🎀.
      • Some checks require that -fcheck=bounds is set for the compilation of the main program.
      • Note: In the future this may also include other forms of checking, e.g., checking substring references.
    • do — enable generation of run-time checks for invalid modification of loop iteration variables 🔁.
    • mem — enable generation of run-time checks for memory allocation 🧠.
      • Note: This option does not affect explicit allocations using the ALLOCATE statement, which will always be checked.
    • pointer — enable generation of run-time checks for pointers and allocatables 👑.
    • recursion — enable generation of run-time checks for recursively called subroutines and functions that aren't marked as recursive. See also -frecursive 🌀.
      • Note: This check does not work for OpenMP programs, and it's disabled if used together with -frecursive and -fopenmp.

Example: Assuming you have a file foo.f90, the command:

gfortran -fcheck=all,no-array-temps foo.f90

will compile the file with all checks enabled as specified above, except warnings for generated array temporaries 💖.

  • -fbounds-check — deprecated alias for -fcheck=bounds 🥀.
  • -ftail-call-workaround, -ftail-call-workaround=n — okay, this one's a lot 😭. Some C interfaces to Fortran code violate the gfortran ABI by omitting the hidden character length arguments as described in. This can lead to crashes, because pushing arguments for tail calls can overflow the stack 💀.
    • To provide a workaround for existing binary packages, this option disables tail call optimization for gfortran procedures with character arguments. With -ftail-call-workaround=2, tail call optimization is disabled in all gfortran procedures with character arguments. With -ftail-call-workaround=1 or the equivalent plain -ftail-call-workaround, it's disabled only in gfortran procedures with character arguments that call implicitly prototyped procedures 🧩.
    • Using this option can lead to problems, including crashes due to insufficient stack space 🥺.
    • It is very strongly recommended to fix the code in question. The -fc-prototypes-external option can be used to generate prototypes that conform to gfortran's ABI, for inclusion in the source code 🛠️.
    • Support for this option will likely be withdrawn in a future release of gfortran 👋.
    • The negative form, -fno-tail-call-workaround or the equivalent -ftail-call-workaround=0, can be used to disable this option 🙅.
    • The default is currently -ftail-call-workaround. This will change in future releases 🔮.
Warning: Relying on this option is risky bestie. Fix the source instead of leaning on the workaround 🚨.
  • -fcheck-array-temporaries — deprecated alias for -fcheck=array-temps 🥀.
  • -fmax-array-constructor=n — this option can be used to increase the upper limit permitted in array constructors 📈. The code below requires this option to expand the array at compile time 🧮.

Here's what that example looks like in action 🧚

program test
implicit none
integer j
integer, parameter :: n = 100000
integer, parameter :: i(n) = (/ (2*j, j = 1, n) /)
print '(10(I0,1X))', i
end program test
⚠️ Caution, bestie: This option can lead to long compile times and excessively large object files 😭

The default value for n is 65535 💜

-fmax-stack-var-size=n ✨

This one sets the size in bytes of the biggest array that's allowed to live on the stack. If an array goes over that size, it gets static memory instead (except inside procedures marked RECURSIVE). If you need recursive procedures that don't have the RECURSIVE attribute, or you're writing parallel programs, use -frecursive to allow it. And if you want the stack to never be used at all, -fno-automatic is your girl 🙈

This option currently only touches local arrays with constant bounds, and it might not apply to every character variable. Future versions of GNU Fortran may improve this, so keep an eye out 👀

The default value for n is 32768 🌸

-fstack-arrays 🦋

This option tells the Fortran compiler to put all arrays of unknown size and array temporaries onto stack memory. Lowkey a big deal: if your program uses very large local arrays, you might have to raise your runtime stack memory limits on some operating systems 😭

This flag is turned on by default at the -Ofast optimization level, unless -fmax-stack-var-size is specified 💅

-fpack-derived 💖

This tells GNU Fortran to pack derived type members as closely together as possible. Code compiled with this option is likely to be incompatible with code compiled without it, and it may run slower 💀

-frepack-arrays 🫶

Sometimes GNU Fortran passes assumed shape array sections through a descriptor that describes a noncontiguous area of memory. This option adds code to the function prologue that repacks the data into a contiguous block at runtime ✨

This should make accesses to the array faster. However, it can add significant overhead to the function call, especially when the passed data is noncontiguous 🫠

-fshort-enums 🎀

This one's for interoperability with C code that was compiled with the -fshort-enums option. It makes GNU Fortran choose the smallest INTEGER kind that a given enumerator set fits in, and then gives all of its enumerators that kind 🧚

-fexternal-blas 🔥

This makes gfortran generate calls to BLAS functions for some matrix operations, like MATMUL, instead of using its own algorithms. That only happens if the matrices involved are larger than a given limit (see -fblas-matmul-limit) 👑

This can be super profitable if an optimized vendor BLAS library is available. The BLAS library has to be specified at link time, so don't forget it 🫶

-fblas-matmul-limit=n 🌈

Only significant when -fexternal-blas is in effect. Matrix multiplication of matrices with a size larger than (or equal to) n gets handled by calls to BLAS functions, while smaller ones are handled by gfortran's internal algorithms 💅

If the matrices aren't square, the size comparison uses the geometric mean of the dimensions of the argument and result matrices 🤓

The default value for n is 30 ✨

-finline-matmul-limit=n 💜

When front-end optimization is active, some calls to the MATMUL intrinsic function get inlined. This can increase code size if the size of the matrix can't be determined at compile time, because code for both cases gets generated 🙈

Setting -finline-matmul-limit=0 disables inlining in all cases. Setting it to a value of n produces inline code for matrices with a size up to n. If the matrices aren't square, the size comparison uses the geometric mean of the dimensions of the argument and result matrices 🌸

The default value for n is 30. The -fblas-matmul-limit option can be used to change this value 🦋

-frecursive 🧚

This allows indirect recursion by forcing all local arrays to be allocated on the stack. Heads up: this flag cannot be used together with -fmax-stack-var-size= or -fno-automatic 🚫

-finit-local-zero, -finit-derived, -finit-integer=n, -finit-real=<zero|inf|-inf|nan|snan>, -finit-logical=<true|false>, -finit-character=n 🍓

-finit-local-zero tells the compiler to initialize local INTEGER, REAL, and COMPLEX variables to zero, LOGICAL variables to false, and CHARACTER variables to a string of null bytes ✨

The finer-grained options are -finit-integer=n, -finit-real=<zero|inf|-inf|nan|snan> (which also initializes the real and imaginary parts of local COMPLEX variables), -finit-logical=<true|false>, and -finit-character=n (where n is an ASCII character value) 💖

With -finit-derived, components of derived type variables get initialized according to these flags. Components whose type isn't covered by an explicit -finit-* flag get treated the same as -finit-local-zero 🫶

These options do not initialize:

  • objects with the POINTER attribute 🙅
  • allocatable arrays 🙅
  • variables that appear in an EQUIVALENCE statement 🙅

(These limitations may be removed in future releases, so no promises yet 🥺)

Note that -finit-real=nan initializes REAL and COMPLEX variables with a quiet NaN. For a signalling NaN, use -finit-real=snan. Be careful though: compile-time optimizations may convert them into a quiet NaN, and trapping needs to be enabled (e.g. via -ffpe-trap) 🔥

The -finit-integer option parses the value into an integer of type INTEGER(kind=C_LONG) on the host. That value is then assigned to the integer variables in the Fortran code, which might wrap around if the value is too large for the kind 💀

Finally, enabling any of the -finit-* options will silence warnings that would've been emitted by -Wuninitialized for the affected local variables 🤫

-falign-commons 🌈

By default, gfortran enforces proper alignment of all variables in a COMMON block by padding them as needed. On certain platforms this is mandatory, and on others it boosts performance 🚀

If a COMMON block isn't declared with consistent data types everywhere, this padding can cause trouble. In that case, -fno-align-commons disables the automatic alignment 🙅. The same form of this option should be used for all files that share a COMMON block 🫶

To avoid potential alignment issues in COMMON blocks, it's recommended to order objects from largest to smallest 📏

-fno-protect-parens 🦋

By default, the parentheses in expressions are honored at all optimization levels, so the compiler doesn't do any re-association 🙈

Using -fno-protect-parens lets the compiler reorder REAL and COMPLEX expressions to produce faster code. For the re-association optimization, -fno-signed-zeros and -fno-trapping-math need to be in effect too 🧠

The parentheses protection is enabled by default, unless -Ofast is given 💅

-frealloc-lhs 💜

An allocatable left-hand side of an intrinsic assignment gets automatically (re)allocated if it's either unallocated or has a different shape. It's enabled by default except when -std=f95 is given 🌸

See also -Wrealloc-lhs 👀

-faggressive-function-elimination 🔥

Functions with identical argument lists get eliminated within statements, regardless of whether they're marked PURE or not 😤

For example, in:

a = f(b,c) + f(b,c)

there will only be a single call to f 👑

This option only works if -ffrontend-optimize is in effect 🫶

-ffrontend-optimize 🧚

This option performs front-end optimization, based on manipulating parts of the Fortran parse tree. It's enabled by default by any -O option except -O0 and -Og ✨

The optimizations enabled by this option include:

  • inlining calls to MATMUL 💖
  • elimination of identical function calls within expressions 💅
  • removing unnecessary calls to TRIM in comparisons and assignments 🌸
  • replacing TRIM(a) with a(1:LEN_TRIM(a)) 🦋
  • short-circuiting of logical operators (.AND. and .OR.) 🫶

It can be deselected by specifying -fno-frontend-optimize 🙅

-ffrontend-loop-interchange 🌈

This attempts to interchange loops in the Fortran front end where it's profitable. It's enabled by default by any -O option ✨

At the moment, this option only affects FORALL and DO CONCURRENT statements with several forall triplets 🤓

✨ ENVIRONMENT ✨

The gfortran compiler currently doesn't use any environment variables to control its operation, beyond the ones that affect the operation of gcc. So no secret switches here, bestie 💅

🐛 BUGS 🐛

For instructions on reporting bugs, see <file:///usr/share/doc/gcc-9/README.Bugs> 🙈

🦋 SEE ALSO 🦋

gpl(7), gfdl(7), fsf-funding(7), cpp(1), gcov(1), gcc(1), as(1), ld(1), gdb(1), dbx(1), and the Info entries for gcc, cpp, gfortran, as, ld, binutils, and gdb 📚

👩‍💻 AUTHOR 👩‍💻

See the Info entry for gfortran for contributors to GCC and GNU Fortran 💜

Copyright (c) 2004-2019 Free Software Foundation, Inc. 🌈

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with the Invariant Sections being "Funding Free Software", the Front-Cover Texts being (a) (see below), and with the Back-Cover Texts being (b) (see below). A copy of the license is included in the gfdl(7) man page 📖

(a) The FSF's Front-Cover Text is:

A GNU Manual

(b) The FSF's Back-Cover Text is:

You have freedom to copy and modify this GNU Manual, like GNU software. Copies published by the Free Software Foundation raise funds for GNU development.

Okay bestie, that's the whole page 🫶 It came from gcc-9 and was last dated 2022-05-27, so you're officially a GFORTRAN(1) expert now 👑💖✨

📦 where this page comes from