2.11.2 Inlining Restrictions

The compiler makes decisions about which functions to inline based on the factors mentioned in Section 2.11. In addition, there are several restrictions that can disqualify a function from being inlined by automatic inlining or inline keyword-based inlining.

The compiler will leave calls as they are if the function:

• Has a different number of arguments than the call site
• Has an argument whose type is incompatible with the corresponding call site argument
• Is not declared inline and returns void but its return value is needed

The compiler will also not inline a call if the function has features that create difficult situations for the compiler:

• Has a variable-length argument list
• Never returns
• Is a recursive or non-leaf function that exceeds the depth limit
• Is not declared inline and contains an asm() statement that is not a comment
• Is an interrupt function
• Is the main() function
• Is not declared inline and will require too much stack space for local array or structure variables
• Contains a volatile local variable or argument
• Is a C++ function that contains a catch
• Is not defined in the current compilation unit and -O4 optimization is not used

A call in a statement that is annotated with a NOINLINE pragma will not be inlined, regardless of other indications (including a FUNC_ALWAYS_INLINE pragma or always_inline attribute on the called function).

A call in a statement that is annotated with a FORCEINLINE pragma will always be inlined, if it is not disqualified for one of the reasons above, even if the called function has a FUNC_CANNOT_INLINE pragma or cannot_inline attribute.

In other words, a statement-level pragma overrides a function-level pragma or attribute. If both NOINLINE and FORCEINLINE apply to the same statement, then the one that appears first will be used and the rest will be ignored.