B.2.117 -xO[1|2|3|4|5] (Sun Studio 12: C User's Guide)

Sun Studio 12: C User's Guide

B.2.117 `-xO`[`1`|`2`|`3`|`4`|`5`]

Optimizes the object code; note the uppercase letter O followed by the digit 1, 2, 3, 4, or 5. Generally, the higher the level of optimization, the better the run-time performance. However, higher optimization levels can result in longer compilation time and larger executable files.

In a few cases,– xO2 might perform better than the others, and– xO3 might outperform– xO4. Try compiling with each level to see if you have one of these rare cases.

If the optimizer runs out of memory, it tries to recover by retrying the current procedure at a lower level of optimization and resumes subsequent procedures at the original level specified in the command-line option.

The default is no optimization. However, this is only possible if you do not specify an optimization level. If you specify an optimization level, there is no option for turning optimization off.

If you are trying to avoid setting an optimization level, be sure not to specify any option that implies an optimization level. For example, -fast is a macro option that sets optimization at -xO5. All other options that imply an optimization level give a warning message that optimization has been set. The only way to compile without any optimization is to delete all options from the command line or make file that specify an optimization level.

If you use -g and the optimization level is -xO3 or lower, the compiler provides best-effort symbolic information with almost full optimization. Tail-call optimization and back-end inlining are disabled.

If you use -g and the optimization level is -xO4 or higher, the compiler provides best-effort symbolic information with full optimization.

Debugging with -g does not suppress -xOn, but -xOn limits -g in certain ways. For example, the optimization options reduce the utility of debugging so that you cannot display variables from dbx, but you can still use the dbx where command to get a symbolic traceback. For more information, see “Debugging Optimized Code” in Chapter 1 of Debugging a Program With dbx.

If you specify both -xO and -xmaxopt, the optimization level set with -xO must not exceed the -xmaxopt value.

If you optimize at -xO3 or -xO4 with very large procedures (thousands of lines of code in the same procedure), the optimizer may require a large amount of virtual memory. In such cases, machine performance may degrade.

B.2.117.1 Explanation of SPARC Optimizations

The following table describes how they operate on the SPARC platform.

Table B–31 The -xO Flags on SPARC Platforms


Value	Meaning
`-xO1`	Does basic local optimization (peephole).
`-xO2`	Does basic local and global optimization. This is induction variable elimination, local and global common subexpression elimination, algebraic simplification, copy propagation, constant propagation, loop-invariant optimization, register allocation, basic block merging, tail recursion elimination, dead code elimination, tail call elimination, and complex expression expansion. The `-xO2` level does not assign global, external, or indirect references or definitions to registers. It treats these references and definitions as if they were declared `volatile`. In general, the `-xO2` level results in minimum code size.
`-xO3`	Performs like `-xO2`, but also optimizes references or definitions for external variables. Loop unrolling and software pipelining are also performed. This level does not trace the effects of pointer assignments. When compiling either device drivers, or programs that modify external variables from within signal handlers, you may need to use the `volatile` type qualifier to protect the object from optimization. In general, the `-xO3` level results in increased code size.
`-xO4`	Performs like `-xO3`, but also automatically inlines functions contained in the same file; this usually improves execution speed. If you want to control which functions are inlined, see B.2.91 `-xinline=list`. This level traces the effects of pointer assignments, and usually results in increased code size.
`-xO5`	Attempts to generate the highest level of optimization. Uses optimization algorithms that take more compilation time or that do not have as high a certainty of improving execution time. Optimization at this level is more likely to improve performance if it is done with profile feedback. See B.2.131 `-xprofile=p`.

B.2.117.2 Explanation of x86 Optimizations

The following table describes how the optimization levels work on the x86 platform.

Table B–32 The -xO Flags on x86 Platforms


Value	Meaning
`-xO1`	Preloads arguments from memory, cross-jumping (tail-merging), as well as the single pass of the default optimization.
`-xO2`	Schedules both high- and low-level instructions and performs improved spill analysis, loop memory-reference elimination, register lifetime analysis, enhanced register allocation, and elimination of global common subexpressions.
`-xO3`	Performs loop strength reduction, induction variable elimination, as well as the optimization done by level `2`.
`-xO4`	Preforms automatic inlining of functions contained in the same file in addition to performing `-xO3` optimizations. This automatic inlining usually improves execution speed, but sometimes makes it worse. In general, this level results in increased code size.
`-xO5`	Generates the highest level of optimization. Uses optimization algorithms that take more compilation time or that do not have as high a certainty of improving execution time. Some of these include generating local calling convention entry points for exported functions, further optimizing spill code and adding analysis to improve instruction scheduling.

For more information on debugging, see the Sun Studio 12: Debugging a Program With dbx manual. For more information on optimization, see theSun Studio 12: Performance Analyzer manual.