Error and Warning Options (The GNU Fortran Compiler)

### 2.4 Options to request or suppress errors and warnings ¶

Errors are diagnostic messages that report that the GNU Fortran compiler cannot compile the relevant piece of source code. The compiler continues to process the program in an attempt to report further errors to aid in debugging, but does not produce any compiled output.

Warnings are diagnostic messages that report constructions that are not inherently erroneous but that are risky or suggest there is likely to be a bug in the program. Unless `-Werror` is specified, they do not prevent compilation of the program.

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

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

`-fmax-errors=n` ¶

  Limits the maximum number of error messages to n, at which point GNU Fortran bails out rather than attempting to continue processing the source code. If n is 0, there is no limit on the number of error messages produced.

`-fsyntax-only` ¶

  Check the code for syntax errors, but do not actually compile it. This generates module files for each module present in the code, but no other output file.

`-Wpedantic` ¶
`-pedantic`

  Issue warnings for uses of extensions to Fortran. `-pedantic` also applies to C-language constructs where they occur in GNU Fortran source files, such as use of ‘`\e`’ in a character constant within a directive like `#include`.

  Valid Fortran programs should compile properly with or without this option. However, without this option, certain GNU extensions and traditional Fortran features are supported as well. With this option, many of them are rejected.

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

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

`-pedantic-errors` ¶

  Like `-pedantic`, except that errors are produced rather than warnings.

`-Wall` ¶

  Enables commonly used warning options pertaining to 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`, `-Wundefined-do-loop` and `-Wundefined-vars`.

`-Waliasing` ¶

  Warn 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 triggers 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` ¶

  Warn about missing ampersand in continued character constants. The warning is given with `-Wampersand`, `-pedantic`, `-std=f95`, `-std=f2003`, `-std=f2008`, `-std=f2018` and `-std=f2023`. Note: With no ampersand given in a continued character constant, GNU Fortran assumes continuation at the first non-comment, non-whitespace character after the ampersand that initiated the continuation.

`-Warray-temporaries` ¶

  Warn about array temporaries generated by the compiler. The information generated by this warning is sometimes useful in optimization, in order to avoid such temporaries.

`-Wc-binding-type` ¶

  Warn if the a variable might not be C interoperable. In particular, warn if the variable has been declared using an intrinsic type with default kind instead of using a kind parameter defined for C interoperability in the intrinsic `ISO_C_Binding` module. This option is implied by `-Wall`.

`-Wcharacter-truncation` ¶

  Warn when a character assignment truncates the assigned string.

`-Wline-truncation` ¶

  Warn when a source code line is truncated. This option is implied by `-Wall`. For free-form source code, the default is `-Werror=line-truncation` such that truncations are reported as error.

`-Wconversion` ¶

  Warn about implicit conversions that are likely to change the value of the expression after conversion. Implied by `-Wall`.

`-Wconversion-extra` ¶

  Warn about implicit conversions between different types and kinds. This option does not imply `-Wconversion`.

`-Wdeprecated-openmp` ¶

  Warn for usage of deprecated OpenMP code.

`-Wexternal-argument-mismatch` ¶

  Warn about argument mismatches for dummy external procedures. This is implied by `-fc-prototypes-external` because generation of a valid C23 interface is not possible in such a case. Also implied by `-Wall`.

`-Wextra` ¶

  Enables some warning options for usages of language features that may be problematic. This currently includes `-Wcompare-reals`, `-Wunused-parameter`, `-Wdo-subscript`, `-Wunused-intent-out` and `-Wunused-read`.

`-Wfrontend-loop-interchange` ¶

  Warn when using `-ffrontend-loop-interchange` for performing loop interchanges.

`-Wimplicit-interface` ¶

  Warn if a procedure is called without an explicit interface. Note this only checks that an explicit interface is present. It does not check that the declared interfaces are consistent across program units.

`-Wimplicit-procedure` ¶

  Warn if a procedure is called that has neither an explicit interface nor has been declared as `EXTERNAL`.

`-Winteger-division` ¶

  Warn if a constant integer division truncates its result. As an example, 3/5 evaluates to 0.

`-Wintrinsics-std` ¶

  Warn if `gfortran` finds a procedure named like an intrinsic not available in the currently selected standard (with `-std`) and treats it as `EXTERNAL` procedure because of this. `-fall-intrinsics` can be used to never trigger this behavior and always link to the intrinsic regardless of the selected standard.

`-Wno-overwrite-recursive` ¶

  Do not warn when `-fno-automatic` is used with `-frecursive`. Recursion is broken if the relevant local variables do not have the attribute `AUTOMATIC` explicitly declared. This option can be used to suppress the warning when it is known that recursion is not broken. Useful for build environments that use `-Werror`.

`-Wreal-q-constant` ¶

  Produce a warning if a real-literal-constant contains a `q` exponent-letter.

`-Wsurprising` ¶

  Produce a warning when “suspicious” code constructs are encountered. While technically legal these usually indicate that an error has been made.

  This currently produces a warning under the following circumstances:

  - An `INTEGER`-typed `SELECT CASE` construct has a `CASE` that can never be matched as its lower value is greater than its upper value.
  - A `LOGICAL`-typed `SELECT CASE` 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.
  - With `-fopenmp`, for fixed-form source code, when an `omx` vendor-extension sentinel is encountered. (The equivalent `ompx`, used in free-form source code, is diagnosed by default.)
  - With `-fopenacc`, when using named constances with clauses that take a variable as doing so has no effect.
`-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` causes a warning to be issued if a tab is encountered. Note, `-Wtabs` is active for `-pedantic`, `-std=f95`, `-std=f2003`, `-std=f2008`, `-std=f2018`, `-std=f2023` and `-Wall`.

`-Wundefined-do-loop` ¶

  Warn if a `DO` loop with step either 1 or -1 yields an underflow or an overflow during iteration of an induction variable of the loop. This option is implied by `-Wall`.

`-Wundefined-vars` ¶

  Warn if variables are found to be used that cannot be defined (have a value assigned to them). This also includes using allocatable variables that are not allocated.

`-Wunderflow` ¶

  Produce a warning when numerical constant expressions that yield an underflow are encountered during compilation. Enabled by default.

`-Wintrinsic-shadow` ¶

  Warn if a user-defined procedure or module procedure has the same name as an intrinsic; in this case, an explicit interface or `EXTERNAL` or `INTRINSIC` declaration might be needed to get calls later resolved to the desired intrinsic/procedure. This option is implied by `-Wall`.

`-Wuse-without-only` ¶

  Warn if a `USE` statement has no `ONLY` qualifier and thus implicitly imports all public entities of the used module.

`-Wunused-dummy-argument` ¶

  Warn about unused dummy arguments. This option is implied by `-Wall`.

`-Wunused-parameter` ¶

  Contrary to `gcc`’s meaning of `-Wunused-parameter`, `gfortran`’s implementation of this option does not warn about unused dummy arguments (see `-Wunused-dummy-argument`), but about unused `PARAMETER` values. `-Wunused-parameter` is implied by `-Wextra` if also `-Wunused` or `-Wall` is used.

`-Wunused-intent-out` ¶

  Warn about variables passed to `INTENT(OUT)` arguments whose values are then unused. This option is implied by `-Wextra`. The following code shows an example where this warning will be emitted:

      module y
        implicit none
      contains
        subroutine bar
          real :: a
          call foo(a) ! Warning will be emitted here
        end subroutine bar
        subroutine foo(x)
          real, intent(out) :: x
          x = 0.4
        end subroutine foo
      end module y

`-Wunused-read` ¶

  Warn about variables in `READ` statements whose values are never used. This warning is implied by `-Wextra`. The following code shows an example where this warning will be emitted:

      program main
        real :: x
        read (*,*) x
      end program main

`-Walign-commons` ¶

  By default, `gfortran` warns about any occasion of variables being padded for proper alignment inside a `COMMON` block. This warning can be turned off via `-Wno-align-commons`. See also `-falign-commons`.

`-Wfunction-elimination` ¶

  Warn if any calls to impure functions are eliminated by the optimizations enabled by the `-ffrontend-optimize` option. This option is implied by `-Wextra`.

`-Wrealloc-lhs` ¶

  Warn when the compiler might insert code to 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 the 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. Note that in some cases the warning is shown, even if the compiler optimizes 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` ¶

  Warn when the compiler inserts code to for allocation or reallocation of an allocatable variable; this includes scalars and derived types.

`-Wcompare-reals` ¶

  Warn when comparing real or complex types for equality or inequality. This option is implied by `-Wextra`.

`-Wtarget-lifetime` ¶

  Warn if the pointer in a pointer assignment might be longer than the its target. This option is implied by `-Wall`.

`-Wzerotrip` ¶

  Warn if a `DO` loop is known to execute zero times at compile time. This option is implied by `-Wall`.

`-Wdo-subscript` ¶

  Warn if an array subscript inside a `DO` loop could lead to an out-of-bounds access even if the compiler cannot prove that the statement is actually executed, in cases like

        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.

See Options to Request or Suppress Errors and Warnings in Using the GNU Compiler Collection (GCC), for information on more options offered by the back end shared by `gfortran`, `gcc` and other GNU compilers.

Some of these have no effect when compiling programs written in Fortran.