.\" Automatically generated by Pod::Man v1.34, Pod::Parser v1.13
.\"
.\" Standard preamble:
.\" ========================================================================
.de Sh \" Subsection heading
.br
.if t .Sp
.ne 5
.PP
\fB\\$1\fR
.PP
..
.de Sp \" Vertical space (when we can't use .PP)
.if t .sp .5v
.if n .sp
..
.de Vb \" Begin verbatim text
.ft CW
.nf
.ne \\$1
..
.de Ve \" End verbatim text
.ft R
.fi
..
.\" Set up some character translations and predefined strings.  \*(-- will
.\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left
.\" double quote, and \*(R" will give a right double quote.  | will give a
.\" real vertical bar.  \*(C+ will give a nicer C++.  Capital omega is used to
.\" do unbreakable dashes and therefore won't be available.  \*(C` and \*(C'
.\" expand to `' in nroff, nothing in troff, for use with C<>.
.tr \(*W-|\(bv\*(Tr
.ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p'
.ie n \{\
.    ds -- \(*W-
.    ds PI pi
.    if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch
.    if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\"  diablo 12 pitch
.    ds L" ""
.    ds R" ""
.    ds C` ""
.    ds C' ""
'br\}
.el\{\
.    ds -- \|\(em\|
.    ds PI \(*p
.    ds L" ``
.    ds R" ''
'br\}
.\"
.\" If the F register is turned on, we'll generate index entries on stderr for
.\" titles (.TH), headers (.SH), subsections (.Sh), items (.Ip), and index
.\" entries marked with X<> in POD.  Of course, you'll have to process the
.\" output yourself in some meaningful fashion.
.if \nF \{\
.    de IX
.    tm Index:\\$1\t\\n%\t"\\$2"
..
.    nr % 0
.    rr F
.\}
.\"
.\" For nroff, turn off justification.  Always turn off hyphenation; it makes
.\" way too many mistakes in technical documents.
.hy 0
.if n .na
.\"
.\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
.\" Fear.  Run.  Save yourself.  No user-serviceable parts.
.    \" fudge factors for nroff and troff
.if n \{\
.    ds #H 0
.    ds #V .8m
.    ds #F .3m
.    ds #[ \f1
.    ds #] \fP
.\}
.if t \{\
.    ds #H ((1u-(\\\\n(.fu%2u))*.13m)
.    ds #V .6m
.    ds #F 0
.    ds #[ \&
.    ds #] \&
.\}
.    \" simple accents for nroff and troff
.if n \{\
.    ds ' \&
.    ds ` \&
.    ds ^ \&
.    ds , \&
.    ds ~ ~
.    ds /
.\}
.if t \{\
.    ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u"
.    ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u'
.    ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u'
.    ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u'
.    ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u'
.    ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u'
.\}
.    \" troff and (daisy-wheel) nroff accents
.ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V'
.ds 8 \h'\*(#H'\(*b\h'-\*(#H'
.ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#]
.ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H'
.ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u'
.ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#]
.ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#]
.ds ae a\h'-(\w'a'u*4/10)'e
.ds Ae A\h'-(\w'A'u*4/10)'E
.    \" corrections for vroff
.if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u'
.if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u'
.    \" for low resolution devices (crt and lpr)
.if \n(.H>23 .if \n(.V>19 \
\{\
.    ds : e
.    ds 8 ss
.    ds o a
.    ds d- d\h'-1'\(ga
.    ds D- D\h'-1'\(hy
.    ds th \o'bp'
.    ds Th \o'LP'
.    ds ae ae
.    ds Ae AE
.\}
.rm #[ #] #H #V #F C
.\" ========================================================================
.\"
.IX Title "G77 1"
.TH G77 1 "2005-05-19" "gcc-3.4.4" "GNU"
.SH "NAME"
g77 \- GNU project Fortran 77 compiler
.SH "SYNOPSIS"
.IX Header "SYNOPSIS"
g77 [\fB\-c\fR|\fB\-S\fR|\fB\-E\fR]
    [\fB\-g\fR] [\fB\-pg\fR] [\fB\-O\fR\fIlevel\fR]
    [\fB\-W\fR\fIwarn\fR...] [\fB\-pedantic\fR]
    [\fB\-I\fR\fIdir\fR...] [\fB\-L\fR\fIdir\fR...]
    [\fB\-D\fR\fImacro\fR[=\fIdefn\fR]...] [\fB\-U\fR\fImacro\fR]
    [\fB\-f\fR\fIoption\fR...] [\fB\-m\fR\fImachine-option\fR...]
    [\fB\-o\fR \fIoutfile\fR] \fIinfile\fR...
.PP
Only the most useful options are listed here; see below for the
remainder.
.SH "DESCRIPTION"
.IX Header "DESCRIPTION"
The \fBg77\fR command supports all the options supported by the
\&\fBgcc\fR command.
.PP
All \fBgcc\fR and \fBg77\fR options
are accepted both by \fBg77\fR and by \fBgcc\fR
(as well as any other drivers built at the same time,
such as \fBg++\fR),
since adding \fBg77\fR to the \fBgcc\fR distribution
enables acceptance of \fBg77\fR options
by all of the relevant drivers.
.PP
In some cases, options have positive and negative forms;
the negative form of \fB\-ffoo\fR would be \fB\-fno\-foo\fR.
This manual documents only one of these two forms, whichever
one is not the default.
.SH "OPTIONS"
.IX Header "OPTIONS"
Here is a summary of all the options specific to \s-1GNU\s0 Fortran, grouped
by type.  Explanations are in the following sections.
.IP "\fIOverall Options\fR" 4
.IX Item "Overall Options"
\&\fB\-fversion  \-fset\-g77\-defaults  \-fno\-silent\fR
.IP "\fIShorthand Options\fR" 4
.IX Item "Shorthand Options"
\&\fB\-ff66  \-fno\-f66  \-ff77  \-fno\-f77  \-fno\-ugly\fR
.IP "\fIFortran Language Options\fR" 4
.IX Item "Fortran Language Options"
\&\fB\-ffree\-form  \-fno\-fixed\-form  \-ff90 
\&\-fvxt  \-fdollar\-ok  \-fno\-backslash 
\&\-fno\-ugly\-args  \-fno\-ugly\-assign  \-fno\-ugly\-assumed 
\&\-fugly\-comma  \-fugly\-complex  \-fugly\-init  \-fugly\-logint 
\&\-fonetrip  \-ftypeless\-boz 
\&\-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 
\&\-ff2c\-intrinsics\-delete  \-ff2c\-intrinsics\-hide 
\&\-ff2c\-intrinsics\-disable  \-ff2c\-intrinsics\-enable 
\&\-fbadu77\-intrinsics\-delete  \-fbadu77\-intrinsics\-hide 
\&\-fbadu77\-intrinsics\-disable  \-fbadu77\-intrinsics\-enable 
\&\-ff90\-intrinsics\-delete  \-ff90\-intrinsics\-hide 
\&\-ff90\-intrinsics\-disable  \-ff90\-intrinsics\-enable 
\&\-fgnu\-intrinsics\-delete  \-fgnu\-intrinsics\-hide 
\&\-fgnu\-intrinsics\-disable  \-fgnu\-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\-\fR\fIn\fR  \fB\-ffixed\-line\-length\-none\fR
.IP "\fIWarning Options\fR" 4
.IX Item "Warning Options"
\&\fB\-fsyntax\-only  \-pedantic  \-pedantic\-errors  \-fpedantic 
\&\-w  \-Wno\-globals  \-Wimplicit  \-Wunused  \-Wuninitialized 
\&\-Wall  \-Wsurprising 
\&\-Werror  \-W\fR
.IP "\fIDebugging Options\fR" 4
.IX Item "Debugging Options"
\&\fB\-g\fR
.IP "\fIOptimization Options\fR" 4
.IX Item "Optimization Options"
\&\fB\-malign\-double 
\&\-ffloat\-store  \-fforce\-mem  \-fforce\-addr  \-fno\-inline 
\&\-ffast\-math  \-fstrength\-reduce  \-frerun\-cse\-after\-loop 
\&\-funsafe\-math\-optimizations \-ffinite\-math\-only \-fno\-trapping\-math 
\&\-fexpensive\-optimizations  \-fdelayed\-branch 
\&\-fschedule\-insns  \-fschedule\-insn2  \-fcaller\-saves 
\&\-funroll\-loops  \-funroll\-all\-loops 
\&\-fno\-move\-all\-movables  \-fno\-reduce\-all\-givs 
\&\-fno\-rerun\-loop\-opt\fR
.IP "\fIDirectory Options\fR" 4
.IX Item "Directory Options"
\&\fB\-I\fR\fIdir\fR  \fB\-I\-\fR
.IP "\fICode Generation Options\fR" 4
.IX Item "Code Generation Options"
\&\fB\-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 
\&\-fzeros  \-fno\-second\-underscore 
\&\-femulate\-complex 
\&\-falias\-check  \-fargument\-alias 
\&\-fargument\-noalias  \-fno\-argument\-noalias\-global 
\&\-fno\-globals  \-fflatten\-arrays 
\&\-fbounds\-check  \-ffortran\-bounds\-check\fR
.PP
Compilation can involve as many as four stages: preprocessing, code
generation (often what is really meant by the term ``compilation''),
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.
.PP
For any given input file, the file name suffix determines what kind of
program is contained in the file\-\-\-that is, the language in which the
program is written is generally indicated by the suffix.
Suffixes specific to \s-1GNU\s0 Fortran are listed below.
.IP "\fIfile\fR\fB.f\fR" 4
.IX Item "file.f"
.PD 0
.IP "\fIfile\fR\fB.for\fR" 4
.IX Item "file.for"
.IP "\fIfile\fR\fB.FOR\fR" 4
.IX Item "file.FOR"
.PD
Fortran source code that should not be preprocessed.
.Sp
Such source code cannot contain any preprocessor directives, such
as \f(CW\*(C`#include\*(C'\fR, \f(CW\*(C`#define\*(C'\fR, \f(CW\*(C`#if\*(C'\fR, and so on.
.Sp
You can force \fB.f\fR files to be preprocessed by \fBcpp\fR by using
\&\fB\-x f77\-cpp\-input\fR.
.IP "\fIfile\fR\fB.F\fR" 4
.IX Item "file.F"
.PD 0
.IP "\fIfile\fR\fB.fpp\fR" 4
.IX Item "file.fpp"
.IP "\fIfile\fR\fB.FPP\fR" 4
.IX Item "file.FPP"
.PD
Fortran source code that must be preprocessed (by the C preprocessor
\&\fBcpp\fR, which is part of \s-1GCC\s0).
.Sp
Note that preprocessing is not extended to the contents of
files included by the \f(CW\*(C`INCLUDE\*(C'\fR directive\-\-\-the \f(CW\*(C`#include\*(C'\fR
preprocessor directive must be used instead.
.IP "\fIfile\fR\fB.r\fR" 4
.IX Item "file.r"
Ratfor source code, which must be preprocessed by the \fBratfor\fR
command, which is available separately (as it is not yet part of the \s-1GNU\s0
Fortran distribution).
A public domain version in C is at
<\fBhttp://sepwww.stanford.edu/sep/prof/ratfor.shar.2\fR>.
.PP
\&\s-1UNIX\s0 users typically use the \fI\fIfile\fI.f\fR and \fI\fIfile\fI.F\fR
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 \fI\fIfile\fI.for\fR and \fI\fIfile\fI.fpp\fR nomenclature.
.PP
Use of the preprocessor \fBcpp\fR allows use of C\-like
constructs such as \f(CW\*(C`#define\*(C'\fR and \f(CW\*(C`#include\*(C'\fR, 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 \f(CW\*(C`#include\*(C'\fR and, in
conjunction with \f(CW\*(C`#define\*(C'\fR, only \f(CW\*(C`#if\*(C'\fR 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
constructs such as Hollerith and character constants can nevertheless
present problems, especially when these are continued across multiple
source lines.
These problems result, primarily, from differences between the way
such constants are interpreted by the C preprocessor and by a Fortran
compiler.
.PP
Another example of a problem that results from using the C preprocessor
is that a Fortran comment line that happens to contain any
characters ``interesting'' to the C preprocessor,
such as a backslash at the end of the line,
is not recognized by the preprocessor as a comment line,
so instead of being passed through ``raw'',
the line is edited according to the rules for the preprocessor.
For example, the backslash at the end of the line is removed,
along with the subsequent newline, resulting in the next
line being effectively commented out\-\-\-unfortunate if that
line is a non-comment line of important code!
.PP
\&\fINote:\fR The \fB\-traditional\fR and \fB\-undef\fR flags are supplied
to \fBcpp\fR by default, to help avoid unpleasant surprises.
.PP
This means that \s-1ANSI\s0 C preprocessor features (such as the \fB#\fR
operator) aren't available, and only variables in the C reserved
namespace (generally, names with a leading underscore) are liable to
substitution by C predefines.
Thus, if you want to do system-specific
tests, use, for example, \fB#ifdef _\|_linux_\|_\fR rather than \fB#ifdef linux\fR.
Use the \fB\-v\fR option to see exactly how the preprocessor is invoked.
.PP
Unfortunately, the \fB\-traditional\fR flag will not avoid an error from
anything that \fBcpp\fR sees as an unterminated C comment, such as:
.PP
.Vb 2
\&        C Some Fortran compilers accept /* as starting
\&        C an inline comment.
.Ve
.PP
The following options that affect overall processing are recognized
by the \fBg77\fR and \fBgcc\fR commands in a \s-1GNU\s0 Fortran installation:
.IP "\fB\-fversion\fR" 4
.IX Item "-fversion"
Ensure that the \fBg77\fR version of the compiler phase is reported,
if run,
and, starting in \f(CW\*(C`egcs\*(C'\fR version 1.1,
that internal consistency checks in the \fIf771\fR program are run.
.Sp
This option is supplied automatically when \fB\-v\fR or \fB\-\-verbose\fR
is specified as a command-line option for \fBg77\fR or \fBgcc\fR
and when the resulting commands compile Fortran source files.
.Sp
In \s-1GCC\s0 3.1, this is changed back to the behavior \fBgcc\fR displays
for \fB.c\fR files.
.IP "\fB\-fset\-g77\-defaults\fR" 4
.IX Item "-fset-g77-defaults"
\&\fIVersion info:\fR
This option was obsolete as of \f(CW\*(C`egcs\*(C'\fR
version 1.1.
The effect is instead achieved
by the \f(CW\*(C`lang_init_options\*(C'\fR routine
in \fIgcc/gcc/f/com.c\fR.
.Sp
Set up whatever \fBgcc\fR options are to apply to Fortran
compilations, and avoid running internal consistency checks
that might take some time.
.Sp
This option is supplied automatically when compiling Fortran code
via the \fBg77\fR or \fBgcc\fR command.
The description of this option is provided so that users seeing
it in the output of, say, \fBg77 \-v\fR understand why it is
there.
.Sp
Also, developers who run \f(CW\*(C`f771\*(C'\fR directly might want to specify it
by hand to get the same defaults as they would running \f(CW\*(C`f771\*(C'\fR
via \fBg77\fR or \fBgcc\fR
However, such developers should, after linking a new \f(CW\*(C`f771\*(C'\fR
executable, invoke it without this option once,
e.g. via \f(CW\*(C`./f771 \-quiet < /dev/null\*(C'\fR,
to ensure that they have not introduced any
internal inconsistencies (such as in the table of
intrinsics) before proceeding\-\-\-\fBg77\fR will crash
with a diagnostic if it detects an inconsistency.
.IP "\fB\-fno\-silent\fR" 4
.IX Item "-fno-silent"
Print (to \f(CW\*(C`stderr\*(C'\fR) the names of the program units as
they are compiled, in a form similar to that used by popular
\&\s-1UNIX\s0 \fBf77\fR implementations and \fBf2c\fR
.Sh "Shorthand Options"
.IX Subsection "Shorthand Options"
The following options serve as ``shorthand''
for other options accepted by the compiler:
.IP "\fB\-fugly\fR" 4
.IX Item "-fugly"
\&\fINote:\fR This option is no longer supported.
The information, below, is provided to aid
in the conversion of old scripts.
.Sp
Specify that certain ``ugly'' constructs are to be quietly accepted.
Same as:
.Sp
.Vb 3
\&        -fugly-args -fugly-assign -fugly-assumed
\&        -fugly-comma -fugly-complex -fugly-init
\&        -fugly-logint
.Ve
.Sp
These constructs are considered inappropriate to use in new
or well-maintained portable Fortran code, but widely used
in old code.
.IP "\fB\-fno\-ugly\fR" 4
.IX Item "-fno-ugly"
Specify that all ``ugly'' constructs are to be noisily rejected.
Same as:
.Sp
.Vb 3
\&        -fno-ugly-args -fno-ugly-assign -fno-ugly-assumed
\&        -fno-ugly-comma -fno-ugly-complex -fno-ugly-init
\&        -fno-ugly-logint
.Ve
.IP "\fB\-ff66\fR" 4
.IX Item "-ff66"
Specify that the program is written in idiomatic \s-1FORTRAN\s0 66.
Same as \fB\-fonetrip \-fugly\-assumed\fR.
.Sp
The \fB\-fno\-f66\fR option is the inverse of \fB\-ff66\fR.
As such, it is the same as \fB\-fno\-onetrip \-fno\-ugly\-assumed\fR.
.Sp
The meaning of this option is likely to be refined as future
versions of \fBg77\fR provide more compatibility with other
existing and obsolete Fortran implementations.
.IP "\fB\-ff77\fR" 4
.IX Item "-ff77"
Specify that the program is written in idiomatic \s-1UNIX\s0 \s-1FORTRAN\s0 77
and/or the dialect accepted by the \fBf2c\fR product.
Same as \fB\-fbackslash \-fno\-typeless\-boz\fR.
.Sp
The meaning of this option is likely to be refined as future
versions of \fBg77\fR provide more compatibility with other
existing and obsolete Fortran implementations.
.IP "\fB\-fno\-f77\fR" 4
.IX Item "-fno-f77"
The \fB\-fno\-f77\fR option is \fInot\fR the inverse
of \fB\-ff77\fR.
It specifies that the program is not written in idiomatic \s-1UNIX\s0
\&\s-1FORTRAN\s0 77 or \fBf2c\fR but in a more widely portable dialect.
\&\fB\-fno\-f77\fR is the same as \fB\-fno\-backslash\fR.
.Sp
The meaning of this option is likely to be refined as future
versions of \fBg77\fR provide more compatibility with other
existing and obsolete Fortran implementations.
.Sh "Options Controlling Fortran Dialect"
.IX Subsection "Options Controlling Fortran Dialect"
The following options control the dialect of Fortran
that the compiler accepts:
.IP "\fB\-ffree\-form\fR" 4
.IX Item "-ffree-form"
.PD 0
.IP "\fB\-fno\-fixed\-form\fR" 4
.IX Item "-fno-fixed-form"
.PD
Specify that the source file is written in free form
(introduced in Fortran 90) instead of the more-traditional fixed form.
.IP "\fB\-ff90\fR" 4
.IX Item "-ff90"
Allow certain Fortran\-90 constructs.
.Sp
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
\&\fB\-fvxt\fR, \fB\-ff90\-intrinsics\-enable\fR, and the
current level of support for Fortran 90.)
.IP "\fB\-fvxt\fR" 4
.IX Item "-fvxt"
Specify the treatment of certain constructs that have different
meanings depending on whether the code is written in
\&\s-1GNU\s0 Fortran (based on \s-1FORTRAN\s0 77 and akin to Fortran 90)
or \s-1VXT\s0 Fortran (more like \s-1VAX\s0 \s-1FORTRAN\s0).
.Sp
The default is \fB\-fno\-vxt\fR.
\&\fB\-fvxt\fR specifies that the \s-1VXT\s0 Fortran interpretations
for those constructs are to be chosen.
.IP "\fB\-fdollar\-ok\fR" 4
.IX Item "-fdollar-ok"
Allow \fB$\fR as a valid character in a symbol name.
.IP "\fB\-fno\-backslash\fR" 4
.IX Item "-fno-backslash"
Specify that \fB\e\fR is not to be specially interpreted in character
and Hollerith constants a la C and many \s-1UNIX\s0 Fortran compilers.
.Sp
For example, with \fB\-fbackslash\fR in effect, \fBA\enB\fR specifies
three characters, with the second one being newline.
With \fB\-fno\-backslash\fR, it specifies four characters,
\&\fBA\fR, \fB\e\fR, \fBn\fR, and \fBB\fR.
.Sp
Note that \fBg77\fR implements a fairly general form of backslash
processing that is incompatible with the narrower forms supported
by some other compilers.
For example, \fB'A\e003B'\fR is a three-character string in \fBg77\fR
whereas other compilers that support backslash might not support
the three-octal-digit form, and thus treat that string as longer
than three characters.
.IP "\fB\-fno\-ugly\-args\fR" 4
.IX Item "-fno-ugly-args"
Disallow passing Hollerith and typeless constants as actual
arguments (for example, \fB\s-1CALL\s0 \s-1FOO\s0(4HABCD)\fR).
.IP "\fB\-fugly\-assign\fR" 4
.IX Item "-fugly-assign"
Use the same storage for a given variable regardless of
whether it is used to hold an assigned-statement label
(as in \fB\s-1ASSIGN\s0 10 \s-1TO\s0 I\fR) or used to hold numeric data
(as in \fBI = 3\fR).
.IP "\fB\-fugly\-assumed\fR" 4
.IX Item "-fugly-assumed"
Assume any dummy array with a final dimension specified as \fB1\fR
is really an assumed-size array, as if \fB*\fR had been specified
for the final dimension instead of \fB1\fR.
.Sp
For example, \fB\s-1DIMENSION\s0 X(1)\fR is treated as if it
had read \fB\s-1DIMENSION\s0 X(*)\fR.
.IP "\fB\-fugly\-comma\fR" 4
.IX Item "-fugly-comma"
In an external-procedure invocation,
treat a trailing comma in the argument list
as specification of a trailing null argument,
and treat an empty argument list
as specification of a single null argument.
.Sp
For example, \fB\s-1CALL\s0 \s-1FOO\s0(,)\fR is treated as
\&\fB\s-1CALL\s0 \s-1FOO\s0(%\f(BIVAL\fB\|(0), %\f(BIVAL\fB\|(0))\fR.
That is, \fItwo\fR null arguments are specified
by the procedure call when \fB\-fugly\-comma\fR is in force.
And \fBF = \s-1\f(BIFUNC\s0()\fB\fR is treated as \fBF = \s-1FUNC\s0(%\f(BIVAL\fB\|(0))\fR.
.Sp
The default behavior, \fB\-fno\-ugly\-comma\fR, is to ignore
a single trailing comma in an argument list.
So, by default, \fB\s-1CALL\s0 \s-1FOO\s0(X,)\fR is treated
exactly the same as \fB\s-1CALL\s0 \s-1FOO\s0(X)\fR.
.IP "\fB\-fugly\-complex\fR" 4
.IX Item "-fugly-complex"
Do not complain about \fB\s-1REAL\s0(\fR\fIexpr\fR\fB)\fR or
\&\fB\s-1AIMAG\s0(\fR\fIexpr\fR\fB)\fR when \fIexpr\fR is a \f(CW\*(C`COMPLEX\*(C'\fR
type other than \f(CW\*(C`COMPLEX(KIND=1)\*(C'\fR\-\-\-usually
this is used to permit \f(CW\*(C`COMPLEX(KIND=2)\*(C'\fR
(\f(CW\*(C`DOUBLE COMPLEX\*(C'\fR) operands.
.Sp
The \fB\-ff90\fR option controls the interpretation
of this construct.
.IP "\fB\-fno\-ugly\-init\fR" 4
.IX Item "-fno-ugly-init"
Disallow use of Hollerith and typeless constants as initial
values (in \f(CW\*(C`PARAMETER\*(C'\fR and \f(CW\*(C`DATA\*(C'\fR statements), and
use of character constants to
initialize numeric types and vice versa.
.Sp
For example, \fB\s-1DATA\s0 I/'F'/, \s-1CHRVAR/65/\s0, J/4HABCD/\fR is disallowed by
\&\fB\-fno\-ugly\-init\fR.
.IP "\fB\-fugly\-logint\fR" 4
.IX Item "-fugly-logint"
Treat \f(CW\*(C`INTEGER\*(C'\fR and \f(CW\*(C`LOGICAL\*(C'\fR variables and
expressions as potential stand-ins for each other.
.Sp
For example, automatic conversion between \f(CW\*(C`INTEGER\*(C'\fR and
\&\f(CW\*(C`LOGICAL\*(C'\fR is enabled, for many contexts, via this option.
.IP "\fB\-fonetrip\fR" 4
.IX Item "-fonetrip"
Executable iterative \f(CW\*(C`DO\*(C'\fR loops are to be executed at
least once each time they are reached.
.Sp
\&\s-1ANSI\s0 \s-1FORTRAN\s0 77 and more recent versions of the Fortran standard
specify that the body of an iterative \f(CW\*(C`DO\*(C'\fR loop is not executed
if the number of iterations calculated from the parameters of the
loop is less than 1.
(For example, \fB\s-1DO\s0 10 I = 1, 0\fR.)
Such a loop is called a \fIzero-trip loop\fR.
.Sp
Prior to \s-1ANSI\s0 \s-1FORTRAN\s0 77, many compilers implemented \f(CW\*(C`DO\*(C'\fR loops
such that the body of a loop would be executed at least once, even
if the iteration count was zero.
Fortran code written assuming this behavior is said to require
\&\fIone-trip loops\fR.
For example, some code written to the \s-1FORTRAN\s0 66 standard
expects this behavior from its \f(CW\*(C`DO\*(C'\fR loops, although that
standard did not specify this behavior.
.Sp
The \fB\-fonetrip\fR option specifies that the source file(s) being
compiled require one-trip loops.
.Sp
This option affects only those loops specified by the (iterative) \f(CW\*(C`DO\*(C'\fR
statement and by implied\-\f(CW\*(C`DO\*(C'\fR lists in I/O statements.
Loops specified by implied\-\f(CW\*(C`DO\*(C'\fR lists in \f(CW\*(C`DATA\*(C'\fR and
specification (non\-executable) statements are not affected.
.IP "\fB\-ftypeless\-boz\fR" 4
.IX Item "-ftypeless-boz"
Specifies that prefix-radix non-decimal constants, such as
\&\fBZ'\s-1ABCD\s0'\fR, are typeless instead of \f(CW\*(C`INTEGER(KIND=1)\*(C'\fR.
.Sp
You can test for yourself whether a particular compiler treats
the prefix form as \f(CW\*(C`INTEGER(KIND=1)\*(C'\fR or typeless by running the
following program:
.Sp
.Vb 6
\&        EQUIVALENCE (I, R)
\&        R = Z'ABCD1234'
\&        J = Z'ABCD1234'
\&        IF (J .EQ. I) PRINT *, 'Prefix form is TYPELESS'
\&        IF (J .NE. I) PRINT *, 'Prefix form is INTEGER'
\&        END
.Ve
.Sp
Reports indicate that many compilers process this form as
\&\f(CW\*(C`INTEGER(KIND=1)\*(C'\fR, though a few as typeless, and at least one
based on a command-line option specifying some kind of
compatibility.
.IP "\fB\-fintrin\-case\-initcap\fR" 4
.IX Item "-fintrin-case-initcap"
.PD 0
.IP "\fB\-fintrin\-case\-upper\fR" 4
.IX Item "-fintrin-case-upper"
.IP "\fB\-fintrin\-case\-lower\fR" 4
.IX Item "-fintrin-case-lower"
.IP "\fB\-fintrin\-case\-any\fR" 4
.IX Item "-fintrin-case-any"
.PD
Specify expected case for intrinsic names.
\&\fB\-fintrin\-case\-lower\fR is the default.
.IP "\fB\-fmatch\-case\-initcap\fR" 4
.IX Item "-fmatch-case-initcap"
.PD 0
.IP "\fB\-fmatch\-case\-upper\fR" 4
.IX Item "-fmatch-case-upper"
.IP "\fB\-fmatch\-case\-lower\fR" 4
.IX Item "-fmatch-case-lower"
.IP "\fB\-fmatch\-case\-any\fR" 4
.IX Item "-fmatch-case-any"
.PD
Specify expected case for keywords.
\&\fB\-fmatch\-case\-lower\fR is the default.
.IP "\fB\-fsource\-case\-upper\fR" 4
.IX Item "-fsource-case-upper"
.PD 0
.IP "\fB\-fsource\-case\-lower\fR" 4
.IX Item "-fsource-case-lower"
.IP "\fB\-fsource\-case\-preserve\fR" 4
.IX Item "-fsource-case-preserve"
.PD
Specify whether source text other than character and Hollerith constants
is to be translated to uppercase, to lowercase, or preserved as is.
\&\fB\-fsource\-case\-lower\fR is the default.
.IP "\fB\-fsymbol\-case\-initcap\fR" 4
.IX Item "-fsymbol-case-initcap"
.PD 0
.IP "\fB\-fsymbol\-case\-upper\fR" 4
.IX Item "-fsymbol-case-upper"
.IP "\fB\-fsymbol\-case\-lower\fR" 4
.IX Item "-fsymbol-case-lower"
.IP "\fB\-fsymbol\-case\-any\fR" 4
.IX Item "-fsymbol-case-any"
.PD
Specify valid cases for user-defined symbol names.
\&\fB\-fsymbol\-case\-any\fR is the default.
.IP "\fB\-fcase\-strict\-upper\fR" 4
.IX Item "-fcase-strict-upper"
Same as \fB\-fintrin\-case\-upper \-fmatch\-case\-upper \-fsource\-case\-preserve
\&\-fsymbol\-case\-upper\fR.
(Requires all pertinent source to be in uppercase.)
.IP "\fB\-fcase\-strict\-lower\fR" 4
.IX Item "-fcase-strict-lower"
Same as \fB\-fintrin\-case\-lower \-fmatch\-case\-lower \-fsource\-case\-preserve
\&\-fsymbol\-case\-lower\fR.
(Requires all pertinent source to be in lowercase.)
.IP "\fB\-fcase\-initcap\fR" 4
.IX Item "-fcase-initcap"
Same as \fB\-fintrin\-case\-initcap \-fmatch\-case\-initcap \-fsource\-case\-preserve
\&\-fsymbol\-case\-initcap\fR.
(Requires all pertinent source to be in initial capitals,
as in \fBPrint *,SqRt(Value)\fR.)
.IP "\fB\-fcase\-upper\fR" 4
.IX Item "-fcase-upper"
Same as \fB\-fintrin\-case\-any \-fmatch\-case\-any \-fsource\-case\-upper
\&\-fsymbol\-case\-any\fR.
(Maps all pertinent source to uppercase.)
.IP "\fB\-fcase\-lower\fR" 4
.IX Item "-fcase-lower"
Same as \fB\-fintrin\-case\-any \-fmatch\-case\-any \-fsource\-case\-lower
\&\-fsymbol\-case\-any\fR.
(Maps all pertinent source to lowercase.)
.IP "\fB\-fcase\-preserve\fR" 4
.IX Item "-fcase-preserve"
Same as \fB\-fintrin\-case\-any \-fmatch\-case\-any \-fsource\-case\-preserve
\&\-fsymbol\-case\-any\fR.
(Preserves all case in user-defined symbols,
while allowing any-case matching of intrinsics and keywords.
For example, \fBcall Foo(i,I)\fR would pass two \fIdifferent\fR
variables named \fBi\fR and \fBI\fR to a procedure named \fBFoo\fR.)
.IP "\fB\-fbadu77\-intrinsics\-delete\fR" 4
.IX Item "-fbadu77-intrinsics-delete"
.PD 0
.IP "\fB\-fbadu77\-intrinsics\-hide\fR" 4
.IX Item "-fbadu77-intrinsics-hide"
.IP "\fB\-fbadu77\-intrinsics\-disable\fR" 4
.IX Item "-fbadu77-intrinsics-disable"
.IP "\fB\-fbadu77\-intrinsics\-enable\fR" 4
.IX Item "-fbadu77-intrinsics-enable"
.PD
Specify status of \s-1UNIX\s0 intrinsics having inappropriate forms.
\&\fB\-fbadu77\-intrinsics\-enable\fR is the default.
.IP "\fB\-ff2c\-intrinsics\-delete\fR" 4
.IX Item "-ff2c-intrinsics-delete"
.PD 0
.IP "\fB\-ff2c\-intrinsics\-hide\fR" 4
.IX Item "-ff2c-intrinsics-hide"
.IP "\fB\-ff2c\-intrinsics\-disable\fR" 4
.IX Item "-ff2c-intrinsics-disable"
.IP "\fB\-ff2c\-intrinsics\-enable\fR" 4
.IX Item "-ff2c-intrinsics-enable"
.PD
Specify status of f2c\-specific intrinsics.
\&\fB\-ff2c\-intrinsics\-enable\fR is the default.
.IP "\fB\-ff90\-intrinsics\-delete\fR" 4
.IX Item "-ff90-intrinsics-delete"
.PD 0
.IP "\fB\-ff90\-intrinsics\-hide\fR" 4
.IX Item "-ff90-intrinsics-hide"
.IP "\fB\-ff90\-intrinsics\-disable\fR" 4
.IX Item "-ff90-intrinsics-disable"
.IP "\fB\-ff90\-intrinsics\-enable\fR" 4
.IX Item "-ff90-intrinsics-enable"
.PD
Specify status of F90\-specific intrinsics.
\&\fB\-ff90\-intrinsics\-enable\fR is the default.
.IP "\fB\-fgnu\-intrinsics\-delete\fR" 4
.IX Item "-fgnu-intrinsics-delete"
.PD 0
.IP "\fB\-fgnu\-intrinsics\-hide\fR" 4
.IX Item "-fgnu-intrinsics-hide"
.IP "\fB\-fgnu\-intrinsics\-disable\fR" 4
.IX Item "-fgnu-intrinsics-disable"
.IP "\fB\-fgnu\-intrinsics\-enable\fR" 4
.IX Item "-fgnu-intrinsics-enable"
.PD
Specify status of Digital's COMPLEX-related intrinsics.
\&\fB\-fgnu\-intrinsics\-enable\fR is the default.
.IP "\fB\-fmil\-intrinsics\-delete\fR" 4
.IX Item "-fmil-intrinsics-delete"
.PD 0
.IP "\fB\-fmil\-intrinsics\-hide\fR" 4
.IX Item "-fmil-intrinsics-hide"
.IP "\fB\-fmil\-intrinsics\-disable\fR" 4
.IX Item "-fmil-intrinsics-disable"
.IP "\fB\-fmil\-intrinsics\-enable\fR" 4
.IX Item "-fmil-intrinsics-enable"
.PD
Specify status of MIL\-STD\-1753\-specific intrinsics.
\&\fB\-fmil\-intrinsics\-enable\fR is the default.
.IP "\fB\-funix\-intrinsics\-delete\fR" 4
.IX Item "-funix-intrinsics-delete"
.PD 0
.IP "\fB\-funix\-intrinsics\-hide\fR" 4
.IX Item "-funix-intrinsics-hide"
.IP "\fB\-funix\-intrinsics\-disable\fR" 4
.IX Item "-funix-intrinsics-disable"
.IP "\fB\-funix\-intrinsics\-enable\fR" 4
.IX Item "-funix-intrinsics-enable"
.PD
Specify status of \s-1UNIX\s0 intrinsics.
\&\fB\-funix\-intrinsics\-enable\fR is the default.
.IP "\fB\-fvxt\-intrinsics\-delete\fR" 4
.IX Item "-fvxt-intrinsics-delete"
.PD 0
.IP "\fB\-fvxt\-intrinsics\-hide\fR" 4
.IX Item "-fvxt-intrinsics-hide"
.IP "\fB\-fvxt\-intrinsics\-disable\fR" 4
.IX Item "-fvxt-intrinsics-disable"
.IP "\fB\-fvxt\-intrinsics\-enable\fR" 4
.IX Item "-fvxt-intrinsics-enable"
.PD
Specify status of \s-1VXT\s0 intrinsics.
\&\fB\-fvxt\-intrinsics\-enable\fR is the default.
.IP "\fB\-ffixed\-line\-length\-\fR\fIn\fR" 4
.IX Item "-ffixed-line-length-n"
Set column after which characters are ignored in typical fixed-form
lines in the source file, and through which spaces are assumed (as
if padded to that length) after the ends of short fixed-form lines.
.Sp
Popular values for \fIn\fR include 72 (the
standard and the default), 80 (card image), and 132 (corresponds
to ``extended\-source'' options in some popular compilers).
\&\fIn\fR may be \fBnone\fR, meaning that the entire line is meaningful
and that continued character constants never have implicit spaces appended
to them to fill out the line.
\&\fB\-ffixed\-line\-length\-0\fR means the same thing as
\&\fB\-ffixed\-line\-length\-none\fR.
.Sh "Options to Request or Suppress Warnings"
.IX Subsection "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.
.PP
You can request many specific warnings with options beginning \fB\-W\fR,
for example \fB\-Wimplicit\fR to request warnings on implicit
declarations.  Each of these specific warning options also has a
negative form beginning \fB\-Wno\-\fR to turn off warnings;
for example, \fB\-Wno\-implicit\fR.  This manual lists only one of the
two forms, whichever is not the default.
.PP
These options control the amount and kinds of warnings produced by \s-1GNU\s0
Fortran:
.IP "\fB\-fsyntax\-only\fR" 4
.IX Item "-fsyntax-only"
Check the code for syntax errors, but don't do anything beyond that.
.IP "\fB\-pedantic\fR" 4
.IX Item "-pedantic"
Issue warnings for uses of extensions to \s-1ANSI\s0 \s-1FORTRAN\s0 77.
\&\fB\-pedantic\fR also applies to C\-language constructs where they
occur in \s-1GNU\s0 Fortran source files, such as use of \fB\ee\fR in a
character constant within a directive like \fB#include\fR.
.Sp
Valid \s-1ANSI\s0 \s-1FORTRAN\s0 77 programs should compile properly with or without
this option.
However, without this option, certain \s-1GNU\s0 extensions and traditional
Fortran features are supported as well.
With this option, many of them are rejected.
.Sp
Some users try to use \fB\-pedantic\fR to check programs for strict \s-1ANSI\s0
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 \fBg77\fR in this area are welcome.
.IP "\fB\-pedantic\-errors\fR" 4
.IX Item "-pedantic-errors"
Like \fB\-pedantic\fR, except that errors are produced rather than
warnings.
.IP "\fB\-fpedantic\fR" 4
.IX Item "-fpedantic"
Like \fB\-pedantic\fR, but applies only to Fortran constructs.
.IP "\fB\-w\fR" 4
.IX Item "-w"
Inhibit all warning messages.
.IP "\fB\-Wno\-globals\fR" 4
.IX Item "-Wno-globals"
Inhibit warnings about use of a name as both a global name
(a subroutine, function, or block data program unit, or a
common block) and implicitly as the name of an intrinsic
in a source file.
.Sp
Also inhibit warnings about inconsistent invocations and/or
definitions of global procedures (function and subroutines).
Such inconsistencies include different numbers of arguments
and different types of arguments.
.IP "\fB\-Wimplicit\fR" 4
.IX Item "-Wimplicit"
Warn whenever a variable, array, or function is implicitly
declared.
Has an effect similar to using the \f(CW\*(C`IMPLICIT NONE\*(C'\fR statement
in every program unit.
(Some Fortran compilers provide this feature by an option
named \fB\-u\fR or \fB/WARNINGS=DECLARATIONS\fR.)
.IP "\fB\-Wunused\fR" 4
.IX Item "-Wunused"
Warn whenever a variable is unused aside from its declaration.
.IP "\fB\-Wuninitialized\fR" 4
.IX Item "-Wuninitialized"
Warn whenever an automatic variable is used without first being initialized.
.Sp
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 \fB\-O\fR, you simply won't
get these warnings.
.Sp
These warnings occur only for variables that are candidates for
register allocation.  Therefore, they do not occur for a variable
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.
.Sp
Note that there might 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.
.Sp
These warnings are made optional because \s-1GNU\s0 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:
.Sp
.Vb 6
\&        SUBROUTINE DISPAT(J)
\&        IF (J.EQ.1) I=1
\&        IF (J.EQ.2) I=4
\&        IF (J.EQ.3) I=5
\&        CALL FOO(I)
\&        END
.Ve
.Sp
If the value of \f(CW\*(C`J\*(C'\fR is always 1, 2 or 3, then \f(CW\*(C`I\*(C'\fR is
always initialized, but \s-1GNU\s0 Fortran doesn't know this.  Here is
another common case:
.Sp
.Vb 6
\&        SUBROUTINE MAYBE(FLAG)
\&        LOGICAL FLAG
\&        IF (FLAG) VALUE = 9.4
\&        ...
\&        IF (FLAG) PRINT *, VALUE
\&        END
.Ve
.Sp
This has no bug because \f(CW\*(C`VALUE\*(C'\fR is used only if it is set.
.IP "\fB\-Wall\fR" 4
.IX Item "-Wall"
The \fB\-Wunused\fR and \fB\-Wuninitialized\fR 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 \fBg77\fR some might
be added to the list enabled by \fB\-Wall\fR.)
.PP
The remaining \fB\-W...\fR options are not implied by \fB\-Wall\fR
because they warn about constructions that we consider reasonable to
use, on occasion, in clean programs.
.IP "\fB\-Wsurprising\fR" 4
.IX Item "-Wsurprising"
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:
.RS 4
.IP "\(bu" 4
Expressions having two arithmetic operators in a row, such
as \fBX*\-Y\fR.
Such a construct is nonstandard, and can produce
unexpected results in more complicated situations such
as \fBX**\-Y*Z\fR.
\&\fBg77\fR along with many other compilers, interprets
this example differently than many programmers, and a few
other compilers.
Specifically, \fBg77\fR interprets \fBX**\-Y*Z\fR as
\&\fB(X**(\-Y))*Z\fR, while others might think it should
be interpreted as \fBX**(\-(Y*Z))\fR.
.Sp
A revealing example is the constant expression \fB2**\-2*1.\fR,
which \fBg77\fR evaluates to .25, while others might evaluate
it to 0., the difference resulting from the way precedence affects
type promotion.
.Sp
(The \fB\-fpedantic\fR option also warns about expressions
having two arithmetic operators in a row.)
.IP "\(bu" 4
Expressions with a unary minus followed by an operand and then
a binary operator other than plus or minus.
For example, \fB\-2**2\fR produces a warning, because
the precedence is \fB\-(2**2)\fR, yielding \-4, not
\&\fB(\-2)**2\fR, which yields 4, and which might represent
what a programmer expects.
.Sp
An example of an expression producing different results
in a surprising way is \fB\-I*S\fR, where \fII\fR holds
the value \fB\-2147483648\fR and \fIS\fR holds \fB0.5\fR.
On many systems, negating \fII\fR results in the same
value, not a positive number, because it is already the
lower bound of what an \f(CW\*(C`INTEGER(KIND=1)\*(C'\fR variable can hold.
So, the expression evaluates to a positive number, while
the ``expected'' interpretation, \fB(\-I)*S\fR, would
evaluate to a negative number.
.Sp
Even cases such as \fB\-I*J\fR produce warnings,
even though, in most configurations and situations,
there is no computational difference between the
results of the two interpretations\-\-\-the purpose
of this warning is to warn about differing interpretations
and encourage a better style of coding, not to identify
only those places where bugs might exist in the user's
code.
.IP "\(bu" 4
\&\f(CW\*(C`DO\*(C'\fR loops with \f(CW\*(C`DO\*(C'\fR variables that are not
of integral type\-\-\-that is, using \f(CW\*(C`REAL\*(C'\fR
variables as loop control variables.
Although such loops can be written to work in the
``obvious'' way, the way \fBg77\fR is required by the
Fortran standard to interpret such code is likely to
be quite different from the way many programmers expect.
(This is true of all \f(CW\*(C`DO\*(C'\fR loops, but the differences
are pronounced for non-integral loop control variables.)
.RE
.RS 4
.RE
.IP "\fB\-Werror\fR" 4
.IX Item "-Werror"
Make all warnings into errors.
.IP "\fB\-W\fR" 4
.IX Item "-W"
Turns on ``extra warnings'' and, if optimization is specified
via \fB\-O\fR, the \fB\-Wuninitialized\fR option.
(This might change in future versions of \fBg77\fR
.Sp
``Extra warnings'' are issued for:
.RS 4
.IP "\(bu" 4
Unused parameters to a procedure (when \fB\-Wunused\fR also is
specified).
.IP "\(bu" 4
Overflows involving floating-point constants (not available
for certain configurations).
.RE
.RS 4
.RE
.PP
Some of these have no effect when compiling programs written in Fortran:
.IP "\fB\-Wcomment\fR" 4
.IX Item "-Wcomment"
.PD 0
.IP "\fB\-Wformat\fR" 4
.IX Item "-Wformat"
.IP "\fB\-Wparentheses\fR" 4
.IX Item "-Wparentheses"
.IP "\fB\-Wswitch\fR" 4
.IX Item "-Wswitch"
.IP "\fB\-Wswitch\-default\fR" 4
.IX Item "-Wswitch-default"
.IP "\fB\-Wswitch\-enum\fR" 4
.IX Item "-Wswitch-enum"
.IP "\fB\-Wtraditional\fR" 4
.IX Item "-Wtraditional"
.IP "\fB\-Wshadow\fR" 4
.IX Item "-Wshadow"
.IP "\fB\-Wid\-clash\-\fR\fIlen\fR" 4
.IX Item "-Wid-clash-len"
.IP "\fB\-Wlarger\-than\-\fR\fIlen\fR" 4
.IX Item "-Wlarger-than-len"
.IP "\fB\-Wconversion\fR" 4
.IX Item "-Wconversion"
.IP "\fB\-Waggregate\-return\fR" 4
.IX Item "-Waggregate-return"
.IP "\fB\-Wredundant\-decls\fR" 4
.IX Item "-Wredundant-decls"
.PD
These options all could have some relevant meaning for
\&\s-1GNU\s0 Fortran programs, but are not yet supported.
.Sh "Options for Debugging Your Program or \s-1GNU\s0 Fortran"
.IX Subsection "Options for Debugging Your Program or GNU Fortran"
\&\s-1GNU\s0 Fortran has various special options that are used for debugging
either your program or \fBg77\fR
.IP "\fB\-g\fR" 4
.IX Item "-g"
Produce debugging information in the operating system's native format
(stabs, \s-1COFF\s0, \s-1XCOFF\s0, or \s-1DWARF\s0).  \s-1GDB\s0 can work with this debugging
information.
.Sp
A sample debugging session looks like this (note the use of the breakpoint):
.Sp
.Vb 24
\&        $ cat gdb.f
\&              PROGRAM PROG
\&              DIMENSION A(10)
\&              DATA A /1.,2.,3.,4.,5.,6.,7.,8.,9.,10./
\&              A(5) = 4.
\&              PRINT*,A
\&              END
\&        $ g77 -g -O gdb.f
\&        $ gdb a.out
\&        ...
\&        (gdb) break MAIN__ 
\&        Breakpoint 1 at 0x8048e96: file gdb.f, line 4.
\&        (gdb) run
\&        Starting program: /home/toon/g77-bugs/./a.out 
\&        Breakpoint 1, MAIN__ () at gdb.f:4
\&        4             A(5) = 4.
\&        Current language:  auto; currently fortran
\&        (gdb) print a(5)
\&        $1 = 5
\&        (gdb) step 
\&        5             PRINT*,A
\&        (gdb) print a(5)
\&        $2 = 4
\&        ...
.Ve
.Sp
One could also add the setting of the breakpoint and the first run command
to the file \fI.gdbinit\fR in the current directory, to simplify the debugging
session.
.Sh "Options That Control Optimization"
.IX Subsection "Options That Control Optimization"
Most Fortran users will want to use no optimization when
developing and testing programs, and use \fB\-O\fR or \fB\-O2\fR when
compiling programs for late-cycle testing and for production use.
However, note that certain diagnostics\-\-\-such as for uninitialized
variables\-\-\-depend on the flow analysis done by \fB\-O\fR, i.e. you
must use \fB\-O\fR or \fB\-O2\fR to get such diagnostics.
.PP
The following flags have particular applicability when
compiling Fortran programs:
.IP "\fB\-malign\-double\fR" 4
.IX Item "-malign-double"
(Intel x86 architecture only.)
.Sp
Noticeably improves performance of \fBg77\fR programs making
heavy use of \f(CW\*(C`REAL(KIND=2)\*(C'\fR (\f(CW\*(C`DOUBLE PRECISION\*(C'\fR) data
on some systems.
In particular, systems using Pentium, Pentium Pro, 586, and
686 implementations
of the i386 architecture execute programs faster when
\&\f(CW\*(C`REAL(KIND=2)\*(C'\fR (\f(CW\*(C`DOUBLE PRECISION\*(C'\fR) data are
aligned on 64\-bit boundaries
in memory.
.Sp
This option can, at least, make benchmark results more consistent
across various system configurations, versions of the program,
and data sets.
.Sp
\&\fINote:\fR The warning in the \fBgcc\fR documentation about
this option does not apply, generally speaking, to Fortran
code compiled by \fBg77\fR
.Sp
\&\fIAlso also note:\fR The negative form of \fB\-malign\-double\fR
is \fB\-mno\-align\-double\fR, not \fB\-benign\-double\fR.
.IP "\fB\-ffloat\-store\fR" 4
.IX Item "-ffloat-store"
Might help a Fortran program that depends on exact \s-1IEEE\s0 conformance on
some machines, but might slow down a program that doesn't.
.Sp
This option is effective when the floating-point unit is set to work in
\&\s-1IEEE\s0 854 `extended precision'\-\-\-as it typically is on x86 and m68k \s-1GNU\s0
systems\-\-\-rather than \s-1IEEE\s0 754 double precision.  \fB\-ffloat\-store\fR
tries to remove the extra precision by spilling data from floating-point
registers into memory and this typically involves a big performance
hit.  However, it doesn't affect intermediate results, so that it is
only partially effective.  `Excess precision' is avoided in code like:
.Sp
.Vb 2
\&        a = b + c
\&        d = a * e
.Ve
.Sp
but not in code like:
.Sp
.Vb 1
\&              d = (b + c) * e
.Ve
.Sp
For another, potentially better, way of controlling the precision,
see \fBFloating-point precision\fR.
.IP "\fB\-fforce\-mem\fR" 4
.IX Item "-fforce-mem"
.PD 0
.IP "\fB\-fforce\-addr\fR" 4
.IX Item "-fforce-addr"
.PD
Might improve optimization of loops.
.IP "\fB\-fno\-inline\fR" 4
.IX Item "-fno-inline"
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.
.IP "\fB\-ffast\-math\fR" 4
.IX Item "-ffast-math"
Might allow some programs designed to not be too dependent
on \s-1IEEE\s0 behavior for floating-point to run faster, or die trying.
Sets \fB\-funsafe\-math\-optimizations\fR, \fB\-ffinite\-math\-only\fR,
and \fB\-fno\-trapping\-math\fR.
.IP "\fB\-funsafe\-math\-optimizations\fR" 4
.IX Item "-funsafe-math-optimizations"
Allow optimizations that may be give incorrect results
for certain \s-1IEEE\s0 inputs.
.IP "\fB\-ffinite\-math\-only\fR" 4
.IX Item "-ffinite-math-only"
Allow optimizations for floating-point arithmetic that assume
that arguments and results are not NaNs or +\-Infs.
.Sp
This option should never be turned on by any \fB\-O\fR option since
it can result in incorrect output for programs which depend on
an exact implementation of \s-1IEEE\s0 or \s-1ISO\s0 rules/specifications.
.Sp
The default is \fB\-fno\-finite\-math\-only\fR.
.IP "\fB\-fno\-trapping\-math\fR" 4
.IX Item "-fno-trapping-math"
Allow the compiler to assume that floating-point arithmetic
will not generate traps on any inputs.  This is useful, for
example, when running a program using \s-1IEEE\s0 \*(L"non\-stop\*(R"
floating-point arithmetic.
.IP "\fB\-fstrength\-reduce\fR" 4
.IX Item "-fstrength-reduce"
Might make some loops run faster.
.IP "\fB\-frerun\-cse\-after\-loop\fR" 4
.IX Item "-frerun-cse-after-loop"
.PD 0
.IP "\fB\-fexpensive\-optimizations\fR" 4
.IX Item "-fexpensive-optimizations"
.IP "\fB\-fdelayed\-branch\fR" 4
.IX Item "-fdelayed-branch"
.IP "\fB\-fschedule\-insns\fR" 4
.IX Item "-fschedule-insns"
.IP "\fB\-fschedule\-insns2\fR" 4
.IX Item "-fschedule-insns2"
.IP "\fB\-fcaller\-saves\fR" 4
.IX Item "-fcaller-saves"
.PD
Might improve performance on some code.
.IP "\fB\-funroll\-loops\fR" 4
.IX Item "-funroll-loops"
Typically improves performance on code using iterative \f(CW\*(C`DO\*(C'\fR loops by
unrolling them and is probably generally appropriate for Fortran, though
it is not turned on at any optimization level.
Note that outer loop unrolling isn't done specifically; decisions about
whether to unroll a loop are made on the basis of its instruction count.
.Sp
Also, no `loop discovery'[1] is done, so only loops written with \f(CW\*(C`DO\*(C'\fR
benefit from loop optimizations, including\-\-\-but not limited
to\-\-\-unrolling.  Loops written with \f(CW\*(C`IF\*(C'\fR and \f(CW\*(C`GOTO\*(C'\fR are not
currently recognized as such.  This option unrolls only iterative
\&\f(CW\*(C`DO\*(C'\fR loops, not \f(CW\*(C`DO WHILE\*(C'\fR loops.
.IP "\fB\-funroll\-all\-loops\fR" 4
.IX Item "-funroll-all-loops"
Probably improves performance on code using \f(CW\*(C`DO WHILE\*(C'\fR loops by
unrolling them in addition to iterative \f(CW\*(C`DO\*(C'\fR loops.  In the absence
of \f(CW\*(C`DO WHILE\*(C'\fR, this option is equivalent to \fB\-funroll\-loops\fR
but possibly slower.
.IP "\fB\-fno\-move\-all\-movables\fR" 4
.IX Item "-fno-move-all-movables"
.PD 0
.IP "\fB\-fno\-reduce\-all\-givs\fR" 4
.IX Item "-fno-reduce-all-givs"
.IP "\fB\-fno\-rerun\-loop\-opt\fR" 4
.IX Item "-fno-rerun-loop-opt"
.PD
In general, the optimizations enabled with these options will lead to
faster code being generated by \s-1GNU\s0 Fortran; hence they are enabled by default
when issuing the \fBg77\fR command.
.Sp
\&\fB\-fmove\-all\-movables\fR and \fB\-freduce\-all\-givs\fR will enable
loop optimization to move all loop-invariant index computations in nested
loops over multi-rank array dummy arguments out of these loops.
.Sp
\&\fB\-frerun\-loop\-opt\fR will move offset calculations resulting
from the fact that Fortran arrays by default have a lower bound of 1
out of the loops.
.Sp
These three options are intended to be removed someday, once
loop optimization is sufficiently advanced to perform all those
transformations without help from these options.
.Sh "Options Controlling the Preprocessor"
.IX Subsection "Options Controlling the Preprocessor"
These options control the C preprocessor, which is run on each C source
file before actual compilation.
.PP
Some of these options also affect how \fBg77\fR processes the
\&\f(CW\*(C`INCLUDE\*(C'\fR directive.
Since this directive is processed even when preprocessing
is not requested, it is not described in this section.
.PP
However, the \f(CW\*(C`INCLUDE\*(C'\fR directive does not apply
preprocessing to the contents of the included file itself.
.PP
Therefore, any file that contains preprocessor directives
(such as \f(CW\*(C`#include\*(C'\fR, \f(CW\*(C`#define\*(C'\fR, and \f(CW\*(C`#if\*(C'\fR)
must be included via the \f(CW\*(C`#include\*(C'\fR directive, not
via the \f(CW\*(C`INCLUDE\*(C'\fR directive.
Therefore, any file containing preprocessor directives,
if included, is necessarily included by a file that itself
contains preprocessor directives.
.Sh "Options for Directory Search"
.IX Subsection "Options for Directory Search"
These options affect how the \fBcpp\fR preprocessor searches
for files specified via the \f(CW\*(C`#include\*(C'\fR directive.
Therefore, when compiling Fortran programs, they are meaningful
when the preprocessor is used.
.PP
Some of these options also affect how \fBg77\fR searches
for files specified via the \f(CW\*(C`INCLUDE\*(C'\fR directive,
although files included by that directive are not,
themselves, preprocessed.
These options are:
.IP "\fB\-I\-\fR" 4
.IX Item "-I-"
.PD 0
.IP "\fB\-I\fR\fIdir\fR" 4
.IX Item "-Idir"
.PD
These affect interpretation of the \f(CW\*(C`INCLUDE\*(C'\fR directive
(as well as of the \f(CW\*(C`#include\*(C'\fR directive of the \fBcpp\fR
preprocessor).
.Sp
Note that \fB\-I\fR\fIdir\fR must be specified \fIwithout\fR any
spaces between \fB\-I\fR and the directory name\-\-\-that is,
\&\fB\-Ifoo/bar\fR is valid, but \fB\-I foo/bar\fR
is rejected by the \fBg77\fR compiler (though the preprocessor supports
the latter form).
Also note that the general behavior of \fB\-I\fR and
\&\f(CW\*(C`INCLUDE\*(C'\fR is pretty much the same as of \fB\-I\fR with
\&\f(CW\*(C`#include\*(C'\fR in the \fBcpp\fR preprocessor, with regard to
looking for \fIheader.gcc\fR files and other such things.
.Sh "Options for Code Generation Conventions"
.IX Subsection "Options for Code Generation Conventions"
These machine-independent options control the interface conventions
used in code generation.
.PP
Most of them have both positive and negative forms; the negative form
of \fB\-ffoo\fR would be \fB\-fno\-foo\fR.  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 \fBno\-\fR or adding
it.
.IP "\fB\-fno\-automatic\fR" 4
.IX Item "-fno-automatic"
Treat each program unit as if the \f(CW\*(C`SAVE\*(C'\fR 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 \fB\-static\fR.)
.IP "\fB\-finit\-local\-zero\fR" 4
.IX Item "-finit-local-zero"
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.
.Sp
Since there is a run-time penalty for initialization of variables
that are not given the \f(CW\*(C`SAVE\*(C'\fR attribute, it might be a
good idea to also use \fB\-fno\-automatic\fR with \fB\-finit\-local\-zero\fR.
.IP "\fB\-fno\-f2c\fR" 4
.IX Item "-fno-f2c"
Do not generate code designed to be compatible with code generated
by \fBf2c\fR use the \s-1GNU\s0 calling conventions instead.
.Sp
The \fBf2c\fR calling conventions require functions that return
type \f(CW\*(C`REAL(KIND=1)\*(C'\fR to actually return the C type \f(CW\*(C`double\*(C'\fR,
and functions that return type \f(CW\*(C`COMPLEX\*(C'\fR to return the
values via an extra argument in the calling sequence that points
to where to store the return value.
Under the \s-1GNU\s0 calling conventions, such functions simply return
their results as they would in \s-1GNU\s0 C\-\-\-\f(CW\*(C`REAL(KIND=1)\*(C'\fR functions
return the C type \f(CW\*(C`float\*(C'\fR, and \f(CW\*(C`COMPLEX\*(C'\fR functions
return the \s-1GNU\s0 C type \f(CW\*(C`complex\*(C'\fR (or its \f(CW\*(C`struct\*(C'\fR
equivalent).
.Sp
This does not affect the generation of code that interfaces with the
\&\f(CW\*(C`libg2c\*(C'\fR library.
.Sp
However, because the \f(CW\*(C`libg2c\*(C'\fR library uses \fBf2c\fR
calling conventions, \fBg77\fR rejects attempts to pass
intrinsics implemented by routines in this library as actual
arguments when \fB\-fno\-f2c\fR is used, to avoid bugs when
they are actually called by code expecting the \s-1GNU\s0 calling
conventions to work.
.Sp
For example, \fB\s-1INTRINSIC\s0 \s-1ABS\s0;CALL \s-1FOO\s0(\s-1ABS\s0)\fR is
rejected when \fB\-fno\-f2c\fR is in force.
(Future versions of the \fBg77\fR run-time library might
offer routines that provide GNU-callable versions of the
routines that implement the \fBf2c\fR intrinsics
that may be passed as actual arguments, so that
valid programs need not be rejected when \fB\-fno\-f2c\fR
is used.)
.Sp
\&\fBCaution:\fR If \fB\-fno\-f2c\fR is used when compiling any
source file used in a program, it must be used when compiling
\&\fIall\fR Fortran source files used in that program.
.IP "\fB\-ff2c\-library\fR" 4
.IX Item "-ff2c-library"
Specify that use of \f(CW\*(C`libg2c\*(C'\fR (or the original \f(CW\*(C`libf2c\*(C'\fR)
is required.
This is the default for the current version of \fBg77\fR
.Sp
Currently it is not
valid to specify \fB\-fno\-f2c\-library\fR.
This option is provided so users can specify it in shell
scripts that build programs and libraries that require the
\&\f(CW\*(C`libf2c\*(C'\fR library, even when being compiled by future
versions of \fBg77\fR that might otherwise default to
generating code for an incompatible library.
.IP "\fB\-fno\-underscoring\fR" 4
.IX Item "-fno-underscoring"
Do not transform names of entities specified in the Fortran
source file by appending underscores to them.
.Sp
With \fB\-funderscoring\fR in effect, \fBg77\fR appends two underscores
to names with underscores and one underscore to external names with
no underscores.  (\fBg77\fR also appends two underscores to internal
names with underscores to avoid naming collisions with external names.
The \fB\-fno\-second\-underscore\fR option disables appending of the
second underscore in all cases.)
.Sp
This is done to ensure compatibility with code produced by many
\&\s-1UNIX\s0 Fortran compilers, including \fBf2c\fR which perform the
same transformations.
.Sp
Use of \fB\-fno\-underscoring\fR is not recommended unless you are
experimenting with issues such as integration of (\s-1GNU\s0) Fortran into
existing system environments (vis\-a\-vis existing libraries, tools, and
so on).
.Sp
For example, with \fB\-funderscoring\fR, and assuming other defaults like
\&\fB\-fcase\-lower\fR and that \fBj()\fR and \fB\f(BImax_count()\fB\fR are
external functions while \fBmy_var\fR and \fBlvar\fR are local variables,
a statement like
.Sp
.Vb 1
\&        I = J() + MAX_COUNT (MY_VAR, LVAR)
.Ve
.Sp
is implemented as something akin to:
.Sp
.Vb 1
\&        i = j_() + max_count__(&my_var__, &lvar);
.Ve
.Sp
With \fB\-fno\-underscoring\fR, the same statement is implemented as:
.Sp
.Vb 1
\&        i = j() + max_count(&my_var, &lvar);
.Ve
.Sp
Use of \fB\-fno\-underscoring\fR allows direct specification of
user-defined names while debugging and when interfacing \fBg77\fR
code with other languages.
.Sp
Note that just because the names match does \fInot\fR mean that the
interface implemented by \fBg77\fR for an external name matches the
interface implemented by some other language for that same name.
That is, getting code produced by \fBg77\fR 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.
.Sp
Also, note that with \fB\-fno\-underscoring\fR, 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.
.Sp
In future versions of \fBg77\fR 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.
.IP "\fB\-fno\-second\-underscore\fR" 4
.IX Item "-fno-second-underscore"
Do not append a second underscore to names of entities specified
in the Fortran source file.
.Sp
This option has no effect if \fB\-fno\-underscoring\fR is
in effect.
.Sp
Otherwise, with this option, an external name such as \fB\s-1MAX_COUNT\s0\fR
is implemented as a reference to the link-time external symbol
\&\fBmax_count_\fR, instead of \fBmax_count_\|_\fR.
.IP "\fB\-fno\-ident\fR" 4
.IX Item "-fno-ident"
Ignore the \fB#ident\fR directive.
.IP "\fB\-fzeros\fR" 4
.IX Item "-fzeros"
Treat initial values of zero as if they were any other value.
.Sp
As of version 0.5.18, \fBg77\fR normally treats \f(CW\*(C`DATA\*(C'\fR 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.
.Sp
This is done to speed up compiling of programs that initialize
large arrays to zeros.
.Sp
Use \fB\-fzeros\fR to revert to the simpler, slower behavior
that can catch multiple initializations by keeping track of
all initializations, zero or otherwise.
.Sp
\&\fICaution:\fR Future versions of \fBg77\fR 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.
.IP "\fB\-femulate\-complex\fR" 4
.IX Item "-femulate-complex"
Implement \f(CW\*(C`COMPLEX\*(C'\fR arithmetic via emulation,
instead of using the facilities of
the \fBgcc\fR back end that provide direct support of
\&\f(CW\*(C`complex\*(C'\fR arithmetic.
.Sp
(\fBgcc\fR had some bugs in its back-end support
for \f(CW\*(C`complex\*(C'\fR arithmetic, due primarily to the support not being
completed as of version 2.8.1 and \f(CW\*(C`egcs\*(C'\fR 1.1.2.)
.Sp
Use \fB\-femulate\-complex\fR if you suspect code-generation bugs,
or experience compiler crashes,
that might result from \fBg77\fR using the \f(CW\*(C`COMPLEX\*(C'\fR support
in the \fBgcc\fR back end.
If using that option fixes the bugs or crashes you are seeing,
that indicates a likely \fBg77\fR 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.)
.Sp
Use of this option should not affect how Fortran code compiled
by \fBg77\fR works in terms of its interfaces to other code,
e.g. that compiled by \fBf2c\fR
.Sp
As of \s-1GCC\s0 version 3.0, this option is not necessary anymore.
.Sp
\&\fICaution:\fR Future versions of \fBg77\fR might ignore both forms
of this option.
.IP "\fB\-falias\-check\fR" 4
.IX Item "-falias-check"
.PD 0
.IP "\fB\-fargument\-alias\fR" 4
.IX Item "-fargument-alias"
.IP "\fB\-fargument\-noalias\fR" 4
.IX Item "-fargument-noalias"
.IP "\fB\-fno\-argument\-noalias\-global\fR" 4
.IX Item "-fno-argument-noalias-global"
.PD
\&\fIVersion info:\fR
These options are not supported by
versions of \fBg77\fR based on \fBgcc\fR version 2.8.
.Sp
These options specify to what degree aliasing
(overlap)
is permitted between
arguments (passed as pointers) and \f(CW\*(C`COMMON\*(C'\fR (external, or
public) storage.
.Sp
The default for Fortran code, as mandated by the \s-1FORTRAN\s0 77 and
Fortran 90 standards, is \fB\-fargument\-noalias\-global\fR.
The default for code written in the C language family is
\&\fB\-fargument\-alias\fR.
.Sp
Note that, on some systems, compiling with \fB\-fforce\-addr\fR in
effect can produce more optimal code when the default aliasing
options are in effect (and when optimization is enabled).
.IP "\fB\-fno\-globals\fR" 4
.IX Item "-fno-globals"
Disable diagnostics about inter-procedural
analysis problems, such as disagreements about the
type of a function or a procedure's argument,
that might cause a compiler crash when attempting
to inline a reference to a procedure within a
program unit.
(The diagnostics themselves are still produced, but
as warnings, unless \fB\-Wno\-globals\fR is specified,
in which case no relevant diagnostics are produced.)
.Sp
Further, this option disables such inlining, to
avoid compiler crashes resulting from incorrect
code that would otherwise be diagnosed.
.Sp
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 \fBg77\fR diagnoses.
.Sp
Use of this option therefore has the effect of
instructing \fBg77\fR 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).
.Sp
Without this option, \fBg77\fR 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.
.IP "\fB\-fflatten\-arrays\fR" 4
.IX Item "-fflatten-arrays"
Use back end's C\-like constructs
(pointer plus offset)
instead of its \f(CW\*(C`ARRAY_REF\*(C'\fR construct
to handle all array references.
.Sp
\&\fINote:\fR This option is not supported.
It is intended for use only by \fBg77\fR developers,
to evaluate code-generation issues.
It might be removed at any time.
.IP "\fB\-fbounds\-check\fR" 4
.IX Item "-fbounds-check"
.PD 0
.IP "\fB\-ffortran\-bounds\-check\fR" 4
.IX Item "-ffortran-bounds-check"
.PD
Enable generation of run-time checks for array subscripts
and substring start and end points
against the (locally) declared minimum and maximum values.
.Sp
The current implementation uses the \f(CW\*(C`libf2c\*(C'\fR
library routine \f(CW\*(C`s_rnge\*(C'\fR to print the diagnostic.
.Sp
However, whereas \fBf2c\fR 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),
\&\fBg77\fR generates a single check per \fIsubscript\fR expression.
This catches some cases of potential bugs that \fBf2c\fR does not,
such as references to below the beginning of an assumed-size array.
.Sp
\&\fBg77\fR also generates checks for \f(CW\*(C`CHARACTER\*(C'\fR substring references,
something \fBf2c\fR currently does not do.
.Sp
Use the new \fB\-ffortran\-bounds\-check\fR option
to specify bounds-checking for only the Fortran code you are compiling,
not necessarily for code written in other languages.
.Sp
\&\fINote:\fR To provide more detailed information on the offending subscript,
\&\fBg77\fR provides the \f(CW\*(C`libg2c\*(C'\fR run-time library routine \f(CW\*(C`s_rnge\*(C'\fR
with somewhat differently-formatted information.
Here's a sample diagnostic:
.Sp
.Vb 3
\&        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
.Ve
.Sp
The above message indicates that the offending source line is
line 4 of the file \fIrnge.f\fR,
within the program unit (or statement function) named \fBbf\fR.
The offended array is named \fBb\fR.
The offended array dimension is the second for a two-dimensional array,
and the offending, computed subscript expression was \fB\-6\fR.
.Sp
For a \f(CW\*(C`CHARACTER\*(C'\fR substring reference, the second line has
this appearance:
.Sp
.Vb 1
\&        Attempt to access the 11-th element of variable a[start-substring].
.Ve
.Sp
This indicates that the offended \f(CW\*(C`CHARACTER\*(C'\fR variable or array
is named \fBa\fR,
the offended substring position is the starting (leftmost) position,
and the offending substring expression is \fB11\fR.
.Sp
(Though the verbage of \f(CW\*(C`s_rnge\*(C'\fR is not ideal
for the purpose of the \fBg77\fR compiler,
the above information should provide adequate diagnostic abilities
to it users.)
.PP
Some of these do \fInot\fR work when compiling programs written in Fortran:
.IP "\fB\-fpcc\-struct\-return\fR" 4
.IX Item "-fpcc-struct-return"
.PD 0
.IP "\fB\-freg\-struct\-return\fR" 4
.IX Item "-freg-struct-return"
.PD
You should not use these except strictly the same way as you
used them to build the version of \f(CW\*(C`libg2c\*(C'\fR with which
you will be linking all code compiled by \fBg77\fR with the
same option.
.IP "\fB\-fshort\-double\fR" 4
.IX Item "-fshort-double"
This probably either has no effect on Fortran programs, or
makes them act loopy.
.IP "\fB\-fno\-common\fR" 4
.IX Item "-fno-common"
Do not use this when compiling Fortran programs,
or there will be Trouble.
.IP "\fB\-fpack\-struct\fR" 4
.IX Item "-fpack-struct"
This probably will break any calls to the \f(CW\*(C`libg2c\*(C'\fR library,
at the very least, even if it is built with the same option.
.SH "ENVIRONMENT"
.IX Header "ENVIRONMENT"
\&\s-1GNU\s0 Fortran currently does not make use of any environment
variables to control its operation above and beyond those
that affect the operation of \fBgcc\fR.
.SH "BUGS"
.IX Header "BUGS"
For instructions on reporting bugs, see
<\fBhttp://gcc.gnu.org/bugs.html\fR>.  Use of the \fBgccbug\fR  
script to report bugs is recommended.
.SH "FOOTNOTES"
.IX Header "FOOTNOTES"
.IP "1." 4
\&\fIloop discovery\fR refers to the
process by which a compiler, or indeed any reader of a program,
determines which portions of the program are more likely to be executed
repeatedly as it is being run.  Such discovery typically is done early
when compiling using optimization techniques, so the ``discovered''
loops get more attention\-\-\-and more run-time resources, such as
registers\-\-\-from the compiler.  It is easy to ``discover'' loops that are
constructed out of looping constructs in the language
(such as Fortran's \f(CW\*(C`DO\*(C'\fR).  For some programs, ``discovering'' loops
constructed out of lower-level constructs (such as \f(CW\*(C`IF\*(C'\fR and
\&\f(CW\*(C`GOTO\*(C'\fR) can lead to generation of more optimal code
than otherwise.
.SH "SEE ALSO"
.IX Header "SEE ALSO"
\&\fIgpl\fR\|(7), \fIgfdl\fR\|(7), \fIfsf\-funding\fR\|(7),
\&\fIcpp\fR\|(1), \fIgcov\fR\|(1), \fIgcc\fR\|(1), \fIas\fR\|(1), \fIld\fR\|(1), \fIgdb\fR\|(1), \fIadb\fR\|(1), \fIdbx\fR\|(1), \fIsdb\fR\|(1)
and the Info entries for \fIgcc\fR, \fIcpp\fR, \fIg77\fR, \fIas\fR,
\&\fIld\fR, \fIbinutils\fR and \fIgdb\fR.
.SH "AUTHOR"
.IX Header "AUTHOR"
See the Info entry for \fBg77\fR for contributors to \s-1GCC\s0 and G77.
.SH "COPYRIGHT"
.IX Header "COPYRIGHT"
Copyright (c) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2004
Free Software Foundation, Inc.
.PP
Permission is granted to copy, distribute and/or modify this document
under the terms of the \s-1GNU\s0 Free Documentation License, Version 1.2 or
any later version published by the Free Software Foundation; with the
Invariant Sections being ``\s-1GNU\s0 General Public License'' and ``Funding
Free Software'', the Front-Cover texts being (a) (see below), and with
the Back-Cover Texts being (b) (see below).  A copy of the license is
included in the \fIgfdl\fR\|(7) man page.
.PP
(a) The \s-1FSF\s0's Front-Cover Text is:
.PP
.Vb 1
\&     A GNU Manual
.Ve
.PP
(b) The \s-1FSF\s0's Back-Cover Text is:
.PP
.Vb 3
\&     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.
.Ve
