| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
-fno-automatic
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'.)
-finit-local-zero
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'.
-fno-f2c
f2c; use the GNU calling conventions instead.
The f2c calling conventions require functions that return
type REAL(KIND=1) to actually return the C type double,
and functions that return type COMPLEX to return the
values via an extra argument in the calling sequence that points
to where to store the return value.
Under the GNU calling conventions, such functions simply return
their results as they would in GNU C---REAL(KIND=1) functions
return the C type float, and COMPLEX functions
return the GNU C type complex (or its struct
equivalent).
This does not affect the generation of code that interfaces with the
libg2c library.
However, because the libg2c library uses f2c
calling conventions, g77 rejects attempts to pass
intrinsics implemented by routines in this library as actual
arguments when `-fno-f2c' is used, to avoid bugs when
they are actually called by code expecting the GNU calling
conventions to work.
For example, `INTRINSIC ABS;CALL FOO(ABS)' is
rejected when `-fno-f2c' is in force.
(Future versions of the g77 run-time library might
offer routines that provide GNU-callable versions of the
routines that implement the f2c-callable intrinsics
that may be passed as actual arguments, so that
valid programs need not be rejected when `-fno-f2c'
is used.)
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.
-ff2c-library
libg2c (or the original 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.
-fno-underscoring
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.
The `-fno-second-underscore' option disables appending of the
second underscore in all cases.)
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
I = J() + MAX_COUNT (MY_VAR, LVAR) |
is implemented as something akin to:
i = j_() + max_count__(&my_var__, &lvar); |
With `-fno-underscoring', the same statement is implemented as:
i = j() + max_count(&my_var, &lvar); |
Use of `-fno-underscoring' allows direct specification of
user-defined names while debugging and when interfacing 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.
-fno-second-underscore
This option has no effect if `-fno-underscoring' is 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__'.
-fno-ident
-fzeros
As of version 0.5.18, g77 normally treats DATA and
other statements that are used to 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.
-fdebug-kludge
COMMON and EQUIVALENCE members
that might help users of debuggers work around lack of proper debugging
information on such members.
As of version 0.5.19, g77 offers this option to emit
information on members of aggregate areas to help users while debugging.
This information consists of establishing the type and contents of each
such member so that, when a debugger is asked to print the contents,
the printed information provides rudimentary debugging information.
This information identifies the name of the aggregate area (either the
COMMON block name, or the g77-assigned name for the
EQUIVALENCE name) and the offset, in bytes, of the member from
the beginning of the area.
Using gdb, this information is not coherently displayed in the Fortran
language mode, so temporarily switching to the C language mode to display the
information is suggested.
Use `set language c' and `set language fortran' to accomplish this.
As of version 0.5.26 of g77 this option has been disabled, as the
compiler is now able to emit correct and complete debug information
for COMMON BLOCK and EQUIVALENCE items.
For example:
COMMON /X/A,B
EQUIVALENCE (C,D)
CHARACTER XX*50
EQUIVALENCE (I,XX(20:20))
END
GDB is free software and you are welcome to distribute copies of it
under certain conditions; type "show copying" to see the conditions.
There is absolutely no warranty for GDB; type "show warranty" for details.
GDB 4.16 (lm-gnits-dwim), Copyright 1996 Free Software Foundation, Inc...
(gdb) b MAIN__
Breakpoint 1 at 0t1200000201120112: file cd.f, line 5.
(gdb) r
Starting program: /home/user/a.out
Breakpoint 1, MAIN__ () at cd.f:5
Current language: auto; currently fortran
(gdb) set language c
Warning: the current language does not match this frame.
(gdb) p a
$2 = "At (COMMON) `x_' plus 0 bytes"
(gdb) p b
$3 = "At (COMMON) `x_' plus 4 bytes"
(gdb) p c
$4 = "At (EQUIVALENCE) `__g77_equiv_c' plus 0 bytes"
(gdb) p d
$5 = "At (EQUIVALENCE) `__g77_equiv_c' plus 0 bytes"
(gdb) p i
$6 = "At (EQUIVALENCE) `__g77_equiv_xx' plus 20 bytes"
(gdb) p xx
$7 = "At (EQUIVALENCE) `__g77_equiv_xx' plus 1 bytes"
(gdb) set language fortran
(gdb)
|
Use `-fdebug-kludge' to generate this information, which might make some programs noticeably larger.
Caution: Future versions of g77 might disregard this option
(and its negative form).
Current plans call for this to happen when published versions of g77
and gdb exist that provide proper access to debugging information on
COMMON and EQUIVALENCE members. This is believed to have
happened as of version 0.5.26 of g77, so that this option has been
disabled starting with this release.
-femulate-complex
COMPLEX arithmetic via emulation,
instead of using the facilities of
the gcc back end that provide direct support of
complex arithmetic.
(gcc had some bugs in its back-end support
for complex arithmetic, due primarily to the support not being
completed as of version 2.8.1 and egcs 1.1.2.)
Use `-femulate-complex' if you suspect code-generation bugs,
or experience compiler crashes,
that might result from g77 using the COMPLEX support
in the gcc back end.
If using that option fixes the bugs or crashes you are seeing,
that indicates a likely g77 bugs
(though, all compiler crashes are considered bugs),
so, please report it.
(Note that the known bugs, now believed fixed, produced compiler crashes
rather than causing the generation of incorrect code.)
Use of this option should not affect how Fortran code compiled
by g77 works in terms of its interfaces to other code,
e.g. that compiled by f2c.
Caution: Future versions of g77 might ignore both forms
of this option.
-falias-check
-fargument-alias
-fargument-noalias
-fno-argument-noalias-global
g77 based on gcc version 2.8.
These options specify to what degree aliasing
(overlap)
is permitted between
arguments (passed as pointers) and COMMON (external, or
public) storage.
The default for Fortran code, as mandated by the FORTRAN 77 and Fortran 90 standards, is `-fargument-noalias-global'. The default for code written in the C language family is `-fargument-alias'.
Note that, on some systems, compiling with `-fforce-addr' in effect can produce more optimal code when the default aliasing options are in effect (and when optimization is enabled).
See section 15.4.7 Aliasing Assumed To Work, for detailed information on the implications of compiling Fortran code that depends on the ability to alias dummy arguments.
-fno-globals
Further, this option disables such inlining, to avoid compiler crashes resulting from incorrect code that would otherwise be diagnosed.
As such, this option might be quite useful when
compiling existing, "working" code that happens
to have a few bugs that do not generally show themselves,
but which g77 diagnoses.
Use of this option therefore has the effect of
instructing g77 to behave more like it did
up through version 0.5.19.1, when it paid little or
no attention to disagreements between program units
about a procedure's type and argument information,
and when it performed no inlining of procedures
(except statement functions).
Without this option, g77 defaults to performing
the potentially inlining procedures as it started doing
in version 0.5.20, but as of version 0.5.21, it also
diagnoses disagreements that might cause such inlining
to crash the compiler as (fatal) errors,
and warns about similar disagreements
that are currently believed to not
likely to result in the compiler later crashing
or producing incorrect code.
-fflatten-arrays
ARRAY_REF construct
to handle all array references.
Note: This option is not supported.
It is intended for use only by g77 developers,
to evaluate code-generation issues.
It might be removed at any time.
-fbounds-check
-ffortran-bounds-check
The current implementation uses the libf2c
library routine s_rnge to print the diagnostic.
However, whereas f2c generates a single check per
reference for a multi-dimensional array, of the computed
offset against the valid offset range (0 through the size of the array),
g77 generates a single check per subscript expression.
This catches some cases of potential bugs that f2c does not,
such as references to below the beginning of an assumed-size array.
g77 also generates checks for CHARACTER substring references,
something f2c currently does not do.
Use the new `-ffortran-bounds-check' option to specify bounds-checking for only the Fortran code you are compiling, not necessarily for code written in other languages.
Note: To provide more detailed information on the offending subscript,
g77 provides the libg2c run-time library routine s_rnge
with somewhat differently-formatted information.
Here's a sample diagnostic:
Subscript out of range on file line 4, procedure rnge.f/bf. Attempt to access the -6-th element of variable b[subscript-2-of-2]. Aborted |
The above message indicates that the offending source line is line 4 of the file `rnge.f', within the program unit (or statement function) named `bf'. The offended array is named `b'. The offended array dimension is the second for a two-dimensional array, and the offending, computed subscript expression was `-6'.
For a CHARACTER substring reference, the second line has
this appearance:
Attempt to access the 11-th element of variable a[start-substring]. |
This indicates that the offended CHARACTER variable or array
is named `a',
the offended substring position is the starting (leftmost) position,
and the offending substring expression is `11'.
(Though the verbage of s_rnge is not ideal
for the purpose of the g77 compiler,
the above information should provide adequate diagnostic abilities
to it users.)
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:
-fpcc-struct-return
-freg-struct-return
libg2c with which
you will be linking all code compiled by g77 with the
same option.
-fshort-double
-fno-common
-fpack-struct
libg2c library,
at the very least, even if it is built with the same option.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |