(How) Can I inline a particular function call?

Question

Let's say that I have a function that gets called in multiple parts of a program. Let's also say that I have a particular call to that function that is in an extremely performance-sensitive section of code (e.g., a loop that iterates tens of millions of times and where each microsecond counts). Is there a way that I can force the complier (gcc in my case) to inline that single, particular function call, without inlining the others?

EDIT: Let me make this completely clear: this question is NOT about forcing gcc (or any other compiler) to inline all calls to a function; rather, it it about requesting that the compiler inline a particular call to a function.

Answer 1

In C (as opposed to C++) there's no standard way to suggest that a function should be inlined. It's only vender-specific extensions.

However you specify it, as far as I know the compiler will always try to inline every instance, so use that function only once:

original:

   int MyFunc()  { /* do stuff */  } 

change to:

   inline int MyFunc_inlined()  { /* do stuff */  }     int MyFunc()  { return MyFunc_inlined(); } 

Now, in theplaces where you want it inlined, use MyFunc_inlined()

Note: "inline" keyword in the above is just a placeholder for whatever syntax gcc uses to force an inlining. If H2CO3's deleted answer is to be trusted, that would be:

static inline __attribute__((always_inline)) int MyFunc_inlined()  { /* do stuff */  } 

Answer 2

It is possible to enable inlining per translation unit (but not per call). Though this is not an answer for the question and is an ugly trick, it conforms to C standard and may be interesting as related stuff.

The trick is to use extern definition where you do not want to inline, and extern inline where you need inlining.

Example:

$ cat func.h  int func();  $ cat func.c  int func() { return 10; }  $ cat func_inline.h  extern inline int func() { return 5; }  $ cat main.c        #include <stdio.h>  #ifdef USE_INLINE # include "func_inline.h" #else # include "func.h" #endif  int main() { printf("%d\n", func()); return 0; }  $ gcc main.c func.c && ./a.out 10                                                // non-inlined version  $ gcc main.c func.c -DUSE_INLINE && ./a.out 10                                                // non-inlined version  $ gcc main.c func.c -DUSE_INLINE -O2 && ./a.out 5                                                 // inlined! 

You can also use non-standard attribute (e.g. __attribute__(always_inline)) in GCC) for extern inline definition, instead of relying on -O2.

BTW, the trick is used in glibc.