CODEWITHSUNDEEP
gccinlinecompiler-flags
HaltingState
HaltingState

Reputation: 1900

How do I force gcc to inline a function?

Does __attribute__((always_inline)) force a function to be inlined by gcc?

Upvotes: 84

Views: 98880

Answers (8)

jmkeyes
jmkeyes

Reputation: 3771

Yes, it will. That doesn't necessarily mean it's a good idea.

Upvotes: 23

RCE
RCE

Reputation: 1721

Yes.

always_inline

Generally, functions are not inlined unless optimization is specified. For functions declared inline, this attribute inlines the function even if no optimization level was specified.

Upvotes: 56

redorav
redorav

Reputation: 962

I want to add here that I have a SIMD math library where inlining is absolutely critical for performance. Initially I set all functions to inline but the disassembly showed that even for the most trivial operators it would decide to actually call the function. Both MSVC and Clang showed this, with all optimization flags on.

I did as suggested in other posts in SO and added __forceinline for MSVC and __attribute__((always_inline)) for all other compilers. There was a consistent 25-35% improvement in performance in various tight loops with operations ranging from basic multiplies to sines.

I didn't figure out why they had such a hard time inlining (perhaps templated code is harder?) but the bottom line is: there are very valid use cases for inlining manually and huge speedups to be gained.

If you're curious this is where I implemented it. https://github.com/redorav/hlslpp

Upvotes: 6

DCBillen
DCBillen

Reputation: 94

Actually the answer is "no". All it means is that the function is a candidate for inlining even with optimizations disabled.

Upvotes: -5

Jie Xu
Jie Xu

Reputation: 19

One can also use __always_inline. I have been using that for C++ member functions for GCC 4.8.1. But could not found a good explanation in GCC doc.

Upvotes: 1

Joe
Joe

Reputation: 538

It should. I'm a big fan of manual inlining. Sure, used in excess it's a bad thing. But often times when optimizing code, there will be one or two functions that simply have to be inlined or performance goes down the toilet. And frankly, in my experience C compilers typically do not inline those functions when using the inline keyword.

I'm perfectly willing to let the compiler inline most of my code for me. It's only those half dozen or so absolutely vital cases that I really care about. People say "compilers do a good job at this." I'd like to see proof of that, please. So far, I've never seen a C compiler inline a vital piece of code I told it to without using some sort of forced inline syntax (__forceinline on msvc __attribute__((always_inline)) on gcc).

Upvotes: 43

Basile Starynkevitch
Basile Starynkevitch

Reputation: 1

According to the gcc optimize options documentation, you can tune inlining with parameters:

-finline-limit=n
By default, GCC limits the size of functions that can be inlined. This flag 
allows coarse control of this limit. n is the size of functions that can be 
inlined in number of  pseudo instructions.

Inlining is actually controlled by a number of parameters, which may be specified
individually by using --param name=value. The -finline-limit=n option sets some 
of these parameters as follows:

    max-inline-insns-single is set to n/2. 
    max-inline-insns-auto is set to n/2.

I suggest reading more in details about all the parameters for inlining, and setting them appropriately.

Upvotes: 13

Matt Joiner
Matt Joiner

Reputation: 118540

Yes. It will inline the function regardless of any other options set. See here.

Upvotes: 5

Related Questions