Sorry, your browser is not supported. We recommend upgrading your browser. We have done our best to make all the documentation and resources available on old versions of Internet Explorer, but vector image support and the layout may not be optimal. Technical documentation is available as a PDF Download.

JavaScript seems to be disabled in your browser.
You must have JavaScript enabled in your browser to utilize the functionality of this website.

You copied the Doc URL to your clipboard.

Optimization options

Control optimization behavior and performance.

Compiler optimization options
Option	Description
`-O0`	Minimum optimization for the performance of the compiled binary. Turns off most optimizations. When debugging is enabled, this option generates code that directly corresponds to the source code. Therefore, this might result in a significantly larger image. This is the default optimization level. Usage `armflang -O0`
`-O1`	Restricted optimization. When debugging is enabled, this option gives the best debug view for the trade-off between image size, performance, and debug. Usage `armflang -O1`
`-O2`	High optimization. When debugging is enabled, the 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. Usage `armflang -O2`
`-O3`	Very high optimization. When debugging is enabled, this option typically gives a poor debug view. Arm recommends debugging at lower optimization levels. Usage `armflang -O3`
`-Ofast`	Enable all the optimizations from level 3, including those performed with the -ffp-mode=fast armflang option. This level also performs other aggressive optimizations that might violate strict compliance with language standards. Usage `armflang -Ofast`
`-ffast-math`	Allow aggressive, lossy floating-point optimizations. Usage `armflang -ffast-math`
`-ffinite-math-only`	Enable optimizations that ignore the possibility of NaN and +/-Inf. Usage `armflang -ffinite-math-only`
`-ffp-contract={fast\|on\|off}`	Controls when the compiler is permitted to form fused floating-point operations (such as FMAs). fast: Always (default). on: Only in the presence of the FP_CONTRACT pragma. off: Never. Usage `armflang -ffp-contract={fast\|on\|off}`
`-finline` `-fno-inline`	Enable or disable inlining (enabled by default). Usage `armflang -finline` (enable) `armflang -fno-inline` (disable)
`-fstack-arrays` `-fnostack-arrays`	Place all automatic arrays on stack memory. For programs using very large arrays on particular operating systems, consider extending stack memory runtime limits. Enabled by default at optimization level `-Ofast`. Usage `armflang -fstack-arrays` (enable) `armflang -fnostack-arrays` (disable)
`-fstrict-aliasing`	Tells the compiler to adhere to the aliasing rules defined in the source language. In some circumstances, this flag allows the compiler to assume that pointers to different types do not alias. Enabled by default when using `-Ofast`. Usage `armflang -fstrict-aliasing`
`-funsafe-math-optimizations` `-fno-unsafe-math-optimizations`	This option enables reassociation and reciprocal math optimizations, and does not honor trapping nor signed zero. Usage `armflang -funsafe-math-optimizations` (enable) `armflang-fno-unsafe-math-optimizations` (disable)
`-fvectorize` `-fno-vectorize`	Enable/disable loop vectorization (enabled by default). Usage `armflang -fvectorize` (enable) `armflang -fno-vectorize` (disable)
`-mcpu=<arg>`	Select which CPU architecture to optimize for `-mcpu=native` causes the compiler to auto-detect the CPU architecture from the build computer. Usage `armflang -mcpu=<arg>`

Previous Next

Was this page helpful? Yes No