How can I tell my compiler or linker, that some symbol reference is only necessary for some function?

what can the user do, and what can/should I do, as a library author, to facilitate their being able to link their program? (That is, other than splitting the library in two or making the compilation of f() conditional at compile-time.)

If you don't want your shared library to depend on aux() then splitting out any aux()-dependent functions is exactly what you should do, protestations notwithstanding. Dependencies for such libraries should be viewed as properties of the library, not of individual functions within.

You do, however, have the alternative of building static libraries instead of shared ones. These are effectively just containers for object files, so if your f() and g() are defined in different source files, each compiled to its own object file, which is added to libmylib.a, then statically linking libmylib to get only a definition of g() will not incorporate f() or its dependency on aux() into your program.

On Linux, you also have the option of providing a weak, stub definition of aux() in your library, so that the symbol is always defined, but it will be superseded by the real aux() if that is linked in. You can make the stub fail loudly at runtime if you like, to help library users recognize when they need to link the additional library that provides the working definition of aux().

Or you can tell library users that, at least as long as they are using the GNU toolchain, they can link with -Wl,--allow-shlib-undefined to make the linker ignore the unresolved symbol. They will want lazy function resolution too (-z lazy), but this is the default. Of course, this will also cause the linker to ignore other unresolved symbols that perhaps it should not. And this is something library users have to do; you as library provider cannot do it for them.

You can compile the library that contains f and g with -ffunction-sections -fdata-sections to put each function in its own ELF section:

gcc -ffunction-sections -fdata-sections -c fg.c
ar rcs libfg.a fg.o

When linking, use Wl,--gc-sections to garbage collect unused sections:

gcc -o prog main.c -Wl,--gc-sections -L. -lfg

tl;dr: Use a 'weak symbol' implementation

Some executable/object formats include support for weak symbols: Symbol definition with low priority, so that they don't clash with a definition provided elsewhere. See also this StackOverflow question:

What are weak functions and what are their uses? I am using an STM32F429 microcontroller

You wrote that a relevant platform for you is GNU/Linux; well, you're in luck, because executables on Linux use the ELF binary format; and ELF supports weak symbols. So, you could provide a dummy definition of the aux symbol within your library, that would be marked "weak". Either you modify your ELF to mark a definition as weak, using some relevant ELF-format tools (not trivial but should be possible), or use a compiler which itself supports setting this attribute on function definitions. And you are again in luck if you use GCC, since it lets you write:

#inclde <stdlib.h>

__weak int aux(int some_argument) // or whatever the signature is
{
  // fputs("Perhaps some kind of error message here\n", stderr);
  exit(EXIT_FAILURE);
}

Now, if your user doesn't provide an aux() implementation and doesn't call f() - the linker will plug the weak aux() into the implementation of f(), but that won't hurt anybody. And if, on the other hand, your user does provide an implementation of f() - that (non-weak, or strong) definition of the symbol will be preferred over the weak one.

This approach has the benefit of not burdening the user with needing special linking switches; nor to adapt to some plugin framework; nor to sacrifice potential optimization or code size benefits in compiling f() and g() in the same section.

The downside is that weakness-of-symbols is not expressible in standard C; and only a subset of platforms and toolchains support this.

The most portable and flexible way is to change the code to use a callback function.

In order to do this, change aux from a declared function with no definition, into a function pointer of the expected format, either initialized to NULL or to a default behavior function. Provide a separate setter function for it, so that the user may pass on a pointer to their defined function. Function pointers have strong type safety and so the user may only pass a function of the correct format.

Pseudo code example:

// header:
typedef void aux_t (void);

void set_aux (aux_t* a);

void f (void);

// .c file:

static void default_aux (void)
{ 
  // ...
}

static aux_t* aux = default_aux;

void set_aux (aux_t* a)
{
  aux = a;
}

void f (void)
{
  // f does not care that aux is a function pointer nor where it points
  aux();
}

Other ways:

Using a "weak linkage" default definition is another way to do it, but it is non-portable.

You could also consider splitting your library up in several files, where one of the files is optional to use.

As you provide no source code is it difficult to give you a point to the solution. I suggest you the following to get to the traitor:

1. Provide a fake version for the aux() function, so the linker can continue linking your code.

2. Run it in the debugger. Put a breakpoint on aux sy mbol.

3. Run the code, when the debugger stops at aux() show a trace of the function calls to that point using the debugger command where.

This should help you find the path to the aux function without any imprecision.

If the aux() function is not called at all using the debugger, then there's another alternative that allows you to check why de linker decided to include de aux() function:

• Generate a map file, for that just include a

  --map=your_program.map
  

  to the linker command, or using

  -Wl,--map=your_program.map
  

  if you invoke the linker through the compiler.

  The linker generates a list of library dependencies satisfied, indicating the module that triggered the dependency to be included. This will help without any chance of failing.

Remember, the linker never generates a dependency error if there''s no reference to be solved. The linker will never know anything about your aux() function if it is actually never mentioned in the main program. Si it must be mentioned somewhere.

By the way, if you want to put (as it seems to by your question) two sets of functions that are unrelated (f() -> aux() and unrelated g() -> nothing) then never put them in the same compilation unit (this means they will never be linked into a .so shared unit) use f.c and g.c You will only require aux() when you have selected f.c in your program.

The linker cannot subdivide a compilation unit to include only part of the functions. (and more when creating a C --this is not C++-- project) You need to structure your library to use compilation unit that will represent the sufficient granularity to allow you to do what you want. If you have included two functions in the compilation unit, they will be included both, or none of them. This is most probably where the unknown dependence appears. The language is flexible enough to allow you to subdivide the library into a set of different .o objects. If you are building a shared library, it is linked as a shared object (not a library archive, where the linker can select the appropiate compilation units to include only the ones referenced in the main program) and the linker doesn't know which functions will the program to be using the library will need, so the shared objects are loaded at runtime in full, as they are shared between all programs that use the library.

The linker doesn't know anything about the internal relationships of the functions included in a compilation library (this doesn't need to be a callable symbol, but a reference to a global variable shared by both functions, which makes impossible to detect where to split the compilation unit without knows how the source was compiled)

A solution would be to put f() in a separate compilation unit, so you will need to include the compilation unit providing aux() only in the case you have included also f() and put both in a .a library archive. This makes the linker to select from the .a archive only the objects (.o or .so) that are required to solve references.

It's not clear what you try to solve, because IMHO you are not understanding the use of a shared library. You cannot link it including only the functions you need in your exact program, you link all, because the library doesn't actually know how many programs will make use of it (the text and read only data of a library are shared between all processes that load that shared library, so there's no penalty on having it replicated to all complete, probably a different program making use of that library will use the function you try to evict)

tl;dr: Don't do it, and tell the users to handle it.

Have you considered "Masterly Inactivity"?

Probably the simplest most portable way to handle your situation is to just leave things as they are, and simply tell your users they must define an aux() function to use the library. Tell users, in the library documentation, that if they are interested in f() but not in g(), they can and should define a trivial aux() function, and provide the source code for it, to make it extra-simple for them to do it.

Yes, this means a slight inconvenience for the user, but assuming your note regarding aux() is prominent enough, they will notice it and follow it.