C++ inline functions using GCC - why the CALL?

Question

I have been testing inline function calls in C++.

Thread model: win32
gcc version 4.3.3 (4.3.3-tdm-1 mingw32)

Stroustrup in The C++ Programming language wirtes:

The inline specifier is a hint to the compiler that it should attempt to generate code [...] inline rather than laying down the code for the function once and then calling through the usual function call mechanism.

However, I have found out that the generated code is simply not inline. There is a CALL instrction for the isquare function.

Why is this happening? How can I use inline functions then?

EDIT: The command line options used:

**** Build of configuration Debug for project InlineCpp ****

**** Internal Builder is used for build               ****
g++ -O0 -g3 -Wall -c -fmessage-length=0 -osrc\InlineCpp.o ..\src\InlineCpp.cpp
g++ -oInlineCpp.exe src\InlineCpp.o

Solution 1

There is no generic C++ way to FORCE the compiler to create inline functions. Note the word 'hint' in the text you quoted - the compiler is not obliged to listen to you.

If you really, absolutely have to make something be in-line, you'll need a compiler specific keyword, OR you'll need to use macros instead of functions.

EDIT: njsf gives the proper gcc keyword in his response.

Solution 2

Like Michael Kohne mentioned, the inline keyword is always a hint, and GCC in the case of your function decided not to inline it.

Since you are using Gcc you can force inline with the __attribute((always_inline)).

Example:

 /* Prototype.  */
 inline void foo (const char) __attribute__((always_inline));

Source:GCC inline docs

Solution 3

Are you looking at a debug build (optimizations disabled)? Compilers usually disable inlining in "debug" builds because they make debugging harder.

In any case, the inline specified is indeed a hint. The compiler is not required to inline the function. There are a number of reasons why any compiler might decide to ignore an inline hint:

• A compiler might be simple, and not support inlining
• A compiler might use an internal algorithm to decide on what to inline and ignore the hints.
  (sometimes, the compiler can do a better job than you can possibly do at choosing what to inline, especially in complex architectures like IA64)
• A compiler might use its own heuristics to decide that despite the hint, inlining will not improve performance

Solution 4

Inline is nothing more than a suggestion to the compiler that, if it's possible to inline this function then the compiler should consider doing so. Some functions it will inline automatically because they are so simple, and other functions that you suggest it inlines it won't because they are to complex.

Also, I noticed that you are doing a debug build. I don't actually know, but it's possible that the compiler disables inlining for debug builds because it makes things difficult for the debugger...

Solution 5

It is a hint and the complier can choice to ignore the hint. I think I read some where that GCC generally ignore it. I remeber hearing there was a flag but it still does not work in 100% of cases. (I have not found a link yet).

Flag: -finline-functions is turned on at -O3 optimisation level.

View more solutions

Comments

[timday]

Yeah, but if the questioner goes away and starts pasting __attribute__((always_inline)); onto all his functions instead of just compiling with -O3, we've failed.

[timday]

I believe the main difference gcc pays to "inline" is that it means the function can be up to 600 instructions big and still get inlined, while functions not declared inline considered for auto inlining with -finline-functions have to be less than 300 instructions. You can mess with all these numbers and more using --param to adjust things with names like max-inline-insns-auto (but you need a pretty good reason to; the defaults are sound). Changing the difference between the numbers for explicit and auto inlining means you can effectively make inline have more or less of an effect though.

[wintercounter]

Agreed. I guess I am still an optimist and believe most people have some common sense ;-)

[David Allan Finch]

That is very interesting. Thanks.

[Mike DeSimone]

For the record, I have to build with -Os and I need this because the compiler isn't inlining an object method that takes all constant arguments and is one line like member = (big integer expression with no function calls and just integer math operations);. gcc 4.6.1 BTW.

[Kevin Vermeer]

For another record, I have to build with -Os (embedded system; won't fit otherwise) and the core scheduler of my RTOS is a big, nasty mess of inline assembly that loads some C variables. I absolutely must not make a function call as that would clobber some registers I need to save. With this attribute I've been able to break the core into something legible and export the assembly to self-documenting function calls. One use case for not pasting the attribute on all the functions! (also 4.6.1)

[Quuxplusone]

@KevinVermeer Your problem (to write a small inline function that doesn't obey the calling convention) would be solved in a more portable way by making a macro that expanded to GNU-syntax inline assembly.

[bitsmack]

Why the downvote? sybreon is correct, in the case that the inlined function is called from another module...