The f77 command can both compile and link a source module. Figure 1-1 shows the primary compilation phases. It also shows the principal inputs and outputs for the source modules more.f.

Figure 1-1. Compilation Process

The compiler system uses drivers that allow you to compile programs for other programming languages, including C and C++. If one of these drivers is installed in your system, you can compile and link your Fortran programs to the language supported by the driver. See the MIPSpro Compiling and Performance Tuning Guide for a list of available drivers and the commands used with them. See Chapter 3, “Fortran Program Interfaces”, for information about the conventions you must follow when writing Fortran program interfaces to C programs.

When your application has two or more source programs written in different languages, you should compile each program module separately with the appropriate driver and then link them in a separate step. Create objects suitable for linking by specifying the -c option, which stops the driver immediately after the assembler phase.

The following two command lines produce linkable objects named main.o and rest.o, as illustrated in Figure 1-2.

% cc -c main.c
% f77 -c rest.f

Figure 1-2. Compiling Multilanguage Programs

You can use the f77 command to link separate objects into one executable program when any one of the objects is compiled from a Fortran source. The compiler recognizes the .o suffix as the name of a file containing object code suitable for linking and it immediately invokes the linker. The following command links the object created in the last example:

% f77 -o myprog main.o rest.o

You can also use the cc command, as shown in this example:

% cc -o myprog main.o rest.o -lftn -lm

Figure 1-3 shows the flow of control for this link.

Figure 1-3. Linking

Both f77 and cc use the C link library by default. However, you must specify them explicitly to the linker using the cc -l option as shown in the previous example. The characters following -l in the previous example are shorthand for link library files described in the following table.

See the FILES section of the f77(1) reference page for a complete list of the files used by the Fortran driver. Also see the ld(1) man page for information on specifying the -l option.

You may need to specify libraries when you use IRIX system packages that are not part of a particular language. Most of the man pages for these packages list the required libraries. For example, the getwd(3B) subroutine requires the BSD compatibility library libbsd.a. Specify this library as follows:

% f77 main.o more.o rest.o -lbsd

To specify a library created with the archiver, type in the pathname of the library as shown below.

% f77 main.o more.o rest.o libfft.a

---

Note: The linker searches libraries in the order you specify. Therefore, if you have a library (for example, libfft.a) that uses data or procedures from -lm, you must specify libfft.a first.

---

You need only a few compiler options when you are compiling a simple program. Examples of simple programs include the following:

In these cases you need only specify the -g option for debugging, specify the target machine architecture, and specify the word-length. For example, to compile a single source file to execute under dbx, you could use the following commands.

f77 -g -mips4 -n32 -o testcase testcase.f
dbx testcase

However, a program compiled in this way takes little advantage of the performance features of the machine. In particular, its speed when doing heavy floating-point calculations will be far slower than the machine capacity. For simple programs, however, that is not important.

You can set the Application Binary Interface (ABI), instruction set architecture (ISA), and processor type without explicitly specifying them. Set the COMPILER_DEFAULTS_PATH environment variable to a colon-separated list of paths indicating where the compiler should check for a compiler.defaults file. If no compiler.defaults file is found or if the environment variable is not set, the compiler looks for /etc/compiler.defaults. If this file is not found, the compiler uses the built-in defaults.

The compiler.defaults file contains a -DEFAULT:option group command that specifies the default ABI, ISA, and processor. The compiler issues a warning if you specify anything other than -DEFAULT: option in the compiler.defaults file.

The format of the -DEFAULT:option group specifier is as follows:

-DEFAULT:[abi=abitype] [:isa= isatype] [:proc=rtype] [:opt=level] [:arith=number] 

See the f77(1) man page for an explanation of the arguments and their allowed values.

To run a Fortran program, invoke the executable object module produced by the f77 command by entering the name of the module as a command. By default, the name of the executable module is a.out. If you included the -o filename option on the ld (or the f77) command line, the executable object module has the name that you specified.

The total memory allocation for a program, and individual arrays, can exceed 2 gigabytes (2 GB, or 2,048 MB).

Previous implementations of FORTRAN 77 limited the total program size, as well as the size of any single array, to 2 GB. The current release allows the total memory in use by the program to exceed this. For details about the memory use of individual scalar values, see “Alignment, Size, and Value Ranges” in Chapter 2.

$cat a2.c

#include <stdlib.h>

int i[0x100000008];

void foo()
{
int k[0x100000008];
 k[0x100000007] = 9;
 printf("%d \n", k[0x100000007]);
}

main()
{
char *j;
j = malloc(0x100000008);
 i[0x100000007] = 7;
 j[0x100000007] = 8;
 printf("%d \n", i[0x100000007]);
 printf("%d \n", j[0x100000007]);
 foo();
}

$uname -a
IRIX64 cydrome 6.2 03131016 IP19
$cc -64 -mips3 a2.c
$limit
cputime         unlimited
filesize        unlimited
datasize        unlimited
stacksize       65536 kbytesn
coredumpsize    unlimited
memoryuse
descriptors     200
vmemoryuse      unlimited
$limit stacksize unlimited
$limit
cputime         unlimited
filesize        unlimited
datasize        unlimited
stacksize       unlimited
coredumpsize    unlimited
memoryuse       754544 kbytes
descriptors     200
vmemoryuse      unlimited
$a.out
7
8
9

    parameter (ndim = 16380)
    integer*8 xmat(ndim,ndim), ymat(ndim,ndim), &
        zmat(ndim,ndim)
    integer k(1073741824)
    integer l(33554432, 256)

    subroutine abc(k)
    integer k(8589934592_8)

    integer *8 ndim
    parameter (ndim = 20001)
    pointer (xptr, xmat), (yptr, ymat), (zptr, zmat), &
        (aptr, amat)
    xptr = malloc(ndim*ndim*8)
    yptr = malloc(ndim*ndim*8)
    zptr = malloc(ndim*ndim*8)
    aptr = malloc(ndim*ndim*8)

The Fortran compiler supports five kinds of external files:

The operating system implements other files as ordinary files and makes no assumptions about their internal structure.

Fortran I/O is based on records. When a program opens a direct file or a key-indexed file, the length of the records must be given. The Fortran I/O system uses the length to make the file appear to be composed of records of the given length. When the record length of a direct unformatted file is 1 byte, the system treats the file as ordinary system files (that is, as byte strings, in which each byte is addressable). A READ or WRITE request on such files consumes bytes until they are used, rather than restricting the request to a single record.

Because of special requirements, sequential unformatted files are usually read or written only by Fortran I/O statements. Each record is preceded and followed by an integer containing the length of the record in bytes.

During a READ, Fortran I/O breaks sequential formatted files into records by using each new line indicator as a record separator. The FORTRAN 77 standard does not define the required result after reading past the end of a record; the I/O system treats the record as being extended by blanks. On output, the I/O system writes a new line indicator at the end of each record. If a user's program also writes a new line indicator, the I/O system treats it as a separate record.

The following table shows the standard preconnected files at program start.

All other units are also preconnected when execution begins. Unit n is connected to a file named fort.n. These files need not exist, nor will they be created unless their units are used without first executing an open statement. The default connection is for sequentially formatted I/O.

The FORTRAN 77 standard does not specify where OPEN should initially position a file that is explicitly opened for sequential I/O. The I/O system positions the file to start of file for both input and output. The execution of an OPEN statement followed by a WRITE on an existing file causes the file to be overwritten, erasing any data in the file. In a program called from a parent process, units 0, 5, and 6 remain where they were positioned by the parent process.

When the STATUS="UNKNOWN" parameter is specified in an OPEN statement, the following occurs:

When running programs that contain quad-precision operations, you must run the compiler in round-to-nearest mode. Because this mode is the default, you usually do not have to set it. You will need to set this mode when writing programs that call your own assembly routines. Refer to the swapRM(3c) man page for details.

When the Fortran run-time system detects an error, the following actions occur:

The libfpe library provides two methods for handling floating point exceptions.

The library provides the handle_sigfpes subroutine and the TRAP_FPE environment variable. Both methods provide mechanisms for handling and classifying floating point exceptions, and for substituting new values. They also provide mechanisms to count, trace, exit, or abort on enabled exceptions. The -TENV:check_div compile option inserts checks for divide by zero or overflow. See the handle_sigfpes(3f) man page for more information.