Go to the first, previous, next, last section, table of contents.

GNU Fortran Command Options

The g77 command supports all the options supported by the gcc command. See section `GNU CC Command Options' in Using and Porting GNU CC, for information on the non-Fortran-specific aspects of the gcc command (and, therefore, the g77 command).

The g77 command supports one option not supported by the gcc command:

Specifies that command, rather than gcc, is to be invoked by g77 to do its job. For example, within the gcc build directory after building GNU Fortran (but without having to install it), `./g77 --driver=./xgcc foo.f -B./'.

All other options are supported both by g77 and by gcc as modified (and reinstalled) by the g77 distribution. In some cases, options have positive and negative forms; the negative form of `-ffoo' would be `-fno-foo'. This manual documents only one of these two forms, whichever one is not the default.

Option Summary

Here is a summary of all the options specific to GNU Fortran, grouped by type. Explanations are in the following sections.

Overall Options
See section Options Controlling the Kind of Output.
--driver  -fversion  -fset-g77-defaults
Fortran Language Options
See section Options Controlling Fortran Dialect.
-ffree-form  -fno-fixed-form  -ff90  -fvxt-not-f90
-ff90-not-vxt  -fdollar-ok  -fno-backslash
-fintrin-case-initcap  -fintrin-case-upper
-fintrin-case-lower  -fintrin-case-any
-fmatch-case-initcap  -fmatch-case-upper
-fmatch-case-lower  -fmatch-case-any
-fsource-case-upper -fsource-case-lower  -fsource-case-preserve
-fsymbol-case-initcap  -fsymbol-case-upper
-fsymbol-case-lower  -fsymbol-case-any
-fcase-strict-upper  -fcase-strict-lower
-fcase-initcap  -fcase-upper  -fcase-lower  -fcase-preserve
-fdcp-intrinsics-delete  -fdcp-intrinsics-hide
-fdcp-intrinsics-disable  -fdcp-intrinsics-enable
-ff2c-intrinsics-delete  -ff2c-intrinsics-hide
-ff2c-intrinsics-disable  -ff2c-intrinsics-enable
-ff90-intrinsics-delete  -ff90-intrinsics-hide
-ff90-intrinsics-disable  -ff90-intrinsics-enable
-fmil-intrinsics-delete  -fmil-intrinsics-hide
-fmil-intrinsics-disable  -fmil-intrinsics-enable
-funix-intrinsics-delete  -funix-intrinsics-hide
-funix-intrinsics-disable  -funix-intrinsics-enable
-fvxt-intrinsics-delete  -fvxt-intrinsics-hide
-fvxt-intrinsics-disable  -fvxt-intrinsics-enable
-ffixed-line-length-n  -ffixed-line-length-none
Warning Options
See section Options to Request or Suppress Warnings.
-fsyntax-only  -pedantic  -pedantic-errors  -fpedantic
-fugly  -fno-ugly-args  -fno-ugly-init  -w  -Wimplicit
-Wunused  -Wuninitialized  -Wall  -Wsurprising  -Werror
Debugging Options
See section Options for Debugging Your Program or GNU Fortran.
Optimization Options
See section Options That Control Optimization.
-ffloat-store  -fforce-mem  -fforce-addr  -fno-inline
-ffast-math  -fstrength-reduce  -frerun-cse-after-loop
-fexpensive-optimizations  -fdelayed-branch
-fschedule-insns  -fschedule-insn2  -fcaller-saves
-funroll-loops  -funroll-all-loops
-fno-move-all-movables  -fno-reduce-all-givs
Directory Options
See section Options for Directory Search.
-Idir  -I-
Code Generation Options
See section Options for Code Generation Conventions.
-fno-automatic  -finit-local-zero  -fno-f2c
-ff2c-library  -fno-underscoring  -fno-ident
-fpcc-struct-return  -freg-struct-return
-fshort-double  -fno-common  -fpack-struct

Options Controlling the Kind of Output

Compilation can involve as many as four stages: preprocessing, compilation proper, assembly, and linking, always in that order. The first three stages apply to an individual source file, and end by producing an object file; linking combines all the object files (those newly compiled, and those specified as input) into an executable file.

For any given input file, the file name suffix determines what kind of compilation is done. Suffixes specific to GNU Fortran are listed below. See section Options Controlling the Kind of Output, for information on suffixes recognized by GNU CC.

Fortran source code that should not be preprocessed.
Fortran source code that must be preprocessed (by the C preprocessor cpp, which is part of GNU CC).

UNIX users typically use the `file.f' and `file.F' nomenclature. Users of other operating systems, especially those that cannot distinguish upper-case letters from lower-case letters in their file names, typically use the `file.for' and `file.fpp' nomenclature.

Use of the preprocessor cpp allows use of C-like constructs such as `#define' and `#include', but can lead to unexpected, even mistaken, results due to Fortran's source file format. It is recommended that use of the C preprocessor be limited to `#include' and, in conjunction with `#define', only `#if' and related directives, thus avoiding in-line macro expansion entirely. This recommendation applies especially when using the traditional fixed source form. With free source form, fewer unexpected transformations are likely to happen, but use of Hollerith and things like continued character constants can nevertheless present problems.

The following options that affect overall processing are recognized by the g77 and gcc commands in a GNU Fortran installation:

This works only when invoking the g77 command, not when invoking the gcc command. See section GNU Fortran Command Options, for information on this option.
Ensure that the g77-specific version of the compiler phase is reported, if run. (This is supplied automatically when `-v' or `--version' is specified as a command-line option for g77 or gcc and when the resulting commands compile Fortran source files.)
Set up whatever gcc options are to apply to Fortran compilations. For version 0.5.18, this is equivalent to `-fmove-all-movables -freduce-all-givs -frerun-loop-opt'. (This is supplied automatically when compiling Fortran code. The description of this option is here so that users seeing it in the output of, say, `g77 -v' understand why it is there. Also, developers who run f771 directly might want to specify it by hand to get the same defaults as they would running f771 via g77 or gcc.)

See section `Options Controlling the Kind of Output' in Using and Porting GNU CC, for information on more options that control the overall operation of the gcc command (and, by extension, the g77 command).

Options Controlling Fortran Dialect

The following options control the dialect of Fortran that the compiler accepts:

Specify that the source file is written in free form (introduced in Fortran 90) instead of the more-traditional fixed form.
Allow certain Fortran-90 constructs. This option controls whether certain Fortran 90 constructs are recognized. (Other Fortran 90 constructs might or might not be recognized depending on other options such as `-fvxt-not-f90', `-ff90-intrinsics-enable', and the current level of support for Fortran 90.) See section GNU Fortran Extensions, for more information.
Specify whether Fortran 90 or other popular extensions are to be assumed for ambiguous constructs. The default is -fvxt-not-f90. For example, with `-ff90-not-vxt', `PRINT *,"double-quoted string"' is valid, while with `-fvxt-not-f90', `PRINT *,"2000' is valid. (There is no way to allow both constructs in the general case, since statements like `PRINT *,"2000 !comment?"' would be ambiguous.) See section GNU Fortran Dialects, for more information.
Allow `$' as a valid character in a symbol name.
Specify that `\' is not to be specially interpreted in character and Hollerith constants a la C and many UNIX Fortran compilers. For example, with `-fbackslash' in effect, `A\nB' specifies three characters, with the second one being newline. With `-fno-backslash', it specifies four characters, `A', `\', `n', and `B'. Note that g77 implements a fairly general form of backslash processing that is incompatible with the narrower forms supported by some other compilers. For example, `'A\003B'' is a three-character string in g77, whereas other compilers that support backslash might not support the three-octal-digit form, and thus treat that string as longer than three characters. See section Certain Changes We Don't Want to Make, for information on why `-fbackslash' is the default instead of `-fno-backslash'.
Specify expected case for intrinsic names. `-fintrin-case-lower' is the default.
Specify expected case for keywords. `-fmatch-case-lower' is the default.
Specify whether source text other than character and Hollerith constants is to be translated to uppercase, to lowercase, or preserved as is. `-fsource-case-lower' is the default.
Specify valid cases for user-defined symbol names. `-fsymbol-case-any' is the default.
Same as `-fintrin-case-upper -fmatch-case-upper -fsource-case-preserve -fsymbol-case-upper'. (Requires all pertinent source to be in uppercase.)
Same as `-fintrin-case-lower -fmatch-case-lower -fsource-case-preserve -fsymbol-case-lower'. (Requires all pertinent source to be in lowercase.)
Same as `-fintrin-case-initcap -fmatch-case-initcap -fsource-case-preserve -fsymbol-case-initcap'. (Requires all pertinent source to be in initial capitals, as in `Print *,SqRt(Value)'.)
Same as `-fintrin-case-any -fmatch-case-any -fsource-case-upper -fsymbol-case-any'. (Maps all pertinent source to uppercase.)
Same as `-fintrin-case-any -fmatch-case-any -fsource-case-lower -fsymbol-case-any'. (Maps all pertinent source to lowercase.)
Same as `-fintrin-case-any -fmatch-case-any -fsource-case-preserve -fsymbol-case-any'. (Preserves all case in user-defined symbols, while allowing any-case matching of intrinsics and keywords. For example, `call Foo(i,I)' would pass two different variables named `i' and `I' to a procedure named `Foo'.)
Specify status of Digital's COMPLEX-related intrinsics. `-fdcp-intrinsics-enable' is the default.
Specify status of f2c-specific intrinsics. `-ff2c-intrinsics-enable' is the default.
Specify status of F90-specific intrinsics. `-ff90-intrinsics-delete' is the default.
Specify status of MIL-STD-1753-specific intrinsics. `-fmil-intrinsics-enable' is the default.
Specify status of UNIX intrinsics. `-funix-intrinsics-enable' is the default. For example, if your code invokes FLUSH as a library function and thus works with other UNIX Fortran compilers or earlier version of g77, either add the `EXTERNAL FLUSH' statement or, perhaps more convenient for you, compile with the -funix-intrinsics-hide or -funix-intrinsics-delete option. Note that ABORT, EXIT, FLUSH, SIGNAL, and SYSTEM are intrinsic subroutines, not functions (since they have side effects), so to get the return values from SIGNAL and SYSTEM, append a final argument specifying an `INTEGER' variable or array element to receive the returned status. (For example, `CALL SYSTEM('rm foo',ISTAT)'.) FLUSH() accepts an optional single `INTEGER' argument, since many Fortran implementations allow or require a unit number. Currently, since libf2c does not flush a given unit number, this argument is not used--all units are flushed by libf2c's implementation of FLUSH(). Do not depend on this behavior--if you want to flush all units, use `CALL FLUSH' (that is, specify no arguments to FLUSH). EXIT() accepts an optional single `INTEGER' argument. If omitted, zero is the default (as in `CALL EXIT(0)'). The default might change on configurations where the "normal return status" is not zero, however. If you want to return a "success" status, it is best to call EXIT with no arguments in your code, and let g77 choose the appropriate default.
Specify status of VXT intrinsics. `-fvxt-intrinsics-delete' is the default.
Set column after which characters are ignored in typical fixed-form lines in the source file. Popular values for n include 72 (the standard and the default), 80 (card image), and 132 (corresponds to "extended-source" options in some popular compilers). n may be `none', meaning that the entire line is meaningful and that continued character constants never have implicit spaces appended to them to fill out the line. `-ffixed-line-length-0' means the same thing as `-ffixed-line-length-none'.

Options to Request or Suppress Warnings

Warnings are diagnostic messages that report constructions which are not inherently erroneous but which are risky or suggest there might have been an error.

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 warnings produced by GNU Fortran:

Check the code for syntax errors, but don't do anything beyond that.
Issue warnings for uses of extensions to ANSI FORTRAN 77. `-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 ANSI FORTRAN 77 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 strict ANSI conformance. They soon find that it does not do quite what they want: it finds some non-ANSI practices, but not all--however, improvements to g77 in this area are welcome.
Like `-pedantic', except that errors are produced rather than warnings.
Like `-pedantic', but applies only to Fortran constructs.
Specify that certain "ugly" constructs are to be quietly accepted. Implies `-fugly-args' and `-fugly-init' as well. For example, with `-fno-ugly', `CALL FOO(,)' means to pass one null argument, whereas with `-fugly', it means to pass two null arguments.
Disallow passing Hollerith and typeless constants as actual arguments (for example, `CALL FOO(4HABCD)').
Disallow use of Hollerith and typeless constants as initial values (in PARAMETER and DATA statements), and use of character constants to initialize numeric types and vice versa. For example, `DATA I/'F'/, CHRVAR/65/, J/4HABCD/' is disallowed by `-fno-ugly-init'.
Inhibit all warning messages.
Warn whenever a variable, array, or function is implicitly declared. Has an effect similar to using the `IMPLICIT NONE' statement in every program unit. (Some Fortran compilers provide this feature by an option named `-u' or `/WARNINGS=DECLARATIONS'.)
Warn whenever a variable is unused aside from its declaration.
Warn whenever an automatic variable is used without first being initialized. These warnings are possible only in optimizing compilation, because they require data flow information that is computed only when optimizing. If you don't specify `-O', you simply won't get these warnings. These warnings occur only for variables that are candidates for register allocation. Therefore, they do not occur for a variable that is declared volatile, or whose address is taken, or whose size is other than 1, 2, 4 or 8 bytes. Also, they do not occur for arrays, even when they are in registers. Note that there may be no warning about a variable that is used only to compute a value that itself is never used, because such computations may be deleted by data flow analysis before the warnings are printed. These warnings are made optional because GNU Fortran is not smart enough to see all the reasons why the code might be correct despite appearing to have an error. Here is one example of how this can happen:
IF (J.EQ.1) I=1
IF (J.EQ.2) I=4
IF (J.EQ.3) I=5
If the value of J is always 1, 2 or 3, then I is always initialized, but GNU Fortran doesn't know this. Here is another common case:
IF (FLAG) VALUE = 3.14
This has no bug because VALUE is used only if it is set.
The `-Wunused' and `-Wuninitialized' options combined. These are all the options which pertain to usage that we recommend avoiding and that we believe is easy to avoid. (As more warnings are added to g77, some might be added to the list enabled by `-Wall'.)

The remaining `-W...' options are not implied by `-Wall' because they warn about constructions that we consider reasonable to use, on occasion, in clean programs.

Warn about "suspicious" constructs that are interpreted by the compiler in a way that might well be surprising to someone reading the code. These differences can result in subtle, compiler-dependent (even machine-dependent) behavioral differences. The constructs warned about include:
Make all warnings into errors.
Turns on "extra warnings" and the `uninitialized' option. (This might change in future versions of g77.) "Extra warnings" are issued for:

See section `Options to Request or Suppress Warnings' in Using and Porting GNU CC, for information on more options offered by the GBE shared by g77, gcc, and other GNU compilers.

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

These options all could have some relevant meaning for GNU Fortran programs, but are not yet supported.

Options for Debugging Your Program or GNU Fortran

GNU Fortran has various special options that are used for debugging either your program or g77.

Produce debugging information in the operating system's native format (stabs, COFF, XCOFF, or DWARF). GDB can work with this debugging information. Support for this option in Fortran programs is incomplete. In particular, names of variables and arrays in common blocks or that are storage-associated via `EQUIVALENCE' are unavailable to the debugger.

See section `Options for Debugging Your Program or GNU CC' in Using and Porting GNU CC, for more information on debugging options.

Options That Control Optimization

Most Fortran users will want to use no optimization when developing and testing programs, and use `-O' or `-O2' when compiling programs for late-cycle testing and for production use.

The following flags have particular applicability when compiling Fortran programs:

Might help a Fortran program that depends on exact IEEE conformance on some machines, but might slow down a program that doesn't.
Might improve optimization of loops.
Don't compile statement functions inline. Might reduce the size of a program unit--which might be at expense of some speed (though it should compile faster). Note that if you are not optimizing, no functions can be expanded inline.
Might allow some programs designed to not be too dependent on IEEE behavior for floating-point to run faster, or die trying.
Might make some loops run faster.
Might improve performance on some code.
Definitely improves performance on some code.
Definitely improves performance on some code.
Each of these might improve performance on some code. Analysis of Fortran code optimization and the resulting optimizations triggered by the above options were contributed by Toon Moene (toon@moene.indiv.nluug.nl). Please let us know how use of these options affects the performance of your production code. We're particularly interested in code that runs faster when these options are disabled, and in non-Fortran code that benefits when they are enabled via the above gcc command-line options.

See section `Options That Control Optimization' in Using and Porting GNU CC, for more information on options to optimize the generated machine code.

Options Controlling the Preprocessor

These options control the C preprocessor, which is run on each C source file before actual compilation.

See section `Options Controlling the Preprocessor' in Using and Porting GNU CC, for information on C preprocessor options.

Some of these options also affect how g77 processes the `INCLUDE' statement. Since this statement is processed even when preprocessing is not requested, it is not described in this section. See section Options for Directory Search, for information on how g77 processes the `INCLUDE' statement.

Options for Directory Search

These options affect how the cpp preprocessor searches for files specified via the `#include' directive. Therefore, when compiling Fortran programs, they are meaningful when the preproecssor is used.

Some of these options also affect how g77 searches for files specified via the `INCLUDE' statement. These options are:

These affect interpretation of the `INCLUDE' statement (as well as of the `#include' directive of the cpp preprocessor). Note that `-Idir' must be specified without any spaces between `-I' and the directory name--that is, `-Ifoo/bar' is valid, but `-I foo/bar' is rejected by the g77 compiler (though the preprocessor supports the latter form). Also note that the general behavior of `-I' and `INCLUDE' is pretty much the same as of `-I' with `#include' in the cpp preprocessor, with regard to looking for `header.gcc' files and other such things. See section `Options for Directory Search' in Using and Porting GNU CC, for information on the `-I' option.

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; the negative form of `-ffoo' would be `-fno-foo'. In the table below, only one of the forms is listed--the one which is not the default. You can figure out the other form by either removing `no-' or adding it.

Treat each program unit as if the SAVE statement was specified for every local variable and array referenced in it. Does not affect common blocks. (Some Fortran compilers provide this option under the name `-static'.)
Specify that variables and arrays that are local to a program unit (not in a common block and not passed as an argument) are to be initialized to binary zeros. Since there is a run-time penalty for initialization of variables that are not given the SAVE attribute, it might be a good idea to also use `-fno-automatic' with `-finit-local-zero'.
Do not generate code designed to be compatible with code generated by f2c. This does not affect the generation of code that interfaces with the libf2c library. Caution: If `-fno-f2c' is used when compiling any source file used in a program, it must be used when compiling all Fortran source files used in that program.
Specify that use of libf2c is required. This is the default for the current version of g77. Currently it is not valid to specify `-fno-f2c-library'. This option is provided so users can specify it in shell scripts that build programs and libraries that require the libf2c library, even when being compiled by future versions of g77 that might otherwise default to generating code for an incompatible library.
Do not transform names of entities specified in the Fortran source file by appending underscores to them. With `-funderscoring' in effect, g77 appends two underscores to names with underscores and one underscore to external names with no underscores. (g77 also appends two underscores to internal names with underscores to avoid naming collisions with external names.) This is done to ensure compatibility with code produced by many UNIX Fortran compilers, including f2c, which perform the same transformations. Use of `-fno-underscoring' is not recommended unless you are experimenting with issues such as integration of (GNU) Fortran into existing system environments (vis-a-vis existing libraries, tools, and so on). For example, with `-funderscoring', and assuming other defaults like `-fcase-lower' and that `j()' and `max_count()' are external functions while `my_var' and `lvar' are local variables, a statement like
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 g77-compiled code with other languages. Note that just because the names match does not mean that the interface implemented by g77 for an external name matches the interface implemented by some other language for that same name. That is, getting code produced by g77 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, which could make finding unresolved-reference bugs quite difficult in some cases--they might occur at program run time, and show up only as buggy behavior at run time. In future versions of g77, 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.
Do not append a second underscore to names of entities specified in the Fortran source file. This option has no effect if `-fno-underscoring' is not in effect. 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__'.
Ignore the `#ident' directive.
Treat initial values of zero as if they were any other value. As of version 0.5.18, g77 normally treats `DATA' and other statements that are used specify initial values of zero for variables and arrays as if no values were actually specified, in the sense that no diagnostics regarding multiple initializations are produced. This is done to speed up compiling of programs that initialize large arrays to zeros. Use `-fzeros' to revert to the simpler, slower behavior that can catch multiple initializations by keeping track of all initializations, zero or otherwise. Caution: Future versions of g77 might disregard this option (and its negative form, the default) or interpret it somewhat differently. The interpretation changes will affect only non-standard programs; standard-conforming programs should not be affected.

See section `Options for Code Generation Conventions' in Using and Porting GNU CC, for information on more options offered by the GBE shared by g77, gcc, and other GNU compilers.

Some of these do not work when compiling programs written in Fortran:

You should not use these except strictly the same way as you used them to build the version of libf2c with which you will be linking all code compiled by g77 with the same option.
This probably either has no effect on Fortran programs, or makes them act loopy.
Do not use this when compiling Fortran programs, or there will be Trouble.
This probably will break any calls to the libf2c library, at the very least, even if it is built with the same option.

Environment Variables Affecting GNU Fortran

GNU Fortran currently does not make use of any environment variables to control its operation above and beyond those that affect the operation of gcc.

See section `Environment Variables Affecting GNU CC' in Using and Porting GNU CC, for information on environment variables.

Go to the first, previous, next, last section, table of contents.