The linker command script includes a command specifically for specifying a version script, and is only meaningful for ELF platforms that support shared libraries. A version script can be build directly into the linker script that you are using, or you can supply the version script as just another input file to the linker at the time that you link. The command script syntax is:
VERSION { version script contents }
The version script can also be specified to the linker by means of the “--version-script” linker command line option. Version scripts are only meaningful when creating shared libraries.
The format of the version script itself is identical to that used by Sun's linker in Solaris 2.5. Versioning is done by defining a tree of version nodes with the names and interdependencies specified in the version script. The version script can specify which symbols are bound to which version nodes, and it can reduce a specified set of symbols to local scope so that they are not globally visible outside of the shared library.
The easiest way to demonstrate the version script language is with a few examples.
VERS_1.1 {
global:
foo1;
local:
old*;
original*;
new*;
};
VERS_1.2 {
foo2;
} VERS_1.1;
VERS_2.0 {
bar1; bar2;
} VERS_1.2;
In this example, three version nodes are defined. “VERS_1.1” is the first version node defined, and has no other dependencies. The symbol “foo1” is bound to this version node, and a number of symbols that have appeared within various object files are reduced in scope to local so that they are not visible outside of the shared library.
Next, the node “VERS_1.2” is defined. It depends upon “VERS_1.1”. The symbol “foo2” is bound to this version node.
Finally, the node “VERS_2.0” is defined. It depends upon “VERS_1.2”. The symbols “bar1” and “bar2” are bound to this version node.
Symbols defined in the library that aren't specifically bound to a version node are effectively bound to an unspecified base version of the library. It is possible to bind all otherwise unspecified symbols to a given version node using “global: *” somewhere in the version script.
Lexically the names of the version nodes have no specific meaning other than what they might suggest to the person reading them. The “2.0” version could just as well have appeared in between “1.1” and “1.2”. However, this would be a confusing way to write a version script.
When you link an application against a shared library that has version-ed symbols, the application itself knows which version of each symbol it requires, and it also knows which version nodes it needs from each shared library it is linked against. Thus at runtime, the dynamic loader can make a quick check to make sure that the libraries you have linked against do in fact supply all of the version nodes that the application will need to resolve all of the dynamic symbols. In this way it is possible for the dynamic linker to know with certainty that all external symbols that it needs will be resolvable without having to search for each symbol reference.
The symbol versioning is in effect a much more sophisticated way of doing minor version checking that Sun-OS does. The fundamental problem that is being addressed here is that typically references to external functions are bound on an as-needed basis, and are not all bound when the application starts up. If a shared library is out of date, a required interface may be missing; when the application tries to use that interface, it may suddenly and unexpectedly fail. With symbol versioning, the user will get a warning when they start their program if the libraries being used with the application are too old.
There are several GNU extensions to Sun's versioning approach. The first of these is the ability to bind a symbol to a version node in the source file where the symbol is defined instead of in the versioning script. This was done mainly to reduce the burden on the library maintainer. This can be done by putting something like:
__asm__(".symver original_foo,foo@VERS_1.1");
in the C source file. This renamed the function “original_foo” to be an alias for “foo” bound to the version node “VERS_1.1”. The “local:” directive can be used to prevent the symbol “original_foo” from being exported.
The second GNU extension is to allow multiple versions of the same function to appear in a given shared library. In this way an incompatible change to an interface can take place without increasing the major version number of the shared library, while still allowing applications linked against the old interface to continue to function.
This can only be accomplished by using multiple “.symver” directives in the assembler. An example of this would be:
__asm__(".symver original_foo,foo@");
__asm__(".symver old_foo,foo@VERS_1.1");
__asm__(".symver old_foo1,foo@VERS_1.2");
__asm__(".symver new_foo,foo@@VERS_2.0");
In this example, “foo@” represents the symbol “foo” bound to the unspecified base version of the symbol. The source file that contains this example would define 4 C functions: “original_foo”, “old_foo”, “old_foo1”, and “new_foo”.
When you have multiple definitions of a given symbol, there needs to be some way to specify a default version to which external references to this symbol will be bound. This can be accomplished with the “foo@@VERS_2.0” type of “.symver” directive. Only one version of a symbol can be declared 'default' in this manner - otherwise you would effectively have multiple definitions of the same symbol.
If you wish to bind a reference to a specific version of the symbol within the shared library, you can use the aliases of convenience (that is “old_foo”), or you can use the “.symver” directive to specifically bind to an external version of the function in question.