How to determine inter-library dependencies?

Question

My project consists of a couple of static libraries, which are linked together in a final step. Now I have the problem, that the link order of the library is important (othe

Answer 1

If you truly have a circular dependency chain of static libraries (and this is not clear from your paste; you show only a non-circular dependency), there are two options:

1. Remove the circular dependency somehow; for example, you could make sure libcommon does not reference symbols in libpthardware.
2. Extract the individual .o files from the .a library, and link them directly. Then link order no longer matters.

In the case of 2., you may find it helpful to use partial linking rather than creating static libraries. On systems using GNU bintools, this can be done by invoking something like:

ld -r -o libfoo.o foo.o bar.o

The effect of this is to combine foo.o and bar.o into a single .o file. The order does not matter. You can then simply reference libfoo.o as a normal object file in your final link step.

Note that doing this may interfere with the linker's ability to discard unreferenced portions of the static library (normally this is done at the level of .o files within the .a, I believe). If you're using all or most of these libraries, this is probably not a problem. However, if code memory is an issue, you may want to look into automatically discarding unused code at the function level. If you do this, pass --gc-sections and -s only at the final link stage (and avoid doing so if you need to debug!). Also, static linking with system libraries does not seem to be necessary with modern gcc.

Answer 2

Another option to link libraries with circular dependencies is to use a special linker option for that. Man ld:

   -( archives -)
   --start-group archives --end-group
       The archives should be a list of archive files.  They may be either
       explicit file names, or -l options.

       The specified archives are searched repeatedly until no new
       undefined references are created.  Normally, an archive is searched
       only once in the order that it is specified on the command line.
       If a symbol in that archive is needed to resolve an undefined
       symbol referred to by an object in an archive that appears later on
       the command line, the linker would not be able to resolve that
       reference.  By grouping the archives, they all be searched
       repeatedly until all possible references are resolved.

       Using this option has a significant performance cost.  It is best
       to use it only when there are unavoidable circular references
       between two or more archives.

It is always cleaner to eliminate the circular dependencies though.