Note that this is a flag to the "iropt" component of the compilation system. In general, flags may be sent to iropt using "Qoption iropt" from the "f90" and "CC" commands; or using "-W2," from the "cc" command.

• -fsimple=0 permits no simplifying assumptions. Preserves strict IEEE 754 conformance.
• -fsimple=1 allows the optimizer to assume:
  • The IEEE 754 default rounding/trapping modes do not change after process initialization.
  • Computations producing no visible result other than potential floating-point exceptions may be deleted.
  • Computations with Infinity or NaNs as operands need not propagate NaNs to their results. For example, x*0 may be replaced by 0.
  • Computations do not depend on sign of zero.
• -fsimple=2 permits more aggressive floating point optimizations that may cause programs to produce different numeric results due to changes in rounding. Even with -fsimple=2, the optimizer still is not permitted to introduce a floating point exception in a program that otherwise produces none. For example, -fsimple=2 permits the optimizer to replace computations of x/y in a loop with x*z, where z=1/y.

The -R flag specifies library search directories to the runtime linker. The information is recorded in the object file and passed to the runtime linker.

The version of SmartHeap that is used can be one of:

• smartheap - 32-bit
• smartheap64 - 64-bit
• smartheap_mt64 - 64-bit, multithreaded

• no%dummy Usage of dummy parameters follows the Fortran standard and may not alias each other or global variables.
• craypointer Cray pointers can point at any global variable or a local variable whose address is taken by the LOC() function.
• no%actual Passing an argument does not result in further aliasing.
• no%overindex Array bounds are not violated. Array references do not reference other variables.
• no%ftnpointer Fortran pointers follow the rules of the standard.

• basic assume that memory references that involve different C basic types do not alias each other.
• std assume aliasing rules described in the ISO 1999 C standard.
• strong in addition to the restrictions at the std level, assume that pointers of type char * are used only to access an object of type char; and assume that there are no interior pointers.
• strict assume that memory references that involve types such as structs or unions, that are the same when tags are removed, can alias each other. Conversely, the compiler assumes that memory references involving types that are not the same even after tags are removed do not alias each other.

• any assumes that any type can alias any other
• simple assumes that fundamental types are not aliased
• compatible assumes that layout-incompatible types are not aliased. If you specify -xalias_level without any values, the compiler sets it to -xalias_level=compatible.

• sse Adds the SSE instruction set
• sse2 Adds the SSE2 instruction set
• sse2a Adds the AMD extensions to the SSE2 instruction set
• sse4_2 Supports SSE4.2 instruction set
• amd64 Compile 64-bit Solaris x86 applications. Is equivalent to -m64 -xarch=sse2
• amd64a Adds the AMD extensions to the AMD64 architecture and generates 64-bit ELF format binary file.
• native Use the instructions available on the current processor
• generic This option generates 32-bit applications. This is default.

• native Optimize for the current processor
• nehalem Optimize for the Intel Nehalem processor
• opteron Optimize for the AMD Opteron processor
• generic Optimize for the most x86 platforms

• 0 = off
• 1 = on
• 2 = performs whole-program detection and analysis.

At -xipo=2, the compiler performs inter-procedural aliasing analysis as well as optimization of memory allocation and layout to improve cache performance.

• O1 does only basic local optimizations (peephole.)
• O2 Do basic local and global optimizations, such as induction variable elimination, common subexpression elimination, constant propogation, register allocation, and basic block merging.
• O3 Add global optimizations at the function level, loop unrolling, and software pipelining. For Fortran, includes dependence analysis (-xdepend)
• O4 Adds automatic inlining of functions in the same file.
• O5 Uses optmization algorithms that may take significantly more compilation time or that do not have as high a probability of improving execution time, such as speculative code motion.

• auto - Enable automatic generation of prefetch instructions
• no%auto - Disable automatic generation of prefetch instructions
• explicit - Enable explicit prefetch macros (SPARC only)
• no%explicit - Disable explicit prefetch macros (SPARC only)
• latx:<n> - Adjust the compiler's assumptions about prefetch latency by the specified factor. Typically values in the range of 0.5 to 2.0 will be useful. A lower number might indicate that data will usually be cache resident; a higher number might indicate a relatively larger gap between the processor speed and the memory speed (compared to the assumptions built into the compiler).

If only -xprefetch is specified, -xprefetch=auto,explicit is assumed.

The default is -xprefetch=auto,explicit.

When FDO is used, the training run gathers information regarding execution paths. As of the Sun Studio 12 version of the compiler suite, the training run gathers information about data values on SPARC systems, but not on x86 systems. Hardware performance counters are not used. FDO improves existing optimizations but does not introduce new classes of optimization.

Synonym for -unroll=n

• -xvector is equivalent to -xvector=yes. If you specify -xvector, but do not provide a flag, the compiler assumes -xvector=lib.
• -xvector=lib Enables the compiler to transform math library calls within loops into single calls to the equivalent vector math routines when such transformations are possible.
• -xvector=simd Directs the compiler to use the native x86 SSE SIMD instructions to improve performance of certain loops.