🚀 go-pugleaf

> Hello, is there anyone who knows, and is willing to explain what is
> meant by the following, taken from 'A Portable Fortran 77 Compiler', 
> S.I.Feldman and P.J.Weinberger.
> 
> 	'......the f77 and cc commands cause slightly different loading
> sequences to be generated, since Fortran programs need a few extra libraries

Under 4.2BSD, the "f77" and "cc" commands both tell the linker "ld" to
place the file "crt0.o" (or "mcrt0.o" if you choose to use the "-p"
option) at the beginning of your executable ("a.out") program.  Both
tell it to search "-lc" ("libc.a", the C library), but "f77" tells it
to search "-lF77", "-lI77", "-lU77", and "-lm" (three Fortran-specific
libraries and the Unix math library) prior to "-lc".

Fortran needs additional libraries (a) to implement Fortran-specific
features like read/write/print and the standard subroutines like csin
and sinh, and (b) to permit you to call routines like "getenv (3f)"
which resemble those in the C library but which use the Fortran calling
conventions (arguments generally passed by reference) rather than the C
calling conventions (arguments passed by value).

When you define or reference a subroutine or function in C, the
compiler constructs a symbol for it by prepending an "_". In Fortran,
the compiler both prepends and appends an "_". This has two advantages:
(a) names you invent within your program will not conflict with those
in the C library, and (b) the Fortran libraries can provide wrappers
for C library routines ("_getenv_" versus "_getenv").

"crt0.o" (or "mcrt0.o") jumps to "_main" to start your program. In C, the
main program is always called "main" (which gets transformed to "_main" as
just described). In Fortran, there's no way for you to create an "_main"
(the closest you can come is "_main_"), so by providing a module "main.o"
with an entry point called "_main", the compiler can guarantee that the
runtime library gets initialized before your own code starts to execute.
Among other things, it sets up signal handlers and arranges for the
subroutine "getargv (3f)" to be able to access the command-line arguments.
Then it transfers control to the entry point _MAIN_, which the compiler
always puts at the beginning of the Fortran main program (even if you use a
"program" statement to give it another name).

If you enjoy peeking at what the compiler is doing, "f77 -S" is a useful
technique.

-- 
...decwrl!mips!sjc						Steve Correll

In article <1709@eagle.ukc.ac.uk>, map@ukc.ac.uk (M.A.Pralat) writes:
> 
> 	'......the f77 and cc commands cause slightly different loading
> sequences to be generated, since Fortran programs need a few extra libraries
> and a different startup routine than do C programs'
> 

  My understanding is that when using ld(1), the entry point is ALWAYS
called "main". In your f77 program, the main f77 routine is referred to
as MAIN_ (any PROGRAM card is ignored). The startup routine for f77 programs
is a C program that looks like

main(argc,argv,envp) int argc; char **argv,**envp; {

f_init(); MAIN_(); f_exit();

}

The f_init and f_exit set up and close the F77 I/O drivers, which
run with FORTRAN logical unit numbers on top of the usual UNIX file
descriptors. This is similar to the stdio library, which uses stream
pointers which run on top of the file descriptors, but of course the
actual routines used are different.

--Greg