Insert string at linking time

Question

I want to define a external global symbol (const char*) used by the program. Add the symbol at linking time with a given value. This is useful for example commit hash or build time.

I found --defsym which does something else. The Go linker supports this functionality via the -X option. (Yeah I know, Go Strings are managed, but I am talking about plain old zero terminated c strings)

For example:

extern const char *git_commit;

int main(int argc, char *argv[]) {
    puts(git_commit);
    return 0;
}

gcc main.o -Wl<something here that adds git_commit and set it to '84e5...'>

I am aware of config.h approach and building object files containing those string. But its 2019 by know. Such a simple task should be easy.

Edit more precise question Is there a equivalent option in gcc/binutils for Go Linker's -X option.

Answer 1

There is a change to do it in compile/preprocessing time, consider this:

#include <stdio.h>

const char * git_commit = GIT_COMMIT;

int main(int argc, char ** argv) {
        puts(git_commit);
        return 0;
}

and in command line:

gcc -o test test.c -DGIT_COMMIT="\"This is a test\""

assuming you are using GCC compiler.

Answer 2

One way:

echo "char const* git_commit = \"$(git rev-parse HEAD)\";" > git_commit.c
gcc -c -o git_commit.o git_commit.c
gcc -o main main.o git_commit.o

When you implement this in a makefile you may like to only recreate git_commit.c when the revision changes, so that it doesn't relink it on each make invokation.

Answer 3

I'm not aware of any way to do what you're seeking to do directly via a flag using one of the commonly used linkers. In general, if you want to link the definition of such an object into your program, you'll have to provide an object file containing a suitable symbol definition.

The probably simplest way to get there would be to just invoke the compiler to compile the definition of your variable with the content being fed from a macro defined via the command line like already suggested in the other answers. If you want to avoid creating temporary source files, gcc can also receive input straight from stdin:

echo "const char git_commit[] = GIT_COMMIT;" | gcc -DGIT_COMMIT=\"asdf\" -c -o git_commit.obj -xc++ -

And in your code your just declare it as

extern const char git_commit[];

Note: I'm using const char git_commit[] rather than const char* git_commit. That way, git_commit will directly be an array of suitable size initialized to hold the contents of the commit hash. const char* git_commit, on the other hand, will create a global pointer object initialized to hold the address of a separate string literal object, which means you introduce an unnecessary indirection. Not that it will really matter here, but it also doesn't really cost you anything to skip the inefficiency, however tiny it might be…

There would also be the objcopy utility which can be used to wrap arbitrary binary content in an object file, see, e.g., here How do I embed the contents of a binary file in an executable on Mac OS X? It may even be possible to pass input to objcopy straight via stdin as well. Finally, you could also just write your own tool that directly writes an object file containing a suitable symbol definition. Consider, however, that, at the end of the day, you're seeking to generate an object file that can be linked with the other object files making up your program. Simply using the same compiler you use to compile the rest of the code is probably the most robust way of going about doing that. With other solutions, you'll always have to manually make sure that the object files are compatible in terms of target architecture, memory layout, …

Answer 4

You could embed it as a ressource file, for example:

GitInfoHTML               HTML                    "GitInfo.html"

This will placed into the executable by the linker (at link time) and can then be loaded.

For more info, see: https://learn.microsoft.com/en-us/cpp/windows/resource-files-visual-studio?view=vs-2019