Specifies the level of optimization to be used:

Instructs the compiler to perform optimizations to reduce image size at the expense of a possible increase in execution time. For example, large structure copies are done by out-of-line function calls instead of inline code. Use this option if code size is more critical than performance. This is the default.

Instructs the compiler to perform optimizations to reduce execution time at the possible expense of a larger image. Use this option if execution time is more critical than code size. For example, it compiles:

while (expression) body;

as:

if (expression) {
    do body;
    while (expression);
}

If you specify neither -Otime nor -Ospace, the compiler uses -Ospace. You can compile time-critical parts of your code with -Otime, and the rest with -Ospace.

If you specify both -Otime and -Ospace in the same compiler invocation, the last one wins (see Ordering command-line options).

Specifies the feedback file created by a previous execution of the ARM linker. The file contains a list of functions that the linker identifies as being unused in your code. The contents of this file are optimization hints only. These hints might be ignored by the compiler. Therefore, this is a safe optimization.

See Linker feedback for more details.

Specifies the floating-point conformance, and sets library attributes and floating-point optimizations. model can be one of:

Enables the compiler to perform optimization across all specified files, instead of on each individual file. The specified files are compiled into one single object file. Using --multifile requires large amounts of memory while compiling. Although there is no limit to the number of files you can specify on the command line, a practical limit is 10 source files.

--multifile is on by default for optimization level -O3.

For more details on multifile compilation, see Multifile compilation.

Enables or disables unused virtual function elimination (VFE) in C++ mode. --vfe is the default, except for the case where legacy object files compiled with a pre-RVCT v2.1 compiler do not contain VFE information.

When VFE is enabled, the compiler places the information in special sections with the prefix .arm_vfe_. These sections are harmless to a linker that is not VFE-aware, because they are not referenced by the rest of the code. Therefore, they do not increase the size of the executable. However, they increase the size of the object files. If this is a problem, then specify --no_vfe.

For more details on VFE, and the associated linker options, see RealView Compilation Tools v3.0 Linker and Utilities Guide. Also, see Calling a pure virtual function for more information on pure virtual functions.

Enables or disables automatic inlining. --no_autoinline is the default for optimization levels -O0 and -O1, and --autoinline is the default for optimization levels -O2 and -O3 (see Multi-optimization options).

The compiler automatically inlines functions where it is sensible to do so. The -Ospace and -Otime options influence how the compiler automatically inlines functions. Selecting -Otime increases the likelihood that functions are inlined.

Enables or disables automatic reordering of top-level data items (globals, for example). The compiler can save memory by eliminating wasted space between data items. However, --data_reorder can break legacy code, if the code makes invalid assumptions about ordering of data by the compiler.

The ISO C Standard does not guarantee data order, so you must avoid writing code that depends on any assumed ordering. If you require data ordering, place the data items into a structure.

If used, the compiler always attempts to inline those functions marked as __inline, if possible. The compiler attempts to inline the function, regardless of the characteristics of the function. However, it does not inline a function if doing so causes problems, for example, a recursive function is inlined only once.

If you want to force specific functions to be inlined, use the __forceinline function storage class modifier (see Function storage class qualifiers).

Disables inlining of functions (see --inline). Calls to inline functions are not expanded inline. You can use this option to help debug inline functions.

If a function is declared inline, then it is compiled out-of-line into a common code section. Functions marked as __forceinline are still expanded inline (see Function storage class qualifiers).

Enables the compiler to inline functions. This is the default.

The compiler inlines functions as follows:

The compiler changes the criteria for inlining functions depending on whether you select -Ospace or -Otime. Select -Otime to increase the likelihood that a function is inlined. See Multi-optimization options for more details.

Sometimes, an out-of-line copy of an inlined function might remain in an object or image, even though that code is no longer used. Linker feedback enables you to detect and remove any unused code fragments. See Linker feedback.

Enables or disables less restrictive C in ROPI mode. See Position independence qualifiers for details of the /ropi option.

Enables or disables less restrictive C and C++ in RWPI mode. --lower_rwpi is the default. See Position independence qualifiers for details of the /rwpi option.

By default, the compiler uses registers for LDM and STM instructions:

The --split_ldm option instructs the compiler to split LDM and STM instructions into two or more LDM or STM instructions, where required, to reduce the maximum number of registers transferred to:

Inline assembler LDM and STM instructions are split by default. However, the compiler might subsequently recombine the separate instructions into an LDM or STM (see Instruction expansion for more details).

The --split_ldm option has the following effects:

There are some systems that do not benefit from being built with --split_ldm:

Specifies that the compiler output works with the RVCT libraries or with any AEABI-compliant library. lib can be one of:

Use this option when linking with any ABI-compliant, third-party, libraries or where your code includes replacement functions, for example, where using an embedded operating system. In this case, use this option to disable the compiler variants, for example, if you are re-implementing any functions such as printf or scanf. This option ensures that the compiler does not generate calls to any optimized functions. See ABI for the ARM Architecture compliance for more details.

Generates one ELF section for each function in the source file. Output sections are named with the same name as the function that generates the section, but with an i. prefix. For example:

compiled with --split_sections gives:

        AREA ||i.f||, CODE, READONLY
f PROC
        ADD      r0,r0,#1
        MOV      pc,lr

This option increases code size slightly (typically by a few percent) for some functions because it reduces the potential for sharing addresses, data, and string literals between functions.