ARM Compiler toolchain v4.1 for µVision Using the Compiler

Compiler Coding Practices
5.21 Automatic function inlining and static functions
At -O2 and -O3 levels of optimization, or when --autoline is specified, the compiler can
automatically inline functions if it is practical and possible to do so, even if the functions are not
declared as __inline or inline. This works best for static functions, because if all use of a static
function can be inlined, no out-of-line copy is required. Unless a function is explicitly declared
as static (or __inline), the compiler has to retain the out-of-line version of it in the object file
in case it is called from some other module.
It is best to mark all non-inline functions as static if they are not used outside the translation unit
where they are defined (a translation unit being the preprocessed output of a source file together
with all of the headers and source files included as a result of the #include directive). Typically,
you do not want to place definitions of non-inline functions in header files.
If you fail to declare functions that are never called from outside a module as static, code can
be adversely affected. In particular, you might have:
• A larger code size, because out-of-line versions of functions are retained in the image.
When a function is automatically inlined, both the in-line version and an out-of-line
version of the function might end up in the final image, unless the function is declared as
static. This might increase code size.
• An unnecessarily complicated debug view, because there are both inline versions and
out-of-line versions of functions to display.
Retaining both inline and out-of-line copies of a function in code can sometimes be
confusing when setting breakpoints or single-stepping in a debug view. The debugger has
to display both in-line and out-of-line versions in its interleaved source view so that you
can see what is happening when stepping through either the in-line or out-of-line version.
Because of these problems, declare non-inline functions as static when you are sure that they
can never be called from another module.
5.21.1 See also
Concepts
• Inline functions on page 5-29
• Compiler decisions on function inlining on page 5-30
• Automatic function inlining and multifile compilation on page 5-34
• Restriction on overriding compiler decisions about function inlining on page 5-35.
Reference
Compiler Reference:
• --autoinline, --no_autoinline on page 3-14
• -Onum on page 3-71.
ARM DUI 0375C Copyright © 2007-2008, 2011 ARM. All rights reserved. 5-32
ID061811
Non-Confidential