• Enables global optimization; this includes data-flow analysis, code motion, strength reduction and test replacement, split-lifetime analysis, and instruction scheduling.
• Disables intrinsic recognition and intrinsics inlining.
• Disables loop unrolling.

The O1 option may improve performance for applications with very large code size, many branches, and execution time not dominated by code within loops.

On IA-32 Mac OSX platforms, -O1 sets the following:

• -unroll0,
• -fno-builtin,
• -mno-ieee-fp,
• -fomit-frame-pointer (same as -fp),
• -ffunction-sections

• Inlining of intrinsics
• Intra-file interprocedural optimizations, which include:
  • inlining
  • constant propagation
  • forward substitution
  • routine attribute propagation
  • variable address-taken analysis
  • dead static function elimination
  • removal of unreferenced variables
• The following capabilities for performance gain:
  • constant propagation
  • copy propagation
  • dead-code elimination
  • global register allocation
  • global instruction scheduling and control speculation
  • loop unrolling
  • optimized code selection
  • partial redundancy elimination
  • strength reduction/induction variable simplification
  • variable renaming
  • exception handling optimizations
  • tail recursions
  • peephole optimizations
  • structure assignment lowering and optimizations
  • dead store elimination

Enables optimizations for maximum speed, such as:

• Loop unrolling, including instruction scheduling
• Code replication to eliminate branches
• Padding the size of certain power-of-two arrays to allow more efficient cache use

On IA-32 and Intel EM64T processors, when O3 is used with options -ax or -x (Linux/Mac OSX), the compiler performs more aggressive data dependency analysis than for O2, which may result in longer compilation times.

The O3 optimizations may not cause higher performance unless loop and memory access transformations take place. The optimizations may slow down code in some cases compared to O2 optimizations.

The O3 option is recommended for applications that have loops that heavily use floating-point calculations and process large data sets.

• inline function expansion
• interprocedural constant propogation
• dead code elimination
• propagation of function characteristics
• passing arguments in registers
• loop-invariant code motion

When you specify this option, the compiler performs inline function expansion for calls to functions defined in separate files.

• -xT (optimizations for Intel Core 2 Duo processor family)
• -O3 (maximum speed and high-level optimizations)
• -ipo (enables interprocedural optimizations across files)
• -no-prec-div (disable -prec-div), where -prec-div improves precision of FP divides (some speed impact)
• -mdynamic-no-pic, where -mydynamic-no-pic indicates that code is not relocatable

Options set by -fast cannot be overidden, list options separately to change behavior. The options set by -fast may change from release to release.

With some optimizations, such as -xN and -xB (Linux) or /QxN and /QxB (Windows), the compiler may change floating-point division computations into multiplication by the reciprocal of the denominator. For example, A/B is computed as A * (1/B) to improve the speed of the computation.

However, sometimes the value produced by this transformation is not as accurate as full IEEE division. When it is important to have fully precise IEEE division, use this option to disable the floating-point division-to-multiplication optimization. The result is more accurate, with some loss of performance.

If you specify -no-prec-div (Linux and Mac OSX), it enables optimizations that give slightly less precise results than full IEEE division. The default is -prec-div.

Without any other options, the current directory is searched for .dyn files