This chapter describes how to use the FORTRAN command to compile your source programs into object files. The following topics are discussed:

• The functions of the compiler ( Section 2.1)
• FORTRAN command syntax, use, and examples ( Section 2.2)
• FORTRAN command qualifiers ( Section 2.3)
• Creating and maintaining text libraries ( Section 2.4)
• Compiler diagnostic messages and error conditions ( Section 2.5)
• Compiler output listing format ( Section 2.6)

The primary functions of the Compaq Fortran compiler are as follows:

• To verify the Compaq Fortran source statements and to issue messages if the source statements contain any errors
• To generate machine language instructions from the source statements of the Compaq Fortran program
• To group these instructions into an object module for the Compaq OpenVMS Linker

When the compiler creates an object file, it provides the linker with the following information:

• The program unit name. The program unit name is the name specified in the PROGRAM, MODULE, SUBROUTINE, FUNCTION, or BLOCK DATA statement in the source program. If a program unit does not contain any of these statements, the source file name is used with $MAIN (or $DATA, for block data subprograms) appended.
• A list of all entry points and common block names that are declared in the program unit. The linker uses this information when it binds two or more program units together and must resolve references to the same names in the program units.
• Traceback information, used by the system default condition handler when an error occurs that is not handled by the program itself. The traceback information permits the default handler to display a list of the active program units in the order of activation, which aids program debugging.
• A symbol table, if specifically requested (/DEBUG qualifier). A symbol table lists the names of all external and internal variables within a object module, with definitions of their locations. The table is of primary use in program debugging.

For More Information:

On the OpenVMS Linker, see Chapter 3.

2.2 The FORTRAN Command

The FORTRAN command initiates compilation of a source program.

The command has the following form:

FORTRAN [/qualifiers] file-spec-list[/qualifiers]

/qualifiers

Indicates either special actions to be performed by the compiler or special properties of input or output files.

file-spec-list

Specifies the source files containing the program units to be compiled. You can specify more than one source file:

• If source file specifications are separated by commas (,), the programs are compiled separately.
• If source file specifications are separated by plus signs (+), the files are concatenated and compiled as one program.

When compiling source files with the default optimization (or additional optimizations), concatenating source files allows full interprocedure optimizations to occur.

In interactive mode, you can also enter the file specification on a separate line by typing the command FORTRAN, followed by a carriage return. The system responds with the following prompt:

_File:

Type the file specification immediately after the prompt and then press Return.

2.2.1 Specifying Input Files and Source Form

If you omit the file type on the FORTRAN command line, the compiler searches first for a file with a file type of F90. If a file with a file type of F90 is not found, it then searches for file with a file type of FOR and then F.

For example, the following FORTRAN command line shows how file type searching occurs:

$ FORTRAN PROJ_ABC

This FORTRAN command searches for the following files:

1. It searches first for PROJ_ABC.F90.
2. If PROJ_ABC.F90 does not exist, it then searches for PROJ_ABC.FOR.
3. If PROJ_ABC.F90 and PROJ_ABC.FOR do not exist, it then searches for PROJ_ABC.F.

Indicate the Fortran 90 source form used in your source files by using certain file types or a command-line qualifier:

• For files using fixed form, use a file type of FOR or F.
• For files using free form, use a file type of F90.
• You can also specify the /SOURCE_FORM qualifier on the FORTRAN command line to specify the source form (FIXED or FREE) for:
  • All files on that command line (when used as a command qualifier)
  • Individual source files in a comma-separated list of files (when used as a positional qualifier)

For example, if you specify a file as PROJ_BL1.F90 on an FORTRAN command line (and omit the /SOURCE_FORM=FIXED qualifier), the FORTRAN command assumes the file PROJ_BL1.F90 contains free-form source code.

2.2.2 Specifying Multiple Input Files

When you specify a list of input files on the FORTRAN command line, you can use abbreviated file specifications for those files that share common device names, directory names, or file names.

The system applies temporary file specification defaults to those files with incomplete specifications. The defaults applied to an incomplete file specification are based on the previous device name, directory name, or file name encountered in the list.

The following FORTRAN command line shows how temporary defaults are applied to a list of file specifications:

$ FORTRAN USR1:[ADAMS]T1,T2,[JACKSON]SUMMARY,USR3:[FINAL]

The preceding FORTRAN command compiles the following files:

USR1:[ADAMS]T1.F90 (or .FOR or .F) USR1:[ADAMS]T2.F90 (or .FOR or .F) USR1:[JACKSON]SUMMARY.F90 (or .FOR or .F) USR3:[FINAL]SUMMARY.F90 (or .FOR or .F)

To override a temporary default with your current default directory, specify the directory as a null value. For example:

$ FORTRAN [OMEGA]T1, []T2

The empty brackets indicate that the compiler is to use your current default directory to locate T2.

FORTRAN qualifiers typically apply to the entire FORTRAN command line. One exception is the /LIBRARY qualifier, which specifies that the file specification it follows is a text library (positional qualifier). The /LIBRARY qualifier is discussed in Section 2.3.26.

You can specify multiple files on the FORTRAN command line. You can separate the multiple source file specifications with:

• Plus signs (+)
  All files separated by plus signs are concatenated and compiled as one program into a single object file.
  A positional qualifier after one of the file specifications applies to all files concatenated by plus signs (+). One exception is the /LIBRARY qualifier (used only as a positional qualifier).
  Concatenating source files allows full interprocedure optimizations to occur across the multiple source files (unless you specify certain command qualifiers, such as /NOOPTIMIZE and /SEPARATE_COMPILATION).
• Commas (,)
  When separated by commas, the files are compiled separately into multiple object files.
  A positional qualifier applies only to the file specification it immediately follows.
  Separate compilation by using comma-separated files (or by using multiple FORTRAN commands) prevents certain interprocedure optimizations.

If you use multiple FORTRAN commands to compile multiple Compaq Fortran source files that are linked together into the same program, you must be consistent when specifying any qualifiers that effect run-time results. For instance, suppose you do the following:

1. Specify /FLOAT=IEEE_FLOAT on one command line
2. Specify /FLOAT=G_FLOAT on another command line
3. Link the resulting object files together into a program

When you run the program, the values returned for floating-point numbers in a COMMON block will be unpredictable. For qualifiers related only to compile-time behavior (such as /LIST and /SHOW), this restriction does not apply.

2.2.3 Creating and Using Module Files

Compaq Fortran creates module files for each module declaration and automatically searches for a module file referenced by a USE statement (introduced in Fortran 90). A module file contains the equivalent of the module source declaration in a post-compiled, binary form.

2.2.3.1 Creating Module Files

When you compile a Compaq Fortran source file that contains module declarations, Compaq Fortran creates a separate file for each module declaration in the current process default device and directory. The name declared in a MODULE statement becomes the base prefix of the file name and is followed by the F90$MOD file type.

For example, consider a file that contains the following statement:

MODULE MOD1

The compiler creates a post-compiled module file MOD1.F90$MOD in the current directory. An object file is also created for the module.

Compiling a source file that contains multiple module declarations will create multiple module files, but only a single object file. If you need a separate object file for each module, place only one module declaration in each file.

If a source file does not contain the main program and you need to create module files only, specify the /NOOBJECT qualifier to prevent object file creation.

To specify a directory other than the current directory for the module file(s) to be placed, use the /MODULE qualifier (see Section 2.3.30).

Note that an object file is not needed if there are only INTERFACE or constant (PARAMETER) declarations; however, it is needed for all other types of declarations including variables.

2.2.3.2 Using Module Files

Once you create a module file, you can copy module files into an appropriate shared or private directory. You reference a module file by specifying the module name in a USE statement (use association). For example:

USE MOD1

By default, the compiler searches for a module file named MOD1.F90$MOD in the current directory.

When selecting a directory location for a set of module files, consider how your application gets built, including:

• Whether the module files need to be available privately, such as for testing purposes (not shared).
• Whether you want the module files to be available to other users on your project or available system-wide (shared).
• Whether test builds and final production builds will use the same or a different directory for module files.

Compaq Fortran allows you to use multiple methods to specify which directories are searched for module files:

• You can specify one or more additional directories for the compiler to search by using the /INCLUDE=directory qualifier.
• You can specify one or more additional directories for the compiler to search by defining the logical name FORT$INCLUDE. To search multiple additional directories with FORT$INCLUDE, define it as a search list. Like other logical names, FORT$INCLUDE can be for a system-wide location (such as a group or system logical name) or a private or project location (such as a process, job, or group logical name).
• You can prevent the compiler from searching in the directory specified by the FORT$INCLUDE logical name by using the /NOINCLUDE qualifier.

To locate modules referenced by USE statements, the compiler searches directories in the following order:

1. The current process device and directory
2. Each directory specified by the /INCLUDE qualifier
3. The directory specified by the logical name FORT$INCLUDE (unless /NOINCLUDE was specified).

You cannot specify a module (.F90$MOD) file directly on the FORTRAN command line.

Suppose you need to compile a main program PROJ_M.F90 that contains one or more USE statements. To request that the compiler look for module files in the additional directories DISKA:[PROJ_MODULE.F90] and then DISKB:[COMMON.FORT] (after looking in the current directory), type the following command line:

$ FORTRAN PROJ_M.F90 /INCLUDE=(DISKA:[PROJ_MODULE.F90],DISKB:[COMMON.FORT])

If you specify multiple directories with the /INCLUDE qualifier, the order of the directories in the /INCLUDE qualifier determines the directory search order.

Module nesting depth is unlimited. If you will use many modules in a program, check the process and system file limits (see Section 1.1).

For More Information:

• On the FORTRAN /INCLUDE qualifier, see Section 2.3.24.
• On an example program that uses a module, see Section 1.3.

You can create include files with a text editor. The include files can be placed in a text library. If needed, you can copy include files or include text library to a shared or private directory.

When selecting a directory location for a set of include files or text libraries, consider how your application is to be built, including:

• Whether the include files or text library needs to be available privately, such as for testing purposes (not shared).
• Whether you want the files to be available to other users on your project or available system-wide (shared).
• Whether test builds and final production builds will use the same or a different directory.
• Instead of placing include files in a directory, consider placing them in a text library. The text library can contain multiple include files in a single library file and is maintained by using the OpenVMS LIBRARY command.

Include files have a file type like other Compaq Fortran source files (F90, FOR, or F). Use an INCLUDE statement to request that the specified file containing source lines be included in place of the INCLUDE statement.

To include a file, the INCLUDE statement has the following form:

INCLUDE 'name' INCLUDE 'name.typ'

You can specify /LIST or /NOLIST after the file name. You can also specify the /SHOW=INCLUDE or /SHOW=NOINCLUDE qualifier to control whether source lines from included files or library modules appear in the listing file (see Section 2.3.42).

You can also include a file with a directory (and optionally the device name) specified with the following form:

INCLUDE '[directory]name' INCLUDE '[directory]name.typ'

If a directory is specified, only the specified directory is searched. The remainder of this section addresses an INCLUDE statement where the directory has not been specified.

Compaq Fortran allows you to use multiple methods to specify which directories are searched for include files:

• You can request that the Compaq Fortran compiler search either in the current process default directory or in the directory where the source file resides that references the include file. To do this, specify the /ASSUME=NOSOURCE_INCLUDE (process default directory) or /ASSUME=SOURCE_INCLUDE qualifier (source file directory). The default is /ASSUME=NOSOURCE_INCLUDE.
• You can specify one or more additional directories for the compiler to search by using the /INCLUDE=directory qualifier.
• You can specify one or more additional directories for the compiler to search by defining the logical name FORT$INCLUDE. To search multiple additional directories with FORT$INCLUDE, define it as a search list. Like other logical names, FORT$INCLUDE can be for:
  • A system-wide location (such as a group or system logical name)
  • A private or project location (such as a process, job, or group logical name)
• You can prevent the compiler from searching in the directory specified by the FORT$INCLUDE logical name by using the /NOINCLUDE qualifier.

To locate include files specified in INCLUDE statements (without a device or directory name), the Compaq Fortran compiler searches directories in the following order:

1. The current process default directory or the directory that the source file resides in (depending on whether /ASSUME=SOURCE_INCLUDE was specified)
2. Each directory specified by the /INCLUDE qualifier
3. The directory specified by the logical name FORT$INCLUDE (unless /NOINCLUDE was specified).

Compaq Fortran provides certain include library modules in the text library FORSYSDEF.TLB. Users can create a text library and populate it with include library modules (see Section 2.4). Within a library, text library modules are identified by a library module name (no file type).

To include a text library module, the INCLUDE statement specifies the name of the library module within parentheses, as follows:

INCLUDE '(name)'

You can specify the library name before the library module name in the INCLUDE statement. For example:

INCLUDE 'MYLIB(PROJINC)'

Use one of the following methods to access a source library module in a text library:

• Specify only the name of the library module in an INCLUDE statement in your Compaq Fortran source program. You use FORTRAN command qualifiers and logical names to control the directory search for the library.
• Specify the name of both the library and library module in an INCLUDE statement in your Compaq Fortran source program.
• When the INCLUDE statement does not specify the library name, you can define a default library by using the logical name FORT$LIBRARY.
• When the INCLUDE statement does not specify the library name, you can specify the name of the library using the /LIBRARY qualifier on the FORTRAN command line that you use to compile the source program.

When the library is named in the INCLUDE statement, the FORTRAN command searches various directories for the named library, similar to the search for an include file.

Compaq Fortran allows you to use multiple methods to specify which directories are searched for named text libraries:

• You can request that the Compaq Fortran compiler search either in the current process default directory or in the directory where the source file resides that references the text library. To do this, specify the /ASSUME=NOSOURCE_INCLUDE (process default directory) or /ASSUME=SOURCE_INCLUDE qualifier (source file directory).
• You can specify one or more additional directories for the compiler to search by using the /INCLUDE=directory qualifier.
• You can specify one or more additional directories for the compile to search by defining the logical name FORT$INCLUDE. To search multiple additional directories with FORT$INCLUDE, define it as a search list. Like other logical names, FORT$INCLUDE can be for:
  • A system-wide location (such as a group or system logical name)
  • A private or project location (such as a process, job, or group logical name)
• You can prevent the compiler from searching in the directory specified by the FORT$INCLUDE logical name by using the /NOINCLUDE qualifier.

The Compaq Fortran compiler searches directories in the following order:

1. The current process default directory or the directory that the source file resides in (depending on whether /ASSUME=SOURCE_INCLUDE was specified)
2. Each directory specified by the /INCLUDE qualifier
3. The directory specified by the logical name FORT$INCLUDE (unless /NOINCLUDE was specified).

You can specify /LIST or /NOLIST after the library module name. For example:

INCLUDE 'PROJLIB(MYINC)/LIST'

You can also specify the /SHOW=INCLUDE or /SHOW=NOINCLUDE qualifier to control whether source lines from included files or library modules appear in the listing file (see Section 2.3.42).

For More Information:

• On the /ASSUME=[NO]SOURCE_INCLUDE qualifier, see Section 2.3.7.
• On the /INCLUDE qualifier, see Section 2.3.24.
• On creating and using text libraries, see Section 2.4.

When the INCLUDE statement does not specify the library, you can specify additional text libraries to be searched on the FORTRAN command line or by defining a logical name. The order in which the compiler searches for a library file follows:

• Specify the library name on the FORTRAN command line, appended with the /LIBRARY positional qualifier. The /LIBRARY qualifier identifies a file specification as a text library.
  Concatenate the name of the text library to the name of the source file and append the /LIBRARY qualifier to the text library name (use the plus sign (+)) separator. For example:

  $ FORTRAN APPLIC+DATAB/LIBRARY

  
  Whenever an INCLUDE statement occurs in APPLIC.FOR, the compiler searches the library DATAB.TLB for the source text module identified in the INCLUDE statement and incorporates it into the compilation.
  When more than one library is specified on a FORTRAN command line, the Compaq Fortran compiler searches the libraries each time it processes an INCLUDE statement that specifies a text module name. The compiler searches the libraries in the order specified on the command line. For example:

  $ FORTRAN APPLIC+DATAB/LIBRARY+NAMES/LIBRARY+GLOBALSYMS/LIBRARY

  
  When the Compaq Fortran compiler processes an INCLUDE statement in the source file APPLIC.FOR, it searches the libraries DATAB.TLB, NAMES.TLB, and GLOBALSYMS.TLB, in that order, for source text modules identified in the INCLUDE statement.
  When the FORTRAN command requests multiple compilations, a library must be specified for each compilation in which it is needed. For example:

  $ FORTRAN METRIC+DATAB/LIBRARY, APPLIC+DATAB/LIBRARY

  
  In this example, Compaq Fortran compiles METRIC.FOR and APPLIC.FOR separately and uses the library DATAB.TLB for each compilation.
  If the text library is not in the current process default directory, specify the device and/or directory. For example:

  $ FORTRAN PROJ_MAIN+$DISK2:[PROJ.LIBS]COMMON_LIB/LIBRARY

  
  Instead of specifying the device and directory name, you can use the /ASSUME=SOURCE_INCLUDE and /INCLUDE qualifiers and FORT$INCLUDE logical name to control the directory search.

• After the compiler has searched all libraries specified on the command line, it searches the default user library (if any) specified by the logical name FORT$LIBRARY. When you want to define one of your private text libraries as a default library for the Compaq Fortran compiler to search, consider using the FORT$LIBRARY logical name.
  For example, define a default library using the logical name FORT$LIBRARY before compilation, as in the following example of the DCL command DEFINE:

  $ DEFINE FORT$LIBRARY $DISK2:[LIB]DATAB $ FORTRAN PROJ_MAIN

  
  While this assignment is in effect, the compiler automatically searches the library $DISK2:[LIB]DATAB.TLB for any include library modules that it cannot locate in libraries explicitly specified, if any, on the FORTRAN command line.
  You can define the logical name FORT$LIBRARY in any logical name table defined in the logical name table search list LMN$FILE_DEV. For example:

  $ DEFINE /GROUP FORT$LIBRARY $DISK2:[PROJ.LIBS]APPLIB.TLB $ FORTRAN PROJ_MAIN

  
  If the name is defined in more than one table, the Compaq Fortran compiler uses the equivalence for the first match it finds in the normal order of search---first the process table, then intermediate tables (job, group, and so on), and finally the system table. If the same logical name is defined in both the process and system logical name tables, the process logical name table assignment overrides the system logical name table assignment.
  If FORT$LIBRARY is defined as a search list, the compiler opens the first text library specified in the list. If the include library module is not found in that text library, the search is terminated and an error message is issued.
  The logical name FORT$LIBRARY is recognized by both Compaq Fortran 77 and Compaq Fortran.

• When the Compaq Fortran compiler cannot find the include library modules in libraries specified on the FORTRAN command line or in the default library defined by FORT$LIBRARY, it then searches the standard text library supplied by Compaq Fortran. This library resides in SYS$LIBRARY with a file name of FORSYSDEF.TLB and simplifies calling OpenVMS system services.
  SYS$LIBRARY identifies the device and directory containing system libraries and is normally defined by the system manager. FORSYSDEF.TLB is a library of include library modules supplied by Compaq Fortran. It contains local symbol definitions and structures required for use with system services and return status values from system services.
  For more information on the contents of FORSYSDEF, see Appendix D.

You can specify /LIST or /NOLIST after the library module name. For example:

INCLUDE '(MYINC)/NOLIST'

You can also specify the /SHOW=INCLUDE or /SHOW=NOINCLUDE qualifier to control whether source lines from included files or library modules appear in the listing file (see Section 2.3.42).

For More Information:

• On the /ASSUME=[NO]SOURCE_INCLUDE qualifier, see Section 2.3.7.
• On the /INCLUDE qualifier, see Section 2.3.24.
• On creating and using text libraries, see Section 2.4.

The output produced by the compiler includes the object and listing files. You can control the production of these files by using the appropriate qualifiers on the FORTRAN command line.

The production of listing files depends on whether you are operating in interactive mode or batch mode:

• In interactive mode, the compiler does not generate listing files by default; you must use the /LIST qualifier to generate the listing file.
• In batch mode, the compiler generates a listing file by default. To suppress it, you must use the /NOLIST qualifier.

For command procedures that compile the application in either batch or interactive mode, consider explicitly specifying /NOLIST (or /LIST).

The compiler generates an object file by default. During the early stages of program development, you may find it helpful to use the /SYNTAX_ONLY or /NOOBJECT qualifiers to prevent the creation of object files until your source program compiles without errors. If you omit /NOOBJECT, the compiler generates object files as follows:

• If you specify one source file, one object file is generated.
• If you specify multiple source files separated by commas, each source file is compiled separately, and an object file is generated for each source file.
• If you specify multiple source files separated by plus signs, the source files are concatenated and compiled, and one object file is generated.

You can use both commas and plus signs in the same command line to produce different combinations of concatenated and separate object files (see the examples of the FORTRAN command at the end of this section).

To name an object file, use the /OBJECT qualifier in the form /OBJECT=file-spec. Otherwise, the object file has the file name of its corresponding source file and a file type of OBJ. By default, the object file produced from concatenated source files has the name of the first source file. All other file specification fields (node, device, directory, and version) assume the default values.

When creating object files that will be placed in an object library, consider using the /SEPARATE_COMPILATION qualifier, which places individual compilation units in a source file as separate components in the object file. This minimizes the size of the routines included by the linker as it creates the executable image. However, to allow more interprocedure optimizations, use the default /NOSEPARATE_COMPILATION.

For More Information:

• On creating and naming object files, see Section 2.2.6.1 and Section 2.3.32.
• On the /SEPARATE_COMPILATION qualifier, see Section 2.3.40.
• On using object libraries, see Chapter 3.

The following examples show the use of the FORTRAN command.

2.2.6.1 Naming the Object File

The following FORTRAN command compiles the Compaq Fortran free-form source file (CIRCLE.F90) into an object file:

$ FORTRAN /OBJECT=[BUILD]SQUARE /NOLIST [Return] _File: CIRCLE

The source file CIRCLE.F90 is compiled, producing an object file named SQUARE.OBJ in the [BUILD] directory, but no listing file.

2.2.6.2 Compiler Source Checking Only (No Object File)

The following FORTRAN command examines Compaq Fortran fixed-form source file (ABC.FOR) without creating an object file:

$ FORTRAN /NOOBJECT ABC.FOR

The source file ABC.FOR is compiled, syntax checking occurs, but no object file is produced. The /NOOBJECT qualifier performs full compilation checking without creating an object file.

2.2.6.3 Requesting a Listing File and Contents

The following FORTRAN command compiles Compaq Fortran free-form source file (XYZ.F90) and requests a listing file:

$ FORTRAN /LIST /SHOW=INCLUDE /MACHINE_CODE XYZ.F90

The source file XYZ.F90 is compiled, and the listing file XYZ.LIS and object file XYZ.OBJ are created. The listing file contains the optional included source files (/SHOW=INCLUDE) and machine code representation (/MACHINE_CODE).

The default is /NOLIST for interactive use and /LIST for batch use, so consider explicitly specifying either /LIST or /NOLIST.

2.2.6.4 Compiling Multiple Files

The following FORTRAN command compiles the Compaq Fortran free-form source files (AAA.F90, BBB.F90, and CCC.F90) into separate object files:

$ FORTRAN/LIST AAA.F90, BBB.F90, CCC.F90

Source files AAA.F90, BBB.F90, and CCC.F90 are compiled as separate files, producing:

• Object files named AAA.OBJ, BBB.OBJ, and CCC.OBJ.
• Listing files named AAA.LIS, BBB.LIS, and CCC.LIS.

The default level of optimization is used (/OPTIMIZE=LEVEL=4), but interprocedure optimizations are less effective because the source files are compiled separately.

The following FORTRAN command compiles the Compaq Fortran fixed-form source files XXX.FOR, YYY.FOR, and ZZZ.FOR into a single object file named XXX.OBJ:

$ FORTRAN XXX.FOR+YYY.FOR+ZZZ.FOR

Source files XXX.FOR, YYY.FOR, and ZZZ.FOR are concatenated and compiled as one file, producing an object file named XXX.OBJ. The default level of optimization is used, allowing interprocedure optimizations since the files are compiled together (see Section 5.1.2). In interactive mode, no listing file is created; in batch mode, a listing file named XXX.LIS would be created.

The following FORTRAN command compiles the Compaq Fortran free-form source files AAA.F90, BBB.F90, and CCC.F90 into two object files:

$ FORTRAN AAA+BBB,CCC/LIST

Two object files are produced: AAA.OBJ (comprising AAA.F90 and BBB.F90) and CCC.OBJ (comprising CCC.F90). One listing file is produced: CCC.LIS (comprising CCC.F90), since the positional /LIST qualifier follows a specific file name (and not the FORTRAN command). Because the default level of optimization is used, interprocedure optimizations for both AAA.F90 and BBB.F90 occur. Only interprocedure optimizations within CCC.F90 occur.

The following FORTRAN command compiles the Compaq Fortran free-form source files ABC.F90, CIRC.F90, and XYZ.F90, but no object file is produced:

$ FORTRAN ABC+CIRC/NOOBJECT+XYZ

The /NOOBJECT qualifier applies to all files in the concatenated file list and suppresses object file creation. Source files ABC.F90, CIRC.F90, and XYZ.F90 are concatenated and compiled, but no object file is produced.

2.2.6.5 Requesting Additional Compile-Time and Run-Time Checking

The following FORTRAN command compiles the Compaq Fortran free-form source file TEST.F90, requesting all possible compile-time diagnostic messages (/WARN=ALL) and run-time checking (/CHECK=ALL):

$ FORTRAN /WARNINGS=ALL /CHECK=ALL TEST.F90

This command creates the object file TEST.OBJ and can result in more informational or warning compilation messages than the default level of warning messages. Additional run-time messages can also occur.

2.2.6.6 Checking Fortran 90 or 95 Standard Conformance

The following FORTRAN command compiles the Compaq Fortran free-form source file PROJ_STAND.F90, requesting compile-time diagnostic messages when extensions to the Fortran 90 language are detected without creating an object file:

$ FORTRAN /STANDARD=F90 /NOOBJECT PROJ_STAND.F90

This command does not create an object file but issues additional compilation messages about the use of any nonstandard extensions to the Fortran 90 standard it detects.

To check for Fortran 95 standard conformance, specify /STANDARD=F95 instead of /STANDARD=F90.

2.2.6.7 Requesting Additional Optimizations

The following FORTRAN command compiles the Compaq Fortran free-form source files (M_APP.F90 and SUB.F90) as a single concatenated file into one object file:

$ FORTRAN /OPTIMIZE=(LEVEL=5,UNROLL=3) M_APP.F90+SUB.F90/NOLIST

The source files are compiled together, producing an object file named M_APP.OBJ. The software pipelining optimization (/OPTIMIZE=LEVEL=4) is requested. Loops within the program are unrolled three times (UNROLL=3). Loop unrolling occurs at optimization level three (LEVEL=3) or above.

For More Information:

• On linking object modules into an executable image (program) and running the program, see Chapter 3.
• On requesting debugger symbol table information, see Section 4.2.1.
• On requesting additional directories to be searched for module files or included source files, see Section 2.3.24 and Section 2.4.
• On the FORTRAN command qualifiers, see Section 2.3.

FORTRAN command qualifiers influence the way in which the compiler processes a file. In some cases, the simplest form of the FORTRAN command is sufficient. Use optional qualifiers when needed.

You can override some qualifiers specified on the command line by using the OPTIONS statement. The qualifiers specified by the OPTIONS statement affect only the program unit where the statement occurs. For more information about the OPTIONS statement, see the Compaq Fortran Language Reference Manual.

2.3.1 FORTRAN Command Qualifier Syntax

Normal DCL parsing rules apply to the FORTRAN command, allowing you to abbreviate qualifier names and keywords as long as they are unique. For example, the following use of the FORTRAN command to specify the /ALIGNMENT qualifier as NATURAL and the /LIST qualifier is valid:

$ FORTRAN /ALIG=NAT /LIS EXTRAPOLATE.FOR

When creating command procedures, avoid using abbreviations for qualifiers and their keywords. Compaq Fortran might add new qualifiers and keywords for a subsequent release that makes an abbreviated qualifier and keyword nonunique in a subsequent release.

If you specify multiple keywords for a qualifier, enclose the keywords in parentheses:

$ FORTRAN /WARN=(ALIGN, DECLARATION) EXTRAPOLATE.FOR

To concatenate source files, separate file names with a plus sign (+) instead of a comma (,) (see Section 2.2.2).

2.3.2 Summary of FORTRAN Command Qualifiers

Table 2-1 lists the FORTRAN Command qualifiers, including their default values.

Sections 2.3.3 through 2.3.50 describe each qualifier in detail.

Table 2-1 FORTRAN Command Qualifiers

Qualifier	Default
/ALIGNMENT or /NOALIGNMENT or /ALIGNMENT= rule class = rule ( class = rule [, ...]) [NO]SEQUENCE ALL (or NATURAL) NONE (or PACKED) where: class = COMMONS RECORDS STRUCTURES and rule = NATURAL PACKED STANDARD 2 [NO]MULTILANGUAGE 2	/ALIGNMENT=(COMMONS=(PACKED 1, NOMULTILANGUAGE), NOSEQUENCE 1, RECORDS=NATURAL)
/ANALYSIS_DATA[=filename] or /NOANALYSIS_DATA	/NOANALYSIS_DATA
/ANNOTATIONS or /NOANNOTATIONS or /ANNOTATIONS= CODE DETAIL INLINING LOOP_TRANSFORMS LOOP_UNROLLING PREFETCHING SHRINKWRAPPING SOFTWARE_PIPELINING TAIL_CALLS TAIL_RECURSION [, ...] ALL NONE	/NOANNOTATIONS
/ARCHITECTURE= GENERIC HOST EV4 EV5 EV56 PCA56 EV6 EV67	/ARCHITECTURE=GENERIC 1
/NOASSUME or /ASSUME= [NO]ACCURACY_SENSITIVE [NO]ALTPARAM [NO]BUFFERED_IO [NO]BYTERECL [NO]DUMMY_ALIASES [NO]FP_CONSTANT [NO]INT_CONSTANT [NO]MINUS0 [NO]PROTECT_CONSTANTS [NO]SOURCE_INCLUDE [, ...] ALL NONE	/ASSUME=(ACCURACY_SENSITIVE 1, ALTPARAM, NOBUFFERED_IO, NOBYTERECL, NODUMMY_ALIASES, NOFP_CONSTANT, NOINT_CONSTANT, NOMINUS0, PROTECT_CONSTANTS, NOSOURCE_INCLUDE)
/AUTOMATIC or /NOAUTOMATIC	/NOAUTOMATIC
/BY_REF_CALL=( routine-list)	No default
/CCDEFAULT or /CCDEFAULT= FORTRAN LIST NONE DEFAULT	/CCDEFAULT=DEFAULT
/NOCHECK or /CHECK= [NO]ARG_TEMP_CREATED [NO]BOUNDS [NO]FORMAT [NO]FP_EXCEPTIONS [NO]OUTPUT_CONVERSION [NO]OVERFLOW [NO]POWER [NO]UNDERFLOW [, ...] ALL NONE	/CHECK=(NOARG_TEMP_CREATED, NOBOUNDS, FORMAT 3, NOFP_EXCEPTIONS, OUTPUT_CONVERSION 3, NOOVERFLOW, POWER, NOUNDERFLOW)
/CONVERT= BIG_ENDIAN CRAY FDX FGX IBM LITTLE_ENDIAN NATIVE VAXD VAXG	/CONVERT=NATIVE
/D_LINES or /NOD_LINES	/NOD_LINES
/DEBUG or /NODEBUG or /DEBUG= [NO]SYMBOLS [NO]TRACEBACK [, ...] ALL NONE	/DEBUG=(NOSYMBOLS, TRACEBACK)
/DIAGNOSTICS[=filename] or /NODIAGNOSTICS	/NODIAGNOSTICS
/DOUBLE_SIZE= 64 128	/DOUBLE_SIZE=64
/ERROR_LIMIT= n or /NOERROR_LIMIT	/ERROR_LIMIT=30
/EXTEND_SOURCE or /NOEXTEND_SOURCE	/NOEXTEND_SOURCE
/F77 or /NOF77	/F77
/FAST	No default
/FLOAT= D_FLOAT G_FLOAT IEEE_FLOAT	/FLOAT=G_FLOAT 4
/GRANULARITY= BYTE LONGWORD QUADWORD	/GRANULARITY=QUADWORD
/IEEE_MODE= FAST UNDERFLOW_TO_ZERO DENORM_RESULTS	/IEEE_MODE=FAST
/INCLUDE= directory [, ...] or /NOINCLUDE	/NOINCLUDE
/INTEGER_SIZE= 16 32 64	/INTEGER_SIZE=32 4
/LIBRARY	No default
/LIST[=file-spec] or /NOLIST	/NOLIST (interactive) /LIST (batch)
/MACHINE_CODE or /NOMACHINE_CODE	/NOMACHINE_CODE
/MATH_LIBRARY= ACCURATE FAST	/MATH_LIBRARY=ACCURATE 1
/MODULE=directory or /NOMODULE	/NOMODULE
/NAMES= UPPERCASE LOWERCASE AS_IS	/NAMES=UPPERCASE
/OBJECT[=file-spec] or /NOOBJECT	/OBJECT
/OLD_F77	Omitted
/OPTIMIZE or /NOOPTIMIZE or /OPTIMIZE= LEVEL= n INLINE= NONE MANUAL SIZE SPEED ALL NOINLINE LOOPS PIPELINE TUNE= GENERIC HOST EV4 EV5 EV56 PCA56 EV6 EV67 UNROLL= n [, ...]	/OPTIMIZE (same as /OPTIMIZE= (LEVEL=4, INLINE=SPEED, NOLOOPS, NOPIPELINE, TUNE=GENERIC 1, UNROLL=0))
/PAD_SOURCE or /NOPAD_SOURCE	/NOPAD_SOURCE
/REAL_SIZE= 32 64 128	/REAL_SIZE=32
/RECURSIVE or /NORECURSIVE	/NORECURSIVE
/NOREENTRANCY or /REENTRANCY= ASYNC NONE THREADED	/REENTRANCY=NONE
/ROUNDING_MODE= NEAREST CHOPPED DYNAMIC MINUS_INFINITY	/ROUNDING_MODE=NEAREST
/SEPARATE_COMPILATION or /NOSEPARATE_COMPILATION	/NOSEPARATE_COMPILATION
/SEVERITY=WARNINGS= WARNING ERROR STDERROR	/SEVERITY=WARNINGS=(WARNING)
/SHOW or /NOSHOW or /SHOW= [NO]INCLUDE [NO]MAP [, ...] ALL NONE	/SHOW=(NOINCLUDE, MAP )
/SOURCE_FORM= FREE FIXED	Depends on file type (F90 for free form and FOR or F for fixed form)
/STANDARD= F90 F95 or /NOSTANDARD	/NOSTANDARD
/SYNCHRONOUS_EXCEPTIONS or /NOSYNCHRONOUS_EXCEPTIONS	/NOSYNCHRONOUS_EXCEPTIONS
/SYNTAX_ONLY or /NOSYNTAX_ONLY	/NOSYNTAX_ONLY
/TIE or /NOTIE	/NOTIE
/VERSION	Omitted
/VMS or /NOVMS	/VMS
/WARNINGS or /NOWARNINGS or /WARNINGS= [NO]ALIGNMENT [NO]ARGUMENT_CHECKING [NO]DECLARATIONS [NO]GENERAL [NO]GRANULARITY [NO]IGNORE_LOC [NO]TRUNCATED_SOURCE [NO]UNCALLED [NO]UNINITIALIZED [NO]UNUSED [NO]USAGE [, ...] ALL NONE	/WARNINGS=(ALIGNMENT, NOARGUMENT_CHECKING, NODECLARATIONS, GENERAL, GRANULARITY, NOIGNORE_LOC, NOTRUNCATED_SOURCE, UNCALLED, UNINITIALIZED, NOUNUSED, USAGE )

Table 2-2 shows the functional groupings of the FORTRAN command qualifiers and the section in which they are described in more detail.

Table 2-2 FORTRAN Command Flags and Categories

Category	Flag Name and Section in this Manual
Carriage control for terminal or printer displays	/CCDEFAULT (see Section 2.3.10)
Code generation for specific Alpha chip	/ARCHITECTURE (see Section 2.3.6)
Convert Nonnative Data Files	/CONVERT (see Section 2.3.12) /ASSUME=BYTERECL (see Section 2.3.7) Also see Chapter 9.
Data Size	/DOUBLE_SIZE (see Section 2.3.16) /INTEGER_SIZE (see Section 2.3.25) /REAL_SIZE (see Section 2.3.36) Also see Chapter 8.
Data Storage and Recursion	/AUTOMATIC (see Section 2.3.8) /RECURSIVE (see Section 2.3.37)
Debugging and Symbol Table	/D_LINES (see Section 2.3.13) /DEBUG (see Section 2.3.14) Also see Chapter 4.
Floating-Point Exceptions and Accuracy	/ASSUME=([NO]ACCURACY_SENSITIVE, [NO]FP_CONSTANT, [NO]MINUS0,) (see Section 2.3.7) /CHECK=([NO]FP_EXCEPTIONS, [NO]POWER, [NO]UNDERFLOW) (see Section 2.3.11) /DOUBLE_SIZE (see Section 2.3.16) /FAST (see Section 2.3.20) /FLOAT (see Section 2.3.21) /IEEE_MODE (see Section 2.3.23) /MATH_LIBRARY (see Section 2.3.29) /REAL_SIZE (see Section 2.3.36) /ROUNDING_MODE (see Section 2.3.39) /SYNCHRONOUS_EXCEPTIONS (see Section 2.3.45)
Floating-Point Format in Memory	/FLOAT (see Section 2.3.21)
Language Compatibility	/F77 (see Section 2.3.19) /ALIGNMENT=COMMONS=STANDARD (see Section 2.3.3) /ASSUME=( [NO]ALTPARAM, [NO]DUMMY_ALIASES, [NO]INT_CONSTANT, /[NO]PROTECT_CONSTANTS ) (see Section 2.3.7) /BY_REF_CALL (see Section 2.3.9) /OLD_F77 (see Section 2.3.33) /PAD_SOURCE (see Section 2.3.43) /SEVERITY (see Section 2.3.41) /STANDARD (see Section 2.3.44) /VMS (see Section 2.3.49)
Language-Sensitive Editor Use	/DIAGNOSTICS (see Section 2.3.15)
Listing File and Contents	/ANNOTATIONS (see Section 2.3.5) /LIST (see Section 2.3.27) /MACHINE_CODE (see Section 2.3.28) /SHOW (see Section 2.3.42) Also see Section 2.6.
Module File Searching and Placement; Include File Searching	/INCLUDE (see Section 2.3.24) /ASSUME=[NO]SOURCE_INCLUDE (see Section 2.3.7) /LIBRARY (see Section 2.3.26) /MODULE (see Section 2.3.30) Also see Section 2.2.3 (modules), Section 2.2.4 (include files), and Section 2.4 (text libraries).
Multithreaded Applications	/REENTRANCY (see Section 2.3.38)
Object File Creation, Contents, Naming, and External Names	/OBJECT (see Section 2.3.32) /NAMES (see Section 2.3.31) /SEPARATE_COMPILATION (see Section 2.3.40) /SYNTAX_ONLY (see Section 2.3.46) /TIE (see Section 2.3.48)
Performance Optimizations and Alignment	/ALIGNMENT (see Section 2.3.3) /ASSUME=(NOACCURACY_SENSITIVE, NODUMMY_ALIASES) (see Section 2.3.7) /ARCHITECTURE (see Section 2.3.6) /FAST (see Section 2.3.20) /MATH_LIBRARY (see Section 2.3.29) /OPTIMIZE (see Section 2.3.34) Also see Chapter 5.
Recursion and Shared Access to Data	/GRANULARITY (see Section 2.3.22) /RECURSIVE (see Section 2.3.37) /REENTRANCY (see Section 2.3.38) /WARNINGS=GRANULARITY (see Section 2.3.50)
Source Code Analyzer Use	/ANALYSIS_DATA (see Section 2.3.4)
Source Form and Column Use	/D_LINES (see Section 2.3.13) /EXTEND_SOURCE (see Section 2.3.18) /PAD_SOURCE (see Section 2.3.35) /SOURCE_FORM (see Section 2.3.43) /WARNINGS=TRUNCATED_SOURCE (see Section 2.3.50)
Warning Messages and Run-Time Checking	/CHECK (see Section 2.3.11) /IEEE_MODE (see Section 2.3.23) /ERROR_LIMIT (see Section 2.3.17) /SEVERITY (see Section 2.3.41) /WARNINGS (see Section 2.3.50) Also see the qualifiers related to "Floating-Point Exceptions and Accuracy" in this table.

2.3.3 /ALIGNMENT --- Data Alignment

The /ALIGNMENT qualifier controls the data alignment of numeric fields in common blocks and structures.

If you omit the /ALIGNMENT and /FAST qualifiers:

• Individual data items (not part of a common block or other structure) are naturally aligned.
• Fields in derived-type (user-defined) structures (where the SEQUENCE statement is omitted) are naturally aligned.
• Fields in Compaq Fortran 77 record structures are naturally aligned.
• Data items in common blocks are not naturally aligned, unless data declaration order has been planned and checked to ensure that all data items are naturally aligned.

Although Compaq Fortran always aligns local data items on natural boundaries, certain data declaration statements and unaligned arguments can force unaligned data.

Use the /ALIGNMENT qualifier to control the alignment of fields associated with common blocks, derived-type structures, and record structures.

The compiler issues messages when it detects unaligned data by default (/WARNINGS=ALIGNMENT). For information about the causes of unaligned data and detection at run-time, see Section 5.3.

The qualifier has the following form:

/ALIGNMENT= rule class = rule (class = rule [, ...]) [NO]SEQUENCE ALL (or NATURAL) NONE (or PACKED) where: class = COMMONS RECORDS STRUCTURES and rule = NATURAL PACKED STANDARD [NO]MULTILANGUAGE

STANDARD and MULTILANGUAGE are valid for class=COMMON (not class=RECORDS).

The /ALIGNMENT qualifier keywords specify whether the Compaq Fortran compiler should naturally align or arbitrarily pack the following:

class

Specifies the type of data blocks:

• COMMONS=rule applies to common blocks (COMMON statement); rule can be PACKED, STANDARD, NATURAL, or MULTILANGUAGE.
• RECORDS=rule applies to derived-type and record structures; rule can be PACKED or NATURAL. However, if a derived-type data definition specifies the SEQUENCE statement, the FORTRAN /ALIGNMENT qualifier has no effect on unaligned data, so data declaration order must be carefully planned to naturally align data.
• STRUCTURES=rule applies to derived-type and record structures; rule can be PACKED or NATURAL. For the Compaq Fortran language, STRUCTURES and RECORDS are the same (they may have a different meaning in other OpenVMS languages).

rule

Specifies the alignment for the specified class of data blocks:

• NATURAL requests that fields in derived-type and record structures and data items in common blocks be naturally aligned on up to 8-byte boundaries, including INTEGER (KIND=8) and REAL (KIND=8) data.
  Specifying /ALIGNMENT=NATURAL is equivalent to any of the following:

  /ALIGNMENT /ALIGNMENT=ALL /ALIGNMENT=(COMMONS=(NATURAL,NOMULTILANGUAGE),RECORDS=NATURAL,SEQUENCE)

• PACKED requests that fields in derived-type and record structures and data items in common blocks be packed on arbitrary byte boundaries and not naturally aligned.
  Specifying /ALIGNMENT=PACKED is equivalent to any of the following:

  /ALIGNMENT=NONE /NOALIGNMENT /ALIGNMENT=(COMMONS=(PACKED,NOMULTILANGUAGE),RECORDS=PACKED,NOSEQUENCE)

• STANDARD specifies that data items in common blocks will be naturally aligned on up to 4-byte boundaries (consistent with the FORTRAN-77, Fortran 90, and Fortran 95 standards).
  The compiler will not naturally align INTEGER (KIND=8) and REAL (KIND=8) data declarations. Such data declarations should be planned so they fall on natural boundaries. Specifying /ALIGNMENT=COMMONS=STANDARD alone is the same as /ALIGNMENT=(COMMONS= (STANDARD,NOMULTILANGUAGE)),RECORDS=NATURAL).
  You cannot specify /ALIGNMENT=RECORDS=STANDARD or /ALIGNMENT=STANDARD.
• MULTILANGUAGE specifies that the compiler pad the size of common block program sections to ensure compatibility when the common block program section is shared by code created by other Compaq OpenVMS compilers.
  When a program section generated by a Fortran common block is overlaid with a program section consisting of a C structure, linker error messages can result. This is because the sizes of the program sections are inconsistent; the C structure is padded and the Fortran common block is not.
  Specifying /ALIGNMENT=COMMONS=MULTILANGUAGE ensures that Compaq Fortran follows a consistent program section size allocation scheme that works with Compaq C program sections that are shared across multiple images. Program sections shared in a single image do not have a problem. The equivalent Compaq C qualifier is /PSECT_MODEL=[NO]MULTILANGUAGE.
  The default is /ALIGNMENT=COMMONS=NOMULTILANGUAGE, which also is the default behavior of Compaq Fortran 77 and is sufficient for most applications.
  The [NO]MULTILANGUAGE keyword only applies to common blocks. You can specify /ALIGNMENT=COMMONS=[NO]MULTILANGUAGE, but you cannot specify /ALIGNMENT=[NO]MULTILANGUAGE.

[NO]SEQUENCE

Specifying /ALIGNMENT=SEQUENCE means that components of derived types with the SEQUENCE attribute will obey whatever alignment rules are currently in use. The default alignment rules align components on natural boundaries.

The default value of /ALIGNMENT=NOSEQUENCE means that components of derived types with the SEQUENCE attribute will be packed, regardless of whatever alignment rules are currently in use.

Specifying /FAST sets /ALIGNMENT=SEQUENCE so that components of derived types with the SEQUENCE attribute will be naturally aligned for improved performance. Specifying /ALIGNMENT=ALL also sets /ALIGNMENT=SEQUENCE.

ALL

Specifying /ALIGNMENT=ALL is equivalent to /ALIGNMENT, /ALIGNMENT=NATURAL), or /ALIGNMENT=(COMMONS= (NATURAL,NOMULTILANGUAGE),RECORDS=NATURAL, SEQUENCE ).

NONE

Specifying /ALIGNMENT=NONE is equivalent to /NOALIGNMENT, /ALIGNMENT=PACKED, or /ALIGNMENT=(COMMONS=(PACKED, NOMULTILANGUAGE), RECORDS=PACKED, NOSEQUENCE ).

Defaults depend on whether you specify or omit the /ALIGNMENT and /FAST qualifiers, as follows:

Command Line	Default
Omit /ALIGNMENT and omit /FAST	/ALIGNMENT=(COMMONS=(PACKED,NOMULTILANGUAGE),NOSEQUENCE,RECORDS=NATURAL)
Omit /ALIGNMENT and specify /FAST	/ALIGNMENT=(COMMONS=NATURAL, RECORDS=NATURAL,SEQUENCE)
/ALIGNMENT=COMMONS= rule	Use whatever the /ALIGNMENT qualifier specifies for COMMONS, but use the default of RECORDS=NATURAL
/ALIGNMENT=RECORDS= rule	Use whatever the /ALIGNMENT qualifier specifies for RECORDS, but use the default for COMMONS (depends on whether /FAST was specified or omitted)

You can override the alignment specified on the command line by using a cDEC$ OPTIONS directive, as described in the Compaq Fortran Language Reference Manual.

The /ALIGNMENT and /WARNINGS=ALIGNMENT qualifiers can be used together in the same command line.

For More Information:

• On run-time performance guidelines, see Chapter 5.
• On data alignment, see Section 5.3.
• On checking for alignment traps with a condition handler, see Section 14.11.
• On intrinsic data sizes, see Chapter 8.
• On the /FAST qualifier, see Section 2.3.20.

The /ANALYSIS_DATA qualifier produces an analysis data file that contains cross-reference and static-analysis information about the source code being compiled.

Analysis data files are reserved for use by Compaq products such as, but not limited to, the Source Code Analyzer (SCA).

The qualifier has the following form:

/ANALYSIS_DATA[=filename.type]

If you omit the file specification, the analysis file name has the name of the primary source file and a file type of ANA (filename.ANA).

The compiler produces one analysis file for each source file that it compiles. If you are compiling multiple files and you type in a file name, each analysis file is given that name (with an incremental version number).

If you do not specify the /ANALYSIS_DATA qualifier, the default is /NOANALYSIS_DATA.

2.3.5 /ANNOTATIONS --- Code Descriptions

The /ANNOTATIONS qualifier controls whether an annotated listing showing optimizations is included with the listing file.

The qualifier has the following form:

/ANNOTATIONS= CODE DETAIL INLINING LOOP_TRANSFORMS LOOP_UNROLLING PREFETCHING SHRINKWRAPPING SOFTWARE_PIPELINING TAIL_CALLS TAIL_RECURSION [, ...] ALL NONE

CODE

Annotates the machine code listing with descriptions of special instructions used for prefetching, alignment, and so on.

DETAIL

Provides additional level of annotation detail, where available.

INLINING

Indicates where code for a called procedure was expanded inline.

LOOP_TRANSFORMS

Indicates where advanced loop nest optimizations have been applied to improve cache performance.

LOOP_UNROLLING

Indicates where a loop was unrolled (contents expanded multiple times).

PREFETCHING

Indicates where special instructions were used to reduce memory latency.

SHRINKWRAPPING

Indicates removal of code establishing routine context when it is not needed.

SOFTWARE_PIPELINING

Indicates where instructions have been rearranged to make optimal use of the processor's functional units.

TAIL_CALLS

Indicates an optimization where a call can be replaced with a jump.

TAIL_RECURSION

Indicates an optimization that eliminates unnecessary routine context for a recursive call.

ALL

All annotations, including DETAIL, are selected. This is the default if no keyword is specified.

NONE

No annotations are selected. This is the same as /NOANNOTATIONS.

The /ARCHITECTURE qualifier specifies the type of Alpha architecture code instructions generated for a particular program unit being compiled; it uses the same options (keywords) as used by the /OPTIMIZE=TUNE qualifier (for instruction scheduling purposes).

OpenVMS Version 7.1 and subsequent releases provide an operating system kernel that includes an instruction emulator. This emulator allows new instructions, not implemented on the host processor chip, to execute and produce correct results. Applications using emulated instructions will run correctly but may incur significant software emulation overhead at runtime.

All Alpha processors implement a core set of instructions. Certain Alpha processor versions include additional instruction extensions.

The qualifier has the following form:

/ARCHITECTURE= GENERIC HOST EV4 EV5 EV56 PCA6 EV6 EV67

GENERIC

Generates code that is appropriate for all Alpha processor generations. This is the default.

Programs compiled with the GENERIC option run on all implementations of the Alpha architecture without any instruction emulation overhead.

HOST

Generates code for the processor generation in use on the system being used for compilation.

Programs compiled with this option may encounter instruction emulation overhead if run on other implementations of the Alpha architecture.

EV4

Generates code for the 21064, 21064A, 21066, and 21068 implementations of the Alpha architecture. Programs compiled with the EV4 option run on all Alpha processors without instruction emulation overhead.

EV5

Generates code for some 21164 chip implementations of the Alpha architecture that use only the base set of Alpha instructions (no extensions). Programs compiled with the EV5 option run on all Alpha processors without instruction emulation overhead.

EV56

Generates code for some 21164 chip implementations that use the BWX (Byte/Word manipulation) instruction extensions of the Alpha architecture.

Programs compiled with the EV56 option may incur emulation overhead on EV4 and EV5 processors but still run correctly on OpenVMS Version 7.1 (or later) systems.

PCA56

Generates code for the 21164PC chip implementation that uses the BWX (Byte/Word manipulation) and MAX (Multimedia) instruction extensions of the Alpha architecture.

Programs compiled with the PCA56 option may incur emulation overhead on EV4, EV5, and EV56 processors but will still run correctly on OpenVMS Version 7.1 (or later) systems.

EV6

Generates code for the 21264 chip implementation that uses the following extensions to the base Alpha instruction set: BWX (Byte/Word manipulation) and MAX (Multimedia) instructions, square root and floating-point convert instructions, and count instructions.

Programs compiled with the EV6 option may incur emulation overhead on EV4, EV5, EV56, and PCA56 processors but will still run correctly on OpenVMS Version 7.1 (or later) systems.

EV67

Generates code for chip implementations that use advanced instruction extensions of the Alpha architecture. This option permits the compiler to generate any EV67 instruction, including the following extensions to the base Alpha instruction set: BWX (Byte/Word manipulation), MVI (Multimedia) instructions, square root and floating-point convert extensions (FIX), and count extensions (C1X).

Programs compiled with the EV67 keyword might incur emulation overhead on EV4, EV5, EV56, PCA56, and EV6 processors but still run correctly on Compaq OpenVMS Alpha systems.

The /ASSUME qualifier specifies a variety of assumptions:

• Whether the compiler should use certain code transformations that affect floating-point operations. These changes may affect the accuracy of the program's results.
• What the compiler can assume about program behavior without affecting correct results when it optimizes code.
• Whether a single-precision constant assigned to a double-precision variable should be evaluated in single or double precision.
• Changes the directory where the compiler searches for files specified by an INCLUDE statement to the directory where the source files reside, not the current default directory.

The qualifier has the following form:

/ASSUME= [NO]ACCURACY_SENSITIVE [NO]ALTPARAM [NO]BUFFERED_IO [NO]BYTERECL [NO]DUMMY_ALIASES [NO]FP_CONSTANT [NO]INT_CONSTANT [NO]MINUS0 [NO]PROTECT_CONSTANTS [NO]SOURCE_INCLUDE [, ...] ALL NONE

[NO]ACCURACY_SENSITIVE

If you use ACCURACY_SENSITIVE (the default unless you specified /FAST), the compiler uses a limited number of rules for calculations, which might prevent some optimizations.

Specifying NOACCURACY_SENSITIVE allows the compiler to reorder code based on algebraic identities (inverses, associativity, and distribution) to improve performance. The numeric results can be slightly different from the default (ACCURACY_SENSITIVE) because of the way intermediate results are rounded. Specifying the /FAST qualifier (described in Section 2.3.20) changes the default to NOACCURACY_SENSITIVE.

Numeric results with NOACCURACY_SENSITIVE are not categorically less accurate. They can produce more accurate results for certain floating-point calculations, such as dot product summations.

For example, the following expressions are mathematically equivalent but may not compute the same value using finite precision arithmetic.

X = (A + B) - C X = A + (B - C)

Optimizations that result in calls to a special reciprocal square root routine for expressions of the form 1.0/SQRT(x) or A/SQRT(B) are enabled only if /ASSUME=NOACCURACY_SENSITIVE is in effect.

[NO]ALTPARAM

Specifying the /ASSUME=ALTPARAM qualifier allows the alternate syntax for PARAMETER statements. The alternate form has no parentheses surrounding the list, and the form of the constant, rather than implicit or explicit typing, determines the data type of the variable. The default is /ASSUME=ALTPARAM.

[NO]BUFFERED_IO

The /ASSUME=[NO]BUFFERED_IO qualifier is provided for compatibility with other platforms. On OpenVMS systems, the SET RMS command controls the number of output buffers.

Specifying /ASSUME=BUFFERED_IO requests that buffered I/O be used for all Fortran logical units opened for sequential writing (default is NOBUFFERED_IO). On OpenVMS systems, this qualifier has an effect only if the system or process RMS default buffers are set to 1.

[NO]BYTERECL

Specifying the /ASSUME=BYTERECL qualifier:

• Indicates that the OPEN statement RECL value for unformatted files is in byte units. If you omit /ASSUME=BYTERECL, Compaq Fortran expects the OPEN statement RECL value for unformatted files to be in longword (4-byte) units.
• Returns the record length value for an INQUIRE by output item list (unformatted files) in byte units. If you omit /ASSUME=BYTERECL, Compaq Fortran returns the record length for an INQUIRE by output item list in longword (4-byte) units.
• Returns the record length value for an INQUIRE by unit or file name (unformatted files) in byte units if all of the following occur:
  • You had specified /ASSUME=BYTERECL for the code being executed
  • The file was opened with an OPEN statement and a RECL specifier
  • The file is still open (connected) when the INQUIRE occurs.
  
  If any one of the preceding conditions are not met, Compaq Fortran returns the RECL value for an INQUIRE in longword (4-byte) units.

To specify /ASSUME=BYTERECL your application must be running on a system that has the associated Fortran Run-Time Library support. This support is provided by installing one of the following on the system where the application will be run:

• Compaq Fortran Version 7.0 or later
• OpenVMS Alpha Version 7.0 or later

If you specify /ASSUME=BYTERECL and your application is running on a system without the proper Run-Time Library support, it will fail with an INVARGFOR, Invalid argument to Fortran Run-Time Library error.

[NO]DUMMY_ALIASES

Specifies whether dummy (formal) arguments are permitted to share memory locations with COMMON block variables or other dummy arguments.

If you specify DUMMY_ALIASES, the compiler must assume that dummy (formal) arguments to procedures share memory locations with other dummy arguments or with variables shared through use association, host association, or common block use.

These program semantics do not strictly obey the Fortran 90 and Fortran 95 Standards and slow performance.

If you use NODUMMY_ALIASES, the default, the compiler does not need to make these assumptions, which results in better run-time performance. However, omitting /ASSUME=DUMMY_ALIASES can cause some programs that depend on such aliases to fail or produce wrong answers.

You only need to compile the called subprogram with DUMMY_ALIASES.

If you compile a program that uses dummy aliasing with NODUMMY_ALIASES in effect, the run-time behavior of the program will be unpredictable. In such programs, the results will depend on the exact optimizations that are performed. In some cases, normal results will occur; however, in other cases, results will differ because the values used in computations involving the offending aliases will differ.

[NO]FP_CONSTANT

Specifies whether a single-precision constant assigned to a double-precision variable will be evaluated in double precision.

If you use NOFP_CONSTANT, the default, a single-precision constant assigned to a double-precision variable is evaluated in single precision. The Fortran 90 and 95 standards require that the constant be evaluated in single precision.

If you specify FP_CONSTANT, a single-precision constant assigned to a double-precision variable is evaluated in double precision.

Certain programs created for FORTRAN-77 compilers (including Compaq Fortran 77) may show different results with FP_CONSTANT than when you use NOFP_CONSTANT, because they rely on single-precision constants assigned to a double-precision variable to be evaluated in double precision.

In the following example, if you specify FP_CONSTANT, identical values are assigned to D1 and D2. If you use NOFP_CONSTANT, Compaq Fortran will follow the standard and assign a less precise value to D1:

REAL (KIND=8) D1,D2 DATA D1 /2.71828182846182/ ! REAL (KIND=4) value expanded to double DATA D2 /2.71828182846182D0/ ! Double value assigned to double

[NO]INT_CONSTANT

Specifies whether Compaq Fortran 77 or Fortran 90/95 semantics are used to determine the type for integer constants.

If you specify /ASSUME=INT_CONSTANT, integer constants take their type from the value, as interpreted by Compaq Fortran 77.

If you specify /ASSUME=NOINT_CONSTANT, integer constants have Fortran 90/95 "default integer" type. This is the default.

[NO]MINUS0

Controls whether the compiler uses Fortran 95 standard semantics for the IEEE floating-point value of -0.0 (minus zero) in the SIGN intrinsic, if the processor is capable of distinguishing the difference between -0.0 and +0.0.

The default is /ASSUME=NOMINUS0, which uses Fortran 90 and FORTRAN 77 semantics where the value -0.0 or +0.0 in the SIGN function is treated as an 0.0.

To request Fortran 95 semantics, specify /ASSUME=MINUS0 to allow use of the IEEE value -0.0 in the SIGN intrinsic and printing -0.0. This option applies only to programs compiled with the /FLOAT=IEEE_FLOAT qualifier.

[NO]PROTECT_CONSTANTS

Specifies whether constant actual arguments can be changed. By default, actual arguments that are constants are read-only (/ASSUME=PROTECT_CONSTANTS): any attempt to modify them in the called routine results in an error. /ASSUME=NOPROTECT_CONSTANTS specifies that a copy of a constant actual argument is to be passed, so it can be modified by the called routine, even though the Fortran standard prohibits such modification. The constant is not modified in the calling routine.

If NOPROTECT_CONSTANTS is specified, a writeable copy of the constant is passed as the actual argument.

[NO]SOURCE_INCLUDE

Controls whether the directory where the compiler searches for source files or text libraries specified by an INCLUDE statement is either:

• The current default directory (NOSOURCE_INCLUDE)
• The directory where the source file reside (SOURCE_INCLUDE)

The default, NOSOURCE_INCLUDE, indicates that the compiler should search in the current default directory.

Specifying SOURCE_INCLUDE causes the compiler to search the directory of the source file specified on the FORTRAN command line, instead of the current default directory.

You can specify additional directories for the compiler to search for module files, include files, or include libraries by using the /INCLUDE qualifier.

For More Information:

• On the effect of /ASSUME=NOACCURACY_SENSITIVE on optimizations, see Section 5.8.8.
• On converting and using nonnative unformatted data files, see Chapter 9.
• On the INQUIRE statement, see Chapter 6.
• On the effect and an example of /ASSUME=DUMMY_ALIASES, see Section 5.8.9.
• On the /INCLUDE qualifier, see Section 2.3.24.

The /AUTOMATIC and /NOAUTOMATIC qualifiers are synonyms of /RECURSIVE or /NORECURSIVE (see Section 2.3.37). This qualifier is provided for Compaq Fortran 77 compatibility.

2.3.9 /BY_REF_CALL --- Character Literal Argument Passing

Specifying /BY_REF_CALL=routine-list indicates that character constants used as actual arguments in calls to the specified routines be passed by reference and not by character descriptor. This helps applications that pass quoted character constants to numeric dummy parameters, such as applications ported from OpenVMS VAX systems that rely on the OpenVMS VAX Linker to change the argument passing mechanism for character constant actual arguments.

By default, Compaq Fortran passes character constants used as actual arguments by the usual OpenVMS character descriptor mechanism.

You can specify a list of routines or use wildcard characters (such as an asterisk (*)) to indicate all routines, for example:

$ FORTRAN/BY_REF_CALL=(PROJA_ROUT,PROJB_ROUT) TEST.FOR $ FORTRAN/BY_REF_CALL=(*) APPLIC.FOR

The first FORTRAN command requests special character constant actual argument handling for two specific routines. The second requests this for all routines. You can select routines whose names match certain characters and a wildcard, such as all routines that start with MY:

$ FORTRAN/BY_REF_CALL=(MY*) X.FOR

2.3.10 /CCDEFAULT --- Carriage Control for Terminals

The /CCDEFAULT qualifiers specify default carriage control when a terminal or printer displays a file.

The qualifier has the following form:

/CCDEFAULT= FORTRAN LIST NONE DEFAULT

FORTRAN

Specifying /CCDEFAULT=FORTRAN results in normal Fortran interpretation of the first character, such as the character "0" resulting in a blank line before output.

LIST

Specifying /CCDEFAULT=LIST results in one linefeed between records.

NONE

Specifying /CCDEFAULT=NONE results in no carriage control processing.

DEFAULT

Specifying /CCDEFAULT=DEFAULT results in the possibility of other qualifiers, such as /VMS, affecting this default setting: if /NOVMS is specified, the default is LIST; otherwise the default is FORTRAN.

The /CHECK qualifier requests certain error checking during program execution (run time). The compiler produces extra code that performs the checks.

The qualifier has the following form:

/CHECK= [NO]ARG_TEMP_CREATED [NO]BOUNDS [NO]FORMAT [NO]FP_EXCEPTIONS [NO]OUTPUT_CONVERSION [NO]OVERFLOW [NO]POWER [NO]UNDERFLOW [, ...] ALL NONE

ARG_TEMP_CREATED

Controls whether a run-time warning message is displayed (execution continues) if a temporary is created for an array actual argument passed to a called routine.

[NO]BOUNDS

Controls whether run-time checking occurs for each dimension of an array reference or substring reference to determine whether it is within the range of the dimension specified by the array or character variable declaration.

Specify BOUNDS to request array bounds and substring checking. With the default, NOBOUNDS, array bounds and substring checking does not occur.

[NO]FORMAT

Controls whether the run-time message number 61 (FORVARMIS) is displayed and halts program execution when the data type for an item being formatted for output does not match the format descriptor being used (such as a REAL data item with an I format).

The default, FORMAT, causes FORVARMIS to be a fatal error and halts program execution.

Specifying NOFORMAT ignores the format mismatch, which suppresses the FORVARMIS error and allows program continuation.

If you omit /NOVMS and omit /CHECK=NOFORMAT, the default is /CHECK=FORMAT.

If you specify /NOVMS, the default is NOFORMAT (unless you also specify /CHECK=FORMAT).

[NO]FP_EXCEPTIONS

Controls whether run-time checking counts calculations that result in exceptional values. With the default, NOFP_EXCEPTIONS, no run-time messages are reported.

Specifying FP_EXCEPTIONS requests reporting of the first two occurrences of each type of exceptional value and a summary run-time message at program completion that displays the number of times exceptional values occurred. Consider using FP_EXCEPTIONS when the /IEEE_MODE qualifier allows generation of exceptional values.

To limit reporting to only denormalized numbers (and not other exceptional numbers), specify UNDERFLOW instead of FP_EXCEPTIONS.

Using FP_EXCEPTIONS applies to all types of native floating-point data.

[NO]OUTPUT_CONVERSION

Controls whether run-time message number 63 (OUTCONERR) is displayed when format truncation occurs. Specifying /CHECK=NOOUTPUT_CONVERSION disables the run-time message (number 63) associated with format truncation. The data item is printed with asterisks. When OUTPUT_CONVERSION is in effect and a number could not be output in the specified format field length without loss of significant digits (format truncation), the OUTCONERR (number 63) error occurs.

If you omit /NOVMS and omit /CHECK=NOOUTPUT_CONVERSION, the default is OUTPUT_CONVERSION.

If you specify /NOVMS, the default is NOOUTPUT_CONVERSION (unless you also specify /CHECK=OUTPUT_CONVERSION).

[NO]OVERFLOW

Controls whether run-time checking occurs for arithmetic overflow of all integer calculations (INTEGER, INTEGER with a kind parameter, or INTEGER with a length specifier). Specify OVERFLOW to request integer overflow checking.

Real and complex calculations are always checked for overflow and are not affected by /NOCHECK. Integer exponentiation is performed by a routine in the mathematical library. The routine in the mathematical library always checks for overflow, even if NOOVERFLOW is specified.

With the default, NOOVERFLOW, overflow checking does not occur.

[NO]POWER

Specifying the /CHECK=NOPOWER qualifier allows certain arithmetic expressions containing floating-point numbers and exponentiation to be evaluated and return a result rather than cause the compiler to display a run-time message and stop the program. The specific arithmetic expressions include:

• 0.0 ** 0.0
• negative-value ** integer-value-of-type-real

For example, if you specify /CHECK=NOPOWER the calculation of the expression 0.0 ** 0.0 results in 1. The expression (--3.0) ** 3.0 results in --27.0.

If you omit /CHECK=NOPOWER for such expressions, an exception occurs, error message number 65 is displayed, and the program stops (default is /CHECK=POWER).

[NO]UNDERFLOW

Controls whether run-time messages are displayed for floating underflow (denormalized numbers) in floating-point calculations. Specifying UNDERFLOW might be used in combination with the /IEEE_MODE=DENORM_RESULTS qualifier. Specify UNDERFLOW to request reporting of the first two occurrences of denormalized numbers and a summary run-time message at program completion that displays the number of times denormalized numbers occurred.

The default, NOUNDERFLOW, means that floating underflow messages are not displayed. To check for all exceptional values (not just denormalized numbers), specify /CHECK=FP_EXCEPTIONS.

ALL

Requests that all run-time checks (BOUNDS, FORMAT, FP_EXCEPTIONS, OUTPUT_CON2VERSION, OVERFLOW, and UNDERFLOW) be performed. Specifying /CHECK and /CHECK=ALL are equivalent.

NONE

Requests no run-time checking. This is the default. Specifying /NOCHECK and /CHECK=NONE are equivalent.

For More Information:

• On exceptional floating-point values, see Section 8.4.8.
• On controlling IEEE arithmetic exception handling (/IEEE_MODE qualifier), see Section 2.3.23.
• On the ranges of the various data types (including denormalized ranges), see Chapter 8.

The /CONVERT qualifier specifies the format of numeric unformatted data in a file, such as IEEE little endian, VAX G_float, VAX D_float floating-point format, or a nonnative big endian format.

By default, an unformatted file containing numeric data is expected to be in the same floating-point format used for memory representation or /CONVERT=NATIVE. You set the floating-point format used for memory representation using the /FLOAT qualifier (see Section 2.3.21).

Instead of specifying the unformatted file format by using the /CONVERT qualifier, you can use one of the other methods (predefined logical names or the OPEN CONVERT keyword) described in Chapter 9, which allow the same program to use different floating-point formats, as shown in Figure 2-1.

The qualifier has the following form (specify one keyword):

/CONVERT= BIG_ENDIAN CRAY FDX FGX IBM LITTLE_ENDIAN NATIVE VAXD VAXG

BIG_ENDIAN

Specifies that unformatted files containing numeric data are in IEEE big endian (nonnative) format.

If you specify BIG_ENDIAN, the resulting program will read and write unformatted files containing numeric data assuming:

• Big endian integer format (INTEGER declarations of the appropriate size)
• Big endian IEEE floating-point formats (REAL and COMPLEX declarations of the appropriate size).

CRAY

Specifies that unformatted files containing numeric data are in CRAY (nonnative) big endian format.

If you specify CRAY, the resulting program will read and write unformatted files containing numeric data assuming:

• Big endian integer format (INTEGER declarations of the appropriate size)
• Big endian CRAY proprietary floating-point formats (REAL and COMPLEX declarations of the appropriate size)

FDX

Specifies that unformatted files containing numeric data are in OpenVMS Alpha little endian format, as follows:

• REAL (KIND=4) and COMPLEX (KIND=4) (same as REAL*4 and COMPLEX*8) single-precision data is in VAX little endian F_float format.
• REAL (KIND=8) and COMPLEX (KIND=8) (same as REAL*8 and COMPLEX*16) double-precision data is in VAX little endian D_float format.
• REAL (KIND=16) (same as REAL*16) data is in Alpha little endian X_float format.

FGX

Specifies that unformatted files containing numeric data are in OpenVMS Alpha little endian format, as follows:

• REAL (KIND=4) and COMPLEX (KIND=4) (same as REAL*4 and COMPLEX*8) single-precision data is in VAX little endian F_float format.
• REAL (KIND=8) and COMPLEX (KIND=8) (same as REAL*8 and COMPLEX*16) double-precision data is in VAX little endian G_float format.
• REAL (KIND=16) (same as REAL*16) data is in Alpha little endian X_float format.

IBM

Specifies that unformatted files containing numeric data are in IBM® (nonnative) big endian format (such as IBM System\370 and similar systems).

If you specify IBM, the resulting program will read and write unformatted files containing numeric data assuming:

• Big endian integer format (INTEGER declarations of the appropriate size)
• Big endian IBM proprietary floating-point formats (REAL and COMPLEX declarations of the appropriate size)

LITTLE_ENDIAN

Specifies that unformatted files containing numeric data are in native little endian integer format and IEEE little endian floating-point format, as follows:

• Integer data is in native little endian format.
• REAL (KIND=4) and COMPLEX (KIND=4) (same as REAL*4 and COMPLEX*8) single-precision data is in IEEE little endian S_float format.
• REAL (KIND=8) and COMPLEX (KIND=8) (same as DOUBLE PRECISION and DOUBLE COMPLEX) double-precision data is in IEEE little endian T_float format.
• REAL (KIND=16) data is in Alpha little endian X_float format.

NATIVE

Specifies that the format for unformatted files containing numeric data is not converted. When using NATIVE (the default), the numeric format in the unformatted files must match the floating-point format representation in memory, which is specified using the /FLOAT qualifier.

This is the default.

VAXD

Specifies that unformatted files containing numeric data are in OpenVMS VAX little endian format, as follows:

• Integer data is in native little endian format.
• REAL (KIND=4) and COMPLEX (KIND=4) (same as REAL*4 and COMPLEX*8) single-precision data is in VAX F_float floating-point format.
• REAL (KIND=8) and COMPLEX (KIND=8) (same as REAL*8 and COMPLEX*16) double-precision data is in VAX D_float little endian format.
• REAL (KIND=16) (same as REAL*16) data is in VAX H_float little endian format.

VAXG

Specifies that unformatted files containing numeric data are in OpenVMS VAX little endian format, as follows:

• Integer data is in native little endian format.
• REAL (KIND=4) and COMPLEX (KIND=4) (same as REAL*4 and COMPLEX*8) single-precision data is in VAX F_float floating-point format.
• REAL (KIND=8) and COMPLEX (KIND=8) (same as REAL*8 and COMPLEX*16) double-precision data is in VAX G_float little endian format.
• REAL (KIND=16) (same as REAL*16) data is in VAX H_float little endian format.

For More Information:

• On limitations of data conversion, see Section 9.3.
• On converting unformatted data files, including using the OPEN statement CONVERT specifier and using FOR$CONVERTnnn logical names, see Section 9.4.
• On the ranges and formats of the various native intrinsic floating-point data types, see Section 8.4.
• On porting Compaq Fortran 77 data from OpenVMS VAX systems, see Section A.7.
• On the ranges of the nonnative VAX H_float data type, see Section A.8.

Specify /D_LINES to request that the compiler should treat lines in fixed-form source files that contain a D in column 1 as source code rather than comment lines. Such lines might print the values of variables or otherwise provide useful debugging information. This qualifier is ignored for free-form source files.

The default is /NOD_LINES, which means that lines with a D in column 1 are treated as comments.

2.3.14 /DEBUG --- Object File Traceback and Symbol Table

The /DEBUG qualifier requests that the object module contain information for use by the OpenVMS Debugger and the run-time error traceback mechanism.

The qualifier has the following form:

/DEBUG= [NO]SYMBOLS [NO]TRACEBACK [, ...] NONE ALL

[NO]SYMBOLS

Controls whether the compiler provides the debugger with local symbol definitions for user-defined variables, arrays (including dimension information), structures, parameter constants, and labels of executable statements.

[NO]TRACEBACK

Controls whether the compiler provides an address correlation table so that the debugger and the run-time error traceback mechanism can translate virtual addresses into source program routine names and compiler-generated line numbers.

ALL

Requests that the compiler provide both local symbol definitions and an address correlation table. If you specify /DEBUG without any keywords, it is the same as /DEBUG=ALL or /DEBUG=(TRACEBACK,SYMBOLS). When you specify /DEBUG, also specify /NOOPTIMIZE to prevent optimizations that complicate debugging.

NONE

Requests that the compiler provide no debugging information. The /NODEBUG, /DEBUG=NONE, and /DEBUG=(NOTRACEBACK, NOSYMBOLS) qualifiers are equivalent.

If you omit /DEBUG, the default is /DEBUG=(TRACEBACK, NOSYMBOLS).

For More Information:

• On using the OpenVMS Debugger, see Chapter 4.
• On debugging qualifiers for the FORTRAN and LINK commands, see Section 4.2.1.
• On LINK command qualifiers related to traceback and debugging, see Section 3.1.2 and Table 3-2.

The /DIAGNOSTICS qualifier creates a file containing compiler messages and diagnostic information.

The qualifier has the following form:

/DIAGNOSTICS[=file-spec]

The default is /NODIAGNOSTICS.

If you omit the file specification, the diagnostics file has the name of your source file and a file type of DIA.

The diagnostics file is reserved for use with Compaq third-party layered products such as, but not limited to, the Language Sensitive Editor (LSE).

For More Information:

On using LSE, see the Guide to Source Code Analyzer for OpenVMS Systems or online LSE HELP.

2.3.16 /DOUBLE_SIZE --- DOUBLE PRECISION Data Size

The /DOUBLE_SIZE qualifier allows you to specify the data size for floating-point DOUBLE PRECISION data declarations. The qualifier has the following form:

/DOUBLE_SIZE= 64 128

To request that all DOUBLE PRECISION declarations, constants, functions, and intrinsics use the REAL (KIND=16) extended-precision data rather than REAL (KIND=8) double-precision data, specify /DOUBLE_SIZE=128. REAL (KIND=16) data is stored in memory using X_float format.

If you omit /DOUBLE_SIZE=128, the size of DOUBLE PRECISION declarations is REAL (KIND=8) or 64-bit double-precision data (default is /DOUBLE_SIZE=64). To select the floating-point format used in memory for 64-bit REAL (KIND=8) data, use the /FLOAT qualifier.

For More Information:

On the /FLOAT qualifier, see Section 2.3.21.

2.3.17 /ERROR_LIMIT --- Limit Compiler Messages

The /ERROR_LIMIT qualifier specifies the maximum number of error-level or fatal-level compiler errors allowed for a given compilation unit (one or more files specified on the FORTRAN command line that create a single object file).

The qualifier has the following form:

/ERROR_LIMIT[=nn] or /NOERROR_LIMIT

If you specify /ERROR_LIMIT=n, the compilation can have up to n - 1 errors without terminating the compilation. When the error limit is reached, compilation is terminated. If you specify /NOERROR_LIMIT, there is no limit on the number of errors that are allowed.

By default, execution of the compiler is terminated when 30 error (E-level) and fatal (F-level) messages are detected (default is /ERROR_LIMIT=30).

When the error limit is surpassed, only compilation of the current comma-list element is terminated; the compiler will proceed to compile any other comma-list element. For example, consider the following:

$ FORTRAN A,B,C

If comma-list element A has more than 30 E- or F-level errors, its compilation is terminated, but the compiler proceeds to compile elements B and C.

A list of files separated by plus signs (+) form a single compilation unit. In the following example, compilation of the plus-sign separated files A, B, or C stops when the total of E- or F-level errors for all three files exceeds 30:

$ FORTRAN A+B+C

Specifying /ERROR_LIMIT=0 is equivalent to specifying /ERROR_LIMIT=1 (compilation terminates when the first error-level or fatal-level error occurs).

For More Information:

On compiler diagnostic messages, see Section 2.5.

2.3.18 /EXTEND_SOURCE --- Line Length for Fixed-Form Source

Specify /EXTEND_SOURCE to request that the compiler increase the length of Compaq Fortran statement fields to column 132 for fixed-form source files, instead of column 72 (the default). It is ignored for free-form source files.

You can also specify this qualifier by using the OPTIONS statement. The default in either case is /NOEXTEND_SOURCE.

To request warning messages for truncated fixed-form source lines, specify /WARNINGS=TRUNCATED_SOURCE.

For More Information:

• On recognized file name suffix characters and their relationship to fixed and free source formats, see Section 2.2.1.
• On column positions and more complete information on the fixed and free source formats, see the Compaq Fortran Language Reference Manual.
• On /WARNINGS=TRUNCATED_SOURCE, see Section 2.3.50.

The /F77 qualifier requests that the compiler use FORTRAN-77 (and thus Fortran 90/95) interpretation rules for those statements that have different meanings in older versions of the Fortran standards. The default is /F77.

If you specify /NOF77, the compiler uses the FORTRAN 66 (FORTRAN IV) interpretation, which include:

• DO loops are always executed at least once FORTRAN-66 EXTERNAL statement syntax and semantics are allowed.
• If the OPEN statement STATUS specifier is omitted, the default changes to STATUS='NEW' instead of STATUS='UNKNOWN'.
• If the OPEN statement BLANK specifier is omitted, the default changes to BLANK='ZERO' instead of BLANK='NULL'.

Specifying /FAST changes the defaults for certain qualifiers, usually improving run-time performance. The new defaults are:

• /ALIGNMENT=(COMMONS=NATURAL,RECORDS=NATURAL,SEQUENCE) (same as /ALIGNMENT=NATURAL) (see Section 2.3.3)
• /ARCHITECTURE=HOST (see Section 2.3.6)
• /ASSUME=NOACCURACY_SENSITIVE (see Section 2.3.7)
• /MATH_LIBRARY=FAST (see Section 2.3.29)
• /OPTIMIZE=TUNE=HOST (see Section 2.3.34)

The /FLOAT qualifier specifies the floating-point data format to be used in memory for REAL or COMPLEX data. For performance reasons, consider specifying the same floating-point memory format as the floating-point format used by unformatted files the program will access if the data falls within the acceptable range.

Figure 2-1 shows the FORTRAN command qualifiers used to specify the floating-point format used in memory and in an unformatted file. Because REAL (KIND=16) (same as REAL*16) data is always in X_float format on Alpha systems, the /FLOAT keyword specifies the format for REAL (KIND=4), COMPLEX (KIND=4), REAL (KIND=8), and COMPLEX (KIND=8) data (or equivalent declarations).

Figure 2-1 Specifying the Format of Numeric Data for Unformatted Files

To specify the floating-point format (such as big endian) for all unformatted files opened by the program, use the /CONVERT qualifier. To allow the same program to use different floating-point formats, you must use the predefined logical names or the OPEN CONVERT keyword to specify the format for specific unit numbers, as described in Chapter 9.

The qualifier has the following form:

/FLOAT= D_FLOAT G_FLOAT IEEE_FLOAT

D_FLOAT

Specifies that the memory format for REAL (KIND=4) and COMPLEX (KIND=4) data is VAX F_float and that the memory format for REAL (KIND=8) and COMPLEX (KIND=8) data is VAX D_float. Same as the obsolete qualifier /NOG_FLOATING.

OpenVMS VAX systems fully support D_float and G_float implementations of the REAL (KIND=8) (DOUBLE PRECISION) data type in memory. OpenVMS Alpha systems can store REAL (KIND=8) floating-point data in memory in D_float, G_float, or T_float format.

Because the Alpha instruction set does not support D_float computations, D_float data is converted to G_float format for arithmetic computations and then converted back to D_float format. For programs that perform many REAL (KIND=8) computations, using D_float data on Alpha systems is slower than G_float or T_float data and the results will differ from VAX D_float computations and results.

Unless a program uses unformatted data files in D_float format, do not use the /FLOAT=D_FLOAT qualifier. If range and accuracy constraints do not disallow the use of the other REAL (KIND=8) data types, consider converting existing unformatted files that contain D_float data to another format, such as G_float, T_float, or X_float (see Chapter 9).

G_FLOAT

Specifies that the memory format for single precision REAL (KIND=4) and COMPLEX (KIND=4) data is VAX F_float and that the memory format for double precision REAL (KIND=8) and COMPLEX (KIND=8) data is VAX G_float. Same as the obsolete qualifier /G_FLOATING.

The default is /FLOAT=G_FLOAT, unless you specify /NOG_FLOATING.

IEEE_FLOAT

Specifies that the memory format for single precision REAL (KIND=4) and COMPLEX (KIND=4) data is IEEE S_float and the memory format for double precision REAL (KIND=8) and COMPLEX (KIND=8) is IEEE T_float.

Specifying /FLOAT=IEEE_FLOAT allows the use of certain IEEE exceptional values. When you specify /FLOAT=IEEE_FLOAT, you should be aware of the /CHECK=FP_EXCEPTIONS, /IEEE_MODE, and /ROUNDING_MODE qualifiers.

Because REAL (KIND=16) (same as REAL*16) and COMPLEX (KIND=16) (same as COMPLEX*32) data is always in X_float format on Alpha systems, operations that use REAL (KIND=16) and COMPLEX (KIND=16) data may encounter certain exceptional values even when /FLOAT=IEEE_FLOAT is not used.

If your program requires the G_float form of double precision for its correct operation (it uses a range larger than 10**38), you should use the /FLOAT qualifier in an OPTIONS statement in your source program.

You should not mix floating data type formats in routines that pass single-precision or double-precision quantities amongst themselves.

For More Information:

• On intrinsic floating-point data types, see Chapter 8.
• On converting unformatted files, see Section 2.3.12.
• On qualifiers of interest when you specify /FLOAT=IEEE_FLOAT, see:

  Section 2.3.11 (/CHECK=FP_EXCEPTIONS)
  Section 2.3.23 (/IEEE_MODE)
  Section 2.3.39 (/ROUNDING_MODE)

The /GRANULARITY qualifier controls the size of data that can be safely accessed from different threads. You do not need to specify this option for local data access by a single process, unless asynchronous write access from outside the user process might occur. The default is /GRANULARITY=QUADWORD.

The qualifier has the following form:

/GRANULARITY= BYTE LONGWORD QUADWORD

Data that can be written from multiple threads must be declared as VOLATILE (so it is not held in registers). To ensure alignment in common blocks, derived types, and record structures, use the /ALIGNMENT qualifier.

BYTE

Requests that all data (one byte or greater) can be accessed from different threads sharing data in memory. This option will slow run-time performance.

LONGWORD

Ensures that naturally aligned data of four bytes or greater can be accessed safely from different threads sharing access to that data in memory. Accessing data items of three bytes or less and unaligned data may result in data items written from multiple threads being inconsistently updated.

QUADWORD

Ensures that naturally aligned data of eight bytes can be accessed safely from different threads sharing data in memory. Accessing data items of seven bytes or less and unaligned data may result in data items written from multiple threads being inconsistently updated. This is the default.

For More Information:

• On the Alpha architecture, see Alpha Architecture Reference Manual.
• On intrinsic data types, see Chapter 8.

The /IEEE_MODE qualifier specifies the arithmetic exception handling used for floating-point calculations, such as for exceptional values. It also controls the precision of exception reporting (like /SYNCHRONOUS_EXCEPTIONS).

Exceptional values are associated with IEEE arithmetic and include Infinity (+ and -) values, Not-A-Number (NaN) values, invalid data values, and denormalized numbers (see Section 8.4.8).

Use the /IEEE_MODE qualifier to control:

• Whether exceptional values cause program termination or continuation
• Whether exception reporting is precise
• Whether underflow (denormalized) values are set to zero

This qualifier only applies to arithmetic calculations when:

• You omit the /MATH_LIBRARY=FAST qualifier (or /FAST) qualifier. Using /MATH_LIBRARY=FAST provides limited handling of exceptional values of arguments to and results from Compaq Fortran intrinsic functions.
• You specify the /FLOAT=IEEE_FLOAT qualifier to request IEEE S_float (KIND=4) and T_float (KIND=8) data.
  If you specify /FLOAT=G_FLOAT (the default) or /FLOAT=D_FLOAT, /IEEE_MODE must not also be specified. Because X_float data (KIND=16) has no denormalized range, DENORM_RESULTS is equivalent to UNDERFLOW_TO_ZERO for X_float data.

The qualifier has the following form:

/IEEE_MODE= FAST UNDERFLOW_TO_ZERO DENORM_RESULTS

The default, /IEEE_MODE=FAST, provides faster run-time performance than UNDERFLOW_TO_ZERO or DENORM_RESULTS. Specifying DENORM_RESULTS provides the slowest run-time performance.

FAST

Specifies that the program should stop if any exceptional values are detected. This is the default.

When the program encounters or calculates any exceptional values (infinity (+ or --), NaN, or invalid data) in a calculation, the program stops and displays a message. This allows the fastest run-time performance.

Denormalized values calculated in an arithmetic expression are set to zero. Denormalized values encountered as variables in an arithmetic expression (including constant values) are treated as invalid data (an exceptional value), which stops the program.

Exceptions are not reported until one or more instructions after the instruction that caused the exception. To have exceptions reported at the instruction that caused the exception when using /IEEE_MODE=FAST, also specify /SYNCHRONOUS_EXCEPTIONS.

Using FAST (default) allows fast run-time performance for those programs that do not generate exceptional values.

UNDERFLOW_TO_ZERO

Specifies that the program should continue if any exceptional values are detected and set calculated denormalized (underflow) values to zero.

When the program encounters an exceptional value (infinity (+ or --), NaN, invalid data) in an arithmetic expression, the program continues. It also continues when the result of a calculation is an exceptional value.

Calculated denormalized values are set to zero (0). This prevents the denormalized number from being used in a subsequent calculation (propagated).

Exceptions are reported at the instruction that caused the exception (same as /SYNCHRONOUS_EXCEPTIONS). This allows precise run-time reporting of exceptions for those programs that generate exceptional values, but this slows program run-time performance.

Using UNDERFLOW_TO_ZERO allows programs to handle exceptional values, but does not propagate numbers in the denormalized range.

To request run-time messages for arithmetic exceptions, specify the /CHECK=FP_EXCEPTIONS qualifier.

DENORM_RESULTS

Specifies that the program should continue if any exceptional values are detected and leave calculated denormalized values as is (allows underflow).

When the program encounters an exceptional value (infinity (+ or --), NaN, invalid data) in an arithmetic expression, the program continues. It also continues when the result of a calculation is an exceptional value.

Calculated denormalized values are left as denormalized values. When a denormalized number is used in a subsequent arithmetic expression, it requires extra software-assisted handling and slows performance. A program that generates denormalized numbers will be slower than the same program compiled using /IEEE_MODE=UNDERFLOW_TO_ZERO.

Exceptions are reported at the instruction that caused the exception (same as /SYNCHRONOUS_EXCEPTIONS). This allows precise run-time reporting of exceptions for those programs that generate exceptional values, but this slows program run-time performance.

Using DENORM_RESULTS allows programs to handle exceptional values, including allowing underflow of denormalized numbers.

To request run-time messages for arithmetic exceptions, specify the /CHECK=FP_EXCEPTIONS qualifier. To request run-time messages for only those arithmetic exceptions related to denormalized numbers, specify the /CHECK=UNDERFLOW qualifier.

For More Information:

• On exceptional floating-point values, see Section 8.4.8.
• On controlling run-time arithmetic exception messages (/CHECK=(FP_EXCEPTIONS,UNDERFLOW) qualifier), see Section 2.3.11.
• On the ranges of the various data types (including denormalized ranges), see Chapter 8.
• On IEEE floating-point exception handling, see the IEEE Standard for Binary Floating-Point Arithmetic (ANSI/IEEE Standard 754-1985).

The /INCLUDE qualifier specifies one or more additional directories for the Compaq Fortran compiler to search for:

• Module files (specified by a USE statement)
  Module files have a file type of F90$MOD and are created by the Compaq Fortran compiler. For more information on module files, see Section 2.2.3.
• Include files (specified by an INCLUDE statement)
  Include files have a file type like other Compaq Fortran source files (F90, FOR, or F) and are usually created by the user with a text editor.
  Compaq Fortran also provides certain include library modules in the text library FORSYSDEF.TLB. Users can create a text library and then populate and maintain include library modules in the library. For more information on include files and include text library modules, see Section 2.2.4.

If the INCLUDE statement specifies an explicit device and/or directory, only that directory is searched.

If you omit /INCLUDE, the compiler searches in the current directory for module files and either the current directory or the directory containing the source file specified on the FORTRAN command line for include files or text libraries:

• If you omit /ASSUME=SOURCE_INCLUDE, only the current default directory is searched.
• If you specify /ASSUME=SOURCE_INCLUDE, the directory where the source file resides is searched instead of the current directory.

The order of directory searching follows:

1. The current directory (omit /ASSUME=SOURCE_INCLUDE) or the directory where the source file resides (specify /ASSUME=SOURCE_INCLUDE).
2. One or more directories specified by the /INCLUDE qualifier.
3. The location defined by the logical name FORT$INCLUDE (if defined). To prevent searching in this directory, specify /NOINCLUDE.

If you do not specify /INCLUDE or /NOINCLUDE, the compiler searches first in the current directory (or directory where the source file resides) and then the directory specified by FORT$INCLUDE (if defined).

To request that the compiler only search in the current directory (or directory where the source file resides), specify /NOINCLUDE. This prevents the compiler from searching the FORT$INCLUDE directory. If you use /NOINCLUDE, you cannot specify /INCLUDE.

To request that the compiler only search in the directory specified by FORT$INCLUDE, specify /INCLUDE=FORT$INCLUDE.

To control the searching for text libraries (not included files or modules), you can also use the logical name FORT$LIBRARY.

Like other OpenVMS logical names, it can specify the location for your process only or for multiple processes (including system-wide).

To specify the additional directories DISKA:[PROJ_MODULE.F90] and DISKB:[F_COMMON.F90] with the /INCLUDE qualifier, use a single /INCLUDE qualifier, as follows:

$ FORTRAN PROJ_M.F90 /INCLUDE=(DISKA:[PROJ_MODULE.F90],DISKB:[F_COMMON.F90])

If you specify multiple directories, the order of the directories (and their devices) in the /INCLUDE qualifier determines the directory search order.

For More Information:

• On the /ASSUME=SOURCE_INCLUDE qualifier, see Section 2.3.7.
• On using library modules in a text library, see Section 2.2.4 and Section 2.3.26.
• On OpenVMS logical names, see the OpenVMS User's Manual.

The /INTEGER_SIZE qualifier controls how the compiler interprets INTEGER or LOGICAL declarations that do not have a specified length. The default is INTEGER_SIZE=32.

The qualifier has the following form:

/INTEGER_SIZE= 16 32 64

16

Indicates that INTEGER declarations are interpreted as INTEGER (KIND=2) and LOGICAL declarations as LOGICAL (KIND=2). Same as the obsolete /NOI4 qualifier.

32

Indicates that INTEGER declarations are interpreted as INTEGER (KIND=4) and LOGICAL declarations as LOGICAL (KIND=4). Same as the obsolete /I4 qualifier.

64

Indicates that INTEGER declarations are interpreted as INTEGER (KIND=8) and LOGICAL declarations as LOGICAL (KIND=8)

For performance reasons, use INTEGER (KIND=4) data instead of INTEGER (KIND=2) or INTEGER (KIND=1) and whenever possible. You must explicitly declare INTEGER (KIND=1) data.

For More Information:

• On intrinsic data types and their ranges, see Chapter 8.
• On run-time integer overflow checking (/CHECK=OVERFLOW), see Section 2.3.11.

The /LIBRARY qualifier specifies that a file is a text library file.

The qualifier has the following form:

text-library-file/LIBRARY

The /LIBRARY qualifier can be specified on one or more text library files in a list of files concatenated by plus signs (+). At least one of the files in the list must be a nonlibrary file. The default file type is TLB.

For More Information:

• On the use of text libraries, see Section 2.4.
• On the OpenVMS Librarian, see the OpenVMS Librarian Utility Manual or type HELP LIBRARY.

The /LIST qualifier requests a source listing file. You can request additional listing information using the /MACHINE_CODE and /SHOW qualifiers.

The qualifier has the following form:

/LIST[=file-spec]

You can include a file specification for the listing file. If you omit the file specification, the listing file has the name of the first source file and a file type of LIS.

The default depth of a page in a listing file is 66 lines. To modify the default, assign the new number to the logical name SYS$LP_LINES, using the DCL command DEFINE. For example, the following DCL command sets the page depth at 88 lines:

$ DEFINE SYS$LP_LINES 88

The valid number of lines per page ranges from 30 to a maximum of 255. The definition can be applied to the entire system by using the command DEFINE/SYSTEM.

In interactive mode, the compiler does not produce a listing file unless you include the /LIST qualifier. In batch mode, the compiler produces a listing file by default. In either case, the listing file is not automatically printed; you must use the PRINT command to obtain a line printer copy of the listing file.

If a source line of length 1 contains a form-feed character, the source code listing begins a new page with the following line; the line containing the form-feed does not appear.

If a source line of length greater than 1 contains a form-feed character, that line is printed but the form-feed character is ignored (does not generate a new page).

Any other nonprinting ASCII characters encountered in Compaq Fortran source files are replaced by a space character, and a warning message appears.

You can request additional information in the listing file using the /MACHINE_CODE and /SHOW qualifiers.

The listing file includes the Compaq Fortran version number.

The /ANNOTATIONS qualifier controls whether an annotated listing showing optimizations is included with the listing file.

For More Information:

• On the format of listing files, see Section 2.6.1.
• On the /MACHINE_CODE qualifier, see Section 2.3.28.
• On the /SHOW qualifier, see Section 2.3.42.
• On the /ANNOTATIONS qualifier, see Section 2.3.5

Specifying /MACHINE_CODE requests that the listing file include a symbolic representation of the OpenVMS Alpha object code generated by the compiler. Generated code and data are represented in a form similar to a Assembly code listing. The code produced by the /MACHINE_CODE qualifier is for informational purposes only. It is not intended to be assembled and is not supported by the MACRO assembler.

If a listing file is not being generated, the /MACHINE_CODE qualifier is ignored.

The default is /NOMACHINE_CODE.

For More Information:

• On the format of a machine code listing, see Section 2.6.2.
• On the /LIST qualifier, see Section 2.3.27.

If you omit /MATH_LIBRARY=FAST (and /FAST), the compiler uses the standard, very accurate math library routines for each Compaq Fortran intrinsic function, such as SQRT (default is /MATH_LIBRARY=ACCURATE).

Specify /MATH_LIBRARY=FAST to use a special version of certain math library routines that produce faster results, but with a slight loss of precision and less exception checking.

This qualifier applies only to IEEE data types (when you specify /FLOAT=IEEE_FLOAT). The qualifier has the following form:

/MATH_LIBRARY= ACCURATE FAST

ACCURATE

Using /MATH_LIBRARY=ACCURATE (default if you omit /FAST) produces the very accurate results and error checking expected of quality compiler products. It uses the standard set of math library routines for the applicable intrinsics.

The standard math library routines are designed to obtain very accurate "near correctly rounded" results and provide the robustness needed to check for IEEE exceptional argument values, rather than achieve the fastest possible run-time execution speed. Using /MATH_LIBRARY=ACCURATE allows user control of arithmetic exception handling with the /IEEE_MODE qualifier.

FAST

Specifying /MATH_LIBRARY=FAST (default if you specify /FAST) use versions of certain math library routines that perform faster computations than the standard, more accurate math library routines, but with slightly less fractional accuracy and less reliable arithmetic exception handling. Using /MATH_LIBRARY=FAST allows certain math library functions to get significant performance improvements when the applicable intrinsic function is used.

If you specify /MATH_LIBRARY=FAST, the math library routines do not necessarily check for IEEE exceptional values and the /IEEE_MODE qualifier is ignored.

When you use MATH_LIBRARY=FAST, you should carefully check the calculated output from your program. Check the program's calculated output to verify that it is not relying on the full fractional accuracy of the floating-point data type (see Section 8.4) to produce correct results or producing unexpected exceptional values (exception handling is indeterminate).

Programs that do not produce acceptable results with /MATH_LIBRARY=FAST and single-precision data might produce acceptable results with /MATH_LIBRARY=FAST if they are modified (or compiled) to use double-precision data.

The specific intrinsic routines that have special fast math routines depend on the version of the OpenVMS Alpha operating system in use. Allowed error bounds vary with each routine.

For More Information:

• On controlling arithmetic exception handling, including using the /IEEE_MODE qualifier, see Section 2.3.23.
• On the /FAST qualifier, see Section 2.3.20.
• On requesting double-precision data during compilation for REAL data declarations (/REAL_SIZE=64 qualifier, see Section 2.3.36.
• On native floating-point formats, see Section 8.4.
• On the specific intrinsic routines that have special fast math routines, see the online release notes.

The /MODULE qualifier controls where module files (.F90$MOD) are placed. If you omit this qualifier or specify /NOMODULE, the .F90$MOD files are placed in your current default directory.

The qualifier has the following form

/MODULE=directory

If you specify this qualifier as shown, .F90$MOD files are placed in the directory location as indicated.

2.3.31 /NAMES --- Control Case of External Names

The /NAMES qualifier specifies how the Compaq Fortran compiler represents external (global) names to the linker.

The qualifier has the following form:

/NAMES= UPPERCASE LOWERCASE AS_IS

UPPERCASE

Causes the compiler to ignore case differences in identifiers and to convert external names to uppercase. This is the default.

LOWERCASE

Causes the compiler to ignore case differences in identifiers and to convert external names to lowercase.

AS_IS

Causes the compiler to distinguish case differences in identifiers and to preserve the case of external names.

The default, /NAMES=UPPERCASE, means that Compaq Fortran converts external names to uppercase.

For More Information:

• On the EXTERNAL statement, see the Compaq Fortran Language Reference Manual.
• On specifying case names with the C property, see Section 10.3.2.1.
• On specifying names with the ALIAS property, see Section 10.3.2.2.

The /OBJECT qualifier specifies the name of the object file or prevents object file creation.

The qualifier has the following form:

/OBJECT[=file-spec]

The default is /OBJECT. If you omit the file specification, the object file has the name of the first source file and a file type of OBJ.

Use the negative form, /NOOBJECT, to suppress object code (for example, when you want to test only for compilation errors in the source program).

For More Information:

On using the /OBJECT qualifier, see Section 2.2.5.

2.3.33 /OLD_F77 --- Use Old FORTRAN 77 Compiler

To use the Compaq Fortran 77 compiler, specify /OLD_F77 as the first qualifier on the FORTRAN command line. The default is to use the Compaq Fortran (90/95 language) compiler. The default Compaq Fortran compiler supports the FORTRAN 77 language as well as the Fortran 90 and Fortran 95 standards.

If you specify the /OLD_F77 qualifier, certain FORTRAN command qualifiers will be ignored, including qualifiers associated with Fortran 90 and Fortran 95 features, Fortran 90 and 95 standards checking, and certain optimization keywords.

2.3.34 /OPTIMIZE --- Specify Compiler Optimizations

The /OPTIMIZE qualifier requests that the compiler produce optimized code.

The qualifier has the following form:

/OPTIMIZE= LEVEL=n INLINE= NONE MANUAL SIZE SPEED ALL NOINLINE LOOPS PIPELINE TUNE= GENERIC HOST EV4 EV5 EV56 PCA6 EV6 EV67 UNROLL=n [, ...]

The default is /OPTIMIZE, which is equivalent to /OPTIMIZE=LEVEL=4. Use the negative form, /NOOPTIMIZE or /OPTIMIZE=LEVEL=0, for a debugging session to ensure that the debugger has sufficient information to locate errors in the source program.

In most cases, using /OPTIMIZE will make the program execute faster. As a side effect of getting the fastest execution speeds, using /OPTIMIZE can produce larger object modules and longer compile times than /NOOPTIMIZE.

To allow full interprocedure optimization when compiling multiple source files, consider separating source file specifications with plus signs (+), so the files are concatenated and compiled as one program. Full interprocedure optimization can reduce overall program execution time (see Section 5.1.2). Consider not concatenating source files when the size of the source files is excessively large and the amount of memory or disk space is limited.

The /OPTIMIZE keywords follow:

LEVEL

You can specify the optimization level with /OPTIMIZE=LEVEL=n, where n is from 0 to 5, as follows:

• LEVEL=0 disables nearly all optimizations. Specifying LEVEL=0 causes the /WARNINGS=UNUSED qualifier to be ignored.
  This provides the same inlining as /OPTIMIZE=INLINE=NONE.
• LEVEL=1 enables local optimizations within the source program unit, recognition of common subexpressions, and integer multiplication and division expansion (using shifts).
• LEVEL=2 enables global optimizations and optimizations performed with LEVEL=1. Global optimizations include data-flow analysis, code motion, strength reduction and test replacement, split-lifetime analysis, and instruction scheduling.
  This provides the same inlining as /OPTIMIZE=INLINE=MANUAL.
• LEVEL=3 enables additional global optimizations that improve speed (at the cost of extra code size) and optimizations performed with LEVEL=2. Additional global optimizations include:
  • Loop unrolling
  • Code replication to eliminate branches
• LEVEL=4 enables interprocedure analysis, automatic inlining of small procedures (with heuristics limiting the amount of extra code), the software pipelining optimization (also set by /OPTIMIZE=PIPELINE), and optimizations performed with LEVEL=3. LEVEL=4 is the default.
  The software pipelining optimization applies instruction scheduling to certain innermost loops, allowing instructions within a loop to "wrap around" and execute in a different iteration of the loop. This can reduce the impact of long-latency operations, resulting in faster loop execution. Software pipelining also enables the prefetching of data to reduce the impact of cache misses.
  For more information on software pipelining, see the PIPELINE keyword in this section.
  This provides the same inlining as /OPTIMIZE=INLINE=SPEED.
• LEVEL=5 activates the loop transformation optimizations (also set by /OPTIMIZE=LOOPS).
  • The loop transformation optimizations are a group of optimizations that apply to array references within loops. These optimizations can improve the performance of the memory system and can apply to multiple nested loops.
    Loop transformation optimizations include loop blocking, loop distribution, loop fusion, loop interchange, loop scalar replacement, and outer loop unrolling.
    To specify loop transformation optimizations without software pipelining, do one of the following:
    • Specify LEVEL=5 with NOPIPELINE (preferred method)
    • Specify LOOPS with LEVEL=4, LEVEL=3, or LEVEL=2. This optimization is not performed at optimization levels below LEVEL=2.
    
    For more information on the loop transformation optimizations, see the LOOPS keyword in this section.
  
  In addition to loop transformation, specifying LEVEL=5 activates certain optimizations that are not activated by LOOPS and PIPELINE, including byte-vectorization, and insertion of additional NOP (No Operation) instructions for alignment of multi-issue sequences.
  To determine whether using LEVEL=5 benefits your particular program, you should time program execution for the same program compiled at LEVEL=4 and LEVEL=5 (see Section 5.2).
  For programs that contain loops that exhaust available registers, longer execution times may result with /OPTIMIZE=LEVEL=5, requiring use of /OPTIMIZE=UNROLL=n to limit loop unrolling (see the UNROLL keyword in this section).
  Specifying LEVEL=5 implies the optimizations performed at LEVEL=1, LEVEL=2, LEVEL=3, and LEVEL=4.
  This provides the same inlining as /OPTIMIZE=INLINE=SPEED.

INLINE

You can specify the level of inlining with /OPTIMIZE=INLINE=xxxxx, where xxxx is one of the following keywords:

• NONE (same as /OPTIMIZE=NOINLINE) prevents any procedures from being inlined, except statement functions, which are always inlined. This type of inlining occurs if you specify /OPTIMIZE=LEVEL=0, LEVEL=1, LEVEL=2, or LEVEL=3 and omit /OPTIMIZE=INLINE=keyword.
• MANUAL is the same as NONE for Compaq Fortran (but not necessarily for other OpenVMS languages). This type of inlining occurs if you specify /OPTIMIZE=LEVEL=0, LEVEL=1, LEVEL=2, or LEVEL=3 and omit /OPTIMIZE=INLINE=keyword.
• SIZE inlines procedures that will improve run-time performance without significantly increasing program size. This type of inlining is relevant at /OPTIMIZE=LEVEL=1 or higher.
• SPEED inlines procedures that will improve run-time performance with a significant increase in program size. This type of inlining is relevant at /OPTIMIZE=LEVEL=1 or higher. INLINE=SPEED occurs if you specify /OPTIMIZE=LEVEL=4 or LEVEL=5 and omit /INLINE=keyword.
• ALL inlines every call that can possibly be inlined while generating correct code, including the following:
  • Statement functions (NONE or MANUAL)
  • Any procedures that Compaq Fortran thinks will improve run-time performance (SPEED)
  • Any other procedures that can possibly be inlined and generate correct code. Certain recursive routines are not inlined to prevent infinite loops.
    This type of inlining is relevant at /OPTIMIZE=LEVEL=1 or higher.

NOINLINE

Same as INLINE=NONE.

LOOPS

Specifying /OPTIMIZE=LOOPS (or /OPTIMIZE=LEVEL=5) activates a group of loop transformation optimizations that apply to array references within loops. These optimizations can improve the performance of the memory system and usually apply to multiple nested loops. The loops chosen for loop transformation optimizations are always counted loops (which include DO or IF loops, but not uncounted DO WHILE loops).

Conditions that typically prevent the loop transformation optimizations from occurring include subprogram references that are not inlined (such as an external function call), complicated exit conditions, and uncounted loops.

The types of optimizations associated with /OPTIMIZE=LOOPS include the following:

• Loop blocking
• Loop distribution
• Loop fusion
• Loop interchange
• Loop scalar replacement
• Outer loop unrolling

The loop transformation optimizations are a subset of optimizations activated by /OPTIMIZE=LEVEL=5. Instead of specifying both LOOPS and PIPELINE, you can specify /OPTIMIZE=LEVEL=5.

To specify loop transformation optimizations without software pipelining, do one of the following:

• Specify LEVEL=5 with NOPIPELINE (preferred method)
• Specify LOOPS with LEVEL=3 or LEVEL=2. This optimization is not performed at optimization levels below LEVEL=2.

To determine whether using /OPTIMIZE=LOOPS benefits your particular program, you should time program execution for the same program (or subprogram) compiled with and without loop transformation optimizations (such as with /OPTIMIZE=LOOPS and /OPTIMIZE=NOLOOPS).

PIPELINE

Specifying /OPTIMIZE=PIPELINE (or /OPTIMIZE=LEVEL=4) activates the software pipelining optimization. The software pipelining optimization applies instruction scheduling to certain innermost loops, allowing instructions within a loop to "wrap around" and execute in a different iteration of the loop. This can reduce the impact of long-latency operations, resulting in faster loop execution.

For this version of Compaq Fortran, loops chosen for software pipelining are always innermost loops and do not contain branches, procedure calls, or COMPLEX floating-point data.

Software pipelining can be more effective when you combine /OPTIMIZE=PIPELINE with the appropriate /OPTIMIZE=TUNE=xxxx keyword for the target Alpha processor generation (see the TUNE keyword in this section).

Software pipelining also enables the prefetching of data to reduce the impact of cache misses.

Software pipelining is a subset of the optimizations activated by /OPTIMIZE=LEVEL=4.

To specify software pipelining without loop transformation optimizations, do one of the following:

• Specify LEVEL=4 with NOLOOPS (preferred method)
• Specify PIPELINE with LEVEL=3 or LEVEL=2. This optimization is not performed at optimization levels below LEVEL=2.

To determine whether using /OPTIMIZE=PIPELINE benefits your particular program, you should time program execution for the same program (or subprogram) compiled with and without software pipelining (such as with /OPTIMIZE=PIPELINE and /OPTIMIZE=NOPIPELINE).

For programs that contain loops that exhaust available registers, longer execution times may result with /OPTIMIZE=LEVEL=5, requiring use of /OPTIMIZE=UNROLL=n to limit loop unrolling (see the UNROLL keyword in this section).

TUNE

You can specify the types of processor-specific instruction tuning for implementations of the Alpha architecture using the /OPTIMIZE=TUNE=xxxx keywords. Regardless of the setting of /OPTIMIZE=TUNE=xxxx you use, the generated code runs correctly on all implementations of the Alpha architecture. Tuning for a specific implementation can improve run-time performance; it is also possible that code tuned for a specific target may run slower on another target.

The /OPTIMIZE=TUNE=xxxx keywords are as follows:

• GENERIC generates and schedules code that will execute well for all generations of Alpha processor chips. This provides generally efficient code for those cases where both processor generations are likely to be used. If /FAST is specified, the default is HOST; otherwise, the default is GENERIC.
• HOST generates and schedules code optimized for the processor generation in use on the system being used for compilation.
• EV4 generates and schedules code optimized for the 21064, 21064A, 21066, and 21068 implementations of the Alpha chip.
• EV5 generates and schedules code optimized for the 21164 implementation of the Alpha chip. This processor generation is faster and more recent than the implementations of the Alpha chip associated with EV4 (21064, 21064A, 21066, and 21068).
• EV56 generates and schedules code optimized for some 21164 Alpha architecture implementations that use the BWX (Byte/Word manipulation) instruction extensions of the Alpha architecture.
• PCA56 generates and schedules code optimized for 21164PC Alpha architecture implementation that uses BWX (Byte/Word manipulation) and MAX (Multimedia) instructions extensions.
• EV6 generates and schedules code optimized for the 21264 chip implementation that uses the following extensions to the base Alpha instruction set: BWX (Byte/Word manipulation) and MAX (Multimedia) instructions, square root and floating-point convert instructions, and count instructions.
• EV67 generates and schedules code optimized for the EV67 Alpha architecture implementation that uses BWX (Byte/Word manipulation), MVI (Multimedia) instructions, square root and floating-point convert extensions (FIX), and count extensions (C1X).

If /OPTIMIZE=TUNE=xxxx specifies a processor of less functionality than is specified by /ARCHITECTURE, code is optimized for the processor specified by /ARCHITECTURE.

If you omit /OPTIMIZE=TUNE=xxxx, HOST is used if /FAST is specified; otherwise GENERIC is used.

UNROLL

You can specify the number of times loops are unrolled with /OPTIMIZE= UNROLL=n, where n is a number from 0 to 16. If you omit the UNROLL keyword or specify UNROLL=0 (the default), the optimizer determines how many times loops are unrolled. Usually loops are unrolled four times, but code analysis may result in certain loops being unrolled two times (twice).

Compaq Fortran unrolls loops at /OPTIMIZE=LEVEL=3 or higher. When timings using LEVEL=5 show that performance has not improved, consider specifying UNROLL=1 with LEVEL=5, such the following:

$ FORTRAN /OPTIMIZE=(LEVEL=5,UNROLL=1) M_APP.F90+SUB.F90/NOLIST

For More Information:

• On the effects of /OPTIMIZE=LEVEL=5, see Section 5.8.2.
• On limiting loop unrolling, see Section 5.7.4.1.
• On timing program execution, see Section 5.2.
• On the related /ASSUME=NOACCURACY_SENSITIVE qualifier, see Section 2.3.7.
• On guidelines for improving performance, see Chapter 5.
• On the optimizations performed at each level, see Section 5.7.

Controls how the compiler treats fixed-form file source lines that are shorter than the statement field width (72 characters, or 132 characters if /EXTEND_SOURCE is in effect.) This determines how the compiler treats character and Hollerith constants that are continued across two or more source lines. This qualifier does not apply to free-form source files.

Specifying /PAD_SOURCE causes the compiler to treat short source lines as if they were padded with blanks out to the statement field width. This may be useful when compiling programs developed for non-Compaq compilers that assume that short source lines are blank-padded.

The default, /NOPAD_SOURCE, is compatible with current and previous Compaq Fortran compilers, which causes the compiler to not treat short source lines as padded with blanks so that the first character of a continuation line immediately follows the last character of the previous line.

If /NOPAD_SOURCE is in effect, the compiler issues an informational message if it detects a continued constant that might be affected by blank padding.

For More Information:

On /WARNINGS=USAGE qualifier, see Section 2.3.50.

2.3.36 /REAL_SIZE --- Floating-Point Data Size

The /REAL_SIZE qualifier controls how the compiler interprets floating-point declarations that do not have a specified length.

The qualifier has the following form:

/REAL_SIZE= 32 64 128

32

Defines REAL declarations, constants, functions, and intrinsics as REAL (KIND=4) (single precision) and COMPLEX declarations, constants, functions, and intrinsics as COMPLEX (KIND=4) (single complex).

64

Defines REAL and COMPLEX declarations, constants, functions, and intrinsics as REAL (KIND=8) (double precision) and COMPLEX declarations, constants, functions, and intrinsics as COMPLEX (KIND=8) (double complex).

This also causes intrinsic functions to produce a double precision REAL (KIND=8) or COMPLEX (KIND=8) result instead of a single precision REAL (KIND=4) or COMPLEX (KIND=4) result, except if the argument is explicitly typed.

For instance, references to the CMPLX intrinsic produce DCMPLX results (COMPLEX (KIND=8)), except if the argument to CMPLX is explicitly typed as REAL (KIND=4) or COMPLEX (KIND=4), in which case the resulting data type is COMPLEX (KIND=4). Other affected intrinsic functions include CMPLX, FLOAT, REAL, SNGL, and AIMAG.

128

Specifying /REAL_SIZE=128 defines:

• REAL and DOUBLE PRECISION declarations, constants, functions, and intrinsics as REAL (KIND=16) (REAL*16)
• COMPLEX and DOUBLE COMPLEX declarations, constants, functions, and intrinsics as COMPLEX (KIND=16) (COMPLEX*32)

If you omit /REAL_SIZE=128, then:

• REAL declarations, constants, functions, and intrinsics are defined as REAL (KIND=4).
• DOUBLE PRECISION declarations, constants, functions, and intrinsics are defined as REAL (KIND=8).
• COMPLEX declarations, constants, functions, and intrinsics are defined as COMPLEX (KIND=4).
• DOUBLE COMPLEX declarations, constants, functions, and intrinsics are defined as COMPLEX (KIND=8).

Specifying /REAL_SIZE=128 causes REAL, DOUBLE PRECISION, COMPLEX, and DOUBLE COMPLEX intrinsic functions to produce REAL (KIND=16) or COMPLEX (KIND=16) results unless their arguments are typed with an explicit KIND type parameter.

For instance, a reference to the CMPLX intrinsic with /REAL_SIZE=128 produces a COMPLEX (KIND=16) result unless the argument is explicitly typed as REAL (KIND=4) or COMPLEX (KIND=4), in which case the result is COMPLEX (KIND=4).

The default is /REAL_SIZE=32.

For More Information:

• On data types, see Chapter 8.
• On intrinsic functions, see the Compaq Fortran Language Reference Manual.

The /RECURSIVE qualifier requests that Compaq Fortran generate code and allocate data so that a subroutine or a function can be called recursively.

The /RECURSIVE qualifier:

• Changes the default allocation class for all local variables from STATIC to AUTOMATIC, except for variables that are data-initialized, named in a SAVE statement, or for declared as STATIC.
• Permits references to a routine name from inside the routine.

Subprograms declared with the RECURSIVE keyword are always recursive (whether you specify or omit the /RECURSIVE qualifier).

Variables declared with the AUTOMATIC statement or attribute always use stack-based storage for all local variables (whether you specify or omit the /RECURSIVE or /AUTOMATIC qualifiers).

Specifying /RECURSIVE sets /AUTOMATIC.

For More Information:

On the RECURSIVE keyword, see the Compaq Fortran Language Reference Manual.

2.3.38 /REENTRANCY --- Specify Threaded or Asynchronous Reentrancy

The /REENTRANCY qualifier specifies whether code generated for the main program and any Fortran procedures it calls will be relying on threaded or asynchronous reentrancy. The default is /REENTRANCY=NONE.

The qualifier has the following form:

/REENTRANCY= ASYNC NONE THREADED

ASYNC

Informs the Compaq Fortran run-time library that the program may contain asynchronous handlers that could call the RTL. The run-time library will guard against asynchronous interrupts inside its own critical regions.

NONE

Informs the Compaq Fortran run-time library that the program will not be relying on threaded or asynchronous reentrancy. The run-time library need not guard against such interrupts inside its own critical regions. Same as /NOREENTRANCY.

THREADED

Informs the Compaq Fortran run-time library that the program is multithreaded, such as programs using the DECthreads library. The run-time library will use thread locking to guard its own critical regions.

To use the kernel threads libraries, also specify the /THREADS_ENABLE qualifier on the LINK command (see the Guide to POSIX Threads Library).

Specifying NOREENTRANCY is equivalent to /REENTRANCY=NONE.

For More Information:

On writing multithreaded applications, see the Guide to POSIX Threads Library.

2.3.39 /ROUNDING_MODE --- Specify IEEE Floating-Point Rounding Mode

The /ROUNDING_MODE qualifier allows you to control how rounding occurs during calculations. This qualifier applies only to IEEE data types (when you specify /FLOAT=IEEE_FLOAT). Note that if you specify /FLOAT=G_FLOAT or /FLOAT=D_FLOAT, /IEEE_MODE must not also be specified.

The qualifier has the following form:

/ROUNDING_MODE= NEAREST CHOPPED MINUS_INFINITY DYNAMIC

NEAREST

This is the normal rounding mode, where results are rounded to the nearest representable value. If you omit the /ROUNDING_MODE qualifier, /ROUNDING_MODE=NEAREST is used.

CHOPPED

Results are rounded toward zero (representative value).

MINUS_INFINITY

Results are rounded toward the next smallest representative value.

The rounding mode applies to each program unit being compiled.

For More Information:

• On IEEE floating-point rounding modes (IEEE Standard for Binary Floating-Point Arithmetic (ANSI/IEEE Std 754-1985) and OpenVMS System Services Reference Manual.
• On the floating-point control register and Alpha architecture, see Alpha Architecture Reference Manual.

Controls whether the Compaq Fortran compiler:

• Places individual compilation units in a Compaq Fortran source file as separate object modules in the object file (/SEPARATE_COMPILATION)
• Groups individual compilation units in a Compaq Fortran source file as a single object module in the object file (/NOSEPARATE_COMPILATION), which allows more interprocedure optimization

The default is /NOSEPARATE_COMPILATION.

When creating object modules for use in an object library, consider using /SEPARATE_COMPILATION to minimize the size of the routines included by the linker as it creates the executable image. In most cases, to allow more interprocedure optimizations, use the default /NOSEPARATE_COMPILATION.

For More Information:

• On compiling multiple files, see Section 2.2.2.
• On the optimizations that can be performed (such as inlining), see Section 2.3.34.

The /SEVERITY qualifier changes one or both of the following:

• Changes compiler diagnostic warning messages to have a severity of error (instead of warning). The severity of informational compiler diagnostic messages remains informational severity.
  To control the conditions checked during compilation that prevent or request messages, use the /WARNINGS qualifier keywords (see Section 2.3.50.
• When used with the /STANDARD qualifier, /SEVERITY changes standards checking warning messages to have a severity of error (instead of warning). The severity of informational standards checking diagnostic messages remains informational severity.
  To control the type of standards checking performed, specify the /STANDARDS qualifier with either the F90 keyword (default) or the F95 keyword (see Section 2.3.44.

The qualifier has the following form:

/SEVERITY=WARNINGS= WARNING ERROR STDERROR

The default is that compiler diagnostic warning messages and standards checking messages have a severity of warning or /SEVERITY=(WARNINGS=WARNING).

You can specify one of the following:

• ERROR
  Specifies that all warning messages are to be issued with ERROR severity.
• STDERROR
  Specifies that if /STANDARD is in effect and diagnostics indicating non-standard features are issued, the diagnostics are issued with ERROR severity (the default is that these are informational). All other warning messages are issued with WARNING severity.
• WARNINGS
  Specifies that all warning messages are to be issued with WARNING severity.

For example, the following command line requests that compiler diagnostic messages have a severity of warning (default) and standards checking messages have a severity of error (and requests Fortran 95 standards checking)::

$ FORTRAN/SEVERITY=WARNINGS=STDERROR/STANDARD=F95 file.F90

For More Information:

• On using the /WARNINGS qualifier to control the conditions checked during compilation, see Section 2.3.50.
• On using the /STANDARDS qualifier to control the type of standards checking performed, see Section 2.3.44.

The /SHOW qualifier controls whether optionally listed source lines and a symbol map appear in the source listing. (Optionally listed source lines are text-module source lines.)

For the /SHOW qualifier to take effect, you must specify the /LIST qualifier.

The qualifier has the following form:

/SHOW = [NO]INCLUDE [NO]MAP [, ...] ALL NONE

ALL

Requests that all optionally listed source lines and a symbol map be included in the listing file. Specifying /SHOW is equivalent to /SHOW=ALL.

[NO]INCLUDE

Controls whether the source lines from any file or text module specified by INCLUDE statements are included in the source listing.

[NO]MAP

Controls whether the symbol map is included in the listing file.

NONE

Requests that no optionally listed source lines or a symbol map be included in the listing file. Specifying /NOSHOW is equivalent to /SHOW=NONE.

The /SHOW qualifier defaults are NOINCLUDE and MAP.

Specifying the qualifier /SHOW without any arguments is equivalent to specifying /SHOW=ALL; specifying /NOSHOW without any arguments is equivalent to specifying /SHOW=NONE.

For More Information:

On the /LIST qualifier, see Section 2.3.27.

2.3.43 /SOURCE_FORM --- Fortran 90/95 Source Form

The /SOURCE_FORM qualifier allows you to specify whether all Compaq Fortran source files on the FORTRAN command line are in fixed or free source form. The qualifier has the following form:

/SOURCE_FORM= FIXED FREE

FIXED

Specifying /SOURCE_FORM=FIXED indicates that the input source files will be in fixed source form, regardless of the file type. Source files with a file type of FOR or F (or any file type other than F90) are assumed to contain fixed source form.

FREE

Specifying /SOURCE_FORM=FREE indicates that the source form will be free form, regardless of the file type. Source files with a file type of F90 are assumed to contain free source form.

For More Information:

On column positions and source forms, see the Compaq Fortran Language Reference Manual.

2.3.44 /STANDARD --- Perform Fortran 90/95 Standards Checking

The /STANDARD qualifier instructs the compiler to generate informational messages for language elements that are not standard in the Fortran 90 or Fortran 95 language and that can be identified at compile-time. The default is /NOSTANDARD. If you specify /STANDARD with no value, the default is Fortran 95.

The qualifier has the following form:

/[NO]STANDARD= F90 F95 NONE

The /STANDARD=F90 qualifier requests that the compiler issue informational messages for:

• Syntax extensions to the Fortran 90 standard. SYNTAX extensions include nonstandard statements and language constructs.
• Fortran 90 standard-conforming statements that become nonstandard due to the way in which they are used. Data type information and statement locations are considered when determining semantic extensions.
• For fixed-format source files, lines that use tab formatting.

The /STANDARD=F95 qualifier (or /STANDARD) requests that the compiler issue informational messages for:

• Syntax extensions to the Fortran 95 standard. SYNTAX extensions include nonstandard statements and language constructs.
• Fortran 95 standard-conforming statements that become nonstandard due to the way in which they are used. Data type information and statement locations are considered when determining semantic extensions.
• For fixed-format source files, lines that use tab formatting.
• Deleted Fortran language features.

Specifying /STANDARD=NONE is equivalent to /NOSTANDARD.

If you specify the /NOWARNINGS qualifier, the /STANDARD qualifier is ignored.

If you omit the /STANDARD qualifier, the default is /NOSTANDARD.

To change the severity of standards checking warning messages to error severity, specify /SEVERITY=WARNINGS=SDTERROR (see Section 2.3.41).

Source statements that do not conform to Fortran 90 or Fortran 95 language standards are detected by the Compaq Fortran compiler under the following circumstances:

• The statements contain ordinary syntax and semantic errors.
• A source program containing nonconforming statements is compiled with the /STANDARD or /CHECK qualifiers.

Given these circumstances, the compiler is able to detect most instances of nonconforming usage. It does not detect all instances because the /STANDARD qualifier does not produce checks for all nonconforming usage at compile time. In general, the unchecked cases of nonconforming usage arise from the following situations:

• The standard violation results from conditions that cannot be checked at compile time.
• The compile-time checking is prone to false alarms.

Most of the unchecked cases occur in the interface between calling and called subprograms. However, other cases are not checked, even within a single subprogram.

The following items are known to be unchecked:

• Use of a data item prior to defining it
• Use of the SAVE statement to ensure that data items or common blocks retain their values when reinvoked
• Association of character data items on the right and left sides of character assignment statements
• Mismatch in order, number, or type in passing actual arguments to subprograms with implicit interfaces
• Association of one or more actual arguments with a data item in a common block when calling a subprogram that assigns a new value to one or more of the arguments

For More Information:

On the Compaq Fortran language, see the Compaq Fortran Language Reference Manual.

2.3.45 /SYNCHRONOUS_EXCEPTIONS --- Report Exceptions More Precisely

The /SYNCHRONOUS_EXCEPTIONS qualifier associates an exception with the instruction that causes it. Specifying /SYNCHRONOUS_EXCEPTIONS slows program execution, so only specify it when debugging a specific problem, such as locating the source of an exception.

If you omit /SYNCHRONOUS_EXCEPTIONS, /NOSYNCHRONOUS_EXCEPTIONS is used where exceptions can be reported imprecisely one or more instructions after the instruction that caused the exception.

Specifying /IEEE_MODE=FAST (default) provides imprecise exception reporting (same as /NOSYNCHRONOUS_EXCEPTIONS). Specifying other /IEEE_MODE keywords (when you also specify /FLOAT=IEEE_FLOAT) provides precise exception reporting (same as /SYNCHRONOUS_EXCEPTIONS).

For More Information:

• On run-time arithmetic exception handling (/IEEE_MODE qualifier), see Section 2.3.23.
• On controlling run-time arithmetic exception messages (/CHECK=FP_EXCEPTIONS qualifier), see Section 2.3.11.
• On the Alpha architecture and instruction pipelining, see the Alpha Architecture Reference Manual.

The /SYNTAX_ONLY qualifier requests that source file be checked only for correct syntax. If you specify the /SYNTAX_ONLY qualifier, no code is generated, no object file is produced, and some error checking done by the optimizer is bypassed (for example, checking for uninitialized variables with /WARNINGS=UNINITIALIZED). This qualifier allows you to do a quick syntax check of your source file, and is especially useful in conjunction with /WARNINGS=ARGUMENT_CHECKING.

For More Information:

• On the related qualifier that prevents object file creation (/NOOBJECT), see Section 2.3.32.
• On the /WARNINGS qualifier, see Section 2.3.50.

The /VERSION qualifier can be used alone on the FORTRAN command line to display the Compaq Fortran version number. If you specify /VERSION, compilation does not occur.

For example:

$ FORTRAN /VERSION Compaq Fortran V7.n-nnn-nnnn $

2.3.48 /TIE --- Enable Code for Shared Translated Images

The /TIE qualifier enables compiled code to be used with translated shared images, either because the code might call into a translated image or might be called from a translated image. Specifying /NOTIE, the default, indicates the compiled code will not be associated with a translated image.

If you specify /TIE, link the object module using the LINK command /NONATIVE_ONLY qualifier, and follow the guidelines provided in Section A.6.

For More Information:

On appropriate LINK command qualifiers, see Section 3.1.1 and Section A.6.

2.3.49 /VMS --- Request Compaq Fortran 77 for OpenVMS VAX Compatibility

The /VMS qualifier (default) specifies that the run-time system behave like Compaq Fortran 77 for OpenVMS VAX Systems (VAX FORTRAN^tm) in certain ways. To prevent this behavior, specify /NOVMS.

The /VMS qualifier specifies the following aspects of the run-time system:

• Allows use of /LIST or /NOLIST in INCLUDE statement specifications (also see /ASSUME=SOURCE_INCLUDE to control included directory).
• Sets the defaults for the following qualifiers:
  • /CHECK=FORMAT
    Specifying /NOVMS changes the default to /CHECK=NOFORMAT (see Section 2.3.11).
  • /CHECK=OUTPUT_CONVERSION
    Specifying /NOVMS changes the default to /CHECK=NOOUTPUT_CONVERSION (see Section 2.3.11).
• Reinforces the defaults of /NORECURSIVE and /IEEE_MODE=FAST.

To override the effects of the /VMS qualifier, specify /NOVMS.

For More Information:

On the OPEN statement, see the Compaq Fortran Language Reference Manual.

2.3.50 /WARNINGS --- Warning Messages and Compiler Checking

The /WARNINGS qualifier instructs the compiler to generate informational (I-level) and warning (W-level) diagnostic messages in response to informational and warning-level errors.

The following /WARNING keywords prevent the display of warning messages:

NOALIGNMENT (default is ALIGNMENT)
NOGENERAL (default is GENERAL)
NOGRANULARITY (default is GRANULARITY)
NOUNCALLED (default is UNCALLED)
NOUNINITIALIZED (default is UNINITIALIZED)
NOUSAGE (default is USAGE)

The following /WARNING keywords can display additional warning messages (request additional checking):

ARGUMENT_CHECKING (default is NOARGUMENT_CHECKING)
DECLARATIONS (default is NODECLARATIONS)
IGNORE_LOC (default is NOIGNORE_LOC)
TRUNCATED_SOURCE (default is NOTRUNCATED_SOURCE)
UNUSED (default is NOUNUSED)

If you omit /WARNINGS, the defaults are:

/WARNINGS=(ALIGNMENTS,NOARGUMENT_CHECKING,NODECLARATIONS, NOERRORS,FILEOPTS, GENERAL,GRANULARITY,NOIGNORE_LOC,NOSTDERRORS,NOTRUNCATED_SOURCE,UNCALLED , UNITIALIZED, NOUNUSED,USAGE)

The qualifier has the following form:

/WARNINGS = [NO]ALIGNMENT [NO]ARGUMENT_CHECKING [NO]DECLARATIONS [NO]GENERAL [NO]GRANULARITY [NO]IGNORE_LOC [NO]TRUNCATED_SOURCE [NO]UNCALLED [NO]UNINITIALIZED [NO]UNUSED [NO]USAGE [, ...] ALL NONE

[NO]ALIGNMENT

Controls whether the compiler issues diagnostic messages when variables or arrays (created in COMMON or EQUIVALENCE statements) are declared in such a way that they cross natural boundaries for their data size. For example, a diagnostic message is issued if /WARNINGS=ALIGNMENT is in effect and the virtual address of a REAL (KIND=8) variable is not a multiple of 8.

The default is ALIGNMENT. To suppress diagnostic messages about unaligned data, specify NOALIGNMENT.

To control the alignment of fields in common blocks, derived types, and record structures, use the /ALIGNMENT qualifier (see Section 2.3.3).

[NO]ARGUMENT_CHECKING

Controls whether the compiler issues diagnostic messages for argument mismatches between caller and callee (when compiled together). The default is /WARNINGS=NOARGUMENT_CHECKING.

[NO]DECLARATIONS

Controls whether the compiler issues diagnostic messages for any untyped data item used in the program. DECLARATIONS acts as an external IMPLICIT NONE declaration. See the description of the IMPLICIT statement in the Compaq Fortran Language Reference Manual for information about the effects of IMPLICIT NONE.

The default is NODECLARATIONS.

[NO]GENERAL

Controls whether the compiler issues I-level and W-level diagnostic messages. An I-level message indicates that a correct Compaq Fortran statement may have unexpected results or contains nonstandard syntax or source form. A W-level message indicates that the compiler has detected acceptable, but nonstandard, syntax or has performed some corrective action; in either case, unexpected results may occur.

To suppress I-level and W-level diagnostic messages, specify the negative form of this qualifier (/WARNINGS=NOGENERAL).

The default is GENERAL.

[NO]GRANULARITY

Controls whether the compiler issues the compiler diagnostic message "Unable to generate code for requested granularity" to indicate when data access might not occur safely from different threads in a shared memory system (such as asynchronous write access from outside the user process). The default is /WARNINGS=GRANULARITY.

For more information on data granularity and controlling the size of data that can be safely accessed from different threads, see Section 2.3.22.

[NO]IGNORE_LOC

Requests that the compiler issue warnings when %LOC is stripped from an argument due to specification of the IGNORE_LOC attribute. The default is /WARNINGS=NOIGNORE_LOC (does not issue a warning for this condition).

[NO]TRUNCATED_SOURCE

Controls whether the compiler issues a warning diagnostic message (EXCCHASRC) when it reads a fixed-form source line with a statement field that exceeds the maximum column width. The maximum column width is column 72 or 132, depending whether /EXTEND_SOURCE qualifier was specified (or its OPTIONS statement qualifier).

This option has no effect on truncation; lines that exceed the maximum column width are always truncated.

The default is /WARNINGS=NOTRUNCATED_SOURCE.

[NO]UNCALLED

Suppresses the compiler warning diagnostic message when a statement function is never called. The default is /WARNINGS=UNCALLED.

[NO]UNINITIALIZED

Controls whether warning messages are issued when a variable is referenced before a value was assigned to it. Specify NOUNINITIALIZED to suppress such warning messages.

The default, UNINITIALIZED, issues warning messages when a variable is referenced before a value was assigned to it.

[NO]UNUSED

Requests warning messages for a variable that is declared but never used. The default is /WARNINGS=NOUNUSED.

[NO]USAGE

Specifying /WARNINGS=NOUSAGE suppresses informational messages about questionable programming practices and the use of intrinsic functions that use only two digits to represent years (such as 2000). The compiler allows such programming practices, although they are often an artifact of programming errors. For example, a continued character or Hollerith literal whose first part ends before the statement field and appears to end with trailing spaces.

The default is USAGE.

ALL

Causes the compiler to print all I-level and W-level diagnostic messages, including warning messages for any unaligned data and untyped data items. Specifying ALL is equivalent to /WARNINGS and has the effect of specifying /WARNINGS=(ALIGNMENT, DECLARATIONS, GENERAL, UNCALLED, UNINITIALIZED ).

NONE

Suppresses all I-level and W-level messages. Specifying /NOWARNINGS is equivalent to /WARNINGS=NONE.

For More Information:

• On compiler diagnostic messages, see Section 2.5.
• On run-time checking for various conditions (/CHECK qualifier), see Section 2.3.11.
• On changing the severity of compiler diagnostic warnings messages to error severity, see Section 2.3.41.

A text library contains library modules of source text. To include a library module from a text library in a program, use an INCLUDE statement.

Library modules within a text library are like ordinary text files, but they differ in the following ways:

• They contain a unique name, called the library module name, that is used to access them.
• Several library modules can be contained within the same library file.

Library modules in text libraries can contain any kind of text; this section only discusses their use when Compaq Fortran language source is used.

You should be aware of the difference between library modules that reside in text libraries and the Compaq Fortran post-compiled module files (.F90$MOD file type) that support use association (see Section 2.2.3).

Use the LIBRARY command (OpenVMS Librarian Utility) to create text libraries and insert, replace, delete, copy, or list library modules in text libraries. Text libraries have a default file type of TLB.

Figure 2-2 shows the creation of a text library and its use in compiling Compaq Fortran programs.

Figure 2-2 Creating and Using a Text Library

For More Information:

• On using the logical name FORT$LIBRARY to define a default library, see Section 2.2.4.
• On specifying the name of the library using the /LIBRARY qualifier on the FORTRAN command line, see Section 2.3.26.
• On specifying the directory location of the library using the /INCLUDE qualifier, see Section 2.3.24.
• On specifying the directory location of the library using the /ASSUME=SOURCE_INCLUDE qualifier, see Section 2.3.7.
• On using Fortran modules, see Section 2.2.3.
• On using INCLUDE or USE statements, see the Compaq Fortran Language Reference Manual.

Table 2-3 summarizes the commands that create libraries and provide maintenance functions. For a complete list of the qualifiers for the LIBRARY command and a description of other DIGITAL Command Language (DCL) commands listed in Table 2-3, see the Guide to Using OpenVMS Command Procedures or type HELP LIBRARY.

Table 2-3 Commands to Control Library Files

Function	Command Syntax1
Create a library.	LIBRARY/TEXT/CREATE library-name file-spec,...
Add one or more library modules to a library.	LIBRARY/TEXT/INSERT library-name file-spec,...
Replace one or more library modules in a library.	LIBRARY/TEXT/REPLACE library-name file-spec,... 2
Specify the names of library modules to be added to a library.	LIBRARY/TEXT/INSERT library-name file-spec/MODULE= module-name
Delete one or more library modules from a library.	LIBRARY/TEXT/DELETE=(module-name,...) library-name
Copy a library module from a library into another file.	LIBRARY/TEXT/EXTRACT=module-name/OUTPUT= file-spec library-name
List the library modules in a library.	LIBRARY/TEXT/LIST=file-spec library-name

When the LIBRARY command adds a library module to a library, by default it uses the file name of the input file as the name of the library module. In the example in Figure 2-2, the LIBRARY command adds the contents of the files APPLIC.SYM and DECLARE.FOR to the library and names the library modules APPLIC and DECLARE.

Alternatively, you can name a module in a library with the /MODULE qualifier. For example:

$ LIBRARY/TEXT/INSERT FORFILES DECLARE.FOR /MODULE=EXTERNAL_DECLARATIONS

The preceding command inserts the contents of the file DECLARE.FOR into the library FORFILES under the name EXTERNAL_DECLARATIONS. This library module can be included in a Compaq Fortran source file during compilation with the following statement:

INCLUDE 'FORFILES(EXTERNAL_DECLARATIONS)'

For More Information:

• On the INCLUDE statement, see the Compaq Fortran Language Reference Manual and Section 2.2.4.1.
• On controlling the directories and libraries searched with FORTRAN command qualifiers and the FORT$INCLUDE logical name, see Section 2.2.4.1.

The following sections discuss the compiler limits and error messages.

2.5.1 Compiler Limits

Table 2-4 lists the limits to the size and complexity of a single Compaq Fortran program unit and to individual statements contained in it.

The amount of data storage, the size of arrays, and the total size of executable programs are limited only by the amount of process virtual address space available, as determined by process quotas and system parameters.

Table 2-4 Compiler Limits

Language Element	Limit
Actual number of arguments per CALL or function reference	No limit
Arguments in a function reference in a specification expression	No limit
Array dimensions	7
Array elements per dimension	9,223,372,036,854,775,807 or process limit
Constants; character and Hollerith	2000 characters
Constants; characters read in list-directed I/O	2048 characters
Continuation lines	511
DO and block IF statement nesting (combined)	128
DO loop index variable	9,223,372,036,854,775,807 or process limit
Format group nesting	8
Fortran source line length	132 characters
INCLUDE file nesting	20 levels
Labels in computed or assigned GOTO list	500
Lexical tokens per statement	3000
Parentheses nesting in expressions	40
Structure nesting	20
Symbolic-name length	63 characters

For More Information:

On relevant process quotas and system parameters, see Section 1.1.

2.5.2 Compiler Diagnostic Messages and Error Conditions

The Compaq Fortran compiler identifies syntax errors and violations of language rules in the source program.

If the compiler locates any errors, it writes messages to your default output device; so, if you enter the FORTRAN command interactively, the messages are displayed on your terminal. If the FORTRAN command is executed in a batch job, the messages appear in the log file for the batch job.

A sample message from the compiler as it would appear on a terminal screen follows:

40 FORMAT (I3,) ................^ %F90-W-ERROR, An extra comma appears in the format list. at line number 13 in file DISK$:[USER]SAMP_MESS.FOR;4

This sample message consists of the following lines:

• The source file line that caused the message
• A pointer (...^ on a terminal or ...1 in a listing file) to the part of the source line causing the error
• The actual message (facility, severity, mnemonic, and text)
• The line number and name of source file

The message line has the following format:

%F90-s-ident, message-text

The facility, F90, follows the percent sign (%). The severity of the message (I for informational, W for warning, E for error, or F for fatal) replaces s. A mnemonic for that message replaces ident. The explanatory text of the message replaces message-text.

Diagnostic messages usually provide enough information for you to determine the cause of an error and correct it. If you compile using the /OPTIMIZE qualifier (the default) and have difficulty determining the cause of an error (possibly because of the optimizations), consider compiling using a lower optimization level or /NOOPTIMIZE.

If the compiler creates a listing file, it also writes the messages to the listing. The pointer (...1) and messages follow the statement that caused the error.

2.6 Compiler Output Listing Format

A compiler output listing produced by a FORTRAN command with the /LIST qualifier consists of the following sections:

• A source code section
• A machine code section---optional
• A storage map section (cross-reference)---optional
• A compilation summary

Section 2.6.1 through Section 2.6.5 describe the compiler listing sections in detail.

For More Information:

• On the /LIST qualifier, see Section 2.3.27)
• On the /MACHINE_CODE qualifier, see Section 2.3.28.
• On the /SHOW qualifier, see Section 2.3.42.

The source code section of a compiler output listing displays the source program as it appears in the input file, with the addition of sequential line numbers generated by the compiler. Example 2-1 shows a sample of a source code section of a free-form compiler output listing.

Example 2-1 Sample Listing of Source Code

RELAX2 Source Listing 19-DEC-2000 16:12:46 Compaq Fortran V7.x-xxxx Page 1 12-DEC-2000 10:41:04 F90$DISK:[TUCKER]LIST_EX.F90;3 1 SUBROUTINE RELAX2(EPS) 2 INTEGER, PARAMETER :: M=40 3 INTEGER, PARAMETER :: N=60 4 5 COMMON X (M,N) 6 7 LOGICAL DONE 8 10 DONE = .TRUE. 9 10 DO J=1,N-1 11 DO I=1,M-1 12 XNEW = (X(I-1,J)+X(I+1,J)+X(I,J-1)+X(I,J+1))/4 13 IF (ABS(XNEW-X(I,J)) > EPS) DONE = .FALSE. 14 X(I,J) = XNEW 15 END DO 16 END DO 17 18 IF (.NOT. DONE) GO TO 10 19 RETURN 20 END SUBROUTINE

Compiler-generated line numbers appear in the left margin and are used with the %LINE prefix in debugger commands. These compiler-generated line numbers are displayed by compiler-generated messages and certain run-time error messages. (For more information on messages, see Appendix B.)

2.6.2 Machine Code Section

The machine code section of a compiler output listing provides a symbolic representation of the compiler-generated object code. The representation of the generated code and data is similar to that of a MACRO assembly listing.

The machine code section is optional. To receive a listing file with a machine code section, you must specify the following:

$ FORTRAN/LIST/MACHINE_CODE

Example 2-2 shows a sample of part of a machine code section of a compiler output listing.

Example 2-2 Sample Listing of Machine Code (Partial Listing)

RELAX2 Machine Code Listing 19-DEC-2000 16:12:46 Compaq Fortran V7.x-xxxx Page 3 12-DEC-2000 10:41:04 F90$DISK:[TUCKER]LIST_EX.F90;3 .PSECT $CODE$, OCTA, PIC, CON, REL, LCL, SHR,- EXE, NORD, NOWRT 0000 RELAX2:: 23DEFFC0 0000 LDA SP, -64(SP) 80100000 0004 LDF F0, (R16) ; 000013 A41B0020 0008 LDQ R0, 32(R27) ; 000012 B77E0000 000C STQ R27, (SP) ; 000001 B75E0008 0010 STQ R26, 8(SP) B7BE0010 0014 STQ FP, 16(SP) 9C5E0018 0018 STT F2, 24(SP) 9C7E0020 001C STT F3, 32(SP) 9C9E0028 0020 STT F4, 40(SP) 9CBE0030 0024 STT F5, 48(SP) 9CDE0038 0028 STT F6, 56(SP) 47FE041D 002C MOV SP, FP 803B0028 0030 LDF F1, 40(R27) ; 000012 2FFE0000 0034 UNOP 2FFE0000 0038 UNOP 2FFE0000 003C UNOP 0040 .10: ; 000008 2FFE0000 0040 UNOP 2FFE0000 0044 UNOP 2FFE0000 0048 UNOP 2FFE0000 004C UNOP 203FFFFF 0050 MOV -1, DONE ; -1, R1 47E77411 0054 MOV 59, var$0002 ; 59, R17 ; 000010 47F41412 0058 MOV 160, R18 ; 000014 2FFE0000 005C UNOP 0060 lab$0004: ; 000010 2FFE0000 0060 UNOP 2FFE0000 0064 UNOP 2FFE0000 0068 UNOP 2FFE0000 006C UNOP 40120413 0070 ADDQ R0, R18, R19 47E4F414 0074 MOV 39, var$0003 ; 39, R20 ; 000011 2273FF5C 0078 LDA R19, -164(R19) ; 000012 2FFE0000 007C UNOP 0080 lab$0008: ; 000011 2FFE0000 0080 UNOP 2FFE0000 0084 UNOP 2FFE0000 0088 UNOP 2FFE0000 008C UNOP 81530008 0090 LDF F10, 8(R19) 8193FF64 0094 LDF F12, -156(R19) 47FF0418 0098 CLR R24 ; 000013 81730000 009C LDF F11, (R19) ; 000012 81B300A4 00A0 LDF F13, 164(R19) 81D3000C 00A4 LDF F14, 12(R19) 8213FF68 00A8 LDF F16, -152(R19) 823300A8 00AC LDF F17, 168(R19) 82730010 00B0 LDF F19, 16(R19) 82B3FF6C 00B4 LDF F21, -148(R19) 82D300AC 00B8 LDF F22, 172(R19) 82F30014 00BC LDF F23, 20(R19) 8333FF70 00C0 LDF F25, -144(R19) 835300B0 00C4 LDF F26, 176(R19) 83730018 00C8 LDF F27, 24(R19) . . . Routine Size: 1020 bytes, Routine Base: $CODE$ + 0000 .PSECT $LINK$, OCTA, NOPIC, CON, REL, LCL,- NOSHR, NOEXE, RD, NOWRT 0000 ; Stack-Frame invocation descriptor Entry point: RELAX2 Entry Length: 48 Registers used: R0-R1, R16-R25, R27-FP, F0-F6, F10-F30 Registers saved: FP, F2-F6 Fixed Stack Size: 64 00000000 0020 .ADDRESS $BLANK 00003F80 0028 .LONG X^3F80 ; .F_FLOATING 0.2500000

The following list provides a detailed explanation of how generated code and data are represented in machine code listings.

• Machine instructions are represented by MACRO mnemonics and syntax. To enable you to identify the machine code that is generated from a particular line of source code, the compiler-generated line numbers that appear in the source code listing are also used in the machine code listing. These numbers appear in the right margin, preceding the machine code generated from individual lines of source code.
• The first line contains a .TITLE assembler directive, indicating the program unit from which the machine code was generated.
  • For a main program, the title is as declared in a PROGRAM statement. If you did not specify a PROGRAM statement, the main program is titled filename$MAIN, where filename is the name of the source file.
  • For a subprogram, the title is the name of the subroutine or function.
  • For a BLOCK DATA subprogram, the title is either the name declared in the BLOCK DATA statement or filename$DATA (by default).
• The lines following .TITLE provide information such as the contents of storage initialized for FORMAT statements, DATA statements, constants, and subprogram argument call lists.
• General registers (0 through 31) are represented by R0 through R31 and floating-point registers are represented by F0 through F31. The relative PC for each instruction or data item is listed at the left margin, in hexadecimal.
• Variables and arrays defined in the source program are shown as they were defined in the program. Offsets from variables and arrays are shown in decimal. (Optimization frequently places variables in registers, so some names may be missing.)
• Compaq Fortran source labels referenced in the source program are shown with a period prefix (.). For example, if the source program refers to label 300, the label appears in the machine code listing as .300. Labels that appear in the source program, but are not referenced or are deleted during compiler optimization, are ignored. They do not appear in the machine code listing unless you specified /NOOPTIMIZE.
• The compiler may generate labels for its own use. These labels appear as L$n or lab$000n, where the value of n is unique for each such label in a program unit.
• Integer constants are shown as signed integer values; real and complex constants are shown as unsigned hexadecimal values preceded by ^X.
• Addresses are represented by the program section name plus the hexadecimal offset within that program section. Changes from one program section to another are indicated by PSECT lines.

The annotations section of the compiler output listing describes special instructions used for optimizations such as prefetching, inlining, and loop unrolling. It is controlled by the /ANNOTATIONS qualifier. Refer to Section 2.3.5 for complete information.

Example 2-3 shows the list of annotations that is produced from the following source code:

1 2 3 4 5 6 7 287 work1=sqrt((xlatt*real(mindex,LONGreal)) **2+(ylatt*real(nindex,LONGreal))**2+(q-p)**2) 8 9 10 11 12 288 work2=q-p

Example 2-3 Sample Listing of Annotations (Partial Listing)

1. Software pipelining across 4 iterations; unrolling loop 2 times; steady state estimated 180 cycles; 0 prefetch iterations 2. Unrolling loop 6 times 3. Prefetching MINDEX, 128 bytes ahead 4. Prefetching NINDEX, 128 bytes ahead 5. Prefetching Q, 128 bytes ahead 6. Write-hinting WORK1, distance 128 7. Prefetching P, 128 bytes ahead 8. Software pipelining across 2 iterations; unrolling loop 2 times; steady state estimated 17 cycles; 0 prefetch iterations 9. Prefetching P, 192 bytes ahead 10. Write-hinting WORK2, distance 128 11. Unrolling loop 7 times 12. Prefetching Q, 192 bytes ahead

2.6.4 Storage Map Section

The storage map section of the compiler output listing is printed after each program unit, or library module. It is not generated when a fatal compilation error is encountered.

The storage map section summarizes information in the following categories:

• Program sections: The program section summary describes each program section (PSECT) generated by the compiler. The descriptions include:
  • PSECT number (used by most of the other summaries)
  • Name
  • Size in bytes
  • Attributes
  
  PSECT usage and attributes are described in Section 13.1.
• Total memory allocated: Following the program sections, the compiler prints the total memory allocated for all program sections compiled in the following form:

  Total Space Allocated nnn

• Entry points: The entry point summary lists all entry points and their addresses. If the program unit is a function, the declared data type of the entry point is also included.
• Variables: The variable summary lists all simple variables, with the data type and address of each. If the variable is removed as a result of optimization, a double asterisk (**) appears in place of the address.
• Records: The record summary lists all record variables and derived types. It shows the address, the structure that defines the fields of the individual records or types, and the total size of each record or type.
• Arrays: The array summary is similar to the variable summary. In addition to data type and address, the array summary gives the total size and dimensions of the array. If the array is an adjustable array or assumed-size array, its size is shown as a double asterisk (**), and each adjustable dimension bound is shown as a single asterisk (*).
• Record Arrays: The record array summary is similar to the record summary. The record array summary gives the dimensions of the record or derived-type array in addition to address, defining structure, and total size. If the record or derived-type array is an adjustable array or assumed-size array, its size is shown as a double asterisk (**), and each adjustable dimension bound is shown as a single asterisk (*).
• Labels: The label summary lists all user-defined statement labels. FORMAT statement labels are suffixed with an apostrophe ('). If the label address field contains a double asterisk (**), the label was not used or referred to by the compiled code.
• Functions and subroutines: The functions and subroutines summary lists all external routine references made by the source program. This summary does not include references to routines that are dummy arguments, because the actual function or subroutine name is supplied by the calling program.

A heading for an information category is printed in the listing only when entries are generated for that category.

Example 2-4 shows an example of a storage map section.

Example 2-4 Sample Storage Map Section

RELAX2 Source Listing 19-DEC-2000 16:12:46 Compaq Fortran V7.x-xxxx Page 1 12-DEC-2000 10:41:04 F90$DISK:[TUCKER]LIST_EX.F90;3 PROGRAM SECTIONS Name Bytes Attributes 1 $CODE$ 1020 PIC CON REL LCL SHR EXE NORD NOWRT OCTA 2 $LINK$ 44 NOPIC CON REL LCL NOSHR NOEXE RD NOWRT OCTA 3 $BLANK 9600 NOPIC OVR REL GBL NOSHR NOEXE RD WRT OCTA Total Space Allocated 10664 ENTRY POINTS Address Name 1-00000000 RELAX2 VARIABLES Address Type Name Address Type Name Address Type Name Address Type Name Address Type Name ** L*4 DONE ** R*4 EPS ** I*4 I ** I*4 J ** R*4 XNEW ARRAYS Address Type Name Bytes Dimensions 3-00000000 R*4 X 9600 (40, 60) LABELS Address Label 1-00000040 10

As shown in Example 2-4, a section size is specified as a number of bytes, expressed in decimal. A data address is specified as an offset from the start of a program section, expressed in hexadecimal.

2.6.5 Compilation Summary Section

The final entries on the compiler output listing are the compiler qualifiers and compiler statistics.

The body of the compilation summary contains information about OPTIONS statement qualifiers (if any), FORTRAN command line qualifiers, and compilation statistics.

"Compiler Statistics" shows the machine resources used by the compiler.

Example 2-5 shows a sample compilation summary.

Example 2-5 Sample Compilation Summary

COMMAND QUALIFIERS /ALIGNMENT=(COMMONS=(NONATURAL,PACKED,NOSTANDARD,NOMULTILANGUAGE),RECORDS=NATURAL,NOSEQUENCE) /ANNOTATIONS=(CODE,DETAIL,FEEDBACK,INLINING,LOOP_TRANSFORMS,LOOP_UNROLLING, PREFETCHING,SHRINKWRAPPING,SOFTWARE_PIPELINING,TAIL_CALLS) /ARCHITECTURE=GENERIC /ASSUME=(ACCURACY_SENSITIVE,ALTPARAM,NOBUFFERED_IO,NOBYTERECL, NODUMMY_ALIASES, NOFP_CONSTANT, NOINT_CONSTANT, NOMINUS0, PROTECT_CONSTANTS,NOUNDERSCORE,NO2UNDERSCORES,NOSOURCE_INCLUDE) /NOAUTOMATIC /NOBY_REF_CALL /CCDEFAULT=DEFAULT /CHECK=(NOARG_TEMP_CREATED,NOBOUNDS,FORMAT,NOFP_EXCEPTIONS, OUTPUT_CONVERSION, NOOVERFLOW, POWER, NOUNDERFLOW) /CONVERT=NATIVE /DEBUG=(NOSYMBOLS,TRACEBACK) /NODEFINE /DOUBLE_SIZE=64 /NOD_LINES /ERROR_LIMIT=30 /NOEXTEND_SOURCE /F77 /NOFAST /FLOAT=G_FLOAT /GRANULARITY=QUADWORD /IEEE_MODE=FAST /INTEGER_SIZE=32 /MACHINE_CODE /MATH_LIBRARY=ACCURATE /NOMODULE /NAMES=UPPERCASE /OPTIMIZE=(INLINE=SPEED,LEVEL=4,NOLOOPS,PIPELINE,TUNE=GENERIC,UNROLL=0) /NOPAD_SOURCE /REAL_SIZE=32 /NORECURSIVE /REENTRANCY=NONE /ROUNDING_MODE=NEAREST /NOSEPARATE_COMPILATION /SEVERITY=(WARNING=WARNING) /SHOW=(NOINCLUDE,MAP) /SOURCE_FORM=FREE /STANDARD=NONE /NOSYNCHRONOUS_EXCEPTIONS /NOSYNTAX_ONLY /NOTIE /VMS /WARNINGS=(ALIGNMENT,NOARGUMENT_CHECKING,NODECLARATIONS,GENERAL, GRANULARITY,NOIGNORE_LOC,NOHPF,NOTRUNCATED_SOURCE,UNCALLED,UNINITIALIZED,NOUNUSED,USAGE) /NOANALYSIS_DATA /NODIAGNOSTICS /INCLUDE=FORT$INCLUDE: /LIST=F90$DISK:[ETZEL]LIST_EX.LIS;9 /OBJECT=F90$DISK:[ETZEL]LIST_EX.OBJ;6 /NOLIBRARY COMPILER: Compaq Fortran V7.x-xxxx COMPILATION STATISTICS CPU time: n.nn seconds Elapsed time: n.nn seconds Pagefaults: nnn I/O Count: nn