# Compaq Fortran
User Manual for
Tru64 UNIX and
Linux Alpha Systems

Previous | Contents | Index

# Chapter 3
f90 and fort Command-Line Options

This chapter describes `f90` and `fort` command-line options in detail.

Note To invoke the Compaq Fortran compiler, use: `f90` on Tru64 UNIX Alpha systems `fort` command on Linux Alpha systems This chapter uses `f90` to indicate invoking Compaq Fortran on both systems, so replace this command with `fort` if you are working on a Linux Alpha system. To invoke the Compaq C compiler, use: `cc` on Tru64 UNIX Alpha systems `ccc` on Linux Alpha systems This chapter uses `cc` to indicate invoking Compaq C on both systems, so replace this command with `ccc` if you are working on a Linux Alpha system.

# 3.1 Overview of Command-Line Options

Options to the `f90` command affect how the compiler processes a file in conjunction with the file name suffix information described in Section 2.1.1. The simplest form of the `f90` command is often sufficient.

You can override some options specified on the command line by using the OPTIONS statement in your Fortran source program. The options specified by the OPTIONS statement affect only the program unit where the statement occurs.

If you compile parts of your program by using multiple `f90` commands, options that affect the execution of the program should be used consistently for all compilations, especially if data is shared or passed between procedures. For example:

- The same data alignment needs to be used for data passed or shared by module definition (such as user-defined structures) or common block. Use the same version of the `-align` option for all compilations (see Section 3.3).
- The program might contain INTEGER, LOGICAL, REAL, COMPLEX, or DOUBLE PRECISION declarations without a kind parameter or size specifier that is passed or shared by module definition or common block. You must consistently use the options that control the size of such numeric data declarations. For information about these options, see:
  - Section 3.53 for INTEGER and LOGICAL declarations
  - Section 3.78 for REAL and COMPLEX declarations
  - Section 3.34 for DOUBLE PRECISION declarations
- On Tru64 UNIX systems, you can specify the `-hpf num` option (to request code generation for parallel HPF execution) for multiple compilation units.

Some options consist of two words separated by a space, while others may have words joined by an underscore ( `_` ). Most options can be abbreviated. For example, you can abbreviate `-check output_conversion` to `-check out` (usually four characters or more).

# 3.2 f90 and fort Command Categories and Options

Table 3-1 lists categories of command-line options, the `f90` and `fort` command-line options, and the sections in which they are described in detail.

Table 3-1 f90 and fort Command Categories and Options
Category | Option Name and Section in this Manual
--- | ---
Assembler File | `-s` (see Section 3.81)
Data Size | `-i2` , `-i4` , `-i8` , `-integer_size num` (see Section 3.53) `-r8` , `-r16` , `-real_size num` , (see Section 3.78) `-double_size num` , (see Section 3.34) For a summary of available data types, see Chapter 9.
Compaq FUSE Cross-Reference File | `-fuse_xref` , (see Section 3.47) (TU*X ONLY)
Debugging and Symbol Table | `-d_lines` (see Section 3.33) `-g0` , `-g1` , `-g2` , `-g` , `-g3` , and `-ladebug` (see Section 3.48) Also see Chapter 4.
Data Accuracy and Floating-Point Exceptions | `-assume noaccuracy_sensitive` (see Section 3.12) `-check nopower` (see Section 3.25) `-double_size num` (see Section 3.34) `-fast` (see Section 3.40) `-fpe n` (see Section 3.44) `-fpconstant` (see Section 3.43) `-fp_reorder` (see Section 3.12) `-fprm keyword` (see Section 3.46) `-intconstant` (see Section 3.55) `-math_library keyword` (see Section 3.61) `-r8` , `-r16` , `-real_size num` (see Section 3.78) `-speculate keyword` (TU*X ONLY) (see Section 3.84) `-synchronous_exceptions` (see Section 3.86)
Language and Run-Time Compatibility | `-1` , `-66` , `-f66` , `-onetrip` (see Section 3.37) `-altparam` (see Section 3.66) `-assume dummy_aliases` (see Section 3.9) `-assume noprotect_constants` (see Section 3.13) `-f77rtl` (see Section 3.39) `-mixed_str_len_arg` (see Section 3.62) `-std, std95` (see Section 3.85) `-vms` (see Section 3.98)
Linking, Loading, and Output File Naming | `-assume nounderscore` (see Section 3.15) `-assume no2underscores` (see Section 3.16) `-c` (see Section 3.19) `-call_shared` , `-non_shared` , `-shared` (see Section 3.20) `-l` (see Section 3.57) `-l dir` (see Section 3.58) `-l string` (see Section 3.59) `-names keyword` (see Section 3.65) `-o output` (see Section 3.71) `-u` (see Section 3.91) `-v` (see Section 3.96) `-Wl, -xxx` (see Section 3.99) Also see Section 2.5.
Listing File | `-show code` , `-show include` , `-machine_code` (see Section 3.82) `-source_listing` (see Section 3.83) `-v` (see Section 3.95) `-vms` (applies to INCLUDE statements with /LIST or /NOLIST) (see Section 3.98) Also see Appendix C.
Module and Include File Directory Searching | `-i dir` , `-noinclude` (see Section 3.52) `-module directory` (see Section 3.63), Also see Section 2.1.3 (module files) and Section 2.1.4 (include files).
Miscellaneous | `-nohpf_main` (TU*X ONLY) (see Section 3.68) `-norun` (see Section 3.70) `-version` (see Section 3.97) `-what` (see Section 3.97)
Nonnative Unformatted Data File Conversion and Use | `-assume byterecl` (see Section 3.7) `-convert keyword` (see Section 3.30) Also see Chapter 10.
Parallel HPF Execution Performance (TU*X ONLY) | `-hpf` , `-hpf n` , `-assume nozsize` , `-nearest_neighbor num` , `-nonearest_neighbor` , `-show hpf` (see Section 3.50)
Parallel Directives Execution (TU*X ONLY) | `-mp` (see Section 3.64) `-omp` (see Section 3.74) `-assume cc_omp` (see Section 3.8)
Performance Optimization (Nonparallel and Parallel) | `-align keyword` (see Section 3.3) `-annotations keyword` (see Section 3.4) `-arch keyword` (see Section 3.5) `-assume noaccuracy_sensitive` (see Section 3.12) `-assume dummy_aliases` (see Section 3.9) `-fast` (see Section 3.40) `-fpe n` (see Section 3.44) `-fp_reorder` ( `-assume noaccuracy_sensitive` ) (see Section 3.12) `-fprm keyword` (see Section 3.46) `-inline type` , `-noinline` (see Section 3.54) `-math_library keyword` (see Section 3.61) `-om` (see Section 3.73) `-o0` , `-o1` , `-o2` , `-o3` , `-o4` , `-o` , `-o5` (see Section 3.72) `-pipeline` (see Section 3.76) `-speculate keyword` (TU*X ONLY) (see Section 3.84) `-synchronous_exceptions` (see Section 3.86) `-transform_loops` (see Section 3.89) `-tune keyword` (see Section 3.90) `-unroll num` (see Section 3.94) Also see Section 5.1.2.
Preprocessor | `-cpp` , `-d name` , `-fpp` (see Section 3.45), `-i` , `-i dir` , `-k` , `-m` , `-p` , `-u name` (see Section 3.31), `-wp, -xxx` (see Section 3.31.3)
Profiling, Feedback Files, and `cord` | `-p0` , `-p1` or `-p` , `-pg` (see Section 3.77) `-gen_feedback` , `-feedback file` , `-cord` (TU*X ONLY) (see Section 3.41)
Record Output | `-assume buffered_io` (see Section 3.6) `-ccdefault keyword` (see Section 3.21)
Recursion and Data Storage | `-automatic` , `-static` (see Section 3.18) `-recursive` (see Section 3.79)
Run-Time Messages and Checking | `-check arg_temp_created` , (see Section 3.22) `-c` , `-check bounds` (see Section 3.23) `-check noformat` (see Section 3.24) `-check nooutput_conversion` (see Section 3.27) `-check overflow` (see Section 3.28) `-check nopower` (see Section 3.25) `-check underflow` (TU*X ONLY) (see Section 3.29) `-fpe n` (see Section 3.44) `-synchronous_exceptions` (see Section 3.86) Also see the options related to "Floating-point exceptions, rounding, and accuracy" in this table.
Shared Access to Data | `-granularity keyword` , (see Section 3.49)
Source Form and Column Use | `-d_lines` (see Section 3.33) `-extend_source` (see Section 3.36) `-fixed` , `-free` (see Section 3.42) `-pad_source` (see Section 3.75)
Threaded Applications | `-granularity keyword` , (see Section 3.49) `-pthread` (TU*X ONLY) (see Section 3.88) `-reentrancy keyword` (see Section 3.80) `-threads` (TU*X ONLY) (see Section 3.88)
VMS Run Time | `-vms` (see Section 3.98)
Warning Messages at Compile Time | `-error_limit num` , `-noerror_limit` (see Section 3.35) `-v` (see Section 3.96) `-warn keyword` `-w1` (see Section 3.100) `-warning_severity` (see Section 3.101)

# 3.3 -align keyword --- Data Alignment

Use the `-align keyword` options to control the alignment of fields associated with common blocks, derived-type structures, and record structures.

If you omit the `-align keyword` , `-fast` , and `-vms` options:

- 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 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.

Note For optimal performance on Alpha systems, make sure your data is aligned naturally (see Section 5.4).

The compiler issues messages when it detects unaligned data (unless you specify `-warn noalignments` ). For information about the causes of unaligned data and detection at run time, see Section 5.4, Data Alignment Considerations.

If necessary, you can specify either `-align records` or `-align norecords` on the same command line as one of the following: `-align nocommons` , `-align commons` , or `-align dcommons` . For example:

    % f90 -align dcommons -align norecords main.f90

If you specify `-fast` and omit the `-align keyword` options, the compiler uses:
`-align dcommons` `-align records` `-align sequence`

If you specify `-vms` and omit the `-fast` and `-align keyword` options, the compiler uses:
`-align commons` `-align norecords` `-align nosequence`

If no `-align` option is specified, the default is `-align records` , which is the same as specifying `-align rec8byte` .

The following options apply:

> ### -align all

> Tells the compiler to add padding bytes wherever possible to obtain the natural alignment of data items in common blocks and structures.

> `-align all` essentially turns on these options: `-align nocommons` , `-align dcommons` , `-align records` , `-align sequence` , `-align norec1byte` , `-align norec2byte` , `-align norec4byte` , and `-align norec8byte` .

> ### -align commons

> Aligns the data items of all common blocks on natural boundaries up to 4 bytes. The default is `-align nocommons` .

> ### -align dcommons

> Aligns the data items of all common blocks on natural boundaries up to 8 bytes instead of the default byte boundary.

> The default is `-align nodcommons` .

> If your command line includes the `-std` , `-std90` , or `-std95` options, then the compiler ignores `-align dcommons` . See Section 3.85.

> ### -align none

> Tells the compiler not to add padding bytes anywhere in common blocks or structures.

> `-align none` essentially turns on these options: `-align nocommons` , `-align nodcommons` , `-align norecords` , `-align nosequence` , `-align norec1byte` , `-align norec2byte` , `-align norec4byte` , and `-align norec8byte` .

> ### -align recNbyte

> Aligns fields of records and components of derived types on the smaller of the size boundary specified (N can be 1, 2, 4, or 8) or the boundary that will naturally align them.

> Specifying `-align recnbyte` does not affect whether common blocks are naturally aligned or packed.

> ### -align norecords

> Aligns fields witin record structures and components of derived types on the next available byte boundary instead of the default natural boundaries.

> The default is `-align records` , which requests alignment of the fields of all derived-type data and RECORD data blocks on natural boundaries up to 8 bytes.

> ### -align sequence

> Tells the compiler that components of derived types with the SEQUENCE attribute will obey whatever alignment rules are currently in use. The default alignment rules align unsequenced components on natural boundaries.

> The default value of `-align 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 `-align sequence` so that components of derived types with the SEQUENCE attribute will be naturally aligned for improved performance. Specifying `-align all` also sets `-align sequence` . If your command line includes the `-std` , `-std90` , or `-std95` options, then the compiler ignores `-align sequence` . See Section 3.85.

For More Information:

- On general performance guidelines, see Section 5.7, Additional Source Code Guidelines for Run-Time Efficiency.
- On alignment, see Section 5.4, Data Alignment Considerations.
- On intrinsic data types, see Chapter 9, Data Types and Representation.

# 3.4 -annotations keyword --- Place Optimization Information in Source Listing

The `-annotations keyword` option specifies that annotations will be added to the source listing file. These annotations indicate which of a set of optimizations the compiler applied to particular parts of the source file. Note that some of the values of `keyword` below may exist for optimizations that are not supported on your platform. If so, the source listing file contains no corresponding annotations.

You can view the resulting annotations in the source listing file to see what optimizations the compiler performed or why the compiler was not able to optimize a particular code sequence.

The default is `-noannotations` , which places no annotations in the source listing file.

The `-annotations` option requires a keyword.

The following options apply:

> ### -annotations none

> Same as `-noannotations` , which is the default value.

> ### -annotations all

> Selects all of the annotations.

> ### -annotations code

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

> ### -annotations detail

> Provides, where available, an additional level of annotation detail.

> ### -annotations feedback

> Annotates the source listing if profile-directed feedback optimizations were used.

> ### -annotations inlining

> Indicates where code for a called procedure was expanded inline.

> ### -annotations loop_transforms

> Indicates where advanced loop nest optimizations have been applied to improve cache performance (unroll and jam, loop fusion, loop interchange, and so on).

> ### -annotations loop_unrolling

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

> ### -annotations prefetching

> Indicates where special instructions were used to reduce memory latency.

> ### -annotations shrinkwrapping

> Annotates the source listing if code establishing routine context was removed.

> ### -annotations software_pipelining

> Indicates where instructions have been rearranged to make optimal use of the processor's functional units. See Section 5.8.6, Software Pipelining.

> ### -annotations tail_calls

> Indicates an optimization where a call from one routine to another can be replaced with a jump.

> ### -annotations tail_recursion

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

# 3.5 -arch keyword --- Specify Type of Code Instructions Generated

Use the `-arch keyword` option to specify the type of Alpha architecture code instructions to be generated for the program unit being compiled.

Compaq Tru64 UNIX provides 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 run time.

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

> BWX - Byte/Word manipulation instructions
> MAX - Multimedia instructions
> FIX - Square root and floating-point conversion
> CIX - Count

If you omit the `-arch keyword` , `-arch generic` is used.

The following options apply:

> ### -arch generic

> Generates instructions that are appropriate for most Alpha processors. This is the default.

> Programs compiled with the `generic` keyword run on all implementations of the Alpha architecture without any instruction emulation overhead.

> ### -arch host

> Generates instructions for the machine the compiler is running on (for example, ev56 instructions on an ev56 processor and ev4 instructions on an ev4 processor).

> Programs compiled with the `host` keyword run on other implementations of the Alpha architecture might encounter instruction emulation overhead.

> ### -arch ev4

> Generates instructions for ev4 processors (for 21064, 20164A, 21066, and 21068 chips).

> Applications compiled with this option will not incur any emulation overhead on any Alpha processor.

> ### -arch ev5

> Generates instructions for ev5 processors (some 21164 chips that use only the base set of Alpha instructions, with no extensions).

> Applications compiled with this option will not incur any emulation overhead on any Alpha processor.

> ### -arch ev56

> Generates instructions for ev56 processors (the 21164 chips that use the BWX extension).

> This option permits the compiler to generate any ev4 instruction plus any instruction contained in the BWX extension.

> Applications compiled with this option might incur emulation overhead on ev4 and ev5 processors, but will still run correctly.

> ### -arch pca56

> Generates instructions for pca56 processors (21164PC chips).

> This option permits the compiler to generate any ev4 instruction plus any instruction contained in the BWX or MAX extension.

> Applications compiled with this option may incur emulation overhead on ev4, ev5, and ev56 processors, but will still run correctly.

> ### -arch ev6

> Generates instructions for ev6 processors (21264 chips).

> This option permits the compiler to generate any ev6 instruction, including instructions contained in the BWX, MAX, and FIX extensions.

> Applications compiled with this option may incur emulation overhead on ev4, ev5, ev56, and pca56 processors, but will still run correctly.

> ### -arch ev67

> Generates instructions for ev67 processors (21264A chips).

> This option permits the compiler to generate any ev67 instruction, including instructions contained in the BWX, MAX, FIX, and CIX extensions. Applications compiled with this option may incur emulation overhead on ev4, ev5, ev56, ev6, and pca56 processors, but will still run correctly.

# 3.6 -assume buffered_io --- Buffered Output

Use the `-assume buffered_io` option so that, at run time, the default value BUFFERED='YES' applies to opening sequential output files. As a result, write statements to these disk files will first fill buffers with data before the run-time library routines move it to the files and empty the buffers.

The default value is `-assume nobuffered_io` . Its effect is to have the run-time library routines move data to sequential disk files immediately.

For More Information:

- See Section 5.6.7, Efficient Use of Record Buffers and Disk I/O.

# 3.7 -assume byterecl --- Units for Unformatted File Record Length

Specifying the `-assume byterecl` option:

- 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.

The default is `-assume nobyterecl` .

For More Information:

- On converting and using nonnative unformatted data files, see Chapter 10.
- On the INQUIRE statement, see Section 7.6.

# 3.8 -assume cc_omp --- Enable Conditional Compilation for OpenMP

(TU*X ONLY) This option enables conditional compilation as defined by the OpenMP Fortran API. (When `!$space` appears in free-form source or `!$spaces` appears in column 1 of fixed-form source, the rest of the line is accepted as a Fortran line.)

If `-omp` is specified, the default is `-assume cc_omp` ; otherwise, the default is `-assume nocc_omp` .

# 3.9 -assume dummy_aliases --- Dummy Variable Aliasing

If you specify the `-assume dummy_aliases` option, 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 95/90 standards and they slow performance.

If you omit `-assume dummy_aliases` , 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 `-assume dummy_aliases` .

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

The default is `-assume nodummy_aliases` .

For More Information:

- See Section 5.9.8, Dummy Aliasing Assumption.

# 3.10 -assume gfullpath --- Source File Path for Debugging

The `-assume gfullpath` option includes the full source file path in debugger information.

The default is `-assume nogfullpath` .

# 3.11 -assume minus0 --- Standard Semantics for Minus Zero

The `-assume minus0` option tells the compiler to use Fortran 95 standard semantics for the treatment of IEEE floating value -0.0 in the SIGN intrinsic. This applies if the processor is capable of differentiating -0.0 from +0.0.

The default is `-assume nominus0` , which tells the compiler to use Fortran 90/77 standard semantics in the SIGN intrinsic to treat -0.0 and +0.0 as 0.0.

# 3.12 -assume noaccuracy_sensitive, -fp_reorder --- Reorder Floating-Point Calculations

Specifying `-assume 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 ( `-assume accuracy_sensitive` ) because of the way intermediate results are rounded.

The `-assume noaccuracy_sensitive` and `-fp_reorder` options are synonymous.

If you omit `-assume noaccuracy_sensitive` and omit `-fast` , the compiler uses a limited number of rules for calculations, which might prevent some optimizations.

The default is `-assume accuracy_sensitive` or `-no_fp_reorder` (unless `-fast` was specified).

For More Information:

- See Section 5.9.7, Arithmetic Reordering Optimizations.

# 3.13 -assume noprotect_constants --- Remove Protection from Constants

The `-assume noprotect_constants` option tells the compiler to pass a copy of a constant actual argument. As a result, the called routine can modify this copy, even though the Fortran standard prohibits such modification. The calling routine does not modify the constant.

The default is `-assume protect_constants` , which results in passing of a constant actual argument. Any attempt to modify it results in an error.

# 3.14 -assume nosource_include --- INCLUDE file search

This option determines where the compiler searches for INCLUDE files.

If you specify `-assume nosource_include` , the compiler searches the default directory for INCLUDE files (the same as if `-vms` is used).

The default is `-assume source_include` , which instructs the compiler to search the directory where the source files are located.

# 3.15 -assume nounderscore --- Underscore on External Names

Specifying `-assume nounderscore` prevents the compiler from appending an underscore ( `_` ) to the following external user-defined names:

- The main program name
- Named common blocks
- BLOCK DATA blocks
- Names implicitly or explicitly declared external

The name of a blank (unnamed) common block remains `_BLNK__` and Compaq Fortran intrinsic names remain the same.

You can also use the cDEC$ ATTRIBUTES ALIAS directive to change how individual external names are spelled.

The default is `-assume underscore` , in which case Compaq Fortran appends an underscore to calls to most external names.

# 3.16 -assume no2underscores --- Two Underscores on External Names

(L*X ONLY) Specifying `-assume no2underscores` prevents the compiler from appending two underscores ( `__` ) to the following external user-defined names:

- The main program name
- Named common blocks
- BLOCK DATA blocks
- Names implicitly or explicitly declared external

The name of a blank (unnamed) common block remains `_BLNK__` and Compaq Fortran intrinsic names remain the same.

You can also use the cDEC$ ATTRIBUTES ALIAS directive to change how individual external names are spelled.

The default is `-assume 2underscores` , in which case Compaq Fortran appends two underscores to calls to most external names.

If `-assume nounderscore` is specified, `-assume 2underscores` and `-assume no2underscores` are ignored.

# 3.17 -assume pthreads_lock --- Thread Lock Selection for Parallel Execution

(TU*X ONLY) The `-assume pthreads_lock` option lets you select the kind of locking used for an unnamed critical section (under `-mp` and `-omp` ). In the rare event that your program should need more restrictive locking, use this option to set `_OtsPthreadLock` , which locks out other pthreads in addition to all critical sections.

The default is `-assume nopthreads_lock` , which results in much faster compile times. Using the default creates a `bifcall (enter_critical)` to set `_OtsGlobalLock` , which does not lock out other pthreads, but does provide a single lock for all unnamed critical sections.

# 3.18 -automatic, -static --- Local Variable Allocation

The `-automatic` and `-static` options control how local variables are allocated.

Specifying `-automatic` puts local variables on the run-time stack. Specifying `-automatic` sets `-recursive` .

Specifying `-static` causes all local variables to be statically allocated.

A subprogram declared with the RECURSIVE keyword is always recursive (whether you specify or omit the `-static` option).

The default is `-static` or `-noautomatic` .

# 3.19 -c --- Inhibit Linking and Retain Object File

Use the `-c` option to suppress the loading phase of the compilation and force an object file to be produced even if only one program is compiled. If you omit `-c` , the linker creates an executable program and any temporary object files are deleted.

If you specify the `-o output` option with the `-c` option and multiple Fortran files, a single `.o` file is created, allowing full interprocedure optimizations.

However, if you specify multiple source files and the `-c` option without the `-o output` option, multiple object files are created and interprocedure optimizations do not occur.

# 3.20 -call_shared, -non_shared, -shared --- Shared Library Use

These options relate to shared libraries.

The default is `-call_shared` .

The following options apply:

> ### -call_shared

> Causes the linker to search for unresolved references in shared libraries ( `.so` files) before archive libraries ( `.a` files).

> If the unresolved reference is found in the shared library, the unresolved reference is resolved when the program is run (during program loading), reducing executable program size. For more information on related options, see Section 2.5.2.

> ### -non_shared

> Requests that the linker search only in archive libraries ( `.a` files) for unresolved references; shared library ( `.so` ) files are not searched. Object files ( `.o` suffix) from archives are included in the executable produced.

> ### -shared

> Produces a dynamic shareable object that can be included into a shared library. This includes creating all of the tables for run-time linking and resolving references to other specified shared objects. The object created can be used by the linker to produce a shareable object that other dynamic executables can use at run time. To explicitly name the resulting object file or shared library, use the `-o` option.

> If you also specify the `-c` option when you use `-shared` , a `.o` file is created; otherwise, a `.so` file is created.

For More Information:

- See Section 2.5.2, Specifying Types of Object Libraries.
- See Section 2.6, Creating Shared Libraries.

# 3.21 -ccdefault keyword --- Carriage Control for Terminals

The `-ccdefault keyword` options specify default carriage control when a terminal displays a file.

The following options apply:

> ### -ccdefault fortran

> Results in normal Fortran interpretation of the first character, such as the character "0" resulting in a blank line before output.

> ### -ccdefault list

> Results in one line feed between records.

> ### -ccdefault none

> Results in no carriage-control processing.

> ### -ccdefault default

> Specifies that the compiler is to use the default carriage-control setting. This is the default value of `-ccdefault` .

> This default setting can be affected by the `-vms` option as follows:

> - If `-vms -ccdefault default` is specified and the file is formatted and the unit is connected to a terminal, then normal Fortran interpretation of the first character occurs (same as `-ccdefault fortran` ).
> - If `-novms -ccdefault default` is specified, then LIST carriage control occurs (same as `-ccdefault list` ).

# 3.22 -check arg_temp_created --- Check for Copy of Temporary Arguments

Specifying `-check arg_temp_created` generates code to check if actual arguments are copied into temporary storage before routine calls. If a copy is made at run time, an informative message is displayed.

The default is `-check noarg_temp_created` .

# 3.23 -check bounds, -C, -check_bounds --- Boundary Run-Time Checking

Specifying `-check bounds` or `-c` or `-check_bounds` (all are synonymous) generates code to perform run-time checks on array subscript and character substring expressions. A run-time message is reported if the expression is outside the addresses of the dimension of the array or outside the length of the string.

The default ( `-check nobounds` ) suppresses range checking.

For array bounds, each individual dimension is checked. Array bounds checking is not performed for arrays that are dummy arguments in which the last dimension bound is specified as * or when both upper and lower dimensions are 1.

Once the program is debugged, omit this option to reduce executable program size and slightly improve run-time performance.

# 3.24 -check format --- Format Mismatches at Run Time

Specifying `-check format` issues the run-time FORVARMIS fatal error when the data type of an item being formatted for output does not match the format descriptor being used (for example, a REAL*4 item formatted with an I edit descriptor).

Specifying `-check noformat` disables the run-time message associated with format mismatches (number 61). It also requests that the data item be formatted using the specified descriptor, unless the length of the item cannot accommodate the descriptor. (For example, it is still an error to pass an INTEGER*2 item to an E edit descriptor.) Specifying `-check noformat` allows such format mismatches as a REAL*4 item formatted with an I edit descriptor.

If you specify the `-vms` option, the default is `-check format` . Otherwise, the default is `-check noformat` .

# 3.25 -check nopower --- Allow Special Floating-Point Expressions

Specifying `-check nopower` allows certain arithmetic expressions containing floating-point numbers and exponentiation to be evaluated and return a result rather than causing 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.

The default is `-check power` , which means that for such expressions, an exception occurs, error message number 65 is displayed, and the program stops.

# 3.26 -check omp_bindings --- OpenMP Fortran API Binding Rules Checking

(TU*X ONLY) Specifying `-check omp_bindings` provides run-time checking to enforce the binding rules for OpenMP Fortran API compiler directives. When this option is in effect, the Compaq Fortran compiler issues an error message if your program attempts any of the following actions:

- Enter a DO, SINGLE, or SECTIONS directive if already in a work-sharing construct, a CRITICAL SECTION, or a MASTER.
- Execute a BARRIER directive if already in a work-sharing construct, a CRITICAL SECTION, or a MASTER.
- Execute a MASTER directive if already in a work-sharing construct.
- Execute an ORDERED directive if already in a CRITICAL SECTION.
- Execute an ORDERED directive unless already in an ORDERED DO.

Additionally, the following conditions apply:

- `-omp` implies `-check omp_bindings`
- `-fast -omp` implies `-check noomp_bindings` , regardless of the placement of `-fast`
- If you want the checking done on `-mp` , specify `-check omp_bindings` explicitly

The default is `-check noomp_bindings` .

For More Information:

- On using OpenMP Fortran API compiler directives, see Section 6.1.
- On rules that apply to dynamic binding of these directives, see the Compaq Fortran Language Reference Manual.

# 3.27 -check output_conversion --- Truncated Format Mismatches at Run Time

Specifying `-check output_conversion` issues the run-time OUTCONERR continuable error message when a data item is too large to fit in a designated format descriptor field. The field is filled with asterisks (*) and execution continues.

Specifying `-check nooutput_conversion` disables the run-time message (number 63) associated with format truncation. Error number 63 occurs when a number could not be output in the specified format field length without loss of significant digits (format truncation).

If you specify the `-vms` option, the default is `-check output_conversion` . Otherwise, the default is `-check nooutput_conversion` .

# 3.28 -check overflow --- Integer Overflow Run-Time Checking

Specifying `-check overflow` requests that all integer calculations (INTEGER, INTEGER with a kind parameter, or INTEGER with a length specifier) be checked for arithmetic overflow at run time. Real and complex calculations are always checked for overflow and are not affected by `-check overflow` .

If the check reveals that the code caused arithmetic overflow, an error message is displayed at run time, program execution stops, and a core dump occurs.

Once the program is debugged, omit this option to reduce executable program size and slightly improve run-time performance.

The default is `-check nooverflow` .

# 3.29 -check underflow --- Floating-Point Underflow Run-Time Checking

(TU*X ONLY) Specifying `-check underflow` displays a run-time warning message (maximum of twice) when a floating-point underflow occurs.

Floating-point underflow is allowed to continue if the `-fpe3` or `-fpe4` option was specified; otherwise, the underflow value is replaced by zero. A count of how many occurrences of each type of exception is displayed on program completion.

The default is `-check nounderflow` .

For More Information:

- On underflow ranges for floating-point data types, see Section 9.4, Native IEEE Floating-Point Representations and Exceptional Values.
- On controlling floating-point exception handling, see Section 3.44.

# 3.30 -convert keyword --- Unformatted Numeric Data Conversion

The `-convert keyword` options determine which format is used to read and write unformatted files.

Numeric data in an unformatted file is expected to be in native little endian integer and little endian IEEE S_float, T_float, and X_float floating-point formats, unless handled otherwise by the application.

You can specify the unformatted data format for specific unit numbers by using the OPEN statement CONVERT specifier or by setting the appropriate `FORT_CONVERTn` environment variable.

The default is `-convert native` .

The following options apply:

> ### -convert big_endian

> Specifies that unformatted data will be in big endian format of the appropriate size:

> > INTEGER*1, INTEGER*2, INTEGER*4, or INTEGER*8
> > IEEE floating point format for REAL*4, REAL*8, REAL*16, COMPLEX*8, COMPLEX*16, or COMPLEX*32

> Note that INTEGER*1 data is the same for little endian and big endian.

> ### -convert cray

> Specifies that unformatted data will be in big endian format of the appropriate size:

> > INTEGER*1, INTEGER*2, INTEGER*4, or INTEGER*8
> > CRAY floating-point format for REAL*8 or COMPLEX*16

> ### -convert fdx

> Specifies that unformatted data will be in little endian format of the appropriate size:

> > INTEGER*1, INTEGER*2, INTEGER*4, or INTEGER*8
> > Compaq VAXtm floating-point format F_floating for REAL*4 or COMPLEX*8, D_floating for REAL*8 or COMPLEX*16, and X_floating for REAL*16 or COMPLEX*32

> ### -convert fgx

> Specifies that unformatted data will be in little endian format of the appropriate size:

> > INTEGER*1, INTEGER*2, INTEGER*4, or INTEGER*8
> > Compaq VAX floating-point format F_floating for REAL*4 or COMPLEX*8, G_floating for REAL*8 or COMPLEX*16, and X_floating for REAL*16 or COMPLEX*32

> ### -convert ibm

> Specifies that unformatted data will be in big endian format of the appropriate size:

> > INTEGER*1, INTEGER*2, or INTEGER*4
> > IBM System\370 floating-point format for REAL*4 or COMPLEX*8 (IBM short 4) and for REAL*8 or COMPLEX*16 (IBM long 8)

> ### -convert little_endian

> Specifies that unformatted data will be in native RISC little endian format of the appropriate size:

> > INTEGER*1, INTEGER*2, INTEGER*4, or INTEGER*8
> > IEEE floating-point format for REAL*4, REAL*8, REAL*16, COMPLEX*8, COMPLEX*16, or COMPLEX*32

> Note that INTEGER*1 data is the same for little endian and big endian.

> Using `-convert little_endian` produces the same results as `-convert native` .

> ### -convert native

> Specifies that unformatted data should not be converted.

> This is the default.

> ### -convert vaxd

> Specifies that unformatted data will be in little endian format of the appropriate size:

> > INTEGER*1, INTEGER*2, INTEGER*4, or INTEGER*8
> > Compaq VAX floating-point format F_floating for REAL*4 or COMPLEX*8, D_floating for REAL*8 or COMPLEX*16, and H_floating for REAL*16 or COMPLEX*32

> ### -convert vaxg

> Specifies that unformatted data will be in little endian format of the appropriate size:

> > INTEGER*1, INTEGER*2, INTEGER*4, or INTEGER*8
> > Compaq VAX floating-point format F_floating for REAL*4 or COMPLEX*8, floating-point format G_floating for REAL*8 or COMPLEX*16, and H_floating for REAL*16 or COMPLEX*32

For More Information:

- On converting unformatted files, including using the OPEN statement CONVERT specifier and using FORT_CONVERTn environment variables, see Chapter 10.
- On native data types, see Chapter 9.
- On OpenVMS floating-point data types, see Section A.4.3.

# 3.31 -cpp and Related Options --- Run C Preprocessor

Specifying `-cpp` runs the C preprocessor `cpp` on all Fortran source files before compiling.

The default is `-nocpp` .

The following `cpp` macros are defined by the `f90` command when any `.f90` , `.f90` , `.f` , `.f` , `.for` , or `.FOR` file is being compiled:

> `LANGUAGE_FORTRAN_90` (UN*X ONLY)
> `__LANGUAGE_FORTRAN_90__` (UN*X ONLY)
> `LANGUAGE_FORTRAN` (UN*X ONLY)
> `__LANGUAGE_FORTRAN__` (UN*X ONLY)
> `linux` (L*X ONLY)
> `__linux__` (L*X ONLY)
> `__alpha`
> `__osf__` (UN*X ONLY)
> `unix` (UN*X ONLY)
> `__unix__` (UN*X ONLY)
> `__OPENMP` if `-omp` is specified (UN*X ONLY)

If you omit `-cpp` and `-p` , the `cpp` preprocessor is not run unless the file name suffix is `.f` or `.for` (for fixed-form source files) or `.f90` (for free-form source files).

If you specify `-cpp` or `-p` , you can also specify these options:

- Section 3.32, -Dname, -Dname=def, -Dname="string" --- Define Symbol Names
- Section 3.51, -I --- Remove Directory from Include Search Path
- Section 3.52, -Idir --- Add Directory for Module and Include File Search
- Section 3.56, -K --- Keep Temporary Files
- Section 3.92, -Uname --- Undefine Preprocessor Symbol Name

For More Information:

- On `cpp` and its options, see `cpp(1)`.
- On the options the `f90` command passes to the `cc` driver program (which do not usually apply to Compaq Fortran files), see Section 2.2.2.
- On recognized file name suffix characters and their meanings, see Section 2.1.1, File Suffixes and Source Forms.

## 3.31.1 -M --- Request cpp Dependency Lists for make

Specifying `-m` requests that `cpp` generate dependency lists suitable for `make` , instead of the normal output.

## 3.31.2 -P --- Retain cpp Intermediate Files

Specifying `-p` runs only the `cpp` preprocessor and puts the result for each source file in an intermediate file, after processing by any appropriate preprocessors. The intermediate file does not have line numbers (#) in it.

The following naming convention is used: `.f` file results are put into `.i` files. `.f90` file results are put into `.i90` files.

This option sets the `-cpp` option.

## 3.31.3 -Wp,-xxx --- Pass Specified Option to cpp

The `-wp,-xxx` option allows you to pass an option (specified by xxx) directly to the `cpp` preprocessor. This is useful for options that the driver does not normally pass to the preprocessor.

For example, to pass `-C -M` to `cpp` , use:

    -Wp,-C,-M

The `-wp` option does not invoke `cpp` . Use `-cpp` to invoke `cpp` .

# 3.32 -Dname, -Dname=def, -Dname="string" --- Define Symbol Names

Specifying `-dname` or `-dname=def` or `-dname="string"` defines name for use by either the `cpp` preprocessor or by Fortran conditional compilation.

When name=def is used for Fortran conditional compilation, def can be an integer string or a character string delimited by double quotation marks as in `-dvehicle_type="red convertible"` . When name=def is used for the `cpp` preprocessor, the definition is interpreted as if by `#define` . Regardless of the usage, if no definition is given, then name is defined as "1".

For example:

    % f90 -Dnum=4 -Dber -Dclock="the time" foo.f90

In this example, num is the integer 4, ber is "1", and clock is the string "the time".

Preprocessor symbols can be used for conditional compilation by using the cDEC$ IF directive construct (see the Compaq Fortran Language Reference Manual) or by using `cpp` . Predefined preprocessor symbols are defined in Section 3.31.

Specifying `-nod` prevents the compiler from receiving any `-dname` or `-uname` options. (The default is to allow the compiler to receive these options.) However, the `cpp` preprocessor always receives these options.

For More Information:

On the C preprocessor, see `cpp(1)`.

# 3.33 -d_lines --- Debugging Statement Indicator, Column 1

Use the `-d_lines` option to request that lines in fixed-format source files that have a D or a d character in column 1 be compiled instead of treated as comment lines. Such lines might print the values of variables or otherwise provide useful debugging information.

The `-d_lines` option does not apply to free-format files.

The default ( `-nod_lines` ) treats all lines with a D or a d in column 1 as comment lines.

# 3.34 -double_size 128, -double_size 64 --- Double Precision Data Size

Use the `-double_size 128` option to specify the size of DOUBLE PRECISION declarations, constants, functions, and intrinsics as REAL*16 and DOUBLE COMPLEX declarations, constants, functions, and intrinsics as COMPLEX*32.

The default is `-double_size 64` , where DOUBLE PRECISION declarations, constants, functions, and intrinsics are specified as REAL*8 and DOUBLE PRECISION COMPLEX declarations, constants, functions, and intrinsics as COMPLEX*16.

# 3.35 -error_limit num, -noerror_limit --- Limit Error Messages

Use the `-error_limit num` and `-noerror_limit` options to specify the maximum number of error-level or fatal-level compiler errors allowed for a given file specified on the command line.

If `-c` is specified on the command line and the maximum number of errors is reached, a warning message is issued and the next file (if any) on the command line is compiled.

If `-c` is not specified, a warning message is issued and compilation terminates.

If you specify `-noerror_limit` , there is no limit on the number of errors that are allowed.

The default is `-error_limit 30` , or a maximum of 30 error-level and fatal-level messages.

# 3.36 -extend_source --- Line Length for Fixed-Format Source

Specifying `-extend_source` treats the statement field of each source line as ending in column 132 instead of column 72.

The default ( `-noextend_source` or `-col72` ) specifies 72-column lines.

Specifying `-extend_source` sets the `-fixed` option.

Specifying `-extend_source` or `-col132` sets the source to fixed format even if implicit naming rules set it to free format.

For More Information:

- On recognized file name suffix characters and their relationship to fixed and free source formats, see Section 2.1.1.
- On column positions and more complete information on the fixed and free source formats, see the Compaq Fortran Language Reference Manual.

# 3.37 -f66, -66, -nof77, -onetrip, -1 --- Use FORTRAN 66 Semantics

Specifying `-f66` , `-66` , `-nof77` , `-onetrip` , or `-1` (all are synonymous) tells the compiler to select FORTRAN 66 (FORTRAN IV) interpretations in cases of incompatibility.

This option applies the following FORTRAN 66 semantics:

- DO loops are always executed at least once.
- FORTRAN 66 EXTERNAL statement syntax and semantics are allowed. See the Compaq Fortran Language Reference Manual.
- In the OPEN statement:
  - If the BLANK specifier is omitted, the default is BLANK='ZERO'.
  - If the STATUS specifier is omitted, the default is STATUS='NEW'.

The default is `-nof66` , which specifies that FORTRAN 77 interpretation rules are used for those statements that have a meaning incompatible with FORTRAN 66. Thus, DO loops whose lower range exceeds the upper range will not be executed.

# 3.38 -f77, -nof66 --- Use FORTRAN 77 Semantics

Specifying `-f77` or `-nof66` (they are synonymous) enforces FORTRAN 77 semantics instead of FORTRAN 66 semantics.

In Fortran F90, the default is to apply Fortran 95/90 semantics.

# 3.39 -f77rtl --- Use Fortran 77 Run-Time Behavior

Specifying `-f77rtl` tells the compiler to create an executable file whose run-time behavior is that of Compaq Fortran 77 instead of Compaq Fortran.

Specifying this option controls control the following run-time behavior:

- When the unit is not connected to a file, some INQUIRE specifiers will return different values:
  - NUMBER returns 0
  - ACCESS returns 'UNKNOWN'
  - BLANK returns 'UNKNOWN'
  - FORM returns 'UNKNOWN'
- List-directed input for character strings must be delimited by apostrophes or quotation marks, or an error will result.
- When processing NAMELIST input:
  - Column 1 of each record is skipped.
  - The '$' or '&' that appears prior to the group-name must appear in column 2 of the input record.

The default is `-nof77rtl` .

# 3.40 -fast --- Set Options to Improve Run-Time Performance

Specifying `-fast` sets the following options:

- `-align dcommons` (see Section 3.3). However, if any of the `-std` options are set (see Section 3.85), then the compiler ignores `-align dcommons` .
- `-align sequence` (see Section 3.3). However, if any of the `-std` options are set (see Section 3.85), then the compiler ignores `-align sequence` .
- `-arch host` (see Section 3.5)
- `-assume bigarrays` (TU*X ONLY) (see Section 3.50.1)
- `-assume noaccuracy_sensitive` (same as `-fp_reorder` ; see Section 3.12)
- `-assume nozsize` (TU*X ONLY) (see Section 3.50)
- `-math_library fast` (see Section 3.61)
- `-o4` (reinforced as the default; see Section 3.72)
- `-tune host` (see Section 3.90)

Avoid using the `-fast` option unless you understand the options that `-fast` sets. For example, the `-fast` option sets the `-assume noaccuracy_sensitive` and `-math_library fast` options, which can change the calculated results of a program.

Also, before you use `-fast` with the `-hpf` option, first make sure your program does not use any zero-sized arrays or array sections (see Section 3.50). And, while the setting of `-arch host` and `-tune host` generates optimal code for the computer architecture on which the compiler is running, this code may run slowly on another version of the computer architecture.

The default is `-nofast` .

# 3.41 -feedback file, -gen_feedback, -cord --- Create and Use Feedback Files

Note These options apply only to Tru64 UNIX systems.

These options allow the creation and use of a feedback file, which can improve run-time performance. You can optionally use `cord` to rearrange procedures.

You create a feedback file by using a series of commands, including `f90` with the `-gen_feedback` option, `pixie` (TU*X ONLY), and `prof` . (See Section 5.3.5.)

The options are:

> ### -cord

> Runs the `cord` procedure-rearranger `cord` after the linker creates the executable program. This rearrangement reduces the cache conflicts of the program's text. The output of `cord` is left in the file specified by the `-o output` option (or `a.out` by default). At least one `-feedback file` must be specified.

> ### -feedback file

> Specifies the `file` to be used by `-cord` or the compiler for further optimizations.

> This `file` is produced by the `prof` command with its `-feedback` option from an execution of the program produced by the `pixie` command (TU*X ONLY).

> ### -gen_feedback

> Directs the compiler to generate code that will produce accurate feedback information when profiled.

> For example:

>     f90 -gen_feedback -o x x.f
>     pixie x
>     x.pixie
>     prof x -pixie -feedback x.fb x.Addrs x.Counts
>     f90 -feedback x.fb -O5 -fast -o x x.f

> Using `-gen_feedback` changes the default optimization level from `-o4` to `-o0` . Avoid using `-gen_feedback` with optimizations higher than `-o3` .

For More Information:

- On using `cord` , see Section 5.3.5.
- On profiling options, see Section 3.77.
- On timing program execution, see Section 5.2.

# 3.42 -fixed, -free --- Fortran Source Format

Use the `-fixed` and `-free` options to specify the source format:

> ### -fixed

> Specifies that the source file is fixed format, regardless of the file name suffix.

> Note that source files with a suffix of `.f` , `.for` , `.f` , `.for` , or `.i` are assumed to be fixed format.

> ### -free

> Specifies that the source file is free format, regardless of the file name suffix.

> Note that source files with a suffix of `.f90` , `.f90` , or `.i90` are assumed to be free format.

You cannot specify both `-free` and `-fixed` on the same command line.

Table 3-2 summarizes how the `-free` and `-fixed` options interact with the file suffix of a source file.

Table 3-2 Interaction of File Suffix and the -free and -fixed Options on Source Form
Suffix | -free Option | -fixed Option | Expected Source Form
--- | --- | --- | ---
.f90, .F90, .i90 | Not specified | Not specified | Free form
.f90, .F90, .i90 | Specified | Not specified | Free form
.f90, .F90, .i90 | Not specified | Specified | Fixed form
.f, .F, .for, .FOR, .i | Not specified | Not specified | Fixed form
.f, .F, .for, .FOR, .i | Specified | Not specified | Free form
.f, .F, .for, .FOR, .i | Not specified | Specified | Fixed form

For More Information:

- On recognized file name suffix characters and their relationship to fixed and free source formats, see Section 2.1.1, File Suffixes and Source Forms.
- On column positions and more complete information on the fixed and free source formats, see the Compaq Fortran Language Reference Manual.

# 3.43 -fpconstant --- Handling of Floating-Point Constants

Specifying `-fpconstant` requests that a single-precision constant assigned to a double-precision variable be evaluated in double precision.

If you omit `-fpconstant` , a single-precision constant assigned to a double-precision variable is evaluated in single precision. The Fortran standard requires that the constant be evaluated in single precision.

Certain programs created for FORTRAN-77 compilers (including Compaq Fortran 77) may show different results, 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 `-fpconstant` , identical values are assigned to D1 and D2. If you omit the `-fpconstant` option, Compaq Fortran will obey 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

# 3.44 -fpen --- Control Arithmetic Exception Handling and Reporting

Use the `-fpe0` , `-fpe1` (TU*X ONLY), `-fpe2` (TU*X ONLY), `-fpe3` , or `-fpe4` (TU*X ONLY) options to control floating-point exception handling at run time for the main program. This includes whether exceptional floating-point values are allowed and how precisely run-time exceptions are reported.

Using these options, you can do the following:

- For floating-point calculations that result in overflow, division by zero, or invalid data, you can request that the compiler:
  - Either stop program execution and perform a core dump (faster run-time performance) or let the program continue with the generated Infinity (+ or --) or NaN exceptional value (slower run-time performance).
  - (TU*X ONLY) Display or not display a message when the arithmetic exception occurs.
  - Report exceptions closer to the instruction that caused the exception.
- For floating-point calculations that result in underflow (a denormalized number; see Section 9.4), you can request that the compiler:
  - Either set the calculated underflowed (denormalized) value to zero (0) or leave the denormalized value as is (slowest run-time performance).
  - (TU*X ONLY) Display or not display a message when the arithmetic exception occurs (you can also specify `-check underflow` ).
  For information on the underflow ranges for floating-point data types, see Section 9.4.
- When a denormalized number or other exceptional number (positive infinity, negative infinity, or a NaN) is present in an arithmetic expression, you can request that the compiler:
  - Either stop program execution and perform a core dump (faster run-time performance) or let the program continue with slower run-time performance.
  - (TU*X ONLY) Display or not display a message when the arithmetic exception occurs.

To associate an exception with the instruction that causes the exception, specify any value other than `-fpe0` (or specify `-synchronous_exceptions` ).

(TU*X ONLY) Specifying `-fpe2` or `-fpe4` displays error messages indicating the cause of the exceptions.

To allow source line correlation when using a debugger to locate the exception, specify the `-g` option when compiling the program (see Chapter 4).

The default is `-fpe0` or `-fpe` , which are synonymous.

The following options apply:

> ### -fpe0, -fpe

> Terminates a program if a floating-point operation results in overflow or division by zero, or if the operands are exceptional values. Before termination, a message is issued and a core dump file is created. If an operand is a denormalized number, it is set to zero.

> In the case of floating-point underflow, the program does not terminate, but continues with the underflow value set to zero. On Tru64 UNIX systems, a warning message is issued if `-check underflow` is set.

> Examining the `core` file shows the exception one or more instructions after the instruction that caused the exception (unless you also specified `-synchronous_exceptions` ).

> To obtain the fastest run-time performance, use `-fpe0` . This is the default. Using other `-fpen` values will slow run-time performance.

> ### -fpe1

> (TU*X ONLY) Continues program execution and generates an Infinity or Nan if a floating-point operation results in overflow, division by zero, or invalid data.

> If an operand is a denormalized number, it is set to zero. In the case of floating-point underflow, the underflow value is set to zero. A warning message is issued if `-check underflow` is set.

> ### -fpe2

> (TU*X ONLY) Continues program execution if a floating-point operation results in overflow, division by zero, or invalid data. A warning message is generated for the first two occurrences. If an operand is a denormalized number, it is set to zero.

> In the case of floating-point underflow, the underflow value is set to zero. On program completion, a count of how many times each exception occurred is displayed.

> ### -fpe3

> Continues program execution if a floating-point operation results in overflow, division by zero, invalid data, or underflow. Calculated denormalized numbers are left as is.

> For underflow, the underflow value is not set to zero, and gradual underflow occurs. On Tru64 UNIX systems, a warning message is issued if `-check underflow` is set.

> ### -fpe4

> (TU*X ONLY) Continues program execution if a floating-point operation results in overflow, division by zero, invalid data, or underflow. A warning message is generated for the first two occurrences. Calculated denormalized numbers are left as is.

> In the case of floating-point underflow, the underflow value is not set to zero and gradual underflow occurs. On program completion, a count of how many times each exception occurred is displayed.

## 3.44.1 Hints on Using These Options

Table 3-3 summarizes the floating-point exception handling options.

Table 3-3 Summary of Floating-Point Exception Command-Line Options
Option | Handling of Underflow | Handling of Overflow, Division by Zero, and Invalid Data
--- | --- | ---
`-fpe0` , `-fpe` | Sets any calculated denormalized value (result) to zero and lets the program continue. Use of a denormalized number in an arithmetic expression uses a value of zero and execution continues. (TU*X ONLY) A message is displayed only if `-check underflow` is also specified. | Exceptional values are not allowed. The program terminates after displaying a message and creating a core dump file.
`-fpe1` (TU*X ONLY) | Sets any calculated denormalized value to zero and lets the program continue. Use of a denormalized number in an arithmetic expression uses a value of zero and execution continues. A message is displayed only if `-check underflow` is also specified. | The program continues (no core dump). No message is displayed. A NaN or Infinity (+ or --) exceptional value is generated.
`-fpe2` (TU*X ONLY) | Sets any calculated denormalized value to zero and lets the program continue. Use of a denormalized number in an arithmetic expression uses a value of zero and execution continues. A message is displayed ( `-check underflow` is not needed). | The program continues (no core dump). A message is displayed a maximum of twice for each type of exception. A NaN or Infinity (+ or --) is generated.
`-fpe3` | Leaves any calculated denormalized value as is. The program continues, allowing gradual underflow. Use of a denormalized number in an arithmetic expression results in program continuation, but with slower performance. (TU*X ONLY) A message is displayed only if `-check underflow` is also specified. | The program continues (no core dump). No message is displayed. A NaN or Infinity (+ or --) is generated.
`-fpe4` (TU*X ONLY) | Leaves any calculated denormalized value as is. The program continues, allowing gradual underflow. Use of a denormalized number in an arithmetic expression results in program continuation, but with slower performance. A message is displayed ( `-check underflow` is not needed). | The program continues (no core dump). A message is displayed a maximum of twice for each type of exception. A NaN or Infinity (+ or --) is generated.

On Tru64 UNIX systems, the exception message reporting specified by the `-fpen` options applies only to the main program and cannot be changed during program execution.

To help you debug a routine, you can associate an exception with the instruction that causes it by specifying any value other than `-fpe0` (such as `-fpe3` ) or specify `-synchronous_exceptions` .

When compiling different routines in a program separately, you should use the same `-fpen` value. For example, assume:

- Routine A is compiled with `-fpe3` . Routine A can create and use an exceptional value.
- Routine B is compiled with `-fpe0` . Routine B cannot create or use an exceptional value (program stops).

If routine A passes an exceptional value to routine B and routine B uses that exceptional value in an arithmetic expression, program execution stops and a `core` file is created.

You can call the `for_set_fpe` routine to set the floating-point exception handling for subprograms (including C functions) or perhaps to change the setting for the main program.

To use `for_set_fpe` in most cases, you should recompile the program with `-fpe1` or higher. You should not change the exception settings to request program continuation with `for_set_fpe` if you compiled the program using `-fpe0` .

Both the `for_set_fpe` and `for_get_fpe` routines can be used by Fortran programs using the INTEGER parameter values located in `/usr/include/for_fpe_flags.f` . Programs written in C can call the `for_rtl_init_` routine prior to calling the `for_get_fpe` or `for_get_fpe` routines, and must include an equivalent header file, `/usr/include/for_fpe_flags.h` .

For programs that use a number of denormalized values (such as those that allow gradual underflow with `-fpe3` , the impact on run-time performance can be significant.

If you use the `-math_library fast` (or `-fast` ) option along with an `-fpen` option, the `-fpen` option is ignored when arithmetic values are evaluated by math library routines.

If you specify the `-speculate all` or `-speculate by_routine` options along with one of the `-fpen` options that request exception reporting, exceptions are not reported as expected (see Section 3.84).

For More Information:

- On IEEE floating-point exception handling, see IEEE Standard for Binary Floating-Point Arithmetic (ANSI/IEEE Standard 754-1985) and `ieee(3)`.
- On Compaq Fortran floating-point exception handling, see Chapter 14.
- On native IEEE floating-point data representation and IEEE exceptional values, see Section 9.4.
- On the `for_set_fpe` and `for_get_fpe` routines, see `for_set_fpe(3f)` and Chapter 12 and Section 14.3.

# 3.45 -fpp --- Run Fortran Preprocessor

Use the `-fpp` option to run the Fortran preprocessor on all Fortran source files in the command line before the Fortran compiler executes. This option has no effect on any C source files in the command line. The Fortran preprocessor has a subset of the functionality of the C preprocessor (which the `-cpp` option invokes).

The default is `-nofpp` , which means that neither the Fortran preprocessor nor the C preprocessor runs on the Fortran source files in the command line.

# 3.46 -fprm keyword --- Control Floating-Point Rounding Mode

The `-fprm nearest` , `-fprm dynamic` (TU*X ONLY), `-fprm chopped` , and `-fprm minus_infinity` options allow you to control how rounding occurs during floating-point operations.

The rounding mode applies to each program unit being compiled.

The following options apply:

> ### -fprm nearest

> Causes the compiler to round results of floating-point operations toward the nearest representable value.

> If the unrounded value is halfway between two representable values, the even value is chosen.

> This is the default.

> ### -fprm chopped

> Causes the compiler to round results of floating-point operations toward zero.

> ### -fprm minus_infinity

> Causes the compiler to round results of floating-point operations toward the next smallest representative value.

> ### -fprm dynamic

> (TU*X ONLY) Allows run-time selection of a rounding mode. You can modify your program to:
> - Call the `read_rnd` Compaq Tru64 UNIX routine to obtain the current rounding mode. The current mode is stored in the floating-point control register ( `fpcr` ).
> - Call the `write_rnd` Compaq Tru64 UNIX routine to set the rounding mode and obtain the previous rounding mode.

> When you call `write_rnd` , you can set the rounding mode to one of the following settings (see `write_rnd(3)`):

> - Round toward zero or truncate (same as `-fprm chopped` )
> - Round toward nearest (same as `-fprm nearest` )
> - Round toward plus infinity
> - Round toward minus infinity (same as `-fprm minus_infinity` )

> If you compile with `-fprm dynamic` and do not call `write_rnd` , the default setting ( `-fprm nearest` ) is used.

For the fastest run-time performance, avoid using `-fprm dynamic` .

For More Information:

- On IEEE floating-point rounding modes, see IEEE Standard for Binary Floating-Point Arithmetic (ANSI/IEEE Std 754-1985), `write_rnd(3)`, `ieee_functions(3)`, and `ieee(3)`.
- On the floating-point control register and Alpha architecture, see Alpha Architecture Reference Manual.

# 3.47 -fuse_xref --- Cross-Reference Information for Compaq FUSE

Use the `-fuse_xref` option (TU*X ONLY) to request that Compaq Fortran generate a data file that the Compaq FUSE Database Manager uses to create a cross-reference database file. This improves the performance of the Compaq FUSE Call Graph Browser and Cross-Referencer, which use the database file for their operations.

# 3.48 -g0, -g1, -g2 or -g, -g3, -ladebug --- Traceback and Symbol Table Information

Use the `-g0` , `-g1` , `-g2` , or `-g` , `-g3` , and `-ladebug` options to control the amount of symbol table information in the object file.

If you intend to use the Compaq Ladebug debugger, specify the `-ladebug` option and one of the following: `-g` , `-g2` , or `-g3` .

The default is `-g1` .

The following options apply:

> ### -g0

> Provides no traceback or symbol table information needed for debugging or profiling. Only symbol information needed for linking (global symbols) is produced. The size of the resulting object file is the minimum size.

> ### -g1

> Produces traceback information, which allows program counter to source file line correlation, but not symbol table information needed for debugging. Specifying `-g1` produces the global symbol information needed for linking or profiling.

> The object file size is somewhat larger than if `-g0` was specified, but is smaller than if either `-g2` or `-g3` was specified.

> This is the default.

> ### -g2, -g

> Produces the following:
> - Traceback information
> - Symbol table information needed for full symbolic debugging of unoptimized code
> - Global symbol information needed for linking or profiling

> If you use this option and do not specify an `-on` option, the default optimization level changes to `-o0` , which disables nearly all optimizations to make debugging more accurate (the default optimization level is usually `-o4` ). If you use this option and specify an `-on` option other than `-o0` , a warning message is displayed.

> `-g2` and `-g` are synonymous.

> ### -g3

> Produces traceback information, symbol table information needed for symbolic debugging of optimized code, and global symbol information needed for linking or profiling. This option can provide additional debugging information to describe the effects of optimization, but debugging inaccuracies may occur as a result of optimizations.

> ### -ladebug

> Produces additional symbolic debugger information for the Compaq Ladebug debugger, if you specify `-g` , `-g2` , or `-g3` . This allows use of standard Fortran syntax when printing dynamic arrays using Compaq Ladebug, including array sections.

> If you specify `-g0` or `-g1` (the default) with `-ladebug` , the `-ladebug` option is ignored.

For More Information:

- See Section 4.2,Compaq Fortran Options for Debugging.
- See Section 4.12, Debugging Optimized Programs.
- See Section 5.8, Optimization Levels: the -On Option.

# 3.49 -granularity keyword --- Control Shared Memory Access to Data

The `-granularity keyword` options allow you to control the size of shared data in memory 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` .

To be written from multiple threads, data must be naturally aligned and declared as VOLATILE (so it is not held in registers). To ensure alignment in common blocks, derived-type structures, and record structures, use the `-align keyword` option.

The following options apply:

> ### -granularity byte

> Ensures that all data 1 byte or greater can be accessed from different threads sharing data in memory. This option will slow run-time performance.

> ### -granularity longword

> Ensures that naturally aligned data of 4 bytes or greater can be accessed safely from different threads sharing access to that data in memory.

> When this option is in effect, attempts to access smaller size data or misaligned data can result in data items that are inconsistently updated for multiple threads.

> ### -granularity quadword

> Ensures that naturally aligned data of 8 bytes can be accessed safely from different threads sharing data in memory.

> When this option is in effect, attempts to access smaller size data or misaligned data can result in data items that are inconsistently updated for multiple threads.

For More Information:

- On the Alpha architecture, see the Alpha Architecture Reference Manual.
- On allowing multiple processes to access common block data in a shared library (using memory mapping), see `shcom_connect(3f)`.
- On intrinsic data types, see Chapter 9.

# 3.50 -hpf, -hpf num, and Related Options --- Compile HPF Programs for Parallel Execution

Note These options apply only to Tru64 UNIX systems. `-wsf` is the nonpreferred synonym for `-hpf` . `-wsf num` is the nonpreferred synonym for `-hpf num` .

Use the `-hpf` option to specify that the HPF program will be compiled to run in parallel on multiple processors using the Message Passing Interface (MPI).

If you omit the `-hpf` option, the executable program will run in a nonparallel (serial) run-time environment and HPF directives will only be checked for correct syntax.

The optional `num` parameter specifies the number of processors on which the program is intended to run, for example, `-hpf 3` . If a number is not specified, the compiler generates code that can run on any number of processors. More efficient code is generated when `num` is specified.

When the HPF parallel programs are compiled with the `-c` option and linked separately, specify `-hpf` both when compiling and linking the program.

The following options are not compatible with the `-hpf` option: `-cord` , `-double_size 128` , `-feedback` , `-fpe1` , `-fpe2` , `-fpe3` , `-fpe4` , `-gen_feedback` , `-om` , `-omp` , `-p1` , and `-pg` .

The `-check bounds` option is compatible with the `-hpf` option only when the optional parameter `num` is set to 1.

When `-hpf` is used, the HPF target must be specified either by using the `-hpf_target` option or by setting the `DECF90_HPF_TARGET` environment variable. If neither is used, the driver will issue an error message and abort the compilation. See Section 3.50.5.

For More Information:

- On compiling an HPF global routine that will be linked with a main program that was not compiled with the `-hpf` option, see Section 3.68.
- On enabling conditional compilation for OpenMP, see Section 3.8.
- On using the `-warn hpf` option for syntax checking, see Section 3.100.

The following options are relevant to the `-hpf` option:

## 3.50.1 -assume bigarrays --- Run-time Checking for Distributed Small Array Dimensions

(UN*X ONLY) Specifying `-assume bigarrays` suppresses run-time checking for distributed small array dimensions. This allows for increased run-time performance and reduced compile time when using the `-hpf` option.

In programs compiled with both the `-hpf` and `-assume bigarrays` options, nearest-neighbor computations that reference small arrays will fail. An array is big enough if, for every dimension with BLOCK distribution, the shadow edge width is no bigger than the block size.

Specifying the `-fast` option sets the `-assume bigarrays` option.

The default is `-assume nobigarrays` .

## 3.50.2 -assume nozsize --- Omit Zero-Sized Array Checking

(UN*X ONLY) Specifying `-assume nozsize` suppresses run-time checking for zero-sized array sections. This allows for increased performance when using the `-hpf` option.

An array (or array section) is zero-sized when the extent of any of its dimensions takes the value zero or less than zero. When the `-hpf` option is specified, the compiler ordinarily inserts a series of checks to guard against irregularities (such as division by zero) in its internal computations that zero-sized arrays can cause. Depending on the particular application, these checks can cause noticeable (or even major) degradation of performance.

Specifying the `-fast` option sets the `-assume nozsize` option.

Avoid using the `-assume nozsize` option with `-hpf` when a program references any zero-sized arrays or array sections, because the resulting executable might fail to execute or might produce incorrect program results.

You can insert a run-time check into your program to ensure that a given line is not executed if an array or array section referenced there is zero-sized.

The default is `-assume zsize` .

## 3.50.3 -nearest_neighbor, -nearest_neighbor num, or -nonearest_neighbor --- Nearest Neighbor Optimization

Use the `-nearest_neighbor` option (TU*X ONLY) to enable the nearest neighbor parallel optimization. The compiler automatically determines the correct shadow-edge widths on an array-by-array, dimension-by-dimension basis.

This option is valid only if the `-hpf` option is specified.

Use the optional `num` field to specify the maximum width of the shadow edge, which limits how much extra storage the compiler can allocate for nearest-neighbor arrays.

When `num` is specified, the compiler will only recognize nearest-neighbor constructs that need shadow-edge widths less than or equal to the value of `num` .

If `num` is not specified, the compiler uses a `num` value of 10.

You can also set shadow-edge widths manually, using the !HPF$ SHADOW directive.

The `-nonearest_neighbor` option turns off the nearest-neighbor optimization. It is equivalent to specifying `-nearest_neighbor` with `nn` set to 0.

## 3.50.4 -show hpf --- Show HPF Parallelization Information

The `-show hpf` options (TU*X ONLY) show information about HPF parallelization by displaying the information to standard error and to the listing (if one is generated using the `-v` option). These options are valid only if the `-hpf` option is specified.

The `-show` option can take only one argument. However, the `-show` options can be combined by specifying `-show` multiple times. For example:

    % f90 -hpf -hpf_target cmpi -show hpf_near -show hpf_punt foo.f90

Specifying `-show hpf` selects a subset of the messages generated by all of the following `-show hpf_*` options. Try using `-show hpf` first, with the following variations only when a more detailed listing is needed.

The following options apply:

> ### -show hpf_all, -show hpfinfo, -show wsfinfo

> The `-show hpf_all` option is the same as specifying all the other `-show hpf_*` options.

> The `-show wsfinfo` option is the nonpreferred synonym of `-show hpfinfo` .

> ### -show hpf_comm

> This instructs the compiler to display information about statements that cause interprocessor communication to be generated.

> ### -show hpf_indep

> This instructs the compiler to display information about the optimization of loops marked with the INDEPENDENT directive.

> ### -show hpf_nearest

> This instructs the compiler to display information about arrays and statements involved in optimized nearest-neighbor computations.

> ### -show hpf_punt

> This instructs the compiler to display information about distribution directives that were ignored and statements that were not handled in parallel.

> ### -show hpf_temps

> This instructs the compiler to display information about temporaries that were created at procedure interfaces.

## 3.50.5 -hpf_target --- Message Passing Protocol for Parallel Programs

This option specifies the message passing protocol to use between processors for programs running in parallel. The format is:

    % -hpf_target cmpi | gmpi | smpi

If this option is used, `-hpf` must also be set.

The following options apply:

> ### -hpf_target cmpi

> Causes the compiler to target Compaq MPI, a version of Message Passing Interface (MPI) specifically tuned for Alpha systems. Compaq MPI is distributed as a Compaq layered product. Compaq MPI supports only Memory Channel clusters and shared-memory (SMP) machines.

> For more information about Compaq MPI, see:

>     http://www.compaq.com/hpc/software/dmpi.html

> ### -hpf_target gmpi

> Causes the compiler to target generic Message Passing Interface (MPI), specifically MPICH 1.2.0 or other libraries compatible with that version of MPICH. MPICH is a public-domain implementation of the MPI specification that is available for many platforms. It can be obtained from:

>     http://www-unix.mcs.anl.gov/mpi/mpich/

> MPICH supports many interconnection networks, including Ethernet, FDDI, and other hardware. Note: The use of the `gmpi` target is officially unsupported.

> When you use this option, you should set the `DECF90_GMPILIB` environment variable to specify a path to the MPI library to link against. If you don't set the `DECF90_GMPILIB` environment variable, then you must specify the MPI library to link against on the command line.

> ### -hpf_target smpi

> Causes the compiler to target the Message Passing Interface (MPI) that comes installed on SC-series systems. It is used in conjunction with the SC's "RMS" software, which provides a set of commands for launching MPI jobs, scheduling those jobs on SC clusters, and other miscellaneous tasks.

# 3.51 -I --- Remove Directory from Include Search Path

Use the `-i` option to prevent the search for `cpp` and `fpp` `#include` files or to prevent Compaq Fortran from searching for files specified in an INCLUDE statement in the standard directory `/usr/include` .

This option is not related to the Fortran USE statement.

# 3.52 -Idir --- Add Directory for Module and Include File Search

Use the `-idir` option to direct the search for `cpp` and `fpp` `#include` files, files specified in an INCLUDE statement, and module files (USE statement). The file names must not begin with a slash (/).

If you use this option, directories are searched in the following order:

1. The directory preceding the input file name on the command line
2. The directory ( `dir` ) specified by the `-idir` option (see Section 3.52)
3. The standard directory `/usr/include`

You can repeat the `-idir` option as many times as needed to specify multiple additional search directories.

To prevent the Compaq Fortran compiler from searching for include files in the `/usr/include` directory, use the `-noinclude` option.

For More Information:

- On creating and using module files, see Section 2.1.3.
- On creating and using include files, see Section 2.1.4.
- On recognized file name suffix characters and their meanings, see Section 2.1.1.

# 3.53 -i2, -i4, -i8, -integer_size num --- Integer and Logical Data Size

Use the following options to control the size of INTEGER and LOGICAL declarations (where no kind parameter or size specifier is indicated).

For optimal performance on Alpha systems, use 4- or 8-byte integer or logical values instead of 2-byte values.

The default is `-i4` or `-integer_size 32` .

The following options apply:

> ### -i2, -noi4, -integer_size 16

> Specifying `-i2` , `-noi4` , or `-integer_size 16` (all are synonymous) makes the default integer and logical variables 2 bytes long. That is, INTEGER and LOGICAL declarations are treated as INTEGER*2 (KIND=2) and LOGICAL*2 (KIND=2).

> ### -i4, -integer_size 32

> Specifying `-i4` or `-integer_size 32` makes default integer and logical variables 4 bytes long. That is, INTEGER and LOGICAL declarations are treated as INTEGER*4 (KIND=4) and LOGICAL*4 (KIND=4).

> ### -i8, -integer_size 64

> Specifying `-i8` or `-integer_size 64` makes default integer and logical variables 8 bytes long. That is, INTEGER and LOGICAL declarations are treated as INTEGER*8 (KIND=8) and LOGICAL*8 (KIND=8).

# 3.54 -inline keyword, -noinline --- Control Procedure Inlining

Specifying `-inline keyword` or `-noinline` controls the type of procedure calls that are inlined by the optimizer.

The following options apply:

> ### -inline all

> Inlines every call that can be inlined while still generating correct code, including:
> - Statement functions
> - Any procedures that Compaq Fortran expects will improve run-time performance with a likely significant increase in program size.
> - Any other procedures that can possibly be inlined and generate correct code. Certain recursive routines are not inlined to prevent infinite expansion.

> ### -inline speed

> Inlines calls that will likely improve run-time performance, even where it might significantly increase the size of the program.

> This option is meaningful only at optimization levels `-o1` and higher.

> This is the default for optimization levels `-o4` and `-o5` .

> ### -inline size

> Inlines calls where inlining will not significantly increase program size, plus any additional calls that the compiler determines will improve run-time performance.

> This option was previously called `-inline automatic` or `-inline space` .

> This option is meaningful only at optimization levels `-o1` and higher.

> ### -inline none, -inline manual, -noinline

> Suppresses all inlining of routines. However, statement functions are always inlined.

> All three options are synonymous.

> This is the default for optimization levels `-o0` , `-o1` , `-o2` , and `-o3` .

For More Information:

- See Section 5.9.3, Controlling the Inlining of Procedures.
- See Chapter 5, Performance: Making Programs Run Faster.
- See Section 5.8, Optimization Levels: the -On Option.

# 3.55 -intconstant --- Handling of Integer Constants

Specify this option to use Compaq Fortran 77 instead of Fortran 95/90 semantics to determine the kind of integer constants. If you don't specify `-intconstant` , Fortran 95/90 semantics are used.

With Fortran 77 semantics, all constants are kept internally by the compiler in the highest precision possible. For example, if you specify `-intconstant` , the compiler stores an integer constant of 14 internally as INTEGER(KIND=8) and converts the constant upon reference to the corresponding proper size. Fortran 95/90 specifies that integer constants with no explicit KIND are kept internally in the default INTEGER kind (KIND=4 by default).

Note that the internal precision for floating-point constants is controlled by the `-fpconstant` option, described in Section 3.43.

# 3.56 -K --- Keep Temporary Files

Specifying `-k` requests that temporary files created by `cpp` or the Compaq Fortran compiler not be automatically deleted.

This option does not affect the naming of temporary files. To see the names and locations of the temporary files, use the `-v` option.

Specifying `-k` also creates, in the current working directory, one temporary file for each input source file specified. This file creation may not be desirable when compiling multiple source files (see Section 2.1.6).

All other temporary files reside in `/tmp` , unless the environment variable `TMPDIR` is set to indicate an alternate directory.

# 3.57 -L --- Remove ld Directory Search Path

Use the `-l` option to prevent the linker from searching for libraries in the standard directories (see Section 3.58).

# 3.58 -Ldir --- Add Directory to ld Search Path

Use the `-ldir` option to specify the directory path dir as a search directory for `ld` , which is searched before the standard directories.

When you specify the `-non_shared` option, the following directories are searched:

- `/lib`
- `/usr/lib`
- `/usr/local/lib`

When searching for shared libraries ( `-call_shared` or `-shared` ), the following directories are searched:

- `/usr/shlib`
- `/usr/ccs/lib`
- `/usr/lib/cmplrs/cc`
- `/usr/lib`
- `/usr/local/lib`

# 3.59 -lstring --- Add Library Name to ld Search

Use the `-lstring` option to specify additional search libraries for `ld` , using `string` as an abbreviation of the library name.

Using this option causes `ld` to search for unresolved references to run-time object files in the specified libraries, in addition to the appropriate Compaq Fortran libraries and related libraries (see Section 2.5.1).

This option should be placed after the file name(s) at the end of the command line.

You can use `-lstring` multiple times to specify multiple search libraries. The order in which the multiple libraries are specified determines the search order used by `ld` .

For example, specifying `-lgraph` causes `ld` to search the standard library directories (and any specified using the `-ldir` option) for the library `libgraph` .

To view libraries accessed during compile and link operation, use the `-v` option, described in Section 3.96.

For More Information:

- On the standard directories searched by `ld` , see Section 3.58.
- On the standard list of library names searched when using the `f90` command, see Section 2.5.1.
- On recognized file name suffix characters and their meanings, see Section 2.1.1.
- On specifying and using archive or shared libraries, see Section 2.5.
- On requirements and other information related to creating a shared library, see Section 2.6.

# 3.60 -machine_code

See Section 3.82, -show keyword, -machine_code --- Control Listing File Content.

# 3.61 -math_library keyword --- Fast or Accurate Math Library Routines

The `-math_library keyword` option lets you choose which math library routines to use.

The default is `-math_library accurate` .

The following options apply:

> ### -math_library accurate

> Specifies that the compiler is to select the version of the math library routine that provides the most accurate result for mathematical intrinsic functions.

> For certain ranges of input values, the selected routine may execute more slowly than if you used `-math_library fast` .

> 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 `-fpen` option and the `for_set_fpe` routine.

> ### -math_library fast

> Specifies that the compiler is to select the version of the math library routine that provides the highest execution performance for certain mathematical intrinsic functions, such as EXP and SQRT.

> For certain ranges of input values, the selected routine may not provide a result that is as accurate as `-math_library accurate` provides.

> This option is set by default if you use the `-fast` option.

> 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 `-fpen` option and calls to the `for_set_fpe` routine are 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 type1 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 Compaq Tru64 UNIX operating system in use. Allowed error bounds vary with each routine.

For More Information:

- On controlling arithmetic exception handling, including using the `-fpen` option, see Section 3.44 and Chapter 14.
- On requesting double-precision data during compilation for REAL data declarations ( `-real_size` option), see Section 3.78.
- On native IEEE floating-point formats, see Section 9.4.

Note #### 1 Single-precision S_float, double-precision T_float, and extended precision X_float data types provide 24, 53, and 113 bits respectively for the normalized fractional part (see Section 9.4.)

# 3.62 -mixed_str_len_arg --- Specify Length of Character Arguments

Use the `-mixed_str_len_arg` option to tell the compiler that the hidden length passed for a character argument is to be placed immediately after its corresponding character argument in the argument list.

The default is `-nomixed_str_len_arg` , which places the hidden lengths in sequential order at the end of the argument list.

# 3.63 -module directory --- Specify Directory for Creating Modules Files

The `-module directory` option tells the compiler to create module files in the specified `directory` instead of the current directory.

# 3.64 -mp --- Enable Parallel Processing Using Directed Decomposition

Use the `-mp` option (TU*X ONLY) to enable parallel processing using directed decomposition. Parallel processing is directed by inserting parallel directives using the !$PAR prefix in your source code. The compiler recognizes these directives only if you specify the `-mp` option. This kind of parallel processing is intended for shared-memory multiprocessor systems.

To enable parallel processing with with !$OMP directives, use the `-omp` compiler option.

To enable parallel processing across clusters of servers or workstations with !HPF$ directives, use the `-hpf` compiler option.

The `-mp` option sets the `-automatic` option.

The default is `-nomp` .

For More Information:

- See Chapter 6, Parallel Compiler Directives and Their Programming Environment.
- See the Compaq Fortran Language Reference Manual.
- See Section 3.74.
- See Section 3.50.

# 3.65 -names keyword --- Case Control of Source and External Names

The `-names keyword` option controls how the case sensitivity of letters in source code identifiers and external names is handled.

The naming convention applies whether names are being defined or referenced.

The default is `-names lowercase` .

The following options apply:

> ### -names as_is, -U

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

> The `-names as_is` and `-u` options are synonymous.

> ### -names lowercase

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

> ### -names uppercase

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

# 3.66 -noaltparam --- Alternative PARAMETER Syntax

Use the `-noaltparam` option to disallow the alternate nonstandard syntax for PARAMETER statements.

The nonstandard PARAMETER statement syntax is:

    PARAMETER par1=exp1 [, par2=exp2] ...

This 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 `-altparam` , which allows use of the nonstandard syntax.

# 3.67 -nofor_main --- Allow Non-Fortran Main Program

Use the `-nofor_main` option when the main program is not written in Fortran. For example, if the main program is written in C and calls a Compaq Fortran subprogram, specify `-nofor_main` when compiling the program with the `f90` command. Specifying `-nofor_main` prevents linking `for_main.o` into applications.

If you omit `-nofor_main` , the main program must be a Fortran program.

The default is `-for_main` .

# 3.68 -nohpf_main, -nowsf_main --- Compile HPF Global Routine for Nonparallel Main Program

(TU*X ONLY) Use the `-nohpf_main` option (the `-nowsf_main` option is synonymous) to specify that the HPF global routine being compiled will be linked with a main program that was not compiled with the `-hpf` option. The main program can be a Fortran program compiled without `-hpf` , or it can be written in an entirely different language.

# 3.69 -noinclude --- Omit Standard Directory Search for INCLUDE Files

Specifying `-noinclude` prevents the compiler from searching in the `/usr/include` directory for files specified in an INCLUDE statement. This option does not apply to the directories searched for module files or preprocessor `#include` files.

To request that the `cpp` preprocessor not search for `#include` files in the `/usr/include` directory, use the `-i` option (see Section 3.51).

# 3.70 -norun --- Do Not Run the Compiler

Specifing the `-norun` option directs the driver not to execute the compiler and other phases of the process. If you use this option with the `-v` option, described in Section 3.96, you can see what would have been executed.

The default is for the driver to execute the compiler and other phases of the process.

# 3.71 -o output --- Name Output File

When you specify `-c` with `-o` output, this names the object file output instead of `source-file-name.o` in the current working directory.

If you omit `-c` and specify `-o` output, this names the executable program file output instead of `a.out` in the current working directory.

An already existing `a.out` file is unaffected by this command.

For More Information:

- On output files and their names, see Section 2.1.5.
- On using multiple input files, see Section 2.1.6.

# 3.72 -O0, -O1, -O2, -O3, -O4 or -O, -O5 --- Specify Optimization Level

Use the `-o0` , `-o1` , `-o2` , `-o3` , `-o4` (same as `-o` ), and `-o5` options to specify the level of optimization performed during compilation.

The default level of optimization is `-o4` unless you specify the `-g2` , `-g` , or `-gen_feedback` option (in which case the default is `-o0` ).

At optimization levels lower than `-o4` , the compiler issues "uninitialized variable" warnings.

In most cases, the higher the level of optimization you specify, the faster the program will execute. However, the faster execution speeds that result from using `-o3` or higher usually produce larger object files and longer compile times.

The following options apply:

> ### -O0

> Disables all optimizations. Does not check for unassigned variables.

> If you specify `-g2` or `-g` , this is the default.

> ### -O1

> Enables local optimizations and recognition of common subexpressions. Optimizations include integer multiplication and division expansion using shifts. The call graph determines the order of compilation of procedures.

> ### -O2

> Enables global optimization and all `-o1` optimizations. This global optimization includes code motion, strength reduction and test replacement, split-lifetime analysis, code scheduling, and inlining of arithmetic statement functions.

> ### -O3

> Enables global optimizations that improve speed (at the cost of increased code size) and all `-o2` optimizations. Optimizations include:
> - Loop unrolling (also set by `-unroll` , described in Section 3.94)
> - Prefetching
> - Code replication to eliminate branches

> ### -O4, -O

> Enables interprocedure analysis and automatic inlining of small procedures (with heuristics limiting the amount of extra code), software pipelining (also set by `-pipeline` , described in Section 3.76), and all `-o3` optimizations.

> This is the default. However, if you specify `-g2` or `-g` or `-gen_feedback` , the default becomes `-o0` .

> ### -O5

> Enables loop transformation optimizations (also set by `-transform_loops` , described in Section 3.89), all `-o4` optimizations, and other optimizations, including byte vectorization and insertion of additional NOPs (No Operations) for alignment of multi-issue sequences. (See also Section 3.84.)

> To determine whether using `-o5` benefits your particular program, you should time program execution for the same program (or subprogram) compiled at levels `-o4` and `-o5` .

For More Information:

- On the effects of the `-o5` option, see Section 3.89 and Section 3.76.
- On limiting loop unrolling with optimization level `-o3` or higher ( `-unroll num` ), see Section 3.94.
- On speculative execution optimization, see Section 3.84.
- On timing program execution, see Section 5.2.
- On the related `-fp_reorder` option, see Section 3.12.
- On the related `-fast` option, see Section 3.40.
- On improving and measuring run-time performance, see Chapter 5.
- On the optimizations performed at each level, see Section 5.8.

# 3.73 -om --- Request Nonshared Object Optimizations

(TU*X ONLY) Use the `-om` option with the `-non_shared` option to request certain code optimizations after linking, including NOP (No Operation) removal, `.lita` removal, and reallocation of common symbols. This option also positions the global pointer register so the maximum addresses fall in the global-pointer window.

Pass `-om` options to the linker using the `-WL,arg` form:

- `-WL,-om_compress_lita`
  Removes unused `.lita` entries after optimization, and then compresses the `.lita` section.
- `-WL,-om_dead_code`
  Removes dead code (unreachable instructions) generated after applying optimizations. The `.lita` section is not compressed.
- `-WL,-om_no_inst_sched`
  Turns off instruction scheduling.
- `-WL,-om_no_align_labels`
  Turns off alignment of labels. Normally, the `-om` option aligns the targets of all branches on quadword boundaries to improve loop performance.
- `-WL,-om_Gcommon,num`
  Sets the size threshold of common symbols. Every common symbol whose size is less than or equal to num will be allocated close to each other. This option can be used to improve the probability that the symbol can be accessed directly from the global pointer register. Normally, `-om` tries to collect all common symbols together.

For more information, see your operating system documentation.

# 3.74 -omp --- Enable OpenMP Parallel Processing Using Directed Decomposition

(UN*X ONLY) Use the `-omp` option to enable parallel processing using directed decomposition following the OpenMP application program interface (API). Parallel processing is directed by inserting !$OMP directives in your source code. This kind of parallel processing is intended for shared-memory multiprocessor systems.

The !$OMP directives are described in Section 6.1.2, Summary Descriptions of OpenMP Fortran API Compiler Directives.

The `-omp` option sets the `-automatic` option.

The default is `-noomp` .

For More Information:

- Chapter 6, Parallel Compiler Directives and Their Programming Environment.
- See the Compaq Fortran Language Reference Manual.

# 3.75 -pad_source --- Pad Short Source Records with Spaces

For fixed-form source files, specify the `-pad_source` option to request that source records shorter than the statement field width are to be padded with spaces on the right, out to the end of the statement field. This affects the interpretation of character and Hollerith literals that are continued across source records.

The default is `-nopad_source` . This causes a warning message to be displayed if a character or Hollerith literal that ends before the statement field ends is continued onto the next source record. To suppress this warning message, specify the `-warn nousage` option.

Specifying `-pad_source` can prevent warning messages associated with `-warn usage` .

# 3.76 -pipeline --- Activate Software Pipelining Optimization

Specifying `-pipeline` (or `-o4` or `-o5` ) 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.

Software pipelining is a subset of the optimizations activated by `-o4` or `-o5` . Instead of specifying both `-pipeline` and `-transform_loops` , you can specify `-o5` .

This optimization is not performed at optimization levels below `-o2` .

You must specify `-nopipeline` if you want this type of optimization disabled and you are also specifying `-o4` or `-o5` .

For More Information:

- On details about using this option, see Section 5.8.6, Software Pipelining.
- On the `-o4` and `-o5` options, see Section 3.72.

# 3.77 -p0, -p1 or -p, and -pg --- Profiling Support

Nonparallel programs (with the `-hpf` option omitted) and (TU*X ONLY) parallel HPF programs ( `-hpf` option specified) use different profiling tools, which need different profiling options. Profiling information identifies those parts of your program where improving source code efficiency would most likely improve run-time performance.

If you omit the `-hpf` option, you can use the `prof` and `pixie` (TU*X ONLY) tools if you specify the `-p0` and `-p1` or `-p` options to control the level of profiling support provided during compilation. When you specify `-hpf` , omit the `-p0` , `-p1` , and `-p` options.

The default is `-p0` .

The following options apply:

> ### -p0

> Does not permit profiling. If loading occurs, the standard run-time startup routine `(crt0.o)` is used, and profiling libraries are not searched.

> ### -p1, -p

> Sets up profiling by periodically sampling the value of the program counter for use with the postprocessor `prof(1)`.

> This option only affects loading. When loading occurs, this option replaces the standard run-time startup routine option with the profiling run-time startup routine `(mcrt0.o)` and searches the level 1 profiling library ( `libprof1` ).

> When profiling occurs, the startup routine calls `monstartup(3)` and produces the file `mon.out` , which contains execution-profiling data for use with the postprocessor `prof(1)` command. (See also `monitor(3)`.)

> If you specify this option, you should also specify `-g1` or higher.

> ### -pg

> Sets up profiling for `gprof(1)`, which produces a call graph showing the execution of the program. With this option, the standard run-time startup routine is replaced by the `gcrt0.o` routine, and `ld(1)` inserts calls to `_mcount` at each entry label.

> When programs are linked with the `-pg` option and then run, these files produced:

> > `gmon.out` contains a dynamic call graph and profile.
> > `gmon.sum` contains a summarized dynamic call graph and profile.

> To display the output, run `gprof` on the `gmon.out` file.

For More Information:

- On using profiling tools `prof` and `pixie` (TU*X ONLY), see Section 5.3.
- On the `-gen_feedback` , `-feedback file` , and `-cord` options, (TU*X ONLY) see Section 3.41.

# 3.78 -real_size number, -r8, -r16 --- Floating-Point Data Size

Use these options to control the size of REAL and COMPLEX declarations that do not have an explicit KIND parameter or size specifier.

The default is `-real_size 32` .

The following options apply:

> ### -real_size 32

> Defines:
> - REAL declarations, constants, functions, and intrinsics as REAL*4
> - COMPLEX declarations, constants, functions, and intrinsics as COMPLEX*8

> ### -real_size 64, -r8

> Defines:
> - REAL declarations, constants, functions, and intrinsics as DOUBLE PRECISION (REAL*8)
> - COMPLEX declarations, constants, functions, and intrinsics as DOUBLE COMPLEX (COMPLEX*16)

> ### -real_size 128, -r16

> defines:
> - REAL and DOUBLE PRECISION declarations, constants, functions, and intrinsics as REAL*16
> - COMPLEX and DOUBLE COMPLEX declarations, constants, functions, and intrinsics as COMPLEX*32

If you omit `-real_size_64` and `-real_size 128` , then:

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

For More Information:

- On data types, see Chapter 9.
- On intrinsic functions, see the Compaq Fortran Language Reference Manual.

# 3.79 -recursive --- Request Recursive Execution

This option compiles all FUNCTION and SUBROUTINE procedures for possible recursive execution.

This option:

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

A subprogram declared with the RECURSIVE keyword is always recursive (whether you specify or omit the `-static` option).

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` options).

Specifying `-recursive` sets `-automatic` (puts local variables on the run-time stack).

The default is `-norecursive` .

# 3.80 -reentrancy keyword --- Control Use of Threaded Run-Time Library

(UN*X ONLY) The `-reentrancy keyword` option specifies whether code generated for the main program and any Fortran procedures it calls will be relying on threaded or asynchronous reentrancy.

To use the threaded libraries, also specify the `-threads` option (see Section 3.88).

The default is `-reentrancy none` . (The option `-noreentrancy` is the same as `-reentrancy none` .)

The following options apply:

> ### -reentrancy asynch

> Tells the Compaq Fortran run-time library (RTL) that the program may contain asynchronous handlers that could call the RTL. This causes the RTL to guard against asynchronous interrupts inside its own critical regions.

> ### -reentrancy none

> Tells the Compaq Fortran RTL that the program will not be relying on threaded or asynchronous reentrancy. Therefore, the RTL will not guard against such interrupts inside its own critical regions.

> ### -reentrancy threaded

> Tells the Compaq Fortran RTL that the program is multithreaded, such as programs using the POSIX threads library. This causes the RTL to use thread locking to guard its own critical regions.

# 3.81 -S --- Create Assembler File

Specifying `-s` creates an assembler file from the compiled source. The name of the assembler file is the base name of the source file with a `.s` file suffix. Linking does not occur.

# 3.82 -show keyword, -machine_code --- Control Listing File Content

Use the `-show keyword` options in conjunction with the `-v` option to control the amount of information in a listing file.

The following options apply:

> ### -show code, -machine_code

> Specifying `-show code` or `-machine_code` includes a machine-language representation of the compiled code if a listing file is being generated. This machine language cannot be assembled.

> The default is `-show nocode` or `-nomachine_code` .

> ### -show hpf

> (TU*X ONLY) When used with the `-hpf num` option, specifying `-show hpf` shows information about HPF parallelization. For more information, see Section 3.50.4, -show hpf --- Show HPF Parallelization Information.

> ### -show include

> Specifying `-show include` lists the contents of any text file specified with INCLUDE in the source file if a listing is generated.

> The default is `-show noinclude` .

> ### -show nomap

> Specifying `-show nomap` excludes information about the symbols used in the source program if a listing is generated.

> The default is `-show map` .

If you omit these options, the listing file contains the minimum amount of information.

For More Information:

- On requesting a listing file, see Section 3.95.
- On examples and explanations of the various listing options, see Appendix C.

# 3.83 -source_listing --- Create a Source Listing File

Specifying `-source_listing` tells the compiler to create a listing file of the source program. The file also contains compiler-generated information such as that specified by the `-v` option. The name of the listing file is the base name of the source file with a `.lis` suffix.

The default is `-nosource_listing` .

# 3.84 -speculate keyword --- Speculative Execution Optimization

Specifying the `-speculate all` option (TU*X ONLY) or the `-speculate by_routine` option (TU*X ONLY) requests the compiler to perform speculative execution optimization on all routines in the application.

Speculation occurs when a conditionally executed instruction is moved to a position before a test instruction so that the moved instruction is then executed unconditionally. This reduces instruction latency stalls to improve run-time performance for certain applications or routines.

Speculative execution affects code most noticeably at optimization level `-o3` and higher.

Performance improvements may be reduced because the run-time system must dismiss exceptions caused by speculative instructions. For certain applications, longer execution times may result. To determine whether using `-speculate all` or `-speculate by_routine` benefits your particular program, you should time program execution for the same program compiled with `-speculate by_routine` or `-speculate all` with `-speculate none` (default).

Any exception (for example, SIGSEGV, SIGBUS, or SIGFPE), anywhere in the entire program, is assumed to be speculative. All of these exceptions are quietly dismissed without calling any user-mode signal handler. If a module is compiled using `-speculate all` , it cannot be linked with any other module or library that does its own exception processing.

Since speculation turns off some run-time error checking, this option should not be used while debugging or while testing for errors.

The following options apply:

> ### -speculate all

> Perform speculative execution optimization on all routines in the program. All exceptions within the entire program are dismissed without calling any user-mode signal handler or reporting exceptions.

> If a compilation unit is compiled with `-speculate all` , then it may not be linked with any other object or library that does its own exception processing. Do not use `-speculate all` if your program does any of the following:

> - Generates any exceptional values other than underflow values
> - Uses a user-supplied signal handler
> - Was compiled with any of the `-check keyword` options

> ### -speculate by_routine

> Specifies that speculative execution optimization should be performed on all routines in the current compilation unit (set of routines being compiled). However, other compilation units in the application will not be affected.

> All exceptions within the routines being compiled with `-speculate by_routine` are quietly dismissed without calling any user-mode signal handler, but the object files created can be linked with other objects or libraries that perform exception processing. For example, using `-speculate by_routine` allows the Compaq Fortran Run-Time Library to report exceptions.

> ### -speculate none, -nospeculate

> Suppresses all speculative execution optimization.

> The `-speculate none` and `-nospeculate` options are synonymous.

> This is the default.

# 3.85 -std, -std90, -std95 --- Perform Fortran Standards Checking

Use these options to request that the compiler produce warnings for syntax that is not standard in the language.

If your command line includes any of these options, then the compiler ignores `-align dcommons` and `-align sequence` .

The default is `-nostd` .

The options are:

> ### -std

> Produces warnings for things that are not standard.

> When `-std` is specified, the compiler being used determines the standard checked.

> For example, on Tru64 UNIX systems, the Compaq Fortran compiler recognizes the following equivalencies:

> > `f95 -std` is the same as `f90 -std95`
> > `f90 -std` is the same as `f90 -std90`

> On Linux systems, the Compaq Fortran compiler recognizes the following equivalency:

> > `fort -std` is the same as `fort -std95`

> 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 `-std` option.

> Given these circumstances, the compiler is able to detect most instances of nonconforming usage. It does not detect all instances because the `-std` options do 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

> On Tru64 UNIX systems only, the `-std` options interact with the `-hpf` option (requests generation of parallel HPF code) as follows:

> - If you omit both `-std` and `-hpf` , HPF directives are checked, but not processed.
> - If you omit `-std` and specify `-hpf` , HPF directives are checked and processed.
> - If you specify `-std` and omit `-hpf` , HPF directives are ignored (treated as comments and not checked).

> You should not specify both `-std` and `-hpf` .

> ### -std90

> Produces warnings for things that are not standard in the Fortran 90 language. This includes:
> - 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.

> ### -std95

> Produces warnings for things that are not standard in the Fortran 95 language. This includes all the checks performed by the `-std90` option with the following exceptions:
> - The FORALL statement is part of Fortran 95; thus it is not flagged as an extension by the `-std95` option
> - User-defined PURE functions are part of Fortran 95; thus they are also not flagged as extensions.
> - The following features that were obsolescent in F90 are deleted in Fortran 95 ( `-std95` flags them as deleted) but the Compaq Fortran compiler fully supports them:
>   - REAL and DOUBLE PRECISION DO variables
>   - Branching to an ENDIF statement from outside the paired IF statement
>   - PAUSE statement
>   - ASSIGN statement, assigned GOTO, and assigned FORMAT statements
>   - H edit descriptor

For More Information:

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

# 3.86 -synchronous_exceptions --- Report Exceptions More Precisely

This option causes the compiler to generate TRAPB instructions after every floating-point instruction, resulting in precise exception reporting.

To use this option, you must also enable `-fpe0` .

This is a very expensive but effective way to synchronize the instruction stream containing floating-point exceptions so the failing instruction can be accurately located by the debugger or a handler. You should use this option only when debugging a specific problem, such as locating the source of an exception.

If you omit the `-synchronous_exceptions` option and `-fpe0` is in effect, exceptions can be reported one or more instructions after the instruction that caused the exception. If you specify `-fpe1` , `-fpe2` , `-fpe3` , or `-fpe4` , exceptions are reported precisely (this is the same as specifying `-synchronous_exceptions` ).

The default is `-nosynchronous_exceptions` .

# 3.87 -syntax_only --- Do Not Create Object File

The `-syntax_only` option specifies that the source file will be checked only for correct syntax. 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).

This option lets you do a quick syntax check of your source file.

The default is `-nosyntax_only` .

# 3.88 -threads, -pthread --- Link Using Threaded Run-Time Library

(UN*X ONLY) Specifying the `-threads` or `-pthread` option (they are synonymous) requests that the linker use threaded libraries. This is usually used with the `-reentrancy threaded` option (see Section 3.80).

# 3.89 -transform_loops --- Activate Loop Transformation Optimizations

Specifying `-transform_loops` (or `-o5` ) 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 multiply nested loops.

The loop transformation optimizations are a subset of optimizations activated by `-o5` . Instead of specifying both `-pipeline` and `-transform_loops` , you can specify `-o5` .

To determine whether using `-transform_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 `-transform_loops` and `-notransform_loops` ).

For More Information:

- On the `-o5` option, see Section 3.72.
- On loop transformations, see Section 5.8.7, Loop Transformation.

# 3.90 -tune keyword --- Specify Alpha Processor Implementation

Use the `-tune keyword` option to specify the types of processor-specific instruction tuning for implementations of the Alpha architecture.

Regardless of the setting of `-tune keyword` option 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 Alpha processor may run more slowly on another Alpha processor.

If you omit `-tune keyword` , `-tune generic` is used.

When `-arch name` is specified and no `-tune` is specified, the following occurs: if `-fast` is specified, then `-tune` is host and `-arch` is name; if `-fast` is not specified, then both `-tune` and `-arch` are name.

If you set `-tune` to an architecture that has fewer features than what `-arch` specifies, the compiler will reset `-tune` to the same architecture as `-arch` .

The following options apply:

> ### -tune generic

> Generates and schedules code that will execute well for all implementations of the Alpha architecture. This provides generally efficient code for those cases where different processor generations are likely to be used.

> This is the default.

> ### -tune host

> Generates and schedules code optimized for the implementation of the Alpha architecture in use on the system being used for compilation.

> ### -tune ev4

> Generates and schedules code optimized for the 21064, 21064A, 21066, and 21068 implementations of the Alpha architecture.

> ### -tune ev5

> Generates and schedules code optimized for the 21164 implementation of the Alpha chip. This implementation of the Alpha architecture is faster and more recent than the implementations of the Alpha architecture associated with `-tune ev4` (21064, 21064A, 21066, and 21068).

> ### -tune ev56

> Generates and schedules code optimized for some 21164 Alpha architecture implementations that use the byte and word manipulation instruction extensions of the Alpha architecture.

> ### -tune pca56

> Generates and schedules code optimized for the 21164PC Alpha architecture implementation that uses the byte and word manipulation instruction extensions and multimedia instruction extensions.

> ### -tune ev6

> Generates and schedules code optimized for the 21264 Alpha architecture implementations that use the byte and word manipulation instruction extensions, multimedia instruction extensions, and square root and floating-point convert extensions.

> ### -tune ev67

> Generates and schedules code optimized for the 21264A Alpha architecture implementations that use the byte and word manipulation instruction extensions, multimedia instruction extensions, square root and floating-point convert extensions, and count extensions.

For More Information:

- On improving and measuring run-time performance, see Chapter 5.

# 3.91 -U --- Activates Case Sensitivity

This option causes the compiler to distinguish between uppercase and lowercase letters in identifiers and external names.

The `-u` option and `-names as_is` option are synonymous.

# 3.92 -Uname --- Undefine Preprocessor Symbol Name

Specifying `-uname` tells `-cpp` to remove the definition of name, such as a predefined symbol. Predefined preprocessor symbols are defined in Section 3.31.

# 3.93 -u

This option causes the compiler to produce messages about undeclared symbols.

The `-u` option is the same as `-warn declarations` .

# 3.94 -unroll num --- Specify Number for Loop Unroll Optimization

The `-unroll num` option sets the depth of loop unrolling done by the optimizer to `num` . `num` must be an integer in the range 0 through 16.

Specify this option only with `-o3` or higher optimization levels, at which loop unrolling occurs.

If you omit `-unroll num` or specify `-unroll 0` , the optimizer determines how many times loops are unrolled. Unless you specify a value, the optimizer will choose an unroll amount that minimizes the overhead of prefetching while also limiting code size expansion.

The option `-nounroll` is not allowed.

For More Information:

- On loop unrolling optimization, see Section 5.8.4.1.
- On software pipelining, which is related to loop unrolling, see Section 3.76.
- On options related to optimization levels, see Section 3.72.

# 3.95 -V --- Create Listing File

Specifying `-v` creates a listing of the source file with various compile-time information appended. The name of the listing file is the base name of the file with the `.l` suffix.

A file name whose suffix is `.l` may conflict with `lex` . If you want the listing file to have the suffix `.lis` , then use the option `-source_listing` .

If you expect your program to get compilation errors, use `-v` to request a separate listing file or use the `error` command to insert the error messages into the appropriate place in your source program.

Using a listing file provides slightly more information and includes the column pointer (1) that indicates the exact part of the line that caused the error. Especially for large files, consider obtaining a printed copy of the listing file you can reference while editing the source file.

If you use `-v` without other options (such as `-show code` ), the listing file will not show the code of included source files or machine code and will not include a cross-reference table.

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 source files are replaced by a space character, and a warning message appears.

If you compile several source files together and specify `-v` , a single listing file (using the name of the first input file) is created.

If you compile several source files one at a time and specify `-v` , multiple listing files are created.

The default is `-nov` .

For More Information:

- On the options that control the contents of the listing file, see Section 3.82.
- On sample listing file content, see Appendix C.

# 3.96 -v --- Verbose Command Processing Display

Specifying `-v` displays the preprocessor (if requested), compiler, and linker passes as they execute, with their arguments and their input and output files, as well as final resource usage in the C shell `time` command format. The Compaq Fortran compiler is `decfort90` , the C compiler is `cc` on Tru64 UNIX systems but `ccc` on Linux systems, the linker is `ld` , and so forth.

The default is `-nov` , which does not display any command processing information.

# 3.97 -version, -what --- Show Compaq Fortran Version Information

Specifying the `-version` (or `-what` ) option prints the version information of the Fortran driver and compiler.

If `-version` appears alone on the command line, the compiler is not executed.

The default is `-noversion` .

# 3.98 -vms --- OpenVMS Fortran Compatibility

Specifying `-vms` causes the run-time system to behave like Compaq Fortran on OpenVMS Alpha systems and VAX systems (VAX FORTRAN) in the following ways:

- Certain defaults
  In the absence of other options, `-vms` sets the `f90` defaults as `-check format` and `-check output_conversion` .
- Alignment
  The `-vms` option does not affect the alignment of fields in records or items in common blocks. Use `-align norecords` to pack fields of records on the next byte boundary for compatibility with Compaq Fortran on OpenVMS systems.
- Carriage control default
  If `-vms -ccdefault default` is specified, carriage control defaults to FORTRAN if the file is formatted and the unit is connected to a terminal. See Section 3.21.
- INCLUDE qualifiers
  /LIST and /NOLIST are recognized at the end of the file name in an INCLUDE statement at compile time (see Section 2.1.4).
  If the file name in the INCLUDE statement does not specify the complete path, the path used is the current directory.
  Note that if `-vms` is not specified, the path used is the directory where the file that contains the INCLUDE statement resides.
- Quotation mark character
  A quotation mark (") character is recognized as starting an octal constant ("0..7) instead of a character literal ("...").
- Deleted records in relative files
  When a record in a relative file is deleted, the first byte of that record is set to a known character (currently `'` @ `'` ). Attempts to read that record later result in ATTACCNON errors. The rest of the record (the whole record, if `-vms` is not specified) is set to nulls for unformatted files and spaces for formatted files.
- ENDFILE records
  When an ENDFILE is performed on a sequential unit, an actual 1-byte record containing a Ctrl/Z is written to the file. If `-vms` is not specified, an internal ENDFILE flag is set and the file is truncated.
  The `-vms` option does not affect ENDFILE on relative files: these files are truncated.
- Implied logical unit numbers
  The `-vms` option enables Compaq Fortran to recognize certain environment variables at run time for ACCEPT, PRINT, and TYPE statements and for READ and WRITE statements that do not specify a unit number (such as READ (*,1000)). See Section 7.5.7, Using Environment Variables.
- Treatment of blanks in input
  The `-vms` option causes the defaults for the keyword `BLANK` in OPEN statements to become `'` NULL `'` for an explicit OPEN and `'` ZERO `'` for an implicit OPEN of an external or internal file. For more information, see the description of the OPEN statement in the Compaq Fortran Language Reference Manual.
- OPEN statement effects
  Carriage control defaults to FORTRAN if the file is formatted, and the unit is connected to a terminal (checked by means of `isatty(3)` ). Otherwise, carriage control defaults to LIST.
  The `-vms` option affects the record length for direct access and relative organization files. The buffer size is increased by 1 to accommodate the deleted record character.
- Reading deleted records and ENDFILE records
  The run-time direct access READ routine checks the first byte of the retrieved record. If this byte is `'` @ `'` or NULL ("\0"), then an ATTACCNON error is returned.
  The run-time sequential access READ routine checks to see if the record it just read is one byte long and contains a Ctrl/Z. If this is true, it returns EOF.

The default is `-novms` .

For More Information:

- On alignment, see Section 3.3 and Section 5.4.

# 3.99 -Wl,-xxx --- Pass Specified Option to ld

The `-Wl,-xxx` option allows you to pass an option (specified by -xxx) directly to the `ld` linker.

For example, to set the linker `-taso` option (TU*X ONLY) to help port 32-bit programs that assume addresses can be stored into 32-bit variables, specify:

`-wl,-taso`

If the -xxx option takes an argument yyy, include yyy after the option separated by a comma.

For example:

`-wl,-xxx,yyy`

results in the passing of

`-xxx yyy`

to `ld` .

For another example, if you want to specify the linker option -VS 3, then a possible command is:

    % f90 -Wl,-VS,3 test123.f90

For More Information:

On linker options, see `ld(1)`.

# 3.100 -warn keyword, -u, -nowarn, -w, -w1 --- Warning Messages and Compiler Checking

You can prevent the display of some or all warning messages and request that additional compile-time checking be performed (can issue additional warning messages):

- The following options prevent the display of warning messages:

  > `-warn noalignments`
  > `-warn nogeneral`
  > `-warn nouncalled`
  > `-warn nouninitialized`
  > `-warn nounused`
  > `-warn nousage`
  > `-nowarn`
  > `-w`

- The `-warn declarations` (or `-u` ) and `-warn argument_checking` options request that additional checking be performed and can display additional warning messages.

If you specify `-syntax_only` , some warning options are ignored (see Section 3.87).

The following options apply:

> ### -warn noalignments

> Disables warning messages about data that is not naturally aligned.

> The default is `-warn alignments` .

> To control alignment of common blocks, derived-type structures, and record structures, specify the `-align keyword` options.

> ### -warn argument_checking

> Enables warnings about mismatched procedure arguments. Specifying `-warn argument_checking` applies to calls with an implicit interface (such as routines declared as EXTERNAL).

> The default is `-warn noargument_checking` .

> When an explicit interface is present between calling and called procedures, warning messages about argument mismatches are reported whether or not you specify `-warn argument_checking` .

> ### -warn declarations, -u

> Sets the default type of a variable as undefined (IMPLICIT NONE), which enables warnings about any undeclared symbols. This behavior differs from default Fortran 95/90 rules.

> The default is `-warn nodeclarations` .

> ### -warn nogranularity

> Disables warnings when the compiler cannot generate code for a requested granularity.

> The default is `-warn granularity` .

> ### -warn hpf

> (TU*X ONLY) Tells the compiler to do both syntax and semantics checking on HPF directives.

> The default vis `-warn nohpf` , unless `-hpf` is specified, in which case `-warn hpf` is assumed.

> ### -warn ignore_loc

> Enables warnings when `%loc` is stripped from an argument.

> The default is `-warn noignore_loc` .

> ### -warn truncated_source

> Enables warnings at compile time about source characters to the right of column 72 (or column 132 if `-extend_source` is specified) in a non-comment line.

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

> This option does not apply to free-format source files.

> The default is `-warn notruncated_source` .

> ### -warn nouninitialized

> Disables warning messages for a variable used before a value could be assigned to it.

> The default is `-warn uninitialized` .

> ### -warn nogeneral, -nowarn, -w

> Disables all warning messages.

> The default is `-warn general` , which enables all warning messages.

> The options `-warn nogeneral` , `-nowarn` , and `-w` are synonymous.

> ### -warn nouncalled

> Disables warning messages about a statement function that is never called.

> The default is `-warn uncalled` .

> ### -warn unused

> Requests warning messages for variables that are declared but not used.

> The default is `-warn nounused` or `-w1` , which are synonymous.

> ### -warn nousage

> Disables warning messages about questionable programming practices which, although allowed, are often the result of programming errors. Examples are a continued character or Hollerith literal whose first part ends before the statement field and appears to end with trailing spaces.

> The default is `-warn usage` .

# 3.101 -warning_severity keyword --- Elevate Severity of Warning Messages

Use this option to elevate warning-level messages to error-level status.

The default is `-warning_severity warning` , which leaves all compiler warning messages at warning-level status.

The following options apply:

> ### -warning_severity error

> Turns all compiler warning-level messages into error-level messages.

> ### -warning_severity stderror

> Turns all standards-checking compiler warning-level messages into error-level messages.

> Standards checking is enabled when the `-std` option is specified.

# 3.102 -what

`-what` is the same as `-version` . See Section 3.97.

# 3.103 -wsf

`-wsf` is the nonpreferred spelling of `-hpf` . See Section 3.50.

Previous | Next | Contents | Index