C++ - When function inlining is not possible?

Question

Folks,

I was reading "Thinking in C++" (Chap - Inline functions), where I encountered this statement.

"The compiler also cannot perform inlining if the address of the function is taken implicitly or explicitly".

What does that mean by "taking address of function implicitly or explicitly" ?
Why it is not possible to inline in this case ?

Thanks.

If the function is 'inlined', where is its address? – Stan Aug 26 '11 at 14:20 — Stan, Aug 26 '11 at 14:20

Péter Török · Answer 1 · 2011-08-26T14:29:28.117

5

Taking the address of a function means assigning it to a function pointer. This can happen explicitly, as in the linked examples. I am not sure what the author means by "implicitly" - maybe things like passing a function as a parameter to another function.

If the address of the function is taken, it must have an address in the first place. Since inlining means basically substituting calls to the function with a copy of its body, after such a transformation the function no more exists, thus has no address - only n distinct copies of identical code in places where there used to be calls to that function. Thus if a function's address is used in any way, it can't be inlined.

edited Aug 26 '11 at 14:29

answered Aug 26 '11 at 14:22

Péter Török

114,404
31
268
329

2

Well, theoretically it could be. Code such as `void foo(void); void (*p)(void) = &foo; p();` *could* be optimized by the compiler. – Oliver Charlesworth Aug 26 '11 at 14:23
Does that mean that compilers with optimizations on speed will inline everything where I don't do anything with the function pointer? – TravisG Aug 26 '11 at 14:26
2

@heishe: compilers have heuristic to try and guess whether it's better to inline or not. It's a complicated topic (you need to reason about cache/registers/etc...) and highly architecture specific. Don't worry too much about it ;) – Matthieu M. Aug 26 '11 at 14:35
@heishe : It is practical to say that if your function has a loop then there is slim to none chances of it getting inlined. So just so that you know, compiler is really selective about inlining, even when we hint it to inline a certain function. – Ajeet Ganga Aug 26 '11 at 14:57

score 4 · Accepted Answer · answered Aug 26 '11 at 14:43

Actually, the quote may mislead.

If a function address is taken, then it is necessary to generate the function in the library/executable, because the execution of a function by its address consist in jumping the instruction pointer to the block of code describing the function.

However, it certainly does not prevent the compiler to inline the function in other places, when called directly.

First, a review:

// Explicit:
void foo();

void (*func_ptr)() = foo;


// Implicit
struct Foo { virtual void bar() {} }; // address used in V-Table

Second, inlining examples:

int main() {
  (*func_ptr)(); // probably not inlined as the compiler can difficultly assert
                 // that nobody may modified it... since it's non-const.

  foo(); // might be inlined

  Foo f;
  f.bar(); // might be inlined (the exact type of `f` is known)
           // this is called, "devirtualizing"

  Foo& g = accessSomeFoo();
  g.bar(); // probably not inlined unless the compiler can assert
           // the type returned by accessSomeFoo
           // (which requires knowing its definition)
}

score 1 · Answer 3 · answered Aug 26 '11 at 14:29

I'm not sure if that is entirely true. However, if you take the address of a function, that function needs to exist in memory complete with the function's preamble and cleanup code. It's this preamble and cleanup that's omitted when inlining. And you get a whole load of optimisation possibilites when inlined.

But a modern compiler should still be able to inline the function wherever it's possible to inline it. Consider:

int compare (int a, int b)
{
  return a compared to b
}

int main ()
{
  a = array of ints

  qsort (a, compare); // take address of compare function, thus compare function exists in
                      // app as a proper function

  compare (value1, value2); // there's no reason why this can't be inlined
}

I think the quote should be more explicit about what can't be inlined:

A function that is called via a function pointer can not be inlined.

This is because there is no way to determine at compile time what function to inline at the point of the indirect call (the call via the function pointer). This doesn't mean to say that the function that has been pointed to by a function pointer can't be inlined wherever it is called directly.

The last bit of your answer isn't necessarily true. See my comment to @Peter's answer. — Oliver Charlesworth, Aug 26 '11 at 14:36
@Oli: Yes, I suppose a function pointer that can be deduced at compile time would certainly be able to be inlined, although I can't think why anyone would go through the trouble of creating a function pointer, assigning a function to it and doing an indirect call through it rather than just calling the function directly. Perhaps if you use templates. — Skizz, Aug 26 '11 at 14:44

C++ - When function inlining is not possible?

3 Answers3