Question

gcc optimizes code when I pass it the -O2 flag, but I’m wondering how well it can actually do that if I compile all source files to object files and then link them afterwards.

Here’s an example:

// in a.h
int foo(int n);

// in foo.cpp
int foo(int n) {
  return n;
}

// in main.cpp
#include "a.h"
int main(void) {
  return foo(5);
}

// code used to compile it all
gcc -c -O2 foo.cpp -o foo.o
gcc -c -O2 main.cpp -o main.o
gcc -O2 foo.o main.o -o executable

Normally, gcc should inline foo because it’s a small function and -O2 enables -finline-small-functions, right? But here, gcc only sees the code of foo and main independently before it creates the object files, so there won’t be any optimizations like that, right? So, does compiling like this really make code slower?

However, I could also compile it like this:

gcc -O2 foo.cpp main.cpp -o executable

Would that be faster? If not, would it be faster this way?

// in foo.cpp
int foo(int n) {
  return n;
}

// in main.cpp
#include "foo.cpp"
int main(void) {
  return foo(5);
}

Edit: I looked at objdump, and its disassembled code showed that only the #include "foo.cpp" thing worked.

Answer 1

You may be looking for Link-Time Optimization (LTO), aka Whole Program Optimization.