g77 code might fail at runtime (probably with a “segmentation violation”) due to overflowing the stack. This happens most often on systems with an environment that provides substantially more heap space (for use when arbitrarily allocating and freeing memory) than stack space.
Often this can be cured by increasing or removing your shell's limit on stack usage, typically using limit stacksize (in csh and derivatives) or ulimit -s (in sh and derivatives).
Increasing the allowed stack size might, however, require changing some operating system or system configuration parameters.
You might be able to work around the problem by compiling with the -fno-automatic option to reduce stack usage, probably at the expense of speed.
g77, on most machines, puts many variables and arrays on the stack
where possible, and can be configured (by changing
FFECOM_sizeMAXSTACKITEM in gcc/gcc/f/com.c) to force
smaller-sized entities into static storage (saving
on stack space) or permit larger-sized entities to be put on the
stack (which can improve run-time performance, as it presents
more opportunities for the GBE to optimize the generated code).
Note: Putting more variables and arrays on the stack
might cause problems due to system-dependent limits on stack size.
Also, the value of
FFECOM_sizeMAXSTACKITEM has no
effect on automatic variables and arrays.
See But-bugs, for more information.
libg2c places a limit on the range
of Fortran file-unit numbers, the underlying library and operating
system might impose different kinds of limits.
For example, some systems limit the number of files simultaneously
open by a running program.
Information on how to increase these limits should be found
in your system's documentation.
However, if your program uses large automatic arrays
(for example, has declarations like `REAL A(N)' where
`A' is a local array and `N' is a dummy or
COMMON variable that can have a large value),
neither use of -fno-automatic,
nor changing the cut-off point for g77 for using the stack,
will solve the problem by changing the placement of these
large arrays, as they are necessarily automatic.
g77 currently provides no means to specify that automatic arrays are to be allocated on the heap instead of the stack. So, other than increasing the stack size, your best bet is to change your source code to avoid large automatic arrays. Methods for doing this currently are outside the scope of this document.
(Note: If your system puts stack and heap space in the same memory area, such that they are effectively combined, then a stack overflow probably indicates a program that is either simply too large for the system, or buggy.)