GFORTRAN(1)

📦
version 11.5.0 · 5 versions
, in ubuntu questing, ubuntu resolute, ubuntu stonking

🎀 GFORTRAN(1) 🎀

Okay bestie, this is the GNU manual page for GFORTRAN(1), so grab your snacks 🍓✨

✨ NAME ✨

gfortran is 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...

Heads up: the synopsis only shows the most useful options, and the rest are waiting for you further down 🧚

💖 DESCRIPTION 💖

The gfortran command is literally a queen. It supports all the options that the gcc command supports 👑 Only the options that are specific to GNU Fortran get documented here, so you don't have to read the same stuff twice.

Every GCC and GNU Fortran option works with both gfortran and gcc, plus any other drivers that got built at the same time, like g++. Adding GNU Fortran to the GCC distribution means all the relevant drivers accept GNU Fortran options, so it's giving teamwork 🫶

Some options come in positive and negative forms. The negative form of -ffoo is -fno-foo. This manual only documents whichever of the two forms is not the default, so keep that in mind 🌈

🌸 OPTIONS 🌸

Here's the full tea on every option that's specific to GNU Fortran, sorted into groups by type. The explanations come after the lists ✨

💅 Fortran Language Options

-fall-intrinsics -fallow-argument-mismatch -fallow-invalid-boz
-fbackslash -fcray-pointer -fd-lines-as-code -fd-lines-as-comments
-fdec -fdec-char-conversions -fdec-structure -fdec-intrinsic-ints
-fdec-static -fdec-math -fdec-include -fdec-format-defaults
-fdec-blank-format-item -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 -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-overwrite-recursive
-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
-fdebug-aux-vars -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|bits|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 -finline-arg-packing
-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

Okay so these options are the ones that control the exact flavor of Fortran the compiler accepts 🦋

  • -ffree-form, -ffixed-form — These pick the layout of the source file. Free form came along in Fortran 90, while fixed form is the classic look that older Fortran programs were written in. If you don't pick either one, the compiler figures out the source form from the file extension, which is kind of iconic of it 💅
  • -fall-intrinsics — This makes the compiler accept every intrinsic procedure, GNU-specific extensions included, so you get the whole intrinsics buffet ✨ It's super handy with -std=f95 if you want standard compliance but still want full gfortran access. The catch: -Wintrinsics-std gets ignored, and no user-defined procedure that shares a name with an intrinsic will be called unless it's explicitly declared EXTERNAL 🙈
  • -fallow-argument-mismatch — Some code calls external procedures with mismatched arguments, either against the procedure's definition or against other calls. That code isn't conforming, and it usually gets flagged as an error. This option downgrades that error to a warning, and the only way to switch that warning off is to disable all warnings with -w. Only one occurrence per argument gets flagged. This option is implied by -std=legacy 💀
Using this option is strongly discouraged, bestie 🚫 You can write standard-conforming code that allows different argument types by using an explicit interface and TYPE(*), so there's zero reason to lean on this one.
  • -fallow-invalid-boz — A BOZ literal constant can only show up in a few contexts in standard-conforming Fortran. This option turns the error into a warning and lets a BOZ literal constant appear where the Fortran standard would normally ban it 🙃
  • -fd-lines-as-code, -fd-lines-as-comments — These give special treatment to lines that start with d or D in fixed form sources. With -fd-lines-as-code, those lines get treated as if their first column held a blank. With -fd-lines-as-comments, they get 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). Heads up, though: these features are non-standard and should be avoided at all costs 💀 For details on how GNU Fortran implements these extensions, check the full documentation. Other flags that this switch turns on are -fdollar-ok, -fcray-pointer, -fdec-char-conversions, -fdec-structure, -fdec-intrinsic-ints, -fdec-static, -fdec-math, -fdec-include, -fdec-blank-format-item, and -fdec-format-defaults. If -fd-lines-as-code or -fd-lines-as-comments aren't set, then -fdec also sets -fd-lines-as-comments 🎀
  • -fdec-char-conversions — This lets you use character literals in assignments and DATA statements for non-character variables 🍓
  • -fdec-structure — This enables DEC STRUCTURE and RECORD, plus UNION, MAP, and the dot (.) as a member separator, which is in addition to %. It's only here for compatibility, so use Fortran 90 derived types instead whenever you can 🫠
  • -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 complete list of intrinsics, see 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 specify the storage of variables and other objects 📦
  • -fdec-include — This lets INCLUDE be parsed as a statement in addition to parsing it as an INCLUDE line. When it's parsed as a statement, the INCLUDE doesn't have to sit on a single line and can use line continuations ✨
  • -fdec-format-defaults — This lets the format specifiers F, G, and I get used without width specifiers, and default widths get used instead 🌸
  • -fdec-blank-format-item — This enables a blank format item at the end of a format specification, meaning there's nothing after the final comma 🙈
  • -fdollar-ok — This allows $ as a valid non-first character in a symbol name. Symbols that start with $ are rejected, because it's unclear which implicit typing rules should apply since different vendors do different things. Using $ in IMPLICIT statements is also rejected 🚫
  • -fbackslash — This changes how backslashes work in string literals. Instead of a single backslash character, you get "C-style" escape characters. These combos get expanded: "\a" (alert), "\b" (backspace), "\f" (form feed), "\n" (newline), "\r" (carriage return), "\t" (horizontal tab), "\v" (vertical tab), "\\" (backslash), and "\0" (NUL). 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 🌈 Every other combo 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. Unless you use -fno-pad-source, it also sets the column through which spaces are assumed (as if the line were padded 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 have implicit spaces appended to fill out the line. -ffixed-line-length-0 does the exact same thing as -ffixed-line-length-none 💖
  • -fno-pad-source — By default, 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 options, continued character constants never get implicit spaces appended to them to fill out the line 🧚
  • -ffree-line-length-n — okay so this sets the column where gfortran stops caring about a typical free-form source line, and everything past it gets ignored 💅 The default is 132. You can pass n as none so the entire line counts, and -ffree-line-length-0 is the exact same thing as -ffree-line-length-none 🦋
  • -fmax-identifier-length=n — sets the longest identifier name you're allowed to use 🧚 Typical values are 31 (Fortran 95) and 63 (Fortran 2003 and Fortran 2008) ✨
  • -fimplicit-none — no implicit typing allowed, unless you override it with explicit IMPLICIT statements 🙈 It's basically the same as slapping implicit none at the top of every procedure 🔥
  • -fcray-pointer — turns on the Cray pointer extension, which gives you C-style pointer vibes 🌸
  • -fopenacc — enables the OpenACC extensions 👑 That means !$acc directives in free form, and c$acc, *$acc and !$acc directives in fixed form. It also covers the !$ conditional compilation sentinels in free form, and c$, *$ and !$ sentinels in fixed form. And when you link, the OpenACC runtime library gets linked in too 🫶
  • -fopenmp — enables the OpenMP extensions 🌈 That means !$omp directives in free form, and c$omp, *$omp and !$omp directives in fixed form. It also covers the !$ sentinels in free form, and c$, *$ and !$ sentinels in fixed form, and linking pulls in the OpenMP runtime library. This option implies -frecursive 🔥
  • -fno-range-check — turns off range checking on the results of simplifying constant expressions at compile time 💀 Normally GNU Fortran errors out on something like a = 1. / 0. With this option there's no error, and a gets +Infinity. If an expression evaluates to something outside the relevant range ["-HUGE()":HUGE()], it gets replaced by -Inf or +Inf, whichever fits. Similarly, DATA i/Z'FFFFFFFF'/ causes an integer overflow on most systems, but with -fno-range-check the value wraps around and i gets initialized to -1 instead ✨
  • -fdefault-integer-8 — the default integer and logical types become 8 bytes wide 🔢 This also changes the kind of integer constants like 42. Unlike -finteger-4-integer-8, it does not promote variables with an explicit kind declaration.
  • -fdefault-real-8 — the default real type becomes 8 bytes wide 💖 This also affects the kind of non-double real constants like 1.0. It bumps the default width of DOUBLE PRECISION and double real constants like 1.d0 up to 16 bytes if possible. If you pass -fdefault-double-8 along with fdefault-real-8, then DOUBLE PRECISION and double real constants are not promoted. Unlike -freal-4-real-8, fdefault-real-8 doesn't promote variables with explicit kind declarations.
  • -fdefault-real-10 — same energy, but the default real type becomes a 10 byte wide type 🧁 This also affects the kind of non-double real constants like 1.0. It bumps the default width of DOUBLE PRECISION and double real constants like 1.d0 up to 16 bytes if possible. If you pass -fdefault-double-8 along with fdefault-real-10, then DOUBLE PRECISION and double real constants are not promoted. Unlike -freal-4-real-10, fdefault-real-10 doesn't promote variables with explicit kind declarations.
  • -fdefault-real-16 — the default real type becomes a 16 byte wide type 🌟 This also affects the kind of non-double real constants like 1.0. It bumps the default width of DOUBLE PRECISION and double real constants like 1.d0 up to 16 bytes if possible. If you pass -fdefault-double-8 along with fdefault-real-16, then DOUBLE PRECISION and double real constants are not promoted. Unlike -freal-4-real-16, fdefault-real-16 doesn't promote variables with explicit kind declarations.
  • -fdefault-double-8 — sets the DOUBLE PRECISION type 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.
  • -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.
🚨 This one should be used with care, and it 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. Inspecting the intermediate representation of the translated Fortran code, produced by -fdump-tree-original, is suggested.
  • -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 promote all REAL(KIND=M) entities to REAL(KIND=N) entities 👑 If REAL(KIND=N) isn't available, you'll get an error. The -freal-4- flags also affect the default real kind, and the -freal-8- flags affect the double-precision real kind. Every other real-kind type is left alone. The promotion also applies to real literal constants of default and double-precision kind with a specified kind number of 4 or 8, respectively. However, -fdefault-real-8, -fdefault-real-10, -fdefault-real-10, and -fdefault-double-8 take precedence for the default and double-precision real kinds, both for real literal constants and for declarations without a kind number. Heads up: for REAL(KIND=KIND(1.0)), the literal may get promoted and then the result may get promoted again 🙈
🚨 These options should be used with care, and they may not suit your codes. Areas of concern include calls to external procedures, alignment in EQUIVALENCE and/or COMMON, generic interfaces, BOZ literal constant conversion, I/O, and calls to intrinsic procedures when passing a value to the kind= dummy argument. Inspecting the intermediate representation of the translated Fortran code, produced by -fdump-fortran-original or -fdump-tree-original, is suggested.
  • -std=std — pick the standard your program is expected to follow 📜 The options are f95, f2003, f2008, f2018, gnu, or legacy.
    • gnu — the default 💅 It's a superset of the latest Fortran standard that includes every extension GNU Fortran supports. You'll still get warnings for obsolete extensions that aren't recommended for new code.
    • legacy — basically the same as gnu, just without those warnings for obsolete extensions. It's handy for old non-standard programs 🧓
    • f95, f2003, f2008, f2018 — strict conformance to the Fortran 95, Fortran 2003, Fortran 2008 and Fortran 2018 standards, respectively 🎯 You get errors for every extension beyond the relevant language standard, and warnings for the Fortran 77 features that are still permitted but obsolescent in later standards.
    • > 🚨 The deprecated -std=f2008ts acts as an alias for -std=f2018. It only exists for backwards compatibility with earlier gfortran versions, so please don't use it any more 💀
  • -ftest-forall-temp — a test coverage booster 🧪 It forces most forall assignments to use a temporary.

🎀 Enable and customize preprocessing 🎀

Preprocessor related options 🧩 For more detailed info on preprocessing in gfortran, check out the section called Preprocessing and conditional compilation.

  • -cpp, -nocpp — -cpp turns preprocessing on 🌸 The preprocessor gets invoked automatically if the file extension is .fpp, .FPP, .F, .FOR, .FTN, .F90, .F95, .F03 or .F08. Use this flag 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. Restrictions on the file format, especially the line length limits, apply to preprocessed output too, 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 all the macros defined while the preprocessor ran, including the predefined ones 🔍 This is a great way to find out what's predefined in your version of the preprocessor. Assuming you have no file foo.f90, run:
touch foo.f90; gfortran -cpp -E -dM foo.f90

and it'll show all the predefined macros ✨

  • -dD — like -dM, except it doesn't include 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, not their expansions 🫧
  • -dU — like dD except only macros that are expanded, or whose definedness is tested in preprocessor directives, get output 🦋 The output is delayed until the macro is used or tested, and #undef directives are also output for macros that were tested but undefined at the time.
  • -dI — outputs #include directives in addition to the result of preprocessing 📂
  • -fworking-directory — enables linemarkers in the preprocessor output so the compiler knows the current working directory at preprocessing time 🗺️ When this is on, the preprocessor emits a second linemarker after the initial one, containing the current working directory followed by two slashes. GCC uses that directory, when it's present in the preprocessed input, as the directory it emits as the current working directory in some debugging information formats. This option is implicitly enabled if debugging information is enabled, but you can inhibit it with the negated form -fno-working-directory. If the -P flag is on the command line, this option has no effect, since no #line directives are emitted whatsoever 🙈
  • -idirafter dir — searches dir for include files, but only after all the directories specified with -I and the standard system directories have been exhausted 🌈 dir is treated as a system include directory. If dir begins with =, then that = gets replaced by the sysroot prefix; see --sysroot and -isysroot 🧚

-imultilib dir — ✨ Okay so this one lets you point to a dir that becomes a subdirectory of the folder holding the target-specific C++ headers. Very niche, very bestie-only 🧚

  • -iprefix prefix — 🌸 This sets the prefix for any -iwithprefix options that come after it. If your prefix is a directory, don't forget the final / 🙈
  • -isysroot dir — 🗺️ This one is basically a sibling of --sysroot, but it only touches header files. Go check the --sysroot option for the full tea ☕
  • -iquote dir — 🦋 This searches dir only for headers pulled in with #include "file". It skips #include <file> entirely, and it runs before all the -I directories and the standard system directories. If dir starts with =, that = gets swapped out for the sysroot prefix. See --sysroot and -isysroot 💅
  • -isystem dir — ⭐ This searches dir for headers after all the -I directories but before the standard system ones. It also gets marked as a system directory, so it gets the same VIP treatment as the standard system dirs. Same deal with =: if dir begins with =, it's replaced by the sysroot prefix. See --sysroot and -isysroot 👑
  • -nostdinc — 🙅 Don't search the standard system directories for headers at all. Only the -I directories get checked (plus the directory of the current file, if that's relevant) 🫶
  • -undef — 🧼 Don't predefine any system-specific or GCC-specific macros. The standard predefined macros stay put, so they're still defined ✨
  • -Apredicate=answer — 💜 This makes an assertion with the predicate predicate and the answer answer. It's the preferred version over the older -A predicate(answer) form, which still works, but this one is way better because it doesn't use shell special characters 🙌
  • -A-predicate=answer — 🗑️ Cancels an assertion with the predicate predicate and the answer answer. Bye bye 👋
  • -C — 💬 Don't throw out comments! Every comment gets passed through to the output file, except comments inside processed directives, which get deleted along with their directive.

Heads up, though: using -C has side effects, because the preprocessor starts treating comments as tokens in their own right. For example, a comment sitting at the start of what would be a directive line turns that line into an ordinary source line, since the first token is no longer a # 😭

⚠️ Warning: this currently handles C-style comments only. The preprocessor doesn't recognize Fortran-style comments yet.
  • -CC — 💬💬 Also don't discard comments, including during macro expansion. It's like -C, except comments inside macros get passed through to the output wherever the macro is expanded.

On top of everything -C does, -CC converts all C++-style comments inside a macro into C-style comments. Why? So using that macro later can't accidentally comment out the rest of your source line 💀 This one is mostly used to support lint comments.

⚠️ Warning: this currently handles C- and C++-style comments only. The preprocessor doesn't recognize Fortran-style comments yet.
  • -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. Heads up that the definition gets cut off at any embedded newline characters.

If you're calling the preprocessor from a shell (or something shell-like), you might need the shell's quoting syntax to protect characters like spaces, since they mean something to the shell too.

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

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

  • -H — 🔍 Prints the name of each header file used, on top of all the usual stuff. Each name is indented to show how deep it sits in the #include stack, which is lowkey so helpful for tracking down nested includes 🌈
  • -P — 🚫 Inhibits the 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 could 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 🚨

Okay, let's talk about the difference between errors and warnings, because it matters 💅

Errors are diagnostic messages saying the GNU Fortran compiler cannot compile that piece of source code. The compiler keeps going anyway, trying to report more errors to help you debug, but it won't produce any compiled output.

Warnings are diagnostic messages about constructions that aren't inherently wrong, but are risky or suggest there's probably a bug in your program. Unless -Werror is specified, warnings don't stop your program from compiling 🦋

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

These options control how many errors and warnings GNU Fortran produces, and what kinds they are:

  • -fmax-errors=n — 🛑 Limits the number of error messages to n. Once that limit is hit, GNU Fortran bails out instead of trying to keep processing the source code. If n is 0, there's no limit on how many error messages get 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 when they show up in GNU Fortran source files, such as using \e in a character constant inside a directive like #include.

Valid Fortran programs should compile properly with or without this option. Without it, certain GNU extensions and traditional Fortran features are still supported. With it, a lot of those get rejected 💀

Some users try to use -pedantic to check programs for conformance, and they soon find it doesn't quite do what they want. It finds some nonstandard practices, but not all of them. Improvements to GNU Fortran in this area are welcome, though 🙏

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

  • -pedantic-errors — 🚨 Like -pedantic, except errors get produced instead of warnings. Serious energy.
  • -Wall — 👑 Enables commonly used warning options for usage that 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: if there's no ampersand in a continued character constant, GNU Fortran assumes continuation happens at the first non-comment, non-whitespace character after the ampersand that started the continuation 🫶

  • -Warray-temporaries — 🧺 Warns about array temporaries generated by the compiler. The info from this warning can be useful for optimization, so you can avoid those temporaries.
  • -Wc-binding-type — 🔗 Warns if a variable might not be C interoperable. In particular, it warns if the variable was declared using an intrinsic type with the 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 get 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 that may be problematic. This currently includes -Wcompare-reals, -Wunused-parameter and -Wdo-subscript.
  • -Wfrontend-loop-interchange — 🔀 Warns when using -ffrontend-loop-interchange to perform loop interchanges.
  • -Wimplicit-interface — 🕵️ Warns if a procedure is called without an explicit interface. Note that this only checks that an explicit interface is present. It doesn't 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. Math is not mathing 💀
  • -Wintrinsics-std — okay so this one is a little heads-up bestie 🔔 If gfortran spots a procedure named like an intrinsic that isn't available in the standard you picked (with -std), it warns you and treats that procedure as an EXTERNAL procedure. If you never want that to happen and always want the intrinsic linked no matter which standard you chose, -fall-intrinsics is the move ✨
  • -Wno-overwrite-recursive — no warning when you use -fno-automatic with -frecursive 🙈 Recursion gets broken if the relevant local variables don't have the AUTOMATIC attribute explicitly declared. Use this to silence the warning when you already know recursion isn't broken. It's super useful for build setups that use -Werror 🫶
  • -Wreal-q-constant — get a warning if a real literal constant has a q exponent letter 🌸
  • -Wsurprising — this one catches "suspicious" code 👀 It's technically legal, but these constructs usually mean you made a mistake somewhere. Right now it warns in these situations:
    • An INTEGER SELECT construct has a CASE that can never be matched, because its lower value is greater than its upper value.
    • A LOGICAL SELECT construct has three CASE statements.
    • A TRANSFER has 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, not just a warning 💀
    • A CHARACTER variable is declared with a negative length.
  • -Wtabs — tabs are accepted as whitespace by default, but tabs are NOT members of the Fortran Character Set, so be careful 🍓 For continuation lines, a tab followed by a digit between 1 and 9 is supported. With -Wtabs, you'll get a warning whenever a tab shows up. It's active for -pedantic, -std=f95, -std=f2003, -std=f2008, -std=f2018 and -Wall 💅
  • -Wundefined-do-loop — warns if a DO loop with a step of either 1 or -1 underflows or overflows while the induction variable is iterating 🌈 This one is implied by -Wall.
  • -Wunderflow — warns when numerical constant expressions are encountered that UNDERFLOW during compilation ⭐ It's enabled by default, so you get it for free.
  • -Wintrinsic-shadow — warns if a user-defined procedure or module procedure has the same name as an intrinsic 🦋 In that case you might need an explicit interface, or an EXTERNAL or INTRINSIC declaration, so later calls get resolved to the procedure you actually meant. This one is implied by -Wall.
  • -Wuse-without-only — warns if a USE statement has no ONLY qualifier, because then it quietly imports every public entity of the used module 🧚
  • -Wunused-dummy-argument — warns about unused dummy arguments. Implied by -Wall 🎀
  • -Wunused-parameter — okay, plot twist: this is NOT the same as gcc's version 😭 gfortran's version doesn't warn about unused dummy arguments (check -Wunused-dummy-argument for that). Instead it warns about unused PARAMETER values. -Wunused-parameter is implied by -Wextra if -Wunused or -Wall is also used.
  • -Walign-commons — by default, gfortran warns about any time variables get padded for proper alignment inside a COMMON block 🧸 You can turn that off with -Wno-align-commons. See also -falign-commons.
  • -Wfunction-elimination — warns if any calls to impure functions get eliminated by the optimizations turned on by -ffrontend-optimize ✨ This one is implied by -Wextra.
  • -Wrealloc-lhs — warns when the compiler might insert code for allocation or reallocation of an allocatable array variable of intrinsic type in intrinsic assignments 🔥 In hot loops, the Fortran 2003 reallocation feature may hurt performance. If the array is already allocated with the right shape, consider using a whole-array array-spec (e.g. (:,:,:)) for the variable on the left-hand side to skip the reallocation check. Heads up: sometimes this warning shows up even when the compiler would optimize those reallocation checks away, like when the right-hand side contains the same variable multiplied by a scalar. See also -frealloc-lhs.
  • -Wrealloc-lhs-all — warns when the compiler inserts code for allocation or reallocation of an allocatable variable. This includes scalars and derived types too 💜
  • -Wcompare-reals — warns when you compare real or complex types for equality or inequality 👀 Implied by -Wextra.
  • -Wtarget-lifetime — warns if the pointer in a pointer assignment might outlive its target 🦋 Implied by -Wall.
  • -Wzerotrip — warns if a DO loop is known to execute zero times at compile time 🙃 Implied by -Wall.
  • -Wdo-subscript — warns if an array subscript inside a DO loop could lead to an out-of-bounds access, even when the compiler can't prove the statement actually runs 😬 Like in this case:
real a(3)
do i=1,4
  if (condition(i)) then
    a(i) = 1.2
  end if
end do

This one is implied by -Wextra.

  • -Werror — turns ALL warnings into errors 🚨

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 🛠️

  • -fdump-fortran-original — outputs the internal parse tree after the source program gets translated into internal representation 🌸 This one is mostly useful for debugging the GNU Fortran compiler itself. The output might change between releases, and it may also generate internal compiler errors for features that were only recently added.
  • -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 features that were only recently added.
  • -fdump-parse-tree — outputs the internal parse tree after translating the source program into internal representation. It's mostly useful for debugging the GNU Fortran compiler itself, and the output might change between releases. It may also generate internal compiler errors for features that were only recently added. > This one is deprecated, so use -fdump-fortran-original instead 😭
  • -fdebug-aux-vars — renames the internal variables the gfortran front end creates and makes them accessible to a debugger 🔍 Their names start with upper-case letters followed by an underscore. This is handy for debugging the compiler's code generation alongside -fdump-tree-original, and for debugging the executable by using -g or -ggdb3.
  • -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 generate internal compiler errors for features that were only recently added.
  • -ffpe-trap=list — specifies a list of floating point exception traps to enable 💥 On most systems, if a floating point exception happens and its trap is enabled, a SIGFPE signal gets sent and the program aborts, producing a core file that's useful for debugging. list is a (possibly empty) comma-separated list of these exceptions:
    • invalid — an invalid floating point operation, such as 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 correspond to the five IEEE 754 exceptions. The last one, denormal, isn't part of IEEE 754, but it's available on some common architectures such as x86 🖥️

The first three (invalid, zero, and overflow) often point to serious errors. Unless your program has ways of dealing with them, enabling traps for these three is probably a good idea 🫶

If the option is used more than once on the command line, the lists get joined. '"ffpe-trap="list1 "ffpe-trap="list2' is equivalent to "ffpe-trap="list1,list2.

Once an exception is enabled, it can't be disabled. There's no negative form!

Lots of floating point operations lose precision due to rounding, so ffpe-trap=inexact is likely to be pretty uninteresting in practice 🥱

By default, no exception traps are enabled.

  • -ffpe-summary=list — specifies a list of floating-point exceptions whose flag status gets printed to ERROR_UNIT when STOP and ERROR STOP are invoked 📋 list can be none, all, or a comma-separated list of these exceptions: invalid, zero, overflow, underflow, inexact and denormal. (Check -ffpe-trap for descriptions of the exceptions.)

If the option is used more than once on the command line, only the last one is used.

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

  • -fno-backtrace — when a serious runtime error or a deadly signal happens (segmentation fault, illegal instruction, bus error, floating-point exception, and the other POSIX signals whose action is core), the Fortran runtime library tries to output a backtrace of the error 🪦 -fno-backtrace turns the backtrace generation off. This option only has an effect when compiling the Fortran main program.

These options change how GNU Fortran looks for files specified by the INCLUDE directive, and where it looks for previously compiled modules 🔎

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

  • -Idir — these affect how the INCLUDE directive gets interpreted (and the #include directive of the cpp preprocessor too) 🦋

okay bestie, the way -I and "INCLUDE" work is basically the same as -I with "#include" in the cpp preprocessor 🌸 when it comes to hunting down header.gcc files and other stuff like that. no cap, it's giving consistency ✨

This path is also used to search for .mod files when previously compiled modules are required by a "USE" statement 💜

  • -Jdir — this one tells the compiler where to drop the .mod files for the modules it compiles 📁 it also gets added to the list of directories a "USE" statement searches 🔍

The default is the current directory.

  • -fintrinsic-modules-path dir — point this at the pre-compiled intrinsic modules if they're chilling somewhere other than the default spot the compiler expects 🧚

⚡ Influencing the linking step ⚡

these options only come into play when the compiler links object files into an executable output file 🔗 if the compiler isn't doing a link step, they're totally meaningless, so don't stress 🙈

  • -static-libgfortran — on systems that have libgfortran as both a shared and a static library, this forces the static version 💜 if no shared version got built when the compiler was configured, this option does absolutely nothing 💀

🌈 Influencing runtime behavior 🌈

these options change how programs compiled with GNU Fortran behave at runtime ✨

  • -fconvert=conversion — this sets how data is represented in unformatted files 🦋 the valid values for conversion are:
    • native — the default, no cap 👑
    • swap — swaps between big- and little-endian 🔄
    • big-endian — uses big-endian representation for unformatted files
    • little-endian — uses little-endian representation for unformatted files
⚠️ this one only has an effect when it's used in the main program. The "CONVERT" specifier and the GFORTRAN_CONVERT_UNIT environment variable both override whatever default you set with -fconvert, so they basically get the final say 💅
  • -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 older gfortran versions, which defaulted to a record marker length of 8 on most systems 🙈 if you want to read or write files that are compatible with earlier gfortran versions, use -frecord-marker=8.
  • -fmax-subrecord-length=length — sets the maximum length for a subrecord 📏 the max permitted value for length is 2147483639, which is also the default. honestly it's only really useful for the gfortran testsuite, so unless you're in that world, you can skip it 🧪
  • -fsign-zero — when this is enabled, floating point numbers with a value of zero but the sign bit set get written as negative numbers in formatted output, and they're treated as negative in the "SIGN" intrinsic 💖 -fno-sign-zero goes the other way: it doesn't print the negative sign of zero values (or values rounded to zero for I/O), and it counts zero as a positive number in the "SIGN" intrinsic, which is for compatibility with Fortran 77 🦋 the default is -fsign-zero.

🎀 Options for code generation conventions 🎀

these machine-independent options control the interface conventions used in code generation 🧚

most of them have both positive and negative forms, and the negative form of -ffoo is -fno-foo 💜 in the table below, only one of the forms is listed, the one that isn't the default. you can figure out the other form by either removing no- or adding it 🙈

  • -fno-automatic — treats each program unit (except those marked as 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 give this option the name -static or -save.) the default, which is -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 the option -frecursive 🌸

Local variables or arrays that have an explicit "SAVE" attribute are silently ignored unless the -pedantic option is added.

  • -ff2c — generates code designed to be compatible with code generated by g77 and f2c 🫶

the calling conventions used by g77 (originally implemented in f2c) require functions that return type default "REAL" to actually return the C type "double", and functions that return type "COMPLEX" to return their values via an extra argument in the calling sequence that points to where the return value should be stored 😭 under the default GNU calling conventions, those functions just return their results the way GNU C does: default "REAL" functions return the C type "float", and "COMPLEX" functions return the GNU C type "complex" ✨ on top of that, this option implies the -fsecond-underscore option, unless -fno-second-underscore is explicitly requested.

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 that were 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 names of entities specified 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 ensure compatibility with code produced by many UNIX Fortran compilers 🌈

⚠️ Caution: the default behavior of GNU Fortran is incompatible with f2c and g77, so please use the -ff2c option if you want object files compiled with GNU Fortran to be compatible with object code created with these tools.

use of -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

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

use of -fno-underscoring allows direct specification of user-defined names while debugging and when interfacing GNU Fortran code with other languages 🫶

note that just because the names match doesn't mean the interface implemented by GNU Fortran for an external name matches the interface implemented by some other language for that same name 🤔 getting code produced by GNU Fortran to link to code produced by some other compiler using this or any other method can be only a small part of the overall solution. getting the code generated by both compilers to agree on issues other than naming can require significant effort, and unlike naming disagreements, linkers normally cannot detect disagreements in these other areas.

also, note that with -fno-underscoring, the lack of appended underscores introduces the very real possibility that a user-defined external name will conflict with a name in a system library 😱 this 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 at run time.

in future versions of GNU Fortran, we hope to improve naming and linking issues so that debugging always involves using the names as they appear in the source, even if the names as seen by the linker are mangled to prevent accidental linking between procedures with incompatible interfaces 🔮

  • -fsecond-underscore — by default, GNU Fortran appends an underscore to external names 💫 if this option is used, GNU Fortran appends two underscores to names with underscores and one underscore to external names with no underscores. GNU Fortran 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.

otherwise, 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 use of the -ff2c option 🦋

  • -fcoarray=<keyword> — controls coarray support 👑 the keyword can be:
    • none — disables 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> — enables the generation of run-time checks 🔍 the argument should be a comma-delimited list of the following keywords. prefixing a check with no- disables it if it was activated by a previous specification 💅
    • all — enables all run-time tests of -fcheck 🌟
    • array-temps — warns at run time when, for passing an actual argument, a temporary array had to be generated. the info from this warning is sometimes useful in optimization, so you can avoid such temporaries 🧠

🙈 Note: the warning is only printed once per location.

  • bits — enables generation of run-time checks for invalid arguments to the bit manipulation intrinsics 🦋
  • bounds — enables 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 — enables generation of run-time checks for invalid modification of loop iteration variables 🔁
  • mem — 🧠 okay so this one turns on run-time checks for memory allocation. Heads up, bestie: it does not touch explicit allocations made with the ALLOCATE statement. Those are always checked, no exceptions 💅
  • pointer — 🦋 checks pointers and allocatables at run time
  • recursion — 🌀 checks for subroutines and functions that get called recursively but aren't marked as RECURSIVE. See also -frecursive. ⚠️ This check doesn't work for OpenMP programs, and it gets switched off if you use it 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 — 🫶 a deprecated alias for -fcheck=bounds, so it still works but it's on its way out
  • -ftail-call-workaround, -ftail-call-workaround=n — 🔧 okay this one is a whole saga. Some C interfaces to Fortran code violate the gfortran ABI by leaving out the hidden character length arguments as described in. This can lead to crashes, because pushing arguments for tail calls can overflow the stack 😭

To help out existing binary packages, this option turns off 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 equivalent -ftail-call-workaround, it's only disabled 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 generate prototypes that conform to gfortran's ABI, which you can include in your source code 🌸

💀 Support for this option will likely be withdrawn in a future release of gfortran.

The negative form, -fno-tail-call-workaround or equivalent -ftail-call-workaround=0, can be used to disable this option.

Default is currently -ftail-call-workaround. This will change in future releases.

  • -fcheck-array-temporaries — 🙈 a deprecated alias for -fcheck=array-temps
  • -fmax-array-constructor=n — 🍓 raises the upper limit allowed in array constructors. The code below needs this option to expand the array at compile time:
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: 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 — 📚 sets the size in bytes of the largest array that gets put on the stack. If the size is exceeded, static memory is used instead (except in procedures marked as RECURSIVE). Use -frecursive to allow recursive procedures that don't have a RECURSIVE attribute, or for parallel programs. Use -fno-automatic to never use the stack.

This option currently only affects local arrays declared with constant bounds, and it may not apply to all character variables. Future versions of GNU Fortran may improve this behavior 🌈

The default value for n is 65536.

  • -fstack-arrays — 🥞 stacks up every array of unknown size plus array temporaries onto stack memory. If your program uses very large local arrays, you might have to extend your runtime limits for stack memory on some operating systems. This flag is enabled by default at optimization level -Ofast, unless -fmax-stack-var-size is specified.
  • -fpack-derived — 📦 tells GNU Fortran to pack derived type members as closely as possible. Code compiled with this option is likely to be incompatible with code compiled without it, and it may execute slower 🐢
  • -frepack-arrays — 🪄 sometimes GNU Fortran passes assumed shape array sections via 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 array accesses faster. However, it can add significant overhead to the function call, especially when the passed data is noncontiguous 🤔

  • -fshort-enums — 🔢 provided for interoperability with C code that was compiled with -fshort-enums. It makes GNU Fortran choose the smallest INTEGER kind that a given enumerator set will fit in, and gives all its enumerators that kind.
  • -finline-arg-packing — 🎁 when you pass an assumed-shape argument of a procedure as an actual argument to an assumed-size or explicit-size argument, or to a procedure without an explicit interface, the argument may need to be packed (put into contiguous memory). An example is the call to foo in:
subroutine foo(a)
   real, dimension(*) :: a
end subroutine foo
subroutine bar(b)
   real, dimension(:) :: b
   call foo(b)
end subroutine bar

With -finline-arg-packing in effect, this packing is done by inline code. That allows more optimization, but the code size goes up 📈

-finline-arg-packing is implied by any of the -O options, except when optimizing for size via -Os. If the code has a very large number of arguments that need packing, the code size and compilation time may get excessive. In that case, it may be better to disable this option. You can find instances of packing by using -Warray-temporaries.

  • -fexternal-blas — 🧮 makes gfortran call BLAS functions for some matrix operations like MATMUL, instead of using its own algorithms, if the matrices involved are bigger than a given limit (see -fblas-matmul-limit). This can be a win if an optimized vendor BLAS library is available. The BLAS library has to be specified at link time 🔗
  • -fblas-matmul-limit=n — 🎯 only matters when -fexternal-blas is in effect. Matrix multiplication of matrices with a size larger than (or equal to) n gets done 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 is generated. Setting -finline-matmul-limit=0 disables inlining in all cases. Setting this option with 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 — 🔁 allows indirect recursion by forcing all local arrays to be allocated on the stack. This flag can't 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 — 🌱 the init crew! -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 way they are with -finit-local-zero, as described above.

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

Note that -finit-real=nan initializes REAL and COMPLEX variables with a quiet NaN. For a signalling NaN, use -finit-real=snan. Heads up 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 -Wuninitialized would have emitted 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, so -fno-align-commons can be used to disable automatic alignment. Use the same form of this option 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 — okay so by default, parentheses in an expression are honored at every optimization level, which means the compiler is not allowed to do any re-association 🙅‍♀️. Using -fno-protect-parens lets the compiler reorder REAL and COMPLEX expressions to get faster code ⚡. Heads up, bestie: for that 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 🦋. This is on by default except when -std=f95 is given. Also check out -Wrealloc-lhs 🌸.
  • -faggressive-function-elimination — functions with identical argument lists get eliminated within statements, whether or not they're marked PURE 💜. 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 one does front-end optimization by messing with parts of the Fortran parse tree 🧚. It's on by default with any -O option except -O0 and -Og 💖. The optimizations it turns on 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)), and
    • short-circuiting of logical operators (.AND. and .OR.).

You can deselect it with -fno-frontend-optimize 🙈.

  • -ffrontend-loop-interchange — this tries to swap loops around in the Fortran front end when it's worth it 🌈. It's on by default with any -O option 👑. Right now it only affects FORALL and DO CONCURRENT statements that have several forall triplets 🍓.

✨ ENVIRONMENT ✨

okay so gfortran doesn't use any environment variables to control how it runs, beyond the ones that already affect gcc 🌸. Main character energy, but make it minimal 💅.

🎀 BUGS 🎀

If you find a bug and want to report it, the instructions live in <file:///usr/share/doc/gcc-11/README.Bugs> 🐛. Go read it, bestie 🫶.

🦋 SEE ALSO 🦋

Here's the squad of related pages and docs 💜: gpl(7), gfdl(7), fsf-funding(7), cpp(1), gcov(1), gcc(1), as(1), ld(1), gdb(1), and dbx(1). You can also check the Info entries for gcc, cpp, gfortran, as, ld, binutils, and gdb 📚✨.

👑 AUTHOR 👑

For the contributors to GCC and GNU Fortran, look up the Info entry for gfortran 🙌. They're the real MVPs 💖.

Copyright (c) 2004-2021 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 📜. The Invariant Sections are "Funding Free Software", the Front-Cover Texts are (a) (see below), and the Back-Cover Texts are (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. 💖

That's the whole page, bestie! 🎉 It's the GFORTRAN(1) manual from the gcc-11 docs, last updated 2024-07-19, and you're officially a gfortran expert now 💅✨ periodt 🦋💜

📦 where this page comes from