User-visible Changes

This chapter describes changes to g77 that are visible to the programmers who actually write and maintain Fortran code they compile with g77. Information on changes to installation procedures, changes to the documentation, and bug fixes is not provided here, unless it is likely to affect how users use g77. See News About GNU Fortran, for information on such changes to g77.

Note that two variants of g77 are tracked below. The egcs variant is described vis-a-vis previous versions of egcs and/or an official FSF version, as appropriate. Note that all such variants are obsolete as of July 1999 - the information is retained here only for its historical value.

Therefore, egcs versions sometimes have multiple listings to help clarify how they differ from other versions, though this can make getting a complete picture of what a particular egcs version contains somewhat more difficult.

For information on bugs in the GCC-3.2 version of g77, see Known Bugs In GNU Fortran.

The following information was last updated on 2002-08-05:

In GCC 3.2 versus GCC 3.1:

• Nothing.

In GCC 3.1 (formerly known as g77-0.5.27) versus GCC 3.0:

• Problem Reports fixed (in chronological order of submission):

  947

  Data statement initialization with subscript of kind INTEGER*2
  

  3743

  Reference to intrinsic `ISHFT' invalid
  

  3807

  Function BESJN(integer,double) problems
  

  3957

  g77 -pipe -xf77-cpp-input sends output to stdout
  

  4279

  g77 -h" gives bogus output
  

  4730

  ICE on valid input using CALL EXIT(%VAL(...))
  

  4752

  g77 -v -c -xf77-version /dev/null -xnone causes ice
  

  4885

  BACKSPACE example that doesn't work as of gcc/g77-3.0.x
  

  5122

  g77 rejects accepted use of INTEGER*2 as type of DATA statement loop index
  

  5397

  ICE on compiling source with 540 000 000 REAL array
  

  5473

  ICE on BESJN(integer*8,real)
  

  5837

  bug in loop unrolling

• g77 now has its man page generated from the texinfo documentation, to guarantee that it remains up to date.
• g77 used to reject the following program on 32-bit targets:

            PROGRAM PROG
            DIMENSION A(140 000 000)
            END
            

  with the message:

            prog.f: In program `prog':
            prog.f:2:
                     DIMENSION A(140 000 000)
                               ^
            Array `a' at (^) is too large to handle
            

  because 140 000 000 REALs is larger than the largest bit-extent that can be expressed in 32 bits. However, bit-sizes never play a role after offsets have been converted to byte addresses. Therefore this check has been removed, and the limit is now 2 Gbyte of memory (around 530 000 000 REALs). Note: On GNU/Linux systems one has to compile programs that occupy more than 1 Gbyte statically, i.e. g77 -static ....
• Based on work done by Juergen Pfeifer (juergen.pfeifer@gmx.net) libf2c is now a shared library. One can still link in all objects with the program by specifying the -static option.
• Robert Anderson (rwa@alumni.princeton.edu) thought up a two line change that enables g77 to compile such code as:

            SUBROUTINE SUB(A, N)
            DIMENSION N(2)
            DIMENSION A(N(1),N(2))
            A(1,1) = 1.
            END
            

  Note the use of array elements in the bounds of the adjustable array A.
• George Helffrich (george@geo.titech.ac.jp) implemented a change in substring index checking (when specifying -fbounds-check) that permits the use of zero length substrings of the form string(1:0).
• Based on code developed by Pedro Vazquez (vazquez@penelope.iqm.unicamp.br), the libf2c library is now able to read and write files larger than 2 Gbyte on 32-bit target machines, if the operating system supports this.

In 0.5.26, GCC 3.0 versus GCC 2.95:

• When a REWIND was issued after a WRITE statement on an unformatted file, the implicit truncation was performed by copying the truncated file to /tmp and copying the result back. This has been fixed by using the ftruncate OS function. Thanks go to the GAMESS developers for bringing this to our attention.
• Using options -g, -ggdb or -gdwarf[-2] (where appropriate for your target) now also enables debugging information for COMMON BLOCK and EQUIVALENCE items to be emitted. Thanks go to Andrew Vaught (andy@xena.eas.asu.edu) and George Helffrich (george@geology.bristol.ac.uk) for fixing this longstanding problem.
• It is not necessary anymore to use the option -femulate-complex to compile Fortran code using COMPLEX arithmetic, even on 64-bit machines (like the Alpha). This will improve code generation.
• INTRINSIC arithmetic functions are now treated as routines that do not depend on anything but their argument(s). This enables further instruction scheduling, because it is known that they cannot read or modify arbitrary locations.

In 0.5.25, GCC 2.95 (EGCS 1.2) versus EGCS 1.1.2:

• The new -fbounds-check option causes g77 to compile run-time bounds checks of array subscripts, as well as of substring start and end points.
• libg2c now supports building as multilibbed library, which provides better support for systems that require options such as -mieee to work properly.
• Source file names with the suffixes .FOR and .FPP now are recognized by g77 as if they ended in .for and .fpp, respectively.
• The order of arguments to the subroutine forms of the CTime, DTime, ETime, and TtyNam intrinsics has been swapped. The argument serving as the returned value for the corresponding function forms now is the second argument, making these consistent with the other subroutine forms of libU77 intrinsics.
• g77 now warns about a reference to an intrinsic that has an interface that is not Year 2000 (Y2K) compliant. Also, libg2c has been changed to increase the likelihood of catching references to the implementations of these intrinsics using the EXTERNAL mechanism (which would avoid the new warnings).

  See Year 2000 (Y2K) Problems, for more information.

• -fno-emulate-complex is now the default option. This should result in improved performance of code that uses the COMPLEX data type.
• The -malign-double option now reliably aligns all double-precision variables and arrays on Intel x86 targets.
• g77 no longer generates code to maintain errno, a C-language concept, when performing operations such as the SqRt intrinsic.
• Support for the -fugly option has been removed.

In 0.5.24 versus 0.5.23:

There is no g77 version 0.5.24 at this time, or planned. 0.5.24 is the version number designated for bug fixes and, perhaps, some new features added, to 0.5.23. Version 0.5.23 requires gcc 2.8.1, as 0.5.24 was planned to require.

Due to EGCS becoming GCC (which is now an acronym for "GNU Compiler Collection"), and EGCS 1.2 becoming officially designated GCC 2.95, there seems to be no need for an actual 0.5.24 release.

To reduce the confusion already resulting from use of 0.5.24 to designate g77 versions within EGCS versions 1.0 and 1.1, as well as in versions of g77 documentation and notices during that period, "mainline" g77 version numbering resumes at 0.5.25 with GCC 2.95 (EGCS 1.2), skipping over 0.5.24 as a placeholder version number.

To repeat, there is no g77 0.5.24, but there is now a 0.5.25. Please remain calm and return to your keypunch units.

In EGCS 1.1.2 versus EGCS 1.1.1:

In EGCS 1.1.1 versus EGCS 1.1:

In EGCS 1.1 versus EGCS 1.0.3:

• Support FORMAT(I<expr>) when expr is a compile-time constant INTEGER expression.
• Fix g77 -g option so procedures that use ENTRY can be stepped through, line by line, in gdb.
• Allow any REAL argument to intrinsics Second and CPU_Time.
• Use tempnam, if available, to open scratch files (as in OPEN(STATUS='SCRATCH')) so that the TMPDIR environment variable, if present, is used.
• g77's version of libf2c separates out the setting of global state (such as command-line arguments and signal handling) from main.o into distinct, new library archive members.

  This should make it easier to write portable applications that have their own (non-Fortran) main() routine properly set up the libf2c environment, even when libf2c (now libg2c) is a shared library.

• The g77 command now expects the run-time library to be named libg2c.a instead of libf2c.a, to ensure that a version other than the one built and installed as part of the same g77 version is picked up.
• Some diagnostics have been changed from warnings to errors, to prevent inadvertent use of the resulting, probably buggy, programs. These mostly include diagnostics about use of unsupported features in the OPEN, INQUIRE, READ, and WRITE statements, and about truncations of various sorts of constants.

In EGCS 1.1 versus g77 0.5.23:

• g77 now treats %LOC(expr) and LOC(expr) as "ordinary" expressions when they are used as arguments in procedure calls. This change applies only to global (filewide) analysis, making it consistent with how g77 actually generates code for these cases.

  Previously, g77 treated these expressions as denoting special "pointer" arguments for the purposes of filewide analysis.

• Align static double-precision variables and arrays on Intel x86 targets regardless of whether -malign-double is specified.

  Generally, this affects only local variables and arrays having the SAVE attribute or given initial values via DATA.

• The g77 driver now ensures that -lg2c is specified in the link phase prior to any occurrence of -lm. This prevents accidentally linking to a routine in the SunOS4 -lm library when the generated code wants to link to the one in libf2c (libg2c).
• g77 emits more debugging information when -g is used.

  This new information allows, for example, which __g77_length_a to be used in gdb to determine the type of the phantom length argument supplied with CHARACTER variables.

  This information pertains to internally-generated type, variable, and other information, not to the longstanding deficiencies vis-a-vis COMMON and EQUIVALENCE.

• The F90 Date_and_Time intrinsic now is supported.
• The F90 System_Clock intrinsic allows the optional arguments (except for the Count argument) to be omitted.

In 0.5.23 versus 0.5.22:

• This release contains several regressions against version 0.5.22 of g77, due to using the "vanilla" gcc back end instead of patching it to fix a few bugs and improve performance in a few cases.

  Features that have been dropped from this version of g77 due to their being implemented via g77-specific patches to the gcc back end in previous releases include:

  • Support for __restrict__ keyword, the options -fargument-alias, -fargument-noalias, and -fargument-noalias-global, and the corresponding alias-analysis code.

    (egcs has the alias-analysis code, but not the __restrict__ keyword. egcs g77 users benefit from the alias-analysis code despite the lack of the __restrict__ keyword, which is a C-language construct.)

  • Support for the GNU compiler options -fmove-all-movables, -freduce-all-givs, and -frerun-loop-opt.

    (egcs supports these options. g77 users of egcs benefit from them even if they are not explicitly specified, because the defaults are optimized for g77 users.)

  • Support for the -W option warning about integer division by zero.
  • The Intel x86-specific option -malign-double applying to stack-allocated data as well as statically-allocate data.
• Support gcc version 2.8, and remove support for prior versions of gcc.
• Remove support for the --driver option, as g77 now does all the driving, just like gcc.
• The g77 command now expects the run-time library to be named libg2c.a instead of libf2c.a, to ensure that a version other than the one built and installed as part of the same g77 version is picked up.
• g77's version of libf2c separates out the setting of global state (such as command-line arguments and signal handling) from main.o into distinct, new library archive members.

  This should make it easier to write portable applications that have their own (non-Fortran) main() routine properly set up the libf2c environment, even when libf2c (now libg2c) is a shared library.

• Some diagnostics have been changed from warnings to errors, to prevent inadvertent use of the resulting, probably buggy, programs. These mostly include diagnostics about use of unsupported features in the OPEN, INQUIRE, READ, and WRITE statements, and about truncations of various sorts of constants.

In 0.5.22 versus 0.5.21:

• Fix Signal intrinsic so it offers portable support for 64-bit systems (such as Digital Alphas running GNU/Linux).
• Support FORMAT(I<expr>) when expr is a compile-time constant INTEGER expression.
• Fix g77 -g option so procedures that use ENTRY can be stepped through, line by line, in gdb.
• Allow any REAL argument to intrinsics Second and CPU_Time.
• Allow any numeric argument to intrinsics Int2 and Int8.
• Use tempnam, if available, to open scratch files (as in OPEN(STATUS='SCRATCH')) so that the TMPDIR environment variable, if present, is used.
• Rename the gcc keyword restrict to __restrict__, to avoid rejecting valid, existing, C programs. Support for restrict is now more like support for complex.
• Fix -fugly-comma to affect invocations of only external procedures. Restore rejection of gratuitous trailing omitted arguments to intrinsics, as in I=MAX(3,4,,).
• Fix compiler so it accepts -fgnu-intrinsics-* and -fbadu77-intrinsics-* options.

In EGCS 1.0.2 versus EGCS 1.0.1:

• Fix compiler so it accepts -fgnu-intrinsics-* and -fbadu77-intrinsics-* options.

In EGCS 1.0.1 versus EGCS 1.0:

In EGCS 1.0 versus g77 0.5.21:

• Version 1.0 of egcs contains several regressions against version 0.5.21 of g77, due to using the "vanilla" gcc back end instead of patching it to fix a few bugs and improve performance in a few cases.

  Features that have been dropped from this version of g77 due to their being implemented via g77-specific patches to the gcc back end in previous releases include:

  • Support for the C-language restrict keyword.
  • Support for the -W option warning about integer division by zero.
  • The Intel x86-specific option -malign-double applying to stack-allocated data as well as statically-allocate data.
• Remove support for the --driver option, as g77 now does all the driving, just like gcc.
• Allow any numeric argument to intrinsics Int2 and Int8.

In 0.5.21:

• When the -W option is specified, gcc, g77, and other GNU compilers that incorporate the gcc back end as modified by g77, issue a warning about integer division by constant zero.
• New option -Wno-globals disables warnings about "suspicious" use of a name both as a global name and as the implicit name of an intrinsic, and warnings about disagreements over the number or natures of arguments passed to global procedures, or the natures of the procedures themselves.

  The default is to issue such warnings, which are new as of this version of g77.

• New option -fno-globals disables diagnostics about potentially fatal disagreements analysis problems, such as disagreements over the number or natures of arguments passed to global procedures, or the natures of those procedures themselves.

  The default is to issue such diagnostics and flag the compilation as unsuccessful. With this option, the diagnostics are issued as warnings, or, if -Wno-globals is specified, are not issued at all.

  This option also disables inlining of global procedures, to avoid compiler crashes resulting from coding errors that these diagnostics normally would identify.

• Fix libU77 routines that accept file and other names to strip trailing blanks from them, for consistency with other implementations. Blanks may be forcibly appended to such names by appending a single null character (CHAR(0)) to the significant trailing blanks.
• Fix CHMOD intrinsic to work with file names that have embedded blanks, commas, and so on.
• Fix SIGNAL intrinsic so it accepts an optional third Status argument.
• Make many changes to libU77 intrinsics to support existing code more directly.

  Such changes include allowing both subroutine and function forms of many routines, changing MCLOCK() and TIME() to return INTEGER(KIND=1) values, introducing MCLOCK8() and TIME8() to return INTEGER(KIND=2) values, and placing functions that are intended to perform side effects in a new intrinsic group, badu77.

• Add options -fbadu77-intrinsics-delete, -fbadu77-intrinsics-hide, and so on.
• Add INT2 and INT8 intrinsics.
• Add CPU_TIME intrinsic.
• Add ALARM intrinsic.
• CTIME intrinsic now accepts any INTEGER argument, not just INTEGER(KIND=2).
• g77 driver now prints version information (such as produced by g77 -v) to stderr instead of stdout.
• The .r suffix now designates a Ratfor source file, to be preprocessed via the ratfor command, available separately.

In 0.5.20:

• The -fno-typeless-boz option is now the default.

  This option specifies that non-decimal-radix constants using the prefixed-radix form (such as Z'1234') are to be interpreted as INTEGER(KIND=1) constants. Specify -ftypeless-boz to cause such constants to be interpreted as typeless.

  (Version 0.5.19 introduced -fno-typeless-boz and its inverse.)

  See Options Controlling Fortran Dialect, for information on the -ftypeless-boz option.

• Options -ff90-intrinsics-enable and -fvxt-intrinsics-enable now are the defaults.

  Some programs might use names that clash with intrinsic names defined (and now enabled) by these options or by the new 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.

• The ALWAYS_FLUSH macro is no longer defined when building 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.

  See Output Assumed To Flush, for more information.

• Dave Love's implementation of 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.
• New option -fvxt specifies that the source file is written in VXT Fortran, instead of GNU Fortran.

  See VXT Fortran, for more information on the constructs recognized when the -fvxt option is specified.

• The -fvxt-not-f90 option has been deleted, along with its inverse, -ff90-not-vxt.

  If you used one of these deleted options, you should re-read the pertinent documentation to determine which options, if any, are appropriate for compiling your code with this version of g77.

  See Other Dialects, for more information.

• The -fugly option now issues a warning, as it likely will be removed in a future version.

  (Enabling all the -fugly-* options is unlikely to be feasible, or sensible, in the future, so users should learn to specify only those -fugly-* options they really need for a particular source file.)

• The -fugly-assumed option, introduced in version 0.5.19, has been changed to better accommodate old and new code.

  See Ugly Assumed-Size Arrays, for more information.

• Related to supporting Alpha (AXP) machines, the LOC() intrinsic and %LOC() construct now return values of INTEGER(KIND=0) type, as defined by the GNU Fortran language.

  This type is wide enough (holds the same number of bits) as the character-pointer type on the machine.

  On most machines, this won't make a difference, whereas, on Alphas and other systems with 64-bit pointers, the INTEGER(KIND=0) type is equivalent to INTEGER(KIND=2) (often referred to as INTEGER*8) instead of the more common INTEGER(KIND=1) (often referred to as INTEGER*4).

• Emulate 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.
• Dummy arguments are no longer assumed to potentially alias (overlap) other dummy arguments or 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.

  See Aliasing Assumed To Work, for detailed information on why the new defaults might result in some programs no longer working the way they did when compiled by previous versions of g77.

• New option -fugly-assign specifies that the same memory locations are to be used to hold the values assigned by both statements I = 3 and ASSIGN 10 TO I, for example. (Normally, g77 uses a separate memory location to hold assigned statement labels.)

  See Ugly Assigned Labels, for more information.

• FORMAT and ENTRY statements now are allowed to precede IMPLICIT NONE statements.
• Enable full support of INTEGER(KIND=2) (often referred to as 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(KIND=2) support routines in the g77 version of libf2c.
• Improve g77 driver and libf2c so that g77 -v yields version information on the library.
• The SNGL and FLOAT intrinsics now are specific intrinsics, instead of synonyms for the generic intrinsic REAL.
• New intrinsics have been added. These are REALPART, IMAGPART, COMPLEX, LONG, and SHORT.
• A new group of intrinsics, gnu, has been added to contain the new REALPART, IMAGPART, and COMPLEX intrinsics. An old group, dcp, has been removed.
• Complain about industry-wide ambiguous references REAL(expr) and AIMAG(expr), where expr is 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.

In previous versions:

Information on previous versions is archived in gcc/gcc/f/news.texi following the test of the DOC-OLDNEWS macro.