tags:

views:

142

answers:

3

Prior to today I had always believed that the order that objects and libraries were passed to g++ during the linking stage was unimportant. Then, today, I tried to link from c++ code to c code. I wrapped all the C headers in an extern "C" block but the linker still had difficulties finding symbols which I knew were in the C object archives.

Perplexed, I created a relatively simple example to isolate the linking error but much to my surprise, the simpler example linked without any problems.

After a little trial and error, I found that by emulating the linking pattern used in the simple example, I could get the main code to link OK. The pattern was object code first, object archives second eg:

g++ -o serverCpp serverCpp.o algoC.o libcrypto.a

Can anyone shed some light on why this might be so?. I've never seen this problem when linking ordinary c++ code.

Thanks, Gearoid

+5  A: 

The order you specify object files and libraries is VERY important in GCC - if you haven't been bitten by this before you have lead a charmed life. The linker searches thinks in the order that they appear, so if you have a source file that contains a call to a library function, you need to put it before the library, or the linker won't know that it has to resolve it. Complex use of libraries can mean that you have to specify the library more than once, which is a royal pain to get right.

anon
Believe me, I haven't :-), is there any documentation on this property?
Gearoid Murphy
Here we go : http://www.network-theory.co.uk/docs/gccintro/gccintro_18.html
Gearoid Murphy
I, too, have always found the link order to be critical; it can be difficult working out why link errors are occurring, too, until you guess that the order is wrong...
PP
@Gearoid In the unlikely event that you are interested in linkers, take a look at http://www.iecc.com/linker.
anon
@PP There is nothing I dread more than linker error messages.
anon
I remember being puzzled by a complex linking operation I saw in a Makefile last year which referenced certain libraries multiple times, now I understand why :)
Gearoid Murphy
+1 for suggesting, "specify the library more than once." Critical, critical, critical!
Andres Jaan Tack
+3  A: 

A static library is a collection of object files grouped into an archive. When linking against it, the linker only chooses the objects it needs to resolve any currently undefined symbols. Since the objects are linked in order given on the command line, objects from the library will only be included if the library comes after all the objects that depend on it.

So the link order is very important; if you're going to use static libraries, then you need to be careful to keep track of dependencies, and don't introduce cyclic dependencies between libraries.

Mike Seymour
Cyclic dependencies are OK - it just means you need to have a link line like "`a.o b.o a.o`".
caf
@caf: if the extra objects from the second inclusion of `a` depend on objects in `b` that haven't been included yet, then that's not good enough; you'll need to add `b` again at the end. Which in turn might introduce more dependencies on `a`. So cyclic dependencies aren't really "OK", it's just rare for them to be pathological enough to need more than one repetition.
Mike Seymour
+2  A: 

The library order pass to gcc/g++ does actually matter. If A depends on B, A must be listed first. The reason is that it optimizes out symbols that aren't referenced, so if it sees library B first, and no one has referenced it at that point then it won't link in anything from it at all.

Mark B