INTEGER constants.
Specify `-ftypeless-boz' to cause such
constants to be interpreted as typeless.
(Version 0.5.19 introduced `-fno-typeless-boz' and
its inverse.)
libU77 intrinsics.
Users of such programs might need to compile them
differently (using, for example, `-ff90-intrinsics-disable')
or, better yet, insert appropriate EXTERNAL
statements specifying that these names are not intended
to be names of intrinsics.
libf2c, which should result in improved
I/O performance, especially over NFS.
Note: If you have code that depends on the behavior
of libf2c when built with `ALWAYS_FLUSH' defined,
you will have to modify libf2c accordingly before
building it from this and future versions of g77.
libU77 has been
added to the version of libf2c distributed with
and built as part of g77.
g77 now knows about the routines in this library
as intrinsics.
g77.
g77 front end and
the gcc back end to better support Alpha (AXP)
machines.
This includes providing at least one bug-fix to the
gcc back end for Alphas.
LOC()
intrinsic and %LOC() construct now return
values of integer type that is the same width (holds
the same number of bits) as the pointer type on the
machine.
On most machines, this won't make a difference, whereas
on Alphas, the type these constructs return is
INTEGER*8 instead of the more common INTEGER*4.
COMPLEX arithmetic in the g77 front
end, to avoid bugs in complex support in the
gcc back end.
New option `-fno-emulate-complex'
causes g77 to revert the 0.5.19 behavior.
g77 command driver so that `g77 -o foo.f'
no longer deletes `foo.f' before issuing other
diagnostics, and so the `-x' option is properly
handled.
gcc
back end.
This works as it does for gcc itself--program units
may be inlined for invocations that follow them in the same
program unit, as long as the appropriate compile-time
options are specified.
COMMON areas when any of
these are defined (assigned to) by Fortran code.
This can result in faster and/or smaller programs when
compiling with optimization enabled, though on some
systems this effect is observed only when `-fforce-addr'
also is specified.
New options `-falias-check', `-fargument-alias',
`-fargument-noalias',
and `-fno-argument-noalias-global' control the
way g77 handles potential aliasing.
CONJG() and DCONJG() intrinsics now
are compiled in-line.
g77 compiler has been changed back to
assume libf2c has no aliasing problems in
its implementations of the COMPLEX (and
DOUBLE COMPLEX) intrinsics.
The libf2c has been changed to have no such
problems.
As a result, 0.5.20 is expected to offer improved performance
over 0.5.19.1, perhaps as good as 0.5.19 in most
or all cases, due to this change alone.
Note: This change requires version 0.5.20 of
libf2c, at least, when linking code produced
by any versions of g77 other than 0.5.19.1.
Use `g77 -v' to determine the version numbers
of the libF77, libI77, and libU77
components of the libf2c library.
(If these version numbers are not printed--in
particular, if the linker complains about unresolved
references to names like `g77__fvers__'---that
strongly suggests your installation has an obsolete
version of libf2c.)
g77 uses a separate memory location
to hold assigned statement labels.)
FORMAT and ENTRY statements now are allowed to
precede IMPLICIT NONE statements.
SELECT CASE on
CHARACTER type, instead of crashing, at compile time.
libf2c archive
(`libf2c.a') so that members are added to it
only when truly necessary, so the user that installs
an already-built g77 doesn't need to have write
access to the build tree (whereas the user doing the
build might not have access to install new software
on the system).
gcc version 2.7.2.2
(modified by g77 into version 2.7.2.2.f.2),
and remove
support for prior versions of gcc.
libf2c as of 1997-02-08, and
fix up some of the build procedures.
g77,
fixing minor bugs (such as deletion of any file
named `f771' in the parent directory of gcc/).
INTEGER*8 available in
libf2c and `f2c.h' so that f2c users
may make full use of its features via the g77
version of `f2c.h' and the INTEGER*8
support routines in the g77 version of libf2c.
g77 driver and libf2c so that `g77 -v'
yields version information on the library.
SNGL and FLOAT intrinsics now are
specific intrinsics, instead of synonyms for the
generic intrinsic REAL.
REALPART, IMAGPART,
COMPLEX,
LONG, and SHORT.
REALPART, IMAGPART,
and COMPLEX intrinsics.
An old group, `dcp', has been removed.
DOUBLE COMPLEX (or any
complex type other than COMPLEX), unless
`-ff90' option specifies Fortran 90 interpretation
or new `-fugly-complex' option, in conjunction with
`-fnot-f90', specifies f2c interpretation.
DOUBLE COMPLEX operand to an INTEGER
power.
(The related generic and `Z'-prefixed intrinsics,
such as `ZSIN()', also were affected.)
For example, `C = CSQRT(C)', `Z = Z/C', and `Z = Z**I'
(where `C' is COMPLEX and `Z' is
DOUBLE COMPLEX) have been fixed.
FORMAT statement parsing so negative values for
specifiers such as `P' (e.g. `FORMAT(-1PF8.1)')
are correctly processed as negative.
SIGNAL intrinsic so it once again accepts a
procedure as its second argument.
COMMON and EQUIVALENCE members at debug time.
DO loops.
f77 and f2c.
INTEGER constants.
f77 programs.
CHARACTER arrays having
names such as `READ', `WRITE', `GOTO', and
`REALFUNCTIONFOO'.
EQUIVALENCE areas so certain cases
of valid Fortran programs are not misdiagnosed as improperly
extending the area backwards.
gcc version 2.7.2.1.
libf2c as of 1996-09-26, and
fix up some of the build procedures.
libf2c that might return non-zero
status codes for some operations previously assumed to always
return zero.
This change not only affects how IOSTAT= variables
are set by list-directed I/O, it also affects whether
END= and ERR= labels are reached by these
operations.
FTELL and FSEEK
procedures in libf2c.
fseek_() in libf2c to be more portable
(though, in practice, there might be no systems where this
matters) and to catch invalid `whence' arguments.
gcc has not been patched
using the patch file provided in the `gcc/f/gbe/'
subdirectory.
g77 command, to conform to GNU coding guidelines.
Also add printing of g77 version number when
the `--verbose' (`-v') option is used.
EQUIVALENCE
areas to one based on the alphabetically sorted first name
in the list of names for entities placed at the beginning
of the areas.
INTEGER*1,
INTEGER*2, INTEGER*8,
and their LOGICAL equivalents.
(This support works on most, maybe all, gcc targets.)
Thanks to Scott Snyder (@email{snyder@d0sgif.fnal.gov})
for providing the patch for this!
Among the missing elements from the support for these
features are full intrinsic support and constants.
BYTE and
WORD type-declaration statements.
BYTE corresponds to INTEGER*1,
while WORD corresponds to INTEGER*2.
Thanks to Scott Snyder (@email{snyder@d0sgif.fnal.gov})
for providing the patch for this!
INTEGER*8,
for example.
g77 incorrectly
interpreted `REAL(Z)' as returning a REAL
result, instead of as a DOUBLE PRECISION
result.
(Here, `Z' is DOUBLE COMPLEX.)
With `-fno-f90' in force, the interpretation remains
unchanged, since this appears to be how at least some
F77 code using the DOUBLE COMPLEX extension expected
it to work.
Essentially, `REAL(Z)' in F90 is the same as
`DBLE(Z)', while in extended F77, it appears to
be the same as `REAL(REAL(Z))'.
INTEGER and the right-hand operand
was negative, was erroneously evaluated.
DATA implied-DO constructs
(these involved an errant diagnostic and a crash, both on good
code, one involving subsequent statement-function definition).
INCLUDE files after processing them, so compiling source
files with lots of INCLUDE statements does not result in
being unable to open INCLUDE files after all the available
file descriptors are used up.
gcc back end (GBE).
These options are `-fmove-all-movables', `-freduce-all-givs',
and `-frerun-loop-opt', which are enabled, by default,
for Fortran compilations.
These optimizations are intended to help toon Fortran programs.
gcc
also is patched to make it easier to manage installations,
especially useful if it turns out a g77 change to the
GBE has a bug.
The g77-modified version number is the gcc
version number with the string `.f.n' appended,
where `f' identifies the version as enhanced for
Fortran, and n is `1' for the first Fortran
patch for that version of gcc, `2' for the
second, and so on.
So, this introduces version 2.7.2.f.1 of gcc.
DO
loops, instead of these being rejected unless `-fpedantic'
or `-fugly' specified.
SAVE of a local variable or array, even after
it has been given an initial value via DATA, for example.
g77 documentation, which
supercedes `gcc/f/CREDITS', `gcc/f/DOC', and
`gcc/f/PROJECTS'.
These files will be removed in a future release.
The files `gcc/f/BUGS', `gcc/f/INSTALL', and
`gcc/f/NEWS' now are automatically built from
the texinfo source when distributions are made.
This effort was inspired by a first pass at translating
`g77-0.5.16/f/DOC' that was contributed to Craig by
David Ronis (@email{ronis@onsager.chem.mcgill.ca}).
DO loops work to follow
the F90 standard.
In particular, calculation of the iteration count is
still done by converting the start, end, and increment
parameters to the type of the DO variable, but
the result of the calculation is always converted to
the default INTEGER type.
(This should have no effect on existing code compiled
by g77, but code written to assume that use
of a wider type for the DO variable
will result in an iteration count being fully calculated
using that wider type (wider
than default INTEGER) must be rewritten.)
gcc version 2.7.2.
libf2c as of 1996-03-23, and
fix up some of the build procedures.
Note that the email addresses related to f2c
have changed--the distribution site now is
named netlib.bell-labs.com, and the
maintainer's new address is @email{dmg@bell-labs.com}.
ld command
with `-o /dev/null' that ld tries to remove the executable
it is supposed to build (especially if it reports unresolved
references, which it should in this case)!
ASSIGN'ed variables so they can be SAVE'd or dummy arguments,
and issue clearer error message in cases where target of ASSIGN
or ASSIGNed GOTO/FORMAT is too small (which should
never happen).
libf2c build procedures work on more systems again by
eliminating unnecessary invocations of `ld -r -x' and `mv'.
IMPLICIT NONE.
INTEGER
constant for the right-hand operator (e.g. `I**32767').
g77 (the fini
utility in particular) is properly built using the host compiler.
g77) in ways that
are surprising to many programmers.
ERF() and ERFC() as generic intrinsics mapping to existing
ERF/DERF and ERFC/DERFC specific intrinsics.
Note: You should
specify `INTRINSIC ERF,ERFC' in any code where you might use
these as generic intrinsics, to improve likelihood of diagnostics
(instead of subtle run-time bugs) when using a compiler that
doesn't support these as intrinsics (e.g. f2c).
DO
with non-INTEGER index variable; issue that under
`-Wsurprising' instead.
.EQ./.NE. on LOGICAL
operands.
LOGICAL operands.
DO loops on some
machines.
gcc version 2.7.1.
libf2c as of 1995-11-15.
EQUIVALENCE statements
not involving COMMON.
libf2c from code compiled with `-fno-f2c' by making these
procedures known to g77 as intrinsics (not affected by -fno-f2c).
This is known to fix code invoking ERF(), ERFC(),
DERF(), and DERFC().
libf2c to include netlib patches through 1995-08-16, and
#define `WANT_LEAD_0' to 1 to make g77-compiled code more
consistent with other Fortran implementations by outputting
leading zeros in formatted and list-directed output.
f2c plus gcc (but apparently only when using
`gcc-2.7.0' or later).
COMPLEX and
DOUBLE COMPLEX FUNCTIONs and doing COMPLEX and
DOUBLE COMPLEX divides, when the result
of the invocation or divide is assigned directly to a variable
that overlaps one or more of the arguments to the invocation or divide.
gcc back end does not support the necessary
mechanics (and the gcc front end rejects the equivalent
construct, as it turns out).
DOUBLE COMPLEX constant to an INTEGER constant power.
DATA,
for example).
g77 driver.
Provide for easy selection of whether to install copy of g77
as f77 to replace the broken code.
gcc driver (affects g77 thereby) to not
gratuitously invoke the
f771 program (e.g. when `-E' is specified).
INCLUDE statement.
gcc/g77 when
compiling Fortran files.
These options include `-p', `-pg', `-aux-info', `-P',
correct setting of version-number macros for preprocessing, full
recognition of `-O0', and
automatic insertion of configuration-specific linker specs.
libf2c:
ABORT, DERF, DERFC, ERF, ERFC, EXIT,
FLUSH, GETARG, GETENV, IARGC,
SIGNAL, and SYSTEM.
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 (e.g. `CALL SYSTEM('rm foo',ISTAT)').
LOC() intrinsic out of the `vxt' group to the new
`unix' group.
g77 so that `g77 -v' by itself (or with
certain other options, including `-B', `-b', `-i',
`-nostdlib', and `-V') reports lots more useful
version info, and so that long-form options gcc accepts are
understood by g77 as well (even in truncated, unambiguous forms).
g77 option `--driver=name' to specify driver when
default, gcc, isn't appropriate.
gcc, with info such as
`In function `foo':' and `In file included from...:'.
gcc's `-fident' and `-fno-ident' options.
DATA implied-DO iteration
variables, even though, strictly speaking, these are not uses
of the variables themselves.
g77 might someday start warning about these)---applies
to gcc versions 2.7.0 and later, since earlier versions didn't
warn about unused dummy arguments.
g77 using the native (non-gcc) compiler on certain machines
(but definitely not all machines nor all non-gcc compilers).
Please
do not report bugs showing problems compilers have with
macros defined in `gcc/f/target.h' and used in places like
`gcc/f/expr.c'.
INTEGER, REAL, or LOGICAL size
is not 32 bits,
since g77 is known to not work well for such cases (to be
fixed in Version 0.6---see section Actual Bugs We Haven't Fixed Yet).
libf2c with `-g0', not `-g2', in effect
(by default), to produce
smaller library without lots of debugging clutter.
g77 and the back end (such as for DO loops).
REAL when
the `-ff2c' option is in force (which it is by default) so that
f2c compatibility is indeed provided.
gcc back end is to be fixed to do this even better, and it
turned out to slow down some code in some cases after all.
COMMON and EQUIVALENCE areas with any members given initial
values (e.g. via DATA), uninitialized members now always
initialized to binary zeros (though this is not required by
the standard, and might not be done in future versions
of g77).
Previously, in some COMMON/EQUIVALENCE areas
(essentially those with members of more than one type), the
uninitialized members were initialized to spaces, to
cater to CHARACTER types, but it seems no existing code expects
that, while much existing code expects binary zeros.
DO loops
for cases
where the loop should not execute at all.
(This bug affected cases
where the difference between the begin and end values was less
than the step count, though probably not for floating-point cases.)
DATA implied-DO list.
MVBITS() intrinsic.
DCMPLX() with a single INTEGER argument.
INCLUDE statement, plus gcc's
`header.gcc' facility for handling systems like MS-DOS.
INCLUDE statement to be continued across multiple lines,
even allow it to coexist with other statements on the same line.
libf2c through 1995-03-15--this
fixes a bug involving infinite loops reading EOF with empty list-directed
I/O list.
g77-specific auto-configuration scripts, code,
and so on,
except for temporary substitutes for bsearch() and strtoul(), as
too many configure/build problems were reported in these areas.
People will have to fix their systems' problems themselves, or at
least somewhere other than g77, which expects a working ANSI C
environment (and, for now, a GNU C compiler to compile g77 itself).
CHARACTER
and Hollerith constants to be interpreted a la GNU C.
Note that
this behavior is somewhat different from f2c's, which supports only
a limited subset of backslash (escape) sequences.
PARAMETER), and also allows character<->numeric conversion in
those contexts--turn off via `-fno-ugly-init'.
SAVEd, i.e. made
automatic or static.
IMPLICIT NONE.)
gcc
(i.e. unless `-O' not specified, since `-Wuninitialized'
requires `-O'), and implies `-Wunused' as well.
EXTERNAL names (since they are assumed to refer to block data
program units, to make use of libraries more reliable).
%LOC() and LOC() of character arguments.
f2c's IMAG() generic intrinsic.
ICHAR(), IACHAR(), and LEN() of
character expressions that are valid in assignments but
not normally as actual arguments.
f2c-style `&' in column 1 to mean continuation line.
NAMELIST, EXTERNAL, INTRINSIC, and VOLATILE
in BLOCK DATA, even though these are not allowed by the standard.
RETURN in main program unit.
INTEGER (padded on right with spaces if constant
too small, otherwise fully intact if constant wider the INTEGER
type) instead of by value.
f2c differs on the
interpretation of `CALL FOO(1HX)', which it treats exactly the
same as `CALL FOO('X')', but which the standard and g77 treat
as `CALL FOO(%REF('X '))' (padded with as many spaces as necessary
to widen to INTEGER), essentially.
INTEGER value.
INTEGER constant.
%DESCR() of a non-CHARACTER expression now passes a pointer to
the expression plus a length for the expression just as if
it were a CHARACTER expression.
For example, `CALL FOO(%DESCR(D))', where
`D' is REAL*8, is the same as `CALL FOO(D,%VAL(8)))'.
DO loops.
g77 man page.
INTEGER.
SQRT() and DSQRT(),
also when `-ffast-math'
specified, enable better code generation for SIN() and COS().
Go to the first, previous, next, last section, table of contents.