You copied the Doc URL to your clipboard.

Automatic function inlining and static functions

At -O2 and -O3 levels of optimization, or when --autoinline 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.