embed string via header that cannot be optimized away

Question

While developing a header-only library, I\'d like to make sure that a given string is embedded in all binaries that use my header, even if the compiler is configured to optimize

Answer 1

TL;DR;

You might not be able to force a value into the compilation unit, but you can force a symbol by defining a global variable in the header. i.e.: long using_my_library_version_1_2_3;

The symbol will be accessible externally in the final binary file and could be tested against (though, like any solution, it could be circumvented, not to mention that the header itself could be altered).

EDIT: To clarify (due to comment), don't use a static variable.

By using a global variable it will default to extern and will not be optimized away (in case other objects loading the binary use the identifier).

Caveats and Example:

As mentioned in the comments, the global variable's identifier (name) is the string in this approach.

However, when compiling executables (and kernels), identifiers could be stripped from the final binary when compiling with (-s). This is often performed by embedded system developers and by people that enjoy making debugging a living hell (even more than it is anyway).

A quick example:

// main.c
int this_is_example_version_0_0_1; /* variable name will show in the file */

int main(void) {
  /* placed anywhere to avoid the "not used" warning: */
  (void)this_is_example_version_0_0_1;
  return 0;
}

// extra.c
int this_is_example_version_0_0_1; /* repeat line to your heart's content  */
int this_is_example_version_0_0_1; /* (i.e., if header has no include guard) */

Compile:

 $ cc -xc -o a -Wall -O2 main.c extra.c

List all identifiers/names (will show global):

 nm ./a | grep "this_is_example_version"

Test for string in binary file using:

$ grep -F "this_is_example_version" ./a

Details:

Funny facts about C that make this solution possible...:

1. C defines extern as the default for both function and variable declarations in the global scope (6.2.2, subsection 5).

2. According to section 6.2.2 ("Linkages of identifiers"), "each declaration of a particular identifier with external linkage denotes the same object or function."

   This means that duplicate declarations in the global scope will be collated to a single declaration.

3. Variable declarations and variable definitions look the same when the variable is placed in the global scope and all of it's bits are set to zero.

   This is because global variables are initialized to zero by default. Hence, compilers can't tell if int foo; is a definition (int foo = 0;) or a declaration (extern int foo;).

Because of this "identity" and these rules, compilers convert ambiguous global variable declarations/definitions into "weak" declarations, to be resolved by the linker.

This means that if you define a global variable without the extern keyword and without a value, the ambiguous declaration/definition will force the compiler to emit a weak symbol that will be exposed in the final binary.

This symbol could be used to identify the fact that the header was used somewhere in the program.