Question

I asked myself the following question, when I was discussing this topic .

Are there cases when some unused code from translation units will link to final executable code (in release mode of course) for popular compilers like GCC and VC++?

For example suppose we have 2 compilation units:

//A.hpp
//Here are declarations of some classes, functions, extern variables etc.

And source file

//A.cpp
//defination of A.hpp declarations

And finally main

//main.cpp
//including A.hpp library
#include "A.hpp"
//here we will use some stuff from A.hpp library, but not everything

My question is. What if in main.cpp not all the stuff from A.hpp is used? Will the linker remove all unused code, or there are some cases, when some unused code can link with executable file?

Edit: I’m interested in G++ and VC++ linkers.

Edit: Of course I mean in release mode.

Edit: I’m starting bounty for this question to get good and full answer. I’m expecting answer, which will explain in which cases g++ and VC++ linkers are linking junk and what kind of code they are able to remove from executable file(unneeded functions, unneeded global variables, unneeded class definitions, etc…) and why aren’t they able to remove some kind of unneeded stuff.

Answer 1

As other posters have indicated, the linker typically does not remove dead code before building the final executable. However, there are often Optimization settings you can use to force the linker to try extra hard to do this.

For GCC, this is accomplished in two stages:

1. First compile the data but tell the compiler to separate the code into separate sections within the translation unit. This will be done for functions, classes, and external variables by using the following two compiler flags:

   -fdata-sections -ffunction-sections

2. Link the translation units together using the linker optimization flag (this causes the linker to discard unreferenced sections):

   -Wl,–gc-sections

So if you had one file called test.cpp that had two functions declared in it, but one of them was unused, you could omit the unused one with the following command to gcc(g++):

gcc -Os -fdata-sections -ffunction-sections test.cpp -o test.o -Wl,--gc-sections

(Note that -Os is an additional linker flag that tells GCC to optimize for size)

I have also read somewhere that linking static libraries is different though. That GCC automatically omits unused symbols in this case. Perhaps another poster can confirm/disprove this.

As for MSVC, as others have mentioned, function level linking accomplishes the same thing.
I believe the compiler flag for this is (to sort things into sections):

/Gy

And then the linker flag (to discard unused sections):

/OPT:REF

EDIT: After further research, I think that bit about GCC automatically doing this for static libraries is false.