Stack Overflow

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.
Note: While 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.)