Minimum optimization. Turns off most optimizations. When debugging is enabled, this
option gives the best possible debug view because the structure of the generated code
directly corresponds to the source code. All optimization that interferes with the
debug view is disabled. In particular:
- Breakpoints can be set on any reachable point, including dead
- The value of a variable is available everywhere within its scope, except where it
- Backtrace gives the stack of open function activations that is
expected from reading the source.
Although the debug view produced by
corresponds most closely to the source code, users might prefer the debug view
-O1 because this improves the quality
of the code without changing the fundamental structure.
NoteDead code includes reachable code that has no effect on the result of the program,
for example an assignment to a local variable that is never used. Unreachable code is
specifically code that cannot be reached via any control flow path, for example code
that immediately follows a return statement.
Restricted optimization. The compiler only performs optimizations that can be described by debug information. Removes unused inline functions and unused static
functions. Turns off optimizations that seriously degrade the debug view. If used with
--debug, this option gives a generally satisfactory debug view with
good code density.
The differences in the debug view from
- Breakpoints cannot be set on dead code.
- Values of variables might not be available within their scope
after they have been initialized. For example if their assigned location has been
- Functions with no side-effects might be called out of sequence, or
might be omitted if the result is not needed.
- Backtrace might not give the stack of open function activations
that is expected from reading the source because of the presence of tailcalls.
The optimization level
good correspondence between source code and object code, especially when the source
code contains no dead code. The generated code can be significantly smaller than the
–O0, which can simplify analysis of the
High optimization. If used with
debug view might be less satisfactory because the mapping of object code to source
code is not always clear. The compiler might perform optimizations that cannot be
described by debug information.
This is the default optimization level.
The differences in the debug view from
- The source code to object code mapping might be many to one,
because of the possibility of multiple source code locations mapping to one point of
the file, and more aggressive instruction scheduling.
- Instruction scheduling is allowed to cross sequence points.
This can lead to mismatches between the reported value of a variable at a particular point, and the value you might expect from reading the source code.
- The compiler automatically inlines functions.
Maximum optimization. When debugging is enabled, this option typically gives a poor
debug view. ARM recommends debugging at lower optimization levels.
If you use
-Otime together, the compiler
performs extra optimizations that are more aggressive, such as:
High-level scalar optimizations, including loop unrolling. This can give
significant performance benefits at a small code size cost, but at the risk of a
longer build time.
More aggressive inlining and automatic inlining.
These optimizations effectively rewrite the input source code, resulting in object
code with the lowest correspondence to source code and the worst debug view. The
--loop_optimization_level=option controls the amount of loop
optimization performed at
–O3 –Otime. The higher the amount of loop
optimization the worse the correspondence between source and object code.
Use of the
--vectorize option also lowers the correspondence between
source and object code.
For extra information about the high level transformations performed on the source
–O3 –Otime use the
By default, the compiler optimizes to reduce image size at the expense of
a possible increase in execution time. That is,
-Ospace is the default,
-Otime. Note that
-Ospace is not affected by
the optimization level
-Onum. That is,
enables more optimizations than
-O2 -Ospace, but does not perform more
aggressive size reduction.