Can GCC optimize things better when I compile everything in one step?

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.