Enables or disables the listing. setting can be either ON or OFF. The default is OFF.

This option is enabled when any other -FLIST:... options are enabled, but it can also be used to enable a listing when no other options are enabled.

Sets ANSI format. setting can be either ON or OFF. When set to ON, the compiler uses a space (instead of tab) for indentation and a maximum of 72 characters per line. The default is OFF.

Writes prefetch information, as comments, in the transformed source file. setting can be either ON or OFF. The default is OFF.

In the listing, PREFETCH identifies a prefetch and includes the variable reference (with an offset in bytes), an indication of read/write, a stride for each dimension, and a number in the range from 1 (low) to 3 (high), which reflects the confidence in the prefetch analysis. prefetch identifies the reference(s) being prefetched by the PREFETCH descriptor. The comments occur after a read/write to a variable and note the identifier of the PREFETCH-spec for each level of the cache.

Controls whether or not code written to listings and intermediate files is written using OpenMP Fortran API directives. setting can be either ON or OFF. The default is ON.

When ON is in effect, which is the default, all generated files are written using OpenMP directives. When OFF is in effect, all generated files are written using the outmoded MIPS multiprocessing directives.

Writes the program to file. By default, the program is written to file.w2f.f.

Sets the maximum line length to n characters.

Writes the input and output filenames to stderr. setting can be either ON or OFF. The default is ON.

Determines heap or stack allocation. If the size of an automatic array or compiler temporary variable exceeds size bytes, it is allocated on the heap instead of the stack. If size is -1, objects are always put on the stack. If size is 0, objects are always put on the heap. The default is -1, which allows for maximum performance and for compatibility with previous releases.

Controls whether or not a minus sign (-) is written for negative zero. Specify either ON or OFF for setting. The default is OFF, which suppresses the minus sign. The minus sign is suppressed by default to prevent problems from hardware instructions and optimizations that can return a -0.0 result from a 0.0 value.

Invokes the language option control group to control recursion support. setting can be either ON or OFF. The default is OFF.

In either mode, the compiler supports a recursive, stack-based calling sequence. The difference lies in the optimization of statically allocated local variables, as follows:

Writes or suppresses the listing file. Specify ON or OFF for setting.

If one or more -LIST options are enabled, the listing file is written. By default, the listing file contains a list of compiler options in effect during compilation.

Writes or suppresses the list of all supported options in the listing file. Specify ON or OFF for setting. The default is OFF.

Writes or suppresses notes regarding various optimization phases in the assembly listing file (file.s). Must be specified in conjunction with -S. Specify ON or OFF for setting. The default is ON.

Writes or suppresses a listing of the compiler options in effect during compilation in the listing file. Specify ON or OFF for setting. The default is OFF.

Writes or suppresses a listing of the internal compiler symbol tables used in the compilation in the listing file. Specify ON or OFF for setting. The default is OFF.

The following sections describe the general options.

      PROGRAM FRED
      REAL A(1000,100)
      COMMON A
!$OMP PARALLEL DO PRIVATE (I,J)
      DO I=1,N
        DO J=1,N
          A(J,I) = 0.0
        END DO
      END DO
      END

      SUBROUTINE SUB(N)
      COMMON/BLK/A(1000),B(1000),C(1000),INDEX(1000)
      DO J = 1,N
        IF(A(J) .EQ. B(J)) THEN
            C(J) = SQRT(A(J))
        END IF
      END DO
      END

        INC = 0
        DO J = 1, N
          ITEMP(INC + 1) = J
          IF(A0(J) .EQ. B0(J)) THEN
            INC = INC + 1
          ENDIF
        END DO
        DO IND_0 = 0, INC_0 + -1
          J_TMP = ITEMP(IND_0 + 1)
          C0(J_TMP) = SQRT(A0(J_TMP))
        END DO

IF ((work_per_processor(N, P) + parallel_overhead) < total_work_in_loop(N)) THEN
   perform parallel execution
   ELSE
      perform serial execution
   END IF 

The loop transformation options described in the following sections allow you to control cache blocking, loop fission, loop fusion, loop unrolling, and loop interchange.

DO I ...
   DO J1 ...
      ...
   ENDDO
   DO J2 ...
      ...
   ENDDO
ENDDO

DO I1 ...
   DO J1 ...
      ...
   ENDDO
ENDDO
DO I2 ...
   DO J2 ...
      ...
   ENDDO
ENDDO

DO I = 1,N
   DO J = 1,N
      A(I,J) = B(I,J) + B(I,J-1) + B(I,J+1)
   END DO
END DO
DO I = 1,N
   DO J = 1,N
      B(I,J) = A(I,J) + A(I,J-1) + A(I,J+1)
   END DO
END DO

DO I=1,N
   A(I,1) = B(I,0) + B(I,1) + B(I,2)
   DO J = 2,N
      A(I,J) = B(I,J) + B(I,J-1) + B(I,J+1)
      B(I,J-1) = A(I,J-2) + A(I,J-1) + A(I,J)
   END DO
   B(I,N) = A(I,N-1) + A(I,N) + A(I,N+1)
END DO

      DO I = 1,N     ! loop 1
        . . .
      END DO

      DO I = 1,N-1     ! loop 2
        . . .
      END DO

DO I ...
   DO J ...
      DO K ...
         A(J,K) = A(J, K) + B(I,K)
      END DO
   END DO
END DO

DO K ...
   DO J ...
      DO I ...
         A(J,K) = A(J,K) + B(I,K)
      END DO
   END DO
END DO

DO I = 1,N
   DO J = 1,N
      A(J,I) = A(J,I) + B(J)
   END DO
END DO

DO I = 1,N-1,2
   DO J = 1,N
      A(J,I) = A(J,I) + B(J)
      A(J,I+1) = A(J,I+1) + B(J)
   END DO
END DO
DO I = I,N        ! This nest computes remaining iterations.
   DO J = 1,N     ! This is the wind down loop.
      A(J,I) = A(J,I) + B(J)
   END DO
END DO

LNO does several transformations, such as blocking and loop interchange, to improve the cache behavior of programs. When performing these transformations, LNO assumes that the target platform has certain cache characteristics. The following sections describe suboptions that allow you to change the default cache characteristics, thereby giving finer control over the optimizations that LNO performs.

The cache memory management options allow you to tune up to four aspects of the memory hierarchy on your system. For example, these four levels could include level 1 cache, level 2 cache, the TLB, and main memory.

The numbering in these arguments starts with the cache level closest to the processor and works outward.

hinv -c memory | grep Secondary

The following options control the TLB. The TLB is a cache for the page table. Blocking for the TLB can improve cache performance. The following sections describe options that control how the loop nest optimizer models the TLB when performing transformations. The TLB hardware is assumed to be fully associative.

The following options control use of the prefetch operation. When an LNO prefetch option is enabled, the compiler examines the source code for memory references that can cause cache misses. It then inserts prefetches into the generated code so that the prefetches are performed ahead of the corresponding memory references.

The -mips4 and -r10000 (or -r12000) options must be in effect in order for the LNO prefetch options to be recognized.

Enables or disables run time consistency checks across procedure boundaries when passing reshaped arrays (or portions thereof) as actual arguments. Specify ON or OFF for setting. The default is check_reshape=OFF.

Enables or disables autocloning. Specify ON or OFF for setting. The compiler automatically duplicates procedures that are called with reshaped arrays as actual arguments for the incoming distribution. If you have explicitly specified the distribution on all relevant dummy arguments, you can disable autocloning. The consistency checking of the distribution between actual and dummy arguments is not affected by this option and is always enabled. The default is clone=ON.

For more information on regular and reshaped distribution, see Chapter 5, “Parallel Processing on Origin Series Systems”.

Enables or disables recognition of the Origin series distributed shared memory directives described in Chapter 5, “Parallel Processing on Origin Series Systems”. These directives begin with a !$ prefix and are outmoded.

Specify ON or OFF for setting. When the -mp option is also in effect, the default is dsm=ON. When the -mp option is not in effect, the default is dsm=OFF.

---

Note: The Origin series distributed shared memory directives that begin with the !$ prefix are outmoded. Silicon Graphics and Cray Research encourage you to write new codes using the Silicon Graphics directives that are extensions to OpenMP Fortran API. The OpenMP extension directives begin with the !$SGI prefix and are otherwise identical to the Origin series distributed shared memory directives.

---

The effects of this option when used in conjunction with -mp are as follows:

When the -mp option is specified on the f90(1) command line, the compiler silently generates bookkeeping information in the rii_files directory. This information is used to implement data distribution directives, as well as perform consistency checks of these directives across multiple source files. To disable the processing of the data distribution directives and not generate the rii_files, compile the program with the -MP:dsm=off option.

Enables or disables recognition of the Silicon Graphics multiprocessing directives described in Appendix D, “Multiprocessing Directives (Outmoded)”, and the Origin series distributed shared memory directives described in Chapter 5, “Parallel Processing on Origin Series Systems”, that begin with a !$ prefix. These directives are the loop-level multiprocessing directives (including those for Origin series systems) and the PCF directives. These directives begin with a !$ or !$PAR prefix.

Specify ON or OFF for setting. The default is ON.

---

Note: The Silicon Graphics multiprocessing directives are outmoded. Their preferred alternatives are the OpenMP Fortran API directives described in Chapter 4, “OpenMP Fortran API Multiprocessing Directives”.

---

The effects of this option when used in conjunction with -mp are as follows:

Enables or disables recognition of the OpenMP Fortran API multiprocessing directives described in Chapter 4, “OpenMP Fortran API Multiprocessing Directives”, and the Silicon Graphics extensions to OpenMP described in Chapter 5, “Parallel Processing on Origin Series Systems”. These directives begin with a !$OMP or a !$SGI prefix.

Specify ON or OFF for setting. The default is ON.

The effects of this option when used in conjunction with -mp are as follows:

Specifies the pointer aliasing model to be used. By specifying one of the following for name, the compiler is able to make assumptions throughout the compilation:

Converts SIN/COS pairs with the same argument to a single call that calculates both values at once. Specify ON or OFF for setting. The default is cis=ON.

Instructs the compiler to ignore all dependencies when an IVDEP directive is encountered. Specify ON or OFF for setting. The default is OFF.

For more information on the IVDEP directive, see “Ignore Vector Dependencies: IVDEP” in Chapter 6.

Enables or disables the calculation of x/y as x× (1.0/y). Specify ON or OFF for setting. The default is div_split=OFF.

This is enabled by the -OPT:IEEE_arithmetic=3 option. Also see the -OPT:recip option. This option should be used with caution because it produces less accurate results.

fast_bit_intrinsics=ON turns off the check for the bit count being within range for Fortran bit intrinsics (for example, BTEST and ISHFT). Specify ON or OFF for setting. The default is fast_bit_intrinsics=OFF.

fast_complex=ON enables fast calculations for values declared as type complex. When set to ON, complex absolute value (norm) and complex division calculations use fast algorithms that can cause overflow for an operand (divisor, in the case of division) that has an absolute value that is larger than the square root of the largest representable floating-point number (or underflow for a value that is smaller than the square root of the smallest representable floating point number).

Specify ON or OFF for setting. The default is fast_complex=OFF. fast_complex=ON is enabled if -OPT:roundoff=3 is in effect.

fast_exp=ON optimizes exponentiation by replacing the run-time call for exponentiation by multiplication and/or square root operations for certain compile-time constant exponents (integers and halves). This can produce results that are rounded differently than the run-time routine. fast_exp=ON is in effect unless -OPT:roundoff=1 is in effect.

Specify ON or OFF for setting. The default is fast_exp=ON.

fast_nint=ON uses hardware features to implement NINT and ANINT (both single- and double-precision versions). Specify ON or OFF for setting. The default is fast_nint=OFF, but fast_nint=ON is enabled by default if -OPT:roundoff=3 is in effect. fast_nint=ON is also enabled when fast_trunc=ON is in effect.

When fast_nint=ON is in effect, rounding is performed according to the IEEE standard rather than the Fortran standard. For example, the Fortran standard requires that NINT(1.5)=2 and NINT(2.5)=3. The IEEE standard, however, rounds both of these to 2.

fast_sqrt=ON calculates square roots using the identity sqrt(x)=x*rsqrt(x), where rsqrt is the reciprocal square root operation. Specify ON or OFF for setting. The default is OFF.

The -mips4 and -r8000 options must be in effect in order for -OPT:fast_sqrt to be recognized.

---

Warning: This option results in sqrt(0.0) producing a NaN result. Use it only when zero sqrt operands are not valid.

---

fast_trunc=ON inlines the NINT, ANINT, AINT, and AMOD Fortran intrinsics, both single- and double-precision versions. Specify ON or OFF for setting. The default is fast_trunc=OFF. fast_trunc=ON is enabled automatically if -OPT:roundoff=1 (or greater) is in effect.

Although fully compliant with the Fortran standard, fast_trunc=ON reduces the valid argument range somewhat.

If fast_trunc=ON is in effect, fast_nint=ON is also enabled.

fold_reassociate=ON allows optimizations involving reassociation of floating-point quantities. Specify ON or OFF for setting. The default is fold_reassociate=OFF. fold_reassociate=ON is enabled automatically when -O3 is in effect or when -OPT:roundoff=2 or greater is in effect.

fold_unsafe_relops=ON folds relational operators in the presence of possible integer overflow. Specify ON or OFF for setting. The default is fold_unsafe_relops=ON.

fold_unsigned_relops=ON folds unsigned relational operators in the presence of possible integer overflow. Specify ON or OFF for setting. The default is fold_unsigned_relops=OFF.

got_call_conversion=ON loads function addresses to be moved out of loops. The load is set up with the proper relocation so that the address is resolved at program start-up time. Specify ON or OFF for setting. got_call_conversion=OFF is the default when -O2 or lower is in effect. got_call_conversion=ON when -O3 is in effect.

---

Note: This option should be disabled when compiling shared objects that contain function addresses that may be preempted by rld(1). For more information, see the dso(5) man page.

---

Specifies the level of conformance to ANSI/IEEE 754-1985, the IEEE Standard for Binary Floating-point Arithmetic, which describes a standard for NaN and inf operands, arithmetic roundoff, and overflow. Specify one of the following for n:

Forces all comparisons to yield results that conform to ANSI/IEEE 754-1985, the IEEE Standard for Binary Floating-point Arithmetic, which describes a standard for NaN and inf operands. Specify ON or OFF for setting. The default is IEEE_comparisons=OFF.

IEEE_comparisons=OFF produces non-IEEE results for comparisons. For example, x=x is treated as TRUE without executing a test.

---

Note: This option has been deprecated and will be removed in a future release. The preferred alternative is -OPT:IEEE_NaN_inf=setting.

---

Forces all operations that might have NaN or inf operands to yield results that conform to ANSI/IEEE 754-1985, the IEEE Standard for Binary Floating-point Arithmetic, which specifies the standard for NaN and inf operands. Specify ON or OFF for setting. The default is IEEE_NaN_inf=OFF.

IEEE_NaN_inf=OFF produces non-IEEE results for various operations. For example, x=x is treated as TRUE without executing a test and x/x is simplified to 1 without dividing. Turning this option on can suppress many such common optimizations and hurt performance.

inline_intrinsics=OFF turns all Fortran intrinsics that have a library function into a call to that function. Specify ON or OFF for setting. The default is inline_intrinsics=ON.

Specifies that the compiler should use UNICOS semantics when a !DIR$ IVDEP directive is encountered. The compiler ignores all lexically backward loop iteration dependencies. Specify ON or OFF for setting. The default is OFF, which directs the compiler to use IRIX semantics when a !DIR$ IVDEP directive is encountered.

For more information on the !DIR$ IVDEP directive, see “Ignore Vector Dependencies: IVDEP” in Chapter 6.

Specifies that any routine bigger than n should not be optimized.

You should use this option if you receive a message indicating that a different Olimit value is needed for optimizing your program; the value itself is based on internal compiler calculations. If -O2 or greater is in effect and a routine is so big that the compile speed can be slow, the compiler generates a message indicating the Olimit value that is needed to optimize. You can recompile with that value of n, or you can recompile with -OPT:Olimit=0 and avoid having any Olimit cutoff.

pad_common=ON reorganizes common blocks to improve the cache behavior of accesses to members of the common block. This may involve adding padding between members and/or breaking a common block into a collection of common blocks. Specify ON or OFF for setting. The default is pad_common=OFF.

This option should not be used unless the common block definitions (including EQUIVALENCE) are consistent among all sources comprising a program. In addition, pad_common=ON should not be specified if common blocks are initialized with DATA statements. If specified, pad_common=ON must be used for all source files in the program.

pad_common=ON is supported for Fortran only. It should not be used if a common block is referenced from C code.

procedure_reorder=ON must be specified in conjunction with the ld(1) command's -LD_LAYOUT:reorder_file=feedback_file option to enable linker cording. Linker cording is the linker's ability to optimize the layout of functions based upon a feedback file; this minimizes page faults and cache misses. The default is OFF.

For more information on the -LD_LAYOUT option, see the ld(1) man page. For an example that shows reordering of code regions, see the MIPSpro Compiling and Performance Tuning Guide.

The -OPT:recip=setting option causes your program's executable code to conform more closely to the IEEE floating-point standard than the default mode. When specified, many identity optimizations are disabled, executable code is slower, and a scaled complex divide mechanism is enabled that increases the range of complex values that can be handled without producing an underflow.

The -OPT:recip=setting option causes the compiler to optimize expressions such as X.NE.X to false and X/X to 1, where X is a floating-point value. With -OPT:recip=setting in effect, these and other similar arithmetic identity optimizations are not performed.

recip=ON specifies that faster, but potentially less accurate, reciprocal operations should be performed. Specify ON or OFF for setting. The default is recip=OFF. -r8000 must be in effect in order for -OPT:recip=ON to have an effect. If -O3 or -OPT:IEEE_arithmetic=2 or above are in effect, recip=ON is enabled automatically.

reorg_common=ON reorganizes common blocks to improve the cache behavior of accesses to members of the common block. The reorganization is performed only if the compiler detects that it is safe to do so. Specify ON or OFF for setting.

This option produces consistent results for programs that conform to the Fortran standard; for example, programs that do not overindex arrays in common blocks. The optimizations performed are safe even if common blocks are declared differently in different subroutines or if elements in the common block are equivalenced.

reorg_common=ON is enabled by default when -O3 is in effect and when all files that reference the common block are compiled at -O3. reorg_common=OFF is set when the file that contains the common block is compiled at -O2 (or below).

Specifies the level of acceptable departure from source language floating-point round-off, and overflow semantics. Specify 0, 1, 2, or 3 for n. Program performance is best at roundoff=3.

roundoff=0 is the default when optimization levels -O0, -O1, and -O2 are in effect. This inhibits optimizations that might affect the floating-point behavior.

roundoff=1 allows simple transformations that might cause limited round-off or overflow differences. Compounding such transformations could have more extensive effects.

roundoff=2 is the default level when -O3 is in effect. This level allows more extensive transformations, such as the reordering of reduction loops.

roundoff=3 enables any mathematically valid transformation.

To obtain best performance in conjunction with software pipelining, specify roundoff=2 or roundoff=3. This is because reassociation is required for many transformations to break recurrences in loops. Also see the descriptions for -OPT:IEEE_arithmetic, -OPT:fast_complex, -OPT:fast_trunc, and -OPT:fast_nint.

rsqrt=ON specifies that faster, but potentially less accurate, reciprocal square root operations may be performed. Specify ON or OFF for setting. The default is rsqrt=OFF.

If -OPT:IEEE_arithmetic=2 or above or -O3 are in effect, rsqrt=ON is enabled.

space=ON specifies that code space is to be given priority in tradeoffs with execution time in optimization choices. For instance, this forces all exits from a function to go through a single exit block. Specify ON or OFF for setting. The default is space=OFF.

This option can affect loop unrolling size. For more information on this, see “-OPT:unroll_size=n”.

This option allows speculative loads of memory locations that differ by a small offset from some referenced memory location.

This option is enabled by default at -O2 and -O3. However, the legal offset ranges are different at each level. At -O2, the range is 32 (-16 .. +16). At -O3, the range is 128 (-64 .. +64).

This optimization can result in an exception if the speculated location is on a different page than that of the referenced memory location. The chances of this happening with these legal offset ranges is very remote.

swp=ON enables software pipelining. Software pipelining is a compiler code generation technique in which operations from various loop iterations are overlapped in order to exploit instruction-level parallelism, increase the instruction issue rate, and better hide memory and instruction latency. As an optimization technique, software pipelining is similar to bottom loading, but it includes additional, and more efficient, scheduling optimizations.

Specify ON or OFF for setting. swp=ON is enabled when -O3 is in effect. The default is swp=OFF.

unroll_analysis=ON analyzes resource usage and recurrences in bodies of innermost loops that do not qualify for being fully unrolled. Such loops are unrolled only to the extent for which there is a potential benefit in doing so. A loop could be unrolled, for example, to decrease the shortest possible schedule length per iteration. Specify ON or OFF for setting. The default is unroll_analysis=ON.

unroll_analysis=ON can have the negative effect of unrolling loops less than the upper limit dictated by the -OPT:unroll_times_max and -OPT:unroll_size specifications.

Specifies the maximum size (in instructions) of an unrolled loop. Specify an integer for n. When -OPT:space=OFF is in effect, the default is unroll_size=80. When -OPT:space=ON is in effect, the default is unroll_size=20. For more information, see “-OPT:space=setting”.

This option indirectly determines which loops can be fully unrolled. Also see the -OPT:unroll_times_max option.

Specifies the maximum number of times a loop will be unrolled if it is not going to be fully unrolled. Specify an integer for n.

The default value of n depends on the target processor. The default is 8 when -r8000, -r10000 or -r12000 are in effect, and the default is 4 in all other cases. Also see the -OPT:unroll_size option.

Allows you to prevent the compiler from performing potentially unsafe optimizations involving induction variable replacement and linear function replacement. These optimizations are performed by default when -O2 or -O3 are specified. Specify ON or OFF for setting.

Setting wrap_around_unsafe_opt=OFF disables both the induction variable replacement and linear function test replacement optimizations. These optimizations are safe when loop induction variables do not overflow or wrap around in memory. These optimizations are unsafe when incorrect code is generated due to multiple induction variables in loops having combined initial values that overflow or wrap around in memory. Using this option can degrade performance. It is provided as a diagnostic tool.

Forces the kernel to dismiss any memory faults, such as SIGSEGV or SIGBUS, that occur during execution of the program (not just the code being compiled). This option allows optimizations that might cause extra faults and can slow down execution if extra faults occur. It also prevents recognition of legitimate faults. setting can be ON or OFF. The default is OFF.

Specifies the maximum set of IEEE-754 floating-point exceptions for which traps may be enabled at run time for the program (not just the code being compiled). The default is IUOZV. The default can be affected by the -TENV:X option.

This option allows optimizations that might cause extra exceptions, and it may prevent recognition of legitimate faults. It does not affect explicit setting of exception enable flags by the program and should be avoided if the program does this.

Specify zero or more of the following for letter to specify exceptions: I specifies inexact; U specifies underflow; O specifies overflow; Z specifies divide by zero; and V specifies invalid operations.

For related information, see the -TARG:exc_min option description. For information on the -TENV:X option, see “-TENV:X=n”.

Specifies the minimum set of IEEE-754 floating-point exceptions for which traps must be enabled at runtime for the program (not just the code being compiled). The default is none.

This option does not affect explicit setting of exception enable flags by the program and should be avoided if the program does this.

Specify zero or more of the following for letter to specify exceptions: I specifies inexact; U specifies underflow; O specifies overflow; Z specifies divide by zero; and V specifies invalid operations.

For related information, see the -TARG:exc_max option description. The -TARG:exc_max and -TARG:exc_min options specified for the various files that comprise a program must be consistent; for example, none of the -TARG:exc_min values may require exceptions disabled by -TARG:exc_max values.

Forces the target processor into precise floating-point mode at execution time. Using this option to compile any component source files of a program invokes this feature in the resulting program. Specify ON or OFF for setting. The default is OFF.

This option is only meaningful when -r8000 is in effect. It can cause significant performance degradation for programs with heavy floating-point usage. For more information on floating-point mode, see the fpmode(1) man page.

Identifies the target instruction set architecture for compilation, such as the set of instructions that are generated. For instruction_set specify mips3 or mips4. Specify -TARG:isa=mips3 for code that must run on R4000 processors. This option is equivalent to specifying -mips3 or -mips4. For information on defaults, and for information on the -mipsn option, see “-mipsn”.

Enables or prevents transformations from using multiply and add instructions. Specify ON or OFF for setting. The default is ON. This option is ignored unless -mips4 is in effect.

These instructions perform a multiply/add with a single round off. They are more accurate than the usual discrete operations, and they may cause results not to match baselines from other targets. Use this option to determine whether observed differences are due to multiply/add instructions.

Specifies the target platform for compilation, choosing various internal parameters (such as cache sizes) appropriately. Supported values are as follows: ip19, ip20, ip21, ip22_4k, ip22_5k, ip24, ip25, ip26, ip27, ip28, ip30, ip32_5k, and ip32_10k. The appropriate selection for your platform can be determined by entering the following command:

hinv -c processor

The first line of output identifies the proper IP number. If a processor suffix (for example, _4k) is required, the next line identifies the processor (for example, R4000).

Selects the processor for which to schedule code. The chosen processor must support the instruction set architecture (ISA) that is specified (or implied by the ABI). Specify one of the following for processor: r4000, r5000, r8000, r10000, or -r12000.

Generates code to work around bugs in the R4000 rev 2.2 chip. This currently means simulating 64-bit variable shifts in the software. Specify ON or OFF for setting. The default is OFF.

Enables or disables use of SYNC instructions. Specify ON or OFF for setting. The default is ON.

The MIPSpro 7 Fortran 90 compiler retrieves default information for the Application Binary Interface (ABI), instruction set architecture (ISA), and processor type, optimization, and IEEE arithmetic computations from /etc/compiler.defaults.

To compile for a different system, set the COMPILER_DEFAULTS_PATH environment variable to a path or to a colon-separated list of paths designating where the compiler is to look for the compiler.defaults file. For more information on this environment variable, see the pe_environ(5) man page.

The target compiler.defaults file must contain a -DEFAULT:option specifier that specifies the default information in the following format:

-DEFAULT:[abi=n32|64] [:isa=mips3|mips4]
[:proc=r4000|r5000|r8000|r10000|r12000] [:opt=0|1|2|3]
[:arith=1|2|3]

Note that command line settings override any settings in the system-supplied compiler.defaults file or in the compiler.defaults file that you create.

Controls alignment of allocated aggregates (that is, arrays and derived types). The value specified for bytes specifies that any aggregate object at least that large is to be given at least that alignment. By default, or if bytes is not specified, aggregates are aligned to the integer register size, which, for example, is 8 bytes for 64-bit programs and 4 bytes for 32-bit programs.

If align_aggregate=0 is specified, the minimum alignment consistent with the ABI is used. Otherwise, the value specified must be 1, 2, 4, 8, or 16.

Inserts checks for divide by zero operations and overflow conditions on integer divide operations. Specify 0, 1, 2, or 3 for n. The default is check_div=1.

check_div=0 inhibits checking. check_div=1 checks for division by zero. check_div=2 checks for overflow. check_div=3 checks for both division by zero and overflow.

---

Note: This option is deprecated. It will be removed in a future release. The preferred alternative is to specify DEBUG:div_check. For more information on the DEBUG:div_check option, see the debug_group(5) man page.

---

Generates code to accommodate a larger Global Offset Table (GOT) than is standard. Specify ON or OFF for setting. The default is large_GOT=OFF.

You can set this option to ON if you get a GOT or GP overflow message. For more information about the GOT, see the What should I do about a GOT overflow? question in the FAQ section of the dso(5) man page.

---

Note: If you specify both -TENV:large_GOT=ON and -TENV:small_GOT=ON on your command line, a message is issued and the -TENV:small_GOT=ON directive is recognized.

---

Assumes that the GOT for shared code is smaller than 64 KB, that is, assumessmall offsets for references to it. Specify ON or OFF for setting. The default is small_GOT=ON.

For more information on controlling the GOT, see the -TENV:large_GOT option.

Specifies the level of enabled exceptions that will be assumed for purposes of performing speculative code motion; exceptions considered here are the floating point exceptions defined in the ANSI/IEEE 754-1985, the IEEE Standard for Binary Floating-point Arithmetic (inexact, overflow, underflow, divide-by-zero, and invalid operation) and memory traps (SIGSEGV and SIGBUS).

The default is X=2 when -O3 is in effect. The default is X=1 when other -O optimization levels are in effect. Specify 0, 1, 2, 3, or 4 for n. The default is X=1.

Generally, an instruction is not speculated (moved above a branch by the optimizer) unless any exceptions it might cause are disabled by this option. X=0 inhibits speculative code motion.

X=1 specifies that safe speculative code motion be performed and disables all underflow and inexact exceptions according to ANSI/IEEE 754-1985.

X=2 disables all exceptions described in ANSI/IEEE 754-1985, except divide by zero.

X=3 disables all exceptions described in ANSI/IEEE 754-1985, including divide by zero.

X=4 disables or ignores memory exceptions.

At levels higher than the X=1 default level, various hardware exceptions, which are normally useful for debugging, or which are trapped and repaired by the hardware, may be disabled or ignored. This can hide obscure bugs. The program should not explicitly manipulate the IEEE floating-point trap-enable flags in the hardware if this option is used.