GFORTRAN(1)

📦
version 12-20220222 · 5 versions
, in ubuntu jammy

🎀 GFORTRAN(1) — GNU Manual 🎀

Part 1 of 7, straight from the 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...

Quick heads up: that synopsis only shows the most useful options 💅. The rest are waiting for you down below ✨.

💖 DESCRIPTION 💖

Okay so, the gfortran command supports every option that gcc supports 🦋. Only the options that are specific to GNU Fortran get documented here, so you're not missing a mountain of stuff 🫶.

Every GCC and GNU Fortran option is accepted by both gfortran and gcc, plus any other drivers built at the same time, like g++ 👑. That's because adding GNU Fortran to the GCC distribution means all the relevant drivers accept GNU Fortran options. Main character energy, honestly ✨.

Some options come in positive and negative forms. So the negative version of -ffoo is -fno-foo 🙈. This manual only documents whichever form isn't the default 💅.

🌈 OPTIONS 🌈

Here's the vibe check of every GNU Fortran option, grouped by type 💅. Explanations live in the sections that follow 🦋.

💫 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

These options tweak the exact flavour of Fortran the compiler accepts 💅:

  • -ffree-form, -ffixed-form — pick the layout of your source file 📜. Free form showed up in Fortran 90, while fixed form is what older Fortran programs were traditionally written in. If you specify neither, the source form is determined by the file extension ✨.
  • -fall-intrinsics — accepts every intrinsic procedure, including the GNU-specific extensions 🌈. It's great alongside -std= if you want standard-compliance but still want the full intrinsic buffet. Heads up: -Wintrinsics-std gets ignored, and no user-defined procedure sharing 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 between the call and the procedure definition or between different calls 😬. That code is non-conforming and usually gets flagged as an error. This option downgrades the error to a warning, which can only be turned off by disabling all warnings with -w. Only a single occurrence per argument gets flagged. It's implied by -std=legacy.
Using this option is strongly discouraged 💀. You can write standard-conforming code that allows different argument types by using an explicit interface and TYPE(*).
  • -fallow-invalid-boz — a BOZ literal constant can show up in a limited number of contexts in standard-conforming Fortran 🔢. This option downgrades the error to a warning and lets a BOZ literal constant appear where the Fortran standard would otherwise prohibit it 🙈.
  • -fd-lines-as-code, -fd-lines-as-comments — special treatment for lines beginning with "d" or "D" in fixed-form sources 💬. With -fd-lines-as-code, they're treated as if the first column held a blank. With -fd-lines-as-comments, they're treated as comment lines.
  • -fdec — DEC compatibility mode 🕰. It enables extensions and other features that mimic the default behavior of older compilers, like DEC's. For details on GNU Fortran's implementation of these extensions, check the full documentation. Other flags enabled by this switch 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/-fd-lines-as-comments are unset, then -fdec also sets -fd-lines-as-comments.
These features are non-standard and should be avoided at all costs 🚫.
  • -fdec-char-conversions — lets you use character literals in assignments and DATA statements for non-character variables 🍓.
  • -fdec-structure — enables DEC STRUCTURE and RECORD, plus UNION, MAP, and the dot (.) as a member separator, on top of % 🧱. This is provided for compatibility only, so Fortran 90 derived types should be used instead wherever possible.
  • -fdec-intrinsic-ints — enables B/I/J/K kind variants of existing integer functions, like BIAND, IIAND, JIAND, etc... 🔢. Check the full documentation for a complete list of intrinsics.
  • -fdec-math — enables legacy math intrinsics like COTAN and degree-valued trigonometric functions, like TAND, ATAND, etc... 📐, for compatibility with older code.
  • -fdec-static — enables DEC-style STATIC and AUTOMATIC attributes to explicitly specify the storage of variables and other objects 📦.
  • -fdec-include — enables parsing of INCLUDE as a statement in addition to parsing it as an INCLUDE line 📎. When parsed as an INCLUDE statement, it doesn't have to be on a single line and can use line continuations.
  • -fdec-format-defaults — enables format specifiers F, G, and I to be used without width specifiers. Default widths get used instead 📏.
  • -fdec-blank-format-item — enables a blank format item at the end of a format specification, i.e. nothing following the final comma 🫧.
  • -fdollar-ok — allows $ as a valid non-first character in a symbol name 💲. Symbols that start with $ are rejected, since it's unclear which implicit typing rules to apply (different vendors implement different rules). Using $ in IMPLICIT statements is also rejected.
  • -fbackslash — changes how backslashes in string literals are read, from a single backslash character to "C-style" escape characters 🧃. The following combinations get expanded: "\a" (alert), "\b" (backspace), "\f" (form feed), "\n" (newline), "\r" (carriage return), "\t" (horizontal tab), "\v" (vertical tab), "\\" (backslash), and "\0" (NUL). Additionally, "\x"nn, "\u"nnnn and "\U"nnnnnnnn (where each n is a hexadecimal digit) are translated into the Unicode characters for those code points 🌍. All other combinations of a character preceded by \ stay unexpanded.
  • -fmodule-private — 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 — sets the column after which characters are ignored in typical fixed-form lines in the source file 📏. Unless -fno-pad-source is used, spaces are assumed (as if padded to that length) after the ends of short fixed-form lines. Popular values for n include 72 (the standard and the default), 80 (card image), and 132 (corresponding to "extended-source" options in some popular compilers). n may also be none, meaning the entire line is meaningful and continued character constants never have implicit spaces appended to fill out the line. -ffixed-line-length-0 means the 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 🧽. This doesn't happen if -ffixed-line-length-0, -ffixed-line-length-none, or -fno-pad-source is used. With any of those options, continued character constants never have implicit spaces appended to fill out the line.
  • -ffree-line-length-n — okay so this one sets the column where the compiler starts ignoring characters on typical free-form lines in your source file. The default is 132 💅. You can pass none for n if you want the whole line to count, and -ffree-line-length-0 is exactly the same as -ffree-line-length-none 🧚
  • -fmax-identifier-length=n — this caps how long an identifier can be 📏. Typical values are 31 (Fortran 95) and 63 (Fortran 2003 and later) ✨
  • -fimplicit-none — bestie, this one bans implicit typing 🙅‍♀️. The only exceptions are explicit IMPLICIT statements. It's the same as putting implicit none at the top of every procedure, so it's giving strict 💜
  • -fcray-pointer — turns on the Cray pointer extension, which gives you C-like pointer functionality 🦋
  • -fopenacc — enables the OpenACC extensions 🔥. In free form that covers !$acc directives, plus the !$ conditional compilation sentinels. In fixed form you get c$acc, *$acc and !$acc directives, plus the c$, *$ and !$ sentinels. When you link, it also makes sure the OpenACC runtime library gets linked in 🌸
  • -fopenmp — enables the OpenMP extensions 👑. Free form gets !$omp directives and the !$ sentinels. Fixed form gets c$omp, *$omp and !$omp directives, plus the c$, *$ and !$ sentinels. Linking also pulls in the OpenMP runtime library. Heads up that -fopenmp implies -frecursive 🫶
  • -fno-range-check — this turns off range checking on the results of simplifying constant expressions at compile time 🧮. Normally GNU Fortran throws an error on something like a = 1. / 0. With this flag there's no error, and a gets +Infinity. If an expression lands outside the relevant range of -HUGE():HUGE(), it's replaced by -Inf or +Inf, whichever fits. Same deal with DATA i/Z'FFFFFFFF'/, which overflows an integer on most systems. With this flag the value wraps around, and i ends up initialized to -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 leaves variables with an explicit kind declaration alone 🎀
  • -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 flag bumps the default width of DOUBLE PRECISION and double real constants like 1.d0 up to 16 bytes if that's possible. If you pass -fdefault-double-8 alongside fdefault-real-8, then DOUBLE PRECISION and double real constants don't get promoted. Unlike -freal-4-real-8, fdefault-real-8 leaves variables with explicit kind declarations alone 🌈
  • -fdefault-real-10 — same vibe as -fdefault-real-8, but the default real type becomes a 10-byte-wide type ⭐. It also changes 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 aren't promoted. Unlike -freal-4-real-10, fdefault-real-10 leaves variables with explicit kind declarations alone 🦋
  • -fdefault-real-16 — once more, but with a 16-byte-wide default real type 🧚. It also changes 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 with fdefault-real-16, then DOUBLE PRECISION and double real constants aren't promoted. Unlike -freal-4-real-16, fdefault-real-16 leaves variables with explicit kind declarations alone 💜
  • -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 flag also 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. Be careful with this one, because it may not suit your code 😭
Be careful with -finteger-4-integer-8! The areas of concern 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, produced by -fdump-tree-original, before you trust it 🙈
  • -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 change the default real kind, and the -freal-8- flags change the double-precision real kind. Every other real-kind type is untouched. The promotion also applies to real literal constants of default and double-precision kind, with a specified kind number of 4 or 8 respectively. Heads up though: -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 🧠. For REAL(KIND=KIND(1.0)), the literal may get promoted and then the result may get promoted again. Lastly, these options should be used with care and may not suit your code. The areas of concern are 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. It's suggested that you inspect the intermediate representation of the translated Fortran code, produced by -fdump-fortran-original or -fdump-tree-original, too 💅
  • -std=std — tells the compiler which standard your program is supposed to follow 📜. Your choices are f95, f2003, f2008, f2018, gnu, or legacy. The default is gnu, which is a superset of the latest Fortran standard and includes every extension GNU Fortran supports. You'll still get warnings for obsolete extensions that aren't recommended in new code 🙃. The legacy value is the same, minus the warnings for obsolete extensions, so it's handy for old non-standard programs 🧓. f95, f2003, f2008 and f2018 mean strict conformance to Fortran 95, Fortran 2003, Fortran 2008 and Fortran 2018 respectively. Any extension beyond the relevant standard throws 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 only exists 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, so many Fortran compilers, GNU Fortran included, let you pass your source code through a C preprocessor (CPP, sometimes called the Fortran preprocessor, or FPP) for conditional compilation 🧚. For GNU Fortran that's the GNU C Preprocessor in traditional mode 🌈. On systems with case-preserving file names, the preprocessor runs automatically if the filename extension is .F, .FOR, .FTN, .fpp, .FPP, .F90, .F95, .F03 or .F08. To run it manually on any file, use -cpp. To turn it off for files where it would otherwise run automatically, use -nocpp 💖

If a preprocessed file pulls in another file with the Fortran INCLUDE statement, that included file is not preprocessed 🙅‍♀️. If you want included files preprocessed, use the equivalent preprocessor statement #include instead 🫶

When GNU Fortran invokes the preprocessor, __GFORTRAN__ gets defined 🎀. You can use the macros __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__ to figure out the compiler version 🔥. For the full details, see Top,,Overview,cpp,The C Preprocessor 📚

GNU Fortran supports several INTEGER and REAL kind types on top of the ones the Fortran standard requires 👑. Which kind types you get depends on your architecture 🧠. These predefined preprocessor macros let you conditionally include code for those extra kinds: __GFC_INT_1__, __GFC_INT_2__, __GFC_INT_8__, __GFC_INT_16__, __GFC_REAL_10__, and __GFC_REAL_16__ 💅

CPP is the de facto standard for preprocessing Fortran code, but Part 3 of the Fortran 95 standard (ISO/IEC 1539-3:1998) defines Conditional Compilation 🦋. It isn't widely used, and GNU Fortran doesn't directly support it 😭. If you need it, you can use the program coco to preprocess those files, and you'll find it at <http://www.daniellnagle.com/coco.html> 🌸

The following options control preprocessing of Fortran code 🍓:

  • -cpp, -nocpp — -cpp enables preprocessing. The preprocessor runs automatically for .fpp, .FPP, .F, .FOR, .FTN, .F90, .F95, .F03 and .F08 files, but use this flag to turn it on manually for any kind of Fortran file ✨. -nocpp is the negative form, and it turns preprocessing off for files with any of those extensions 🙈. The preprocessor runs in traditional mode, so any file-format restrictions (especially the line length limits) also apply to the preprocessed output. That means you might want -ffree-line-length-none or -ffixed-line-length-none 💜
  • -dM — instead of the normal output, this generates a list of #define directives for every macro defined while the preprocessor runs, predefined ones included 🧚. It's a sneaky way to find out what's predefined in your version of the preprocessor 👀. Assuming you have no file foo.f90, this command shows all the predefined macros:
touch foo.f90; gfortran -cpp -E -dM foo.f90
  • -dD — Okay so this one is like -dM but with two big differences 💅. It skips the predefined macros, and it spits out both the #define directives and the result of preprocessing. Both kinds of output land in the standard output file 🖨️✨.
  • -dN — Basically -dD, but it only shows the macro names and skips their expansions 🦋.
  • -dU — Also like -dD, but way more selective 🎀. It only outputs macros that get expanded, or macros whose definedness gets tested in preprocessor directives. The output is delayed until that use or test happens, and #undef directives also show up for macros that were tested but were undefined at that moment 🙈.
  • -dI — Outputs #include directives on top of the preprocessing result 🧚.
  • -fworking-directory — This one is giving main character energy 👑. It turns on linemarkers in the preprocessor output so the compiler knows the current working directory at preprocessing time. When it's on, the preprocessor emits a second linemarker after the initial one, containing the current working directory followed by two slashes. GCC will use that directory, if it's in the preprocessed input, as the working directory in some debugging information formats 🌸. It's implicitly enabled when debugging information is on, but you can shut it off with the negated form -fno-working-directory. If -P 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 every directory from -I and the standard system directories have been exhausted 🌈. dir gets treated as a system include directory. If dir begins with =, that = gets swapped out for the sysroot prefix. See --sysroot and -isysroot 🫶.
  • -imultilib dir — Uses dir as a subdirectory of the directory that holds the target-specific C++ headers 💜.
  • -iprefix prefix — Sets prefix as the prefix for later -iwithprefix options. If the prefix is a directory, make sure you include the final / 🍓.
  • -isysroot dir — Basically the --sysroot option, but it only applies to header files. Check out the --sysroot option for the full scoop ✨.
  • -iquote dir — Only searches dir for header files requested with "#include "file"". These don't get searched for #include <file>. It happens before all the -I directories and the standard system directories 🎀. If dir begins with =, 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 ones. If dir begins with =, that = is replaced by the sysroot prefix. See --sysroot and -isysroot 👑.
  • -nostdinc — Don't search the standard system directories for header files. Only the directories you gave with -I options (plus the directory of the current file, if that applies) 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 the preferred one over the older -A predicate(answer) form. The old one still works, but the new one is better 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 throw away comments! 🫧 All comments get passed through to the output file, except comments inside processed directives. Those get deleted along with the directive 😭.

You should be ready for side effects when you use -C, bestie ⚠️. It makes the preprocessor treat comments as tokens in their own right. For example, a comment 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 does not yet recognize Fortran-style comments 💀.
  • -CC — Don't throw away comments, 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 side effects of -C, the -CC option converts all C++-style comments inside a macro into C-style comments 🦋. That's so using the macro later can't accidentally comment out the rest of the source line. -CC is mostly 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 definition gets cut off by 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 that mean something in shell syntax 🌸.

If you want to define a function-like macro on the command line, write its argument list in parentheses before the equals sign (if there is one). 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 get 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 that gets used, along with the other normal stuff 🦋. Each name is indented to show how deep it is in the #include stack 🌈.
  • -P — Inhibits linemarker generation in the preprocessor output 🎀. This can be useful when you're running the preprocessor on something that isn't C code and that's going 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 that say the GNU Fortran compiler can't 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, they don't stop the program from compiling 🫶.

You can request lots of specific warnings with options that start with -W. For example, -Wimplicit asks for warnings about implicit declarations 🔮. Each of these specific warning options also has a negative form that starts with -Wno-, which turns the warnings off. For example, -Wno-implicit 🙅‍♀️. This manual only lists one of the two forms, whichever one isn't the default 🌷.

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

  • -fmax-errors=n — Limits the maximum number of error messages to n. Once that number 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 🫧. It generates module files for each module 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, like using \e in a character constant inside a directive such as "#include" 🙈.

Valid Fortran programs should compile fine with or without this option 💖. Without it, certain GNU extensions and traditional Fortran features are supported too 🌈. With it, lots of those get rejected 🚫.

Some people try to use -pedantic to check programs for conformance, and then they're shocked 😭. It finds some nonstandard practices, but not all of them. Still, improvements to GNU Fortran in this area are very welcome 🫶.

This should be used together with -std=f95, -std=f2003, -std=f2008 or -std=f2018 💅.

  • -pedantic-errors — Like -pedantic, except that you get errors instead of warnings 🔥.
  • -Wall — Turns on commonly used warning options for usage that we recommend avoiding, and that we believe are easy to avoid 👑. Right now this 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 🦋.

This 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 the continuation happens at the first non-comment, non-whitespace character after the ampersand that started the continuation 🫶.
  • -Warray-temporaries — Warns about array temporaries the compiler generates 🌈. The info from this warning is sometimes useful for optimization, so you can avoid those temporaries ⭐.

Okay so this next batch is all about warnings 🚨 and the debugging flags 🐛, and I'm obsessed with how many of them exist. Let's go, bestie 💅

  • -Wc-binding-type — ✨ warns if a variable might not be C interoperable 🦋. It's the vibe where you declare something with an intrinsic type using the default kind instead of a kind parameter from the intrinsic ISO_C_Binding module, and gfortran calls you out for it. This one is implied by -Wall.
  • -Wcharacter-truncation — 🎀 heads up if a character assignment is going to chop off the string you're assigning ✂️.
  • -Wline-truncation — 📏 warns when a source code line is about to get cut short. This is implied by -Wall. For free-form source code, the default is -Werror=line-truncation, so truncations get reported as errors instead 😭.
  • -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. It does not imply -Wconversion 🙅‍♀️.
  • -Wextra — 💫 turns on some warning options for language features that can be problematic. Right now that's -Wcompare-reals, -Wunused-parameter and -Wdo-subscript.
  • -Wfrontend-loop-interchange — warns when you're using -ffrontend-loop-interchange to do loop interchanges 🔄.
  • -Wimplicit-interface — warns if a procedure is called without an explicit interface. Note that it 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. For 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 (-std). Because of that, it treats it as an "EXTERNAL" procedure. Use -fall-intrinsics if you want to never trigger this and always link to the intrinsic, no matter which standard is selected 🧚.
  • -Wno-overwrite-recursive — 🙈 don't warn when -fno-automatic is used with -frecursive. Recursion will be broken if the relevant local variables don't have the attribute "AUTOMATIC" explicitly declared. Use this to shush the warning when you know recursion isn't broken. It's useful for build environments that use -Werror.
  • -Wreal-q-constant — warns if a real-literal-constant contains a "q" exponent-letter.
  • -Wsurprising — 👀 warns when "suspicious" code constructs show up. They're technically legal, but they usually mean an error was made. Right now it fires under these circumstances:
    • An INTEGER SELECT construct has a CASE that can never be matched, since 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 — 🙃 by default, tabs are accepted as whitespace, 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 makes gfortran issue a warning whenever a tab is encountered. 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 yields an underflow or an overflow while the induction variable of the loop is iterating. This is implied by -Wall.
  • -Wunderflow — ✅ produces a warning when numerical constant expressions are encountered that yield an UNDERFLOW during compilation. Enabled by default.
  • -Wintrinsic-shadow — warns if a user-defined procedure or module procedure has the same name as an intrinsic. In that case, an explicit interface or an "EXTERNAL" or "INTRINSIC" declaration might be needed so calls get resolved to the procedure you actually want. This is implied by -Wall.
  • -Wuse-without-only — warns if a USE statement has no ONLY qualifier, which means it implicitly imports all public entities of the used module.
  • -Wunused-dummy-argument — warns about unused dummy arguments. Implied by -Wall.
  • -Wunused-parameter — 🤔 this one is different from gcc's meaning. gfortran's version doesn't warn about unused dummy arguments (for that, see -Wunused-dummy-argument). 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 variables being padded for proper alignment inside a "COMMON" block. You can turn this off with -Wno-align-commons. See also -falign-commons.
  • -Wfunction-elimination — warns if any calls to impure functions are eliminated by the optimizations enabled by -ffrontend-optimize. 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 reduce performance. If the array is already allocated with the correct shape, consider using a whole-array array-spec (e.g. "(:,:,:)") for the variable on the left-hand side to prevent the reallocation check. The warning can show up even when the compiler would optimize the reallocation checks away, for instance 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.
  • -Wcompare-reals — warns when comparing real or complex types for equality or inequality. Implied by -Wextra.
  • -Wtarget-lifetime — warns if the pointer in a pointer assignment might live longer than 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 if the compiler can't prove the statement is actually executed. Here's the sort of situation it's talking about:
real a(3)
do i=1,4
  if (condition(i)) then
    a(i) = 1.2
  end if
end do

This option 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. Bestie, these are for the deep dives 🧠✨

  • -fdump-fortran-original — outputs the internal parse tree after the source program has been translated into internal representation. It's mostly useful for debugging the GNU Fortran compiler itself. The output might change between releases, and this option 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 this option may also generate internal compiler errors for features that were only recently added.
  • -fdump-parse-tree — outputs the internal parse tree after the source program has been translated into internal representation. It's mostly useful for debugging the GNU Fortran compiler itself. The output might change between releases, and this option may also generate internal compiler errors for features that were only recently added.
⚠️ This option is deprecated; use -fdump-fortran-original instead.
  • -fdebug-aux-vars — 🔍 renames internal variables created by the gfortran front end and makes them accessible to a debugger. Their names then start with upper-case letters followed by an underscore. This is useful for debugging the compiler's code generation together with -fdump-tree-original, and for debugging the executable program 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 this option 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 occurs and the trap for that exception is enabled, a SIGFPE signal is sent and the program is aborted, producing a core file that's useful for debugging. list is a (possibly empty) comma-separated list of the following exceptions:
    • invalid (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 operation)
    • denormal (operation performed on a denormal value)

The first five exceptions correspond to the five IEEE 754 exceptions, whereas the last one (denormal) is not part of the IEEE 754 standard but is available on some common architectures such as x86.

The first three exceptions (invalid, zero, and overflow) often indicate serious errors. Unless the program has provisions for dealing with these, enabling traps for them is probably a good idea 💖.

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

Bestie, once you turn an exception trap on, it can't be turned off again 😭 There's no negative form, so choose wisely 💅

Many, if not most, floating point operations lose a little precision from rounding 🌸 so ffpe-trap=inexact is honestly going to be super uninteresting in real life 🥱

By default, no exception traps are enabled 🦋

  • -ffpe-summary=list — Okay, this one lets you pick which floating-point exceptions get their flag status printed to ERROR_UNIT whenever STOP or ERROR STOP runs ✨ The list can be none, all, or a comma-separated list of invalid, zero, overflow, underflow, inexact and denormal. (See -ffpe-trap for what each exception means 🧚) If you use this option more than once on the command line, only the last one counts 👑 By default, you get a summary for all exceptions except inexact 💖
  • -fno-backtrace — So when a serious runtime error hits, or a deadly signal goes off (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 only has an effect when compiling the Fortran main program.

These options are all about how GNU Fortran hunts down files pulled in by the INCLUDE directive, and where it looks for previously compiled modules 🔍

They also change the search paths that cpp uses when it preprocesses Fortran source 🌈

  • -Idir — These affect how the INCLUDE directive gets interpreted (and the #include directive in the cpp preprocessor too) 🫶 Also, -I and INCLUDE basically behave the same as -I with #include in cpp, when it comes to looking for header.gcc files and other stuff like that. This path is also where it searches for .mod files when a previously compiled module is needed by a USE statement 📦
  • -Jdir — This one tells the compiler where to put the .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 — Use this if the pre-compiled intrinsic modules aren't in the default spot the compiler expects 🗺️

🔗 Influencing the linking step 🔗

These options only matter when the compiler links object files into an executable output file 💅 If there's no link step, they're meaningless 🙃

  • -static-libgfortran — On systems that ship libgfortran as both a shared and a static library, this forces the static version to be used 🧊 If no shared version of libgfortran 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 💖
    • swap — swap between big- and little-endian 🔄
    • big-endian — use big-endian representation for unformatted files 🌊
    • little-endian — use little-endian representation for unformatted files 🌊

This option only has an effect when used in the main program 🎯 The CONVERT specifier and the GFORTRAN_CONVERT_UNIT environment variable both override whatever default -fconvert sets 👑

  • -frecord-marker=length — This sets the length of record markers for unformatted files. Valid values 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 need to read or write files that are compatible with earlier versions of gfortran, use -frecord-marker=8 🕰️
  • -fmax-subrecord-length=length — This sets the maximum length for a subrecord 📏 The maximum permitted value for length is 2147483639, which is also the default. Honestly, it's only really useful for the gfortran testsuite 🧪
  • -fsign-zero — When enabled, floating point zeros with the sign bit set get written as negative numbers in formatted output, and get treated as negative by the SIGN intrinsic ➖ -fno-sign-zero skips printing the negative sign on zero values (or values rounded to zero for I/O), and treats zero as a positive number in the SIGN intrinsic. That's 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 come in both positive and negative forms, where the negative form of -ffoo is -fno-foo 🔁 The list below only shows the form that is not the default. You can figure out the other form by removing no- or adding it 🧠

  • -fno-automatic — Treats each program unit (except the ones marked RECURSIVE) as if the SAVE statement were specified for every local variable and array in it 📌 It doesn't affect common blocks. (Some Fortran compilers call this option -static or -save.) The default, which is -fautomatic, puts local variables smaller than the value given by -fmax-stack-var-size on the stack 🥞 Use -frecursive if you want no static memory at all 🙅

Local variables or arrays that have an explicit SAVE attribute get silently ignored, unless you add the -pedantic option 🤓

  • -ff2c — This generates code that's compatible with code generated by g77 and f2c 🤝 The g77 calling conventions (originally from f2c) make functions that return default REAL actually return the C type double, and functions that return COMPLEX send their values back through an extra argument in the calling sequence that points to where the return value should be stored 🎈 With the default GNU calling conventions, those functions just return their results like GNU C does: 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 code that interfaces with the libgfortran library 📚

Caution: It's not a good idea to mix Fortran code compiled with -ff2c with code compiled with the default -fno-f2c calling conventions 😬 If you call COMPLEX or default REAL functions between program parts that were compiled with different calling conventions, things 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 — This stops GNU Fortran from transforming the names of entities in your Fortran source by appending underscores to them 🙅

With -funderscoring in effect, GNU Fortran appends one underscore to external names that don't have any underscores already 🪄 This keeps things compatible with code produced by a lot of UNIX Fortran compilers 🐧

Caution: GNU Fortran's default behavior is incompatible with f2c and g77 💔 If you want object files from GNU Fortran to be compatible with object code made by these tools, please use -ff2c instead.

Using -fno-underscoring isn't recommended unless you're experimenting with things like plugging GNU Fortran into existing system environments (vis-a-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)

gets 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 use your own names directly while debugging, and when you're interfacing GNU Fortran code with other languages 🫶

Heads up though: just because the names match doesn't mean the interface GNU Fortran uses for an external name matches the interface another language uses for that same name 👀 Getting code from GNU Fortran to link with code from some other compiler, by this method or any other, is only a small part of the overall solution 🧩 Getting both compilers' output to agree on everything other than naming can take serious effort, and unlike naming disagreements, linkers usually can't detect those other mismatches 😭

Also, with -fno-underscoring, the lack of appended underscores makes it very real that a user-defined external name could clash with a name in a system library 💥 That can make unresolved-reference bugs really hard to find, since they might only show up at program run time as weird buggy behavior 🙃

In future versions of GNU Fortran, the hope is to improve naming and linking so debugging always uses the names as they appear in the source, even when the linker sees mangled names to stop accidental linking between procedures with incompatible interfaces 🔮

  • -fsecond-underscore — By default, GNU Fortran appends an underscore to external names 🌱 If you use this option, GNU Fortran appends two underscores to names that already have underscores, and one underscore to external names with no underscores 🌟 It also appends two underscores to internal names with underscores, so they don't collide with external names 🫧

This option has no effect if -fno-underscoring is in effect 🙅 It's implied by the -ff2c option 🎀

Otherwise, with this option, an external name such as MAX_COUNT gets 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 the -ff2c option 💜

  • -fcoarray=<keyword> — This picks which coarray support you get 🦋
    • none — Disables coarray support, so using coarray declarations and image-control statements produces a compile-time error 🚫 (Default)
  • single — Single-image mode, so num_images() is always one. Think solo act, no backup dancers 💅
  • lib — Library-based coarray parallelization. You'll need to link a suitable GNU Fortran coarray library for this one ✨

🎀 -fcheck=<keyword>

Turns on run-time checks. The argument is a comma-delimited list of the keywords below. Slap a no- in front of any check to switch it off, but only if an earlier specification turned it on 🙈

  • all — Turns on every run-time test that -fcheck offers 👑
  • array-temps — Warns at run time when a temporary array had to be made to pass an actual argument. This info can be handy for optimization, since it helps you dodge those temporaries 🦋
    • Note: The warning only prints once per location, so don't panic when it goes quiet 💜
  • bits — Run-time checks for invalid arguments to the bit manipulation intrinsics 🧚
  • bounds — Run-time checks for array subscripts against the declared minimum and maximum values. It also checks array indices for assumed and deferred shape arrays against the actual allocated bounds, and makes sure all string lengths match for character array constructors that don't have an explicit typespec 🌸
    • Some checks need -fcheck=bounds set when the main program gets compiled 🫶
    • Note: Future versions might add other kinds of checking too, like checking substring references 🔮
  • do — Run-time checks for invalid modification of loop iteration variables 🍓
  • mem — Run-time checks for memory allocation 💖
    • Note: This one does not touch explicit allocations made with the ALLOCATE statement. Those are always checked, no exceptions 💀
  • pointer — Run-time checks for pointers and allocatables 🌈
  • recursion — Run-time checks for recursively called subroutines and functions that aren't marked as recursive. See also -frecursive 🦋
    • Note: This check doesn't work for OpenMP programs. It also gets disabled if you use it together with -frecursive and -fopenmp 😭

Example: say you've got a file called foo.f90. This command:

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

will compile the file with every check turned on, except the warnings for generated array temporaries ✨

  • -fbounds-check — Deprecated alias for -fcheck=bounds. It's on its way out, so switch to the new spelling 🫶
  • -ftail-call-workaround, -ftail-call-workaround=n — Okay, this one's a whole saga 🎭 Some C interfaces to Fortran code break the gfortran ABI by leaving out the hidden character length arguments (the source text cuts off right at "as described in", so that's all the detail there is). This can cause crashes, because pushing arguments for tail calls can overflow the stack 💀
    • This option works around that for existing binary packages by turning off tail call optimization for gfortran procedures that have character arguments.
    • -ftail-call-workaround=2 turns tail call optimization off in all gfortran procedures with character arguments.
    • -ftail-call-workaround=1, or just plain -ftail-call-workaround, only does it for gfortran procedures with character arguments that call implicitly prototyped procedures.
    • Heads up: Using this can cause problems, including crashes from not having enough stack space 😭
    • It is very strongly recommended that you fix the code in question instead. The -fc-prototypes-external option can generate prototypes that follow gfortran's ABI, so you can drop them into your source code 🌸
    • Support for this option will probably be withdrawn in a future gfortran release, so don't get too attached 🥀
    • To turn it off, use -fno-tail-call-workaround or -ftail-call-workaround=0 🙅‍♀️
    • Right now the default is -ftail-call-workaround, but that's going to change in future releases ⭐
  • -fcheck-array-temporaries — Deprecated alias for -fcheck=array-temps. Same vibe, shorter spelling is the new move 💅
  • -fmax-array-constructor=n — Lets you raise the upper limit allowed in array constructors. The code below needs this option so it can 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 really long compile times and excessively large object files. Proceed with love but also with snacks 🍿

The default value for n is 65535.

  • -fmax-stack-var-size=n — Sets the size in bytes of the biggest array that can go on the stack. If an array is bigger than that, it uses static memory instead (except in procedures marked RECURSIVE) 🧱
    • Use -frecursive to allow recursive procedures that don't have a RECURSIVE attribute, or for parallel programs 🔁
    • Use -fno-automatic if you want to never use the stack 🚫
    • Note: This only affects local arrays declared with constant bounds, and it may not apply to every character variable. Future versions of GNU Fortran might improve this 🌱
    • The default value for n is 65536.
  • -fstack-arrays — Puts all arrays of unknown size, plus array temporaries, onto stack memory. If your program uses super large local arrays, you might have to raise your runtime stack memory limits 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 together as possible. Code built with this is likely to be incompatible with code built without it, and it may run slower 🐢
  • -frepack-arrays — Sometimes GNU Fortran passes assumed shape array sections through a descriptor that describes a noncontiguous chunk of memory. This option adds code to the function prologue that repacks the data into a contiguous block at runtime 📦
    • Result: faster array accesses, but it can add a lot of overhead to the function call, especially when the passed data is noncontiguous 😬
  • -fshort-enums — Here for interop with C code that was compiled using -fshort-enums. GNU Fortran will pick the smallest INTEGER kind that an enumerator set fits into, then give all of 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 procedure (or to one without an explicit interface), the argument might have to be packed, meaning put into contiguous memory. Here's the classic example, a 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, that packing is done by inline code. That means more optimization, but also a bigger code size 📈

  • It's implied by any of the -O options, except when you're optimizing for size with -Os 🧠
  • If your code has a very large number of arguments that need packing, code size and compile time can get out of hand. In that case, disabling this option might be the better move 🙃
  • To find instances of packing, use -Warray-temporaries 🔍
  • -fexternal-blas — Makes gfortran call BLAS functions for some matrix operations, like MATMUL, instead of using its own algorithms. This only happens when the matrices are bigger than a given limit (see -fblas-matmul-limit) 🧮 This can pay off if you have an optimized vendor BLAS library available. The BLAS library has to be specified at link time 🔗
  • -fblas-matmul-limit=n — Only matters when -fexternal-blas is in effect. Matrix multiplications with a size larger than, or equal to, n get handled by BLAS calls, while smaller ones use 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 make your code bigger if the matrix size can't be figured out at compile time, since code for both cases gets generated 🫠
    • -finline-matmul-limit=0 turns inlining off in all cases 🛑
    • Setting it to some value 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 initialization squad 🧊
    • -finit-local-zero tells the compiler to set local INTEGER, REAL, and COMPLEX variables to zero, LOGICAL variables to false, and CHARACTER variables to a string of null bytes 0️⃣
    • For finer control, you've got -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. Here n is an ASCII character value for the character one 🔡
    • 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 way as with -finit-local-zero 🧬
    • Not included: These options do not initialize:
      • objects with the POINTER attribute 🚫
      • allocatable arrays 🚫
      • variables that show up in an EQUIVALENCE statement 🚫

(psst, these limitations might get removed in future releases 🌸)

okay so -finit-real=nan sets up REAL and COMPLEX variables with a quiet NaN ✨. If you want a signalling NaN, use -finit-real=snan instead. ngl though, compile-time optimizations can quietly turn those into quiet NaNs 💀, and trapping has to be enabled too (for example with -ffpe-trap) 🫶

The -finit-integer option parses the value into an integer of type INTEGER(kind=C_LONG) on the host. That value then gets assigned to the integer variables in your Fortran code, and if it's too big for the kind, it can wrap around 😬

And last but not least, turning on any of the -finit-* options silences the warnings -Wuninitialized would've thrown for the affected local variables. main character energy 👑

  • -falign-commons — By default, gfortran pads every variable in a COMMON block so it's properly aligned 💅. On some platforms this is mandatory, and on others it just boosts performance. If a COMMON block isn't declared with consistent data types everywhere, that padding can cause trouble, so -fno-align-commons lets you turn automatic alignment off. Use the same form of this option for every file that shares a COMMON block. To dodge alignment issues in COMMON blocks, it's recommended to order objects from largest to smallest 🍓
  • -fno-protect-parens — By default, parentheses in expressions are honored at every optimization level, so the compiler doesn't re-associate anything 🦋. Using -fno-protect-parens lets it reorder REAL and COMPLEX expressions for faster code. For that re-association to happen, -fno-signed-zeros and -fno-trapping-math need to be in effect. Parentheses protection is on 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 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, 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 option does front-end optimization by manipulating parts of the Fortran parse tree 🌈. It's enabled by default by 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.).

If you don't vibe with it, you can deselect it by specifying -fno-frontend-optimize.

  • -ffrontend-loop-interchange — This one attempts to interchange loops in the Fortran front end wherever it's profitable 🔥. It's enabled by default by any -O option. Right now it only affects FORALL and DO CONCURRENT statements that have several forall triplets.

🌍 ENVIRONMENT 🌍

The gfortran compiler doesn't use any environment variables to control its operation beyond the ones that affect the operation of gcc. So just gcc's vibes 💜

🐛 BUGS 🐛

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

🔗 SEE ALSO 🔗

Here's your reading list, bestie 📚: gpl(7), gfdl(7), fsf-funding(7), cpp(1), gcov(1), gcc(1), as(1), ld(1), gdb(1), dbx(1), plus the Info entries for gcc, cpp, gfortran, as, ld, binutils and gdb 🧚

✍️ AUTHOR ✍️

Check the Info entry for gfortran to see the contributors to GCC and GNU Fortran 🫶

Copyright (c) 2004-2022 Free Software Foundation, Inc. 💖

Okay, legal stuff, but it's actually cute: you're allowed to copy, distribute and/or modify this document under 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! 🎀 Source gcc-12, dated 2022-02-22, and you literally made it through the entire gfortran manual. You're so iconic 💅🌸

📦 where this page comes from