Functions only getting inlined if defined in a header. Am I missing something?

Question

Using gcc v4.8.1

If I do:

//func.hpp

#ifndef FUNC_HPP
#define FUNC_HPP

int func(int);

#endif

//func.cpp

#include "func.hpp"

int func(int x){
    return 5*x+7;
}

//main.cpp

#include <iostream>

#include "func.hpp"

using std::cout;
using std::endl;

int main(){
    cout<<func(5)<<endl;
    return 0;
}

Even the simple function func will not get inlined. No combination of inline, extern, static, and __attribute__((always_inline)) on the prototype and/or the definition changes this (obviously some combinations of these specifiers cause it to not even compile and/or produce warnings, not talking about those). I'm using g++ *.cpp -O3 -o run and g++ *.cpp -O3 -S for assembly output. When I look at the assembly output, I still see call func. It appears only way I can get the function to be properly inlined is to have the prototype (probably not necessary) and the definition of the function in the header file. If the header is only included by one file in the whole program (included by only main.cpp for example) it will compile and the function will be properly inlined without even needing the inline specifier. If the header is to be included by multiple files, the inline specifier appears to be needed to resolve multiple definition errors, and that appears to be its only purpose. The function is of course inlined properly.

So my question is: am I doing something wrong? Am I missing something? Whatever happened to:

"The compiler is smarter than you. It knows when a function should be inlined better than you do. And never ever use C arrays. Always use std::vector!"

-Every other StackOverflow user

Really? So calling func(5) and printing the result is faster than just printing 32? I will blindly follow you off the edge of a cliff all mighty all knowing and all wise gcc.

For the record, the above code is just an example. I am writing a ray tracer and when I moved all of the code of my math and other utility classes to their header files and used the inline specifier, I saw massive performance gains. Literally like 10 times faster for some scenes.

Regarding "Every other SO user:" note `std::vector` is a template and as such, it's *always* defined in header files and thus available for the compiler to inline at compile time. — Angew is no longer proud of SO, Oct 22 '13 at 12:24

score 10 · Accepted Answer · edited May 23 '17 at 11:51

Recent GCC is able to inline across compilation units through link-time optimizations (LTO). You need to compile - and link - with -flto; see Link-time optimization and inline and GCC optimize options.

(Actually, LTO is done by a special variant lto1 of the compiler at link time; LTO works by serializing, inside the object files, some internal representations of GCC, which are also used by lto1; so what happens with -flto is that when compiling a src1.c with it the generated src1.o contains the GIMPLE representations in addition of the object binary; and when linking with gcc -flto src*.o the lto1 "front-end" is extracting that GIMPLE representations from inside the src*.o and almost recompiling all again...)

You need to explicitly pass -flto both at compile time AND at link time (see this). If using a Makefile you could try make CC='gcc -flto'; otherwise, compile each translation unit with e.g. gcc -Wall -flto -O2 -c src1.c (and likewise for src2.c etc...) and link all of your program (or library) with gcc -Wall -flto -O2 src1.o src2.o -o prog -lsomelib

Notice that -flto will significantly slow down your build (it is not passed by -O3 so you need to use it explicitly, and you need to link with it also). Often you get a 5% or 10% improvement of performance -of the built program- at the expense of nearly doubling the build time. Sometimes you can get more improvements.

@Mike You probably already found out yourself by now, but the answer is no. Link-time optimization must be invoked explicitly. — Marc.2377, May 23 '16 at 21:06

score 3 · Answer 2 · answered Oct 22 '13 at 12:14

3

The compiler can't inline what it doesn't have. It needs the full body of the function to inline its code.

You have to remember that the compiler only works on one source file at a time (more precisely, one translation unit at a time), and have no idea about other source files and whats in them.

The linker might be able to do it though, as it sees all the code, and some linkers have flags that allows some link-time optimizations.

answered Oct 22 '13 at 12:14

Some programmer dude

400,186
35
402
621

inlining across TUs is nothing new. – Luchian Grigore Oct 22 '13 at 12:15
@LuchianGrigore But then it's the linker that does it, yes? – Some programmer dude Oct 22 '13 at 12:17
1

@JaochimPileborg: Actually, LTO is done by the compiler at link time. In GCC, `lto1` is (like `cc1` or `cc1plus`) a variant of the compiler. – Basile Starynkevitch Oct 22 '13 at 12:19
@BasileStarynkevitch Okay, didn't know that (obviously). – Some programmer dude Oct 22 '13 at 12:22
@Joachim: A delightful day! the first time I taught you something. Most of the time it is the other way: you are teaching us a lot of things! – Basile Starynkevitch Oct 22 '13 at 12:27
@BasileStarynkevitch So so, no need to be sarcastic (or ironic, take a pick) ;) – Some programmer dude Oct 22 '13 at 12:35
3

Does the classical distinction between compiler and linker even make sense today. The modern linker ends up doing a lot that would have been done by the compiler previously, and a lot of what the classical linker did now takes place at runtime. – James Kanze Oct 22 '13 at 12:42
Actually, LTO is mostly done by the *compiler* at *link-time*. – Basile Starynkevitch Oct 22 '13 at 13:50

score 1 · Answer 3 · answered Oct 22 '13 at 12:19

The inline keyword is nothing more than a suggestion to the compiler, "i want this function to be inlined". It can ignore this keyword, without even a warning.

In order for your function func(...) to be inlined, your compiler/linker HAVE TO support some form of link-time code generation(and optimizaton). Because func() and main() lie in different code units, the C++ compiler can't see them both at the same time, and therefore can't inline one function within the other. It NEEDS the LINKER SUPPORT to do so.

Consult your build tool manuals on how to switch link time code gen features on, if they are supported at all.

`inline` is more than a suggestion to the compiler. It also introduces a requirement for the function to be defined in every translation unit where it's used. — Angew is no longer proud of SO, Oct 22 '13 at 12:22

Functions only getting inlined if defined in a header. Am I missing something?

3 Answers3

Linked