Copyright (C) 1996-2003, 2005 Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with the no Invariant Sections, with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License".
This file documents GNU Libtool, a script that allows package developers to provide generic shared library support. This edition documents version 1.5.22.
See Reporting bugs, for information on how to report problems with libtool.
Introduction
Using libtool
Invoking libtool
Integrating libtool with your package
Configuring libtool
Including libtool in your package
Library interface versions
Tips for interface design
Dlopened modules
Using libltdl
Using libtool with other languages
Troubleshooting
The libtool test suite
Maintenance notes for libtool
Porting libtool to new systems
Platform quirks
In the past, if a source code package developer wanted to take advantage of the power of shared libraries, he needed to write custom support code for each platform on which his package ran. He also had to design a configuration interface so that the package installer could choose what sort of libraries were built.
GNU Libtool simplifies the developer's job by encapsulating both the platform-specific dependencies, and the user interface, in a single script. GNU Libtool is designed so that the complete functionality of each host type is available via a generic interface, but nasty quirks are hidden from the programmer.
GNU Libtool's consistent interface is reassuring... users don't need
to read obscure documentation in order to have their favorite source
package build shared libraries. They just run your package
configure script (or equivalent), and libtool does all the dirty
work.
There are several examples throughout this document. All assume the same environment: we want to build a library, libhello, in a generic way.
libhello could be a shared library, a static library, or both... whatever is available on the host system, as long as libtool has been ported to it.
This chapter explains the original design philosophy of libtool. Feel free to skip to the next chapter, unless you are interested in history, or want to write code to extend libtool in a consistent way.
Since early 1995, several different GNU developers have recognized the importance of having shared library support for their packages. The primary motivation for such a change is to encourage modularity and reuse of code (both conceptually and physically) in GNU programs.
Such a demand means that the way libraries are built in GNU packages needs to be general, to allow for any library type the package installer might want. The problem is compounded by the absence of a standard procedure for creating shared libraries on different platforms.
The following sections outline the major issues facing shared library support in GNU, and how shared library support could be standardized with libtool.
The following specifications were used in developing and evaluating this system:
The following issues need to be addressed in any reusable shared library system, specifically libtool:
LD_LIBRARY_PATH must be set properly (if
it is supported), or programs fail to run.
LD_LIBRARY_PATH or equivalent),
or run ldconfig.
Even before libtool was developed, many free software packages built and installed their own shared libraries. At first, these packages were examined to avoid reinventing existing features.
Now it is clear that none of these packages have documented the details of shared library systems that libtool requires. So, other packages have been more or less abandoned as influences.
In all fairness, each of the implementations that were examined do the job that they were intended to do, for a number of different host systems. However, none of these solutions seem to function well as a generalized, reusable component.
Most were too complex to use (much less modify) without understanding exactly what the implementation does, and they were generally not documented.
The main difficulty is that different vendors have different views of what libraries are, and none of the packages which were examined seemed to be confident enough to settle on a single paradigm that just works.
Ideally, libtool would be a standard that would be implemented as series of extensions and modifications to existing library systems to make them work consistently. However, it is not an easy task to convince operating system developers to mend their evil ways, and people want to build shared libraries right now, even on buggy, broken, confused operating systems.
For this reason, libtool was designed as an independent shell script. It isolates the problems and inconsistencies in library building that plague Makefile writers by wrapping the compiler suite on different platforms with a consistent, powerful interface.
With luck, libtool will be useful to and used by the GNU community, and that the lessons that were learned in writing it will be taken up by designers of future library systems.
At first, libtool was designed to support an arbitrary number of library object types. After libtool was ported to more platforms, a new paradigm gradually developed for describing the relationship between libraries and programs.
In summary, “libraries are programs with multiple entry points, and more formally defined interfaces.”
Version 0.7 of libtool was a complete redesign and rewrite of libtool to reflect this new paradigm. So far, it has proved to be successful: libtool is simpler and more useful than before.
The best way to introduce the libtool paradigm is to contrast it with the paradigm of existing library systems, with examples from each. It is a new way of thinking, so it may take a little time to absorb, but when you understand it, the world becomes simpler.
It makes little sense to talk about using libtool in your own packages until you have seen how it makes your life simpler. The examples in this chapter introduce the main features of libtool by comparing the standard library building procedure to libtool's operation on two different platforms:
You can follow these examples on your own platform, using the preconfigured libtool script that was installed with libtool (see Configuring).
Source files for the following examples are taken from the demo subdirectory of the libtool distribution. Assume that we are building a library, libhello, out of the files foo.c and hello.c.
Note that the foo.c source file uses the cos math library
function, which is usually found in the standalone math library, and not
the C library (see Trigonometric Functions (The GNU C Library Reference Manual)). So, we need to add -lm to
the end of the link line whenever we link foo.o or foo.lo
into an executable or a library (see Inter-library dependencies).
The same rule applies whenever you use functions that don't appear in the standard C library... you need to add the appropriate -lname flag to the end of the link line when you link against those objects.
After we have built that library, we want to create a program by linking main.o against libhello.
To create an object file from a source file, the compiler is invoked with the `-c' flag (and any other desired flags):
burger$ gcc -g -O -c main.c
burger$
The above compiler command produces an object file, main.o, from the source file main.c.
For most library systems, creating object files that become part of a static library is as simple as creating object files that are linked to form an executable:
burger$ gcc -g -O -c foo.c
burger$ gcc -g -O -c hello.c
burger$
Shared libraries, however, may only be built from position-independent code (PIC). So, special flags must be passed to the compiler to tell it to generate PIC rather than the standard position-dependent code.
Since this is a library implementation detail, libtool hides the complexity of PIC compiler flags by using separate library object files (which end in .lo instead of .o). On systems without shared libraries (or without special PIC compiler flags), these library object files are identical to “standard” object files.
To create library object files for foo.c and hello.c, simply invoke libtool with the standard compilation command as arguments (see Compile mode):
a23$ libtool --mode=compile gcc -g -O -c foo.c
gcc -g -O -c foo.c
echo timestamp > foo.lo
a23$ libtool --mode=compile gcc -g -O -c hello.c
gcc -g -O -c hello.c
echo timestamp > hello.lo
a23$
Note that libtool creates two files for each invocation. The .lo file is a library object, which may be built into a shared library, and the .o file is a standard object file. On a23, the library objects are just timestamps, because only static libraries are supported.
On shared library systems, libtool automatically inserts the PIC generation flags into the compilation command, so that the library object and the standard object differ:
burger$ libtool --mode=compile gcc -g -O -c foo.c
gcc -g -O -c -fPIC -DPIC foo.c
mv -f foo.o foo.lo
gcc -g -O -c foo.c >/dev/null 2>&1
burger$ libtool --mode=compile gcc -g -O -c hello.c
gcc -g -O -c -fPIC -DPIC hello.c
mv -f hello.o hello.lo
gcc -g -O -c hello.c >/dev/null 2>&1
burger$
Notice that the second run of GCC has its output discarded. This is done so that compiler warnings aren't annoyingly duplicated.
Without libtool, the programmer would invoke the ar command to
create a static library:
burger$ ar cru libhello.a hello.o foo.o
burger$
But of course, that would be too simple, so many systems require that
you run the ranlib command on the resulting library (to give it
better karma, or something):
burger$ ranlib libhello.a
burger$
It seems more natural to use the C compiler for this task, given
libtool's “libraries are programs” approach. So, on platforms without
shared libraries, libtool simply acts as a wrapper for the system
ar (and possibly ranlib) commands.
Again, the libtool library name differs from the standard name (it has a .la suffix instead of a .a suffix). The arguments to libtool are the same ones you would use to produce an executable named libhello.la with your compiler (see Link mode):
a23$ libtool --mode=link gcc -g -O -o libhello.la foo.o hello.o
libtool: cannot build libtool library `libhello.la' from non-libtool \
objects
a23$
Aha! Libtool caught a common error... trying to build a library from standard objects instead of library objects. This doesn't matter for static libraries, but on shared library systems, it is of great importance.
So, let's try again, this time with the library object files. Remember
also that we need to add -lm to the link command line because
foo.c uses the cos math library function (see Using libtool).
Another complication in building shared libraries is that we need to specify the path to the directory in which they (eventually) will be installed (in this case, /usr/local/lib)1:
a23$ libtool --mode=link gcc -g -O -o libhello.la foo.lo hello.lo \
-rpath /usr/local/lib -lm
mkdir .libs
ar cru .libs/libhello.a foo.o hello.o
ranlib .libs/libhello.a
creating libhello.la
a23$
Now, let's try the same trick on the shared library platform:
burger$ libtool --mode=link gcc -g -O -o libhello.la foo.lo hello.lo \
-rpath /usr/local/lib -lm
mkdir .libs
ld -Bshareable -o .libs/libhello.so.0.0 foo.lo hello.lo -lm
ar cru .libs/libhello.a foo.o hello.o
ranlib .libs/libhello.a
creating libhello.la
burger$
Now that's significantly cooler... libtool just ran an obscure
ld command to create a shared library, as well as the static
library.
Note how libtool creates extra files in the .libs subdirectory, rather than the current directory. This feature is to make it easier to clean up the build directory, and to help ensure that other programs fail horribly if you accidentally forget to use libtool when you should.
If you choose at this point to install the library (put it in a permanent location) before linking executables against it, then you don't need to use libtool to do the linking. Simply use the appropriate -L and -l flags to specify the library's location.
Some system linkers insist on encoding the full directory name of each shared library in the resulting executable. Libtool has to work around this misfeature by special magic to ensure that only permanent directory names are put into installed executables.
The importance of this bug must not be overlooked: it won't cause programs to crash in obvious ways. It creates a security hole, and possibly even worse, if you are modifying the library source code after you have installed the package, you will change the behaviour of the installed programs!
So, if you want to link programs against the library before you install it, you must use libtool to do the linking.
Here's the old way of linking against an uninstalled library:
burger$ gcc -g -O -o hell.old main.o libhello.a -lm
burger$
Libtool's way is almost the same2 (see Link mode):
a23$ libtool --mode=link gcc -g -O -o hell main.o libhello.la -lm
gcc -g -O -o hell main.o ./.libs/libhello.a -lm
a23$
That looks too simple to be true. All libtool did was transform libhello.la to ./.libs/libhello.a, but remember that a23 has no shared libraries.
On burger the situation is different:
burger$ libtool --mode=link gcc -g -O -o hell main.o libhello.la -lm
gcc -g -O -o .libs/hell main.o -L./.libs -R/usr/local/lib -lhello -lm
creating hell
burger$
Now assume libhello.la had already been installed, and you want to link a new program with it. You could figure out where it lives by yourself, then run:
burger$ gcc -g -O -o test test.o -L/usr/local/lib -lhello
However, unless /usr/local/lib is in the standard library search
path, you won't be able to run test. However, if you use libtool
to link the already-installed libtool library, it will do The Right
Thing (TM) for you:
burger$ libtool --mode=link gcc -g -O -o test \
test.o /usr/local/lib/libhello.la
gcc -g -O -o .libs/test test.o -Wl,--rpath
-Wl,/usr/local/lib /usr/local/lib/libhello.a -lm
creating test
burger$
Note that libtool added the necessary run-time path flag, as well as -lm, the library libhello.la depended upon. Nice, huh?
Since libtool created a wrapper script, you should use libtool to install it and debug it too. However, since the program does not depend on any uninstalled libtool library, it is probably usable even without the wrapper script. Libtool could probably be made smarter to avoid the creation of the wrapper script in this case, but this is left as an exercise for the reader.
Notice that the executable, hell, was actually created in the
.libs subdirectory. Then, a wrapper script was created
in the current directory.
On NetBSD 1.2, libtool encodes the installation directory of libhello, by using the -R/usr/local/lib compiler flag. Then, the wrapper script guarantees that the executable finds the correct shared library (the one in ./.libs) until it is properly installed.
Let's compare the two different programs:
burger$ time ./hell.old
Welcome to GNU Hell!
** This is not GNU Hello. There is no built-in mail reader. **
0.21 real 0.02 user 0.08 sys
burger$ time ./hell
Welcome to GNU Hell!
** This is not GNU Hello. There is no built-in mail reader. **
0.63 real 0.09 user 0.59 sys
burger$
The wrapper script takes significantly longer to execute, but at least the results are correct, even though the shared library hasn't been installed yet.
So, what about all the space savings that shared libraries are supposed to yield?
burger$ ls -l hell.old libhello.a
-rwxr-xr-x 1 gord gord 15481 Nov 14 12:11 hell.old
-rw-r--r-- 1 gord gord 4274 Nov 13 18:02 libhello.a
burger$ ls -l .libs/hell .libs/libhello.*
-rwxr-xr-x 1 gord gord 11647 Nov 14 12:10 .libs/hell
-rw-r--r-- 1 gord gord 4274 Nov 13 18:44 .libs/libhello.a
-rwxr-xr-x 1 gord gord 12205 Nov 13 18:44 .libs/libhello.so.0.0
burger$
Well, that sucks. Maybe I should just scrap this project and take up basket weaving.
Actually, it just proves an important point: shared libraries incur overhead because of their (relative) complexity. In this situation, the price of being dynamic is eight kilobytes, and the payoff is about four kilobytes. So, having a shared libhello won't be an advantage until we link it against at least a few more programs.
If hell was a complicated program, you would certainly want to test and debug it before installing it on your system. In the above section, you saw how the libtool wrapper script makes it possible to run the program directly, but unfortunately, this mechanism interferes with the debugger:
burger$ gdb hell
GDB is free software and you are welcome to distribute copies of it
under certain conditions; type "show copying" to see the conditions.
There is no warranty for GDB; type "show warranty" for details.
GDB 4.16 (i386-unknown-netbsd), (C) 1996 Free Software Foundation, Inc.
"hell": not in executable format: File format not recognized
(gdb) quit
burger$
Sad. It doesn't work because GDB doesn't know where the executable lives. So, let's try again, by invoking GDB directly on the executable:
burger$ gdb .libs/hell
trick:/home/src/libtool/demo$ gdb .libs/hell
GDB is free software and you are welcome to distribute copies of it
under certain conditions; type "show copying" to see the conditions.
There is no warranty for GDB; type "show warranty" for details.
GDB 4.16 (i386-unknown-netbsd), (C) 1996 Free Software Foundation, Inc.
(gdb) break main
Breakpoint 1 at 0x8048547: file main.c, line 29.
(gdb) run
Starting program: /home/src/libtool/demo/.libs/hell
/home/src/libtool/demo/.libs/hell: can't load library 'libhello.so.2'
Program exited with code 020.
(gdb) quit
burger$
Argh. Now GDB complains because it cannot find the shared library that hell is linked against. So, we must use libtool in order to properly set the library path and run the debugger. Fortunately, we can forget all about the .libs directory, and just run it on the executable wrapper (see Execute mode):
burger$ libtool --mode=execute gdb hell
GDB is free software and you are welcome to distribute copies of it
under certain conditions; type "show copying" to see the conditions.
There is no warranty for GDB; type "show warranty" for details.
GDB 4.16 (i386-unknown-netbsd), (C) 1996 Free Software Foundation, Inc.
(gdb) break main
Breakpoint 1 at 0x8048547: file main.c, line 29.
(gdb) run
Starting program: /home/src/libtool/demo/.libs/hell
Breakpoint 1, main (argc=1, argv=0xbffffc40) at main.c:29
29 printf ("Welcome to GNU Hell!\n");
(gdb) quit
The program is running. Quit anyway (and kill it)? (y or n) y
burger$
Installing libraries on a non-libtool system is quite straightforward... just copy them into place:3
burger$ su
Password: ********
burger# cp libhello.a /usr/local/lib/libhello.a
burger#
Oops, don't forget the ranlib command:
burger# ranlib /usr/local/lib/libhello.a
burger#
Libtool installation is quite simple, as well. Just use the
install or cp command that you normally would
(see Install mode):
a23# libtool --mode=install cp libhello.la /usr/local/lib/libhello.la
cp libhello.la /usr/local/lib/libhello.la
cp .libs/libhello.a /usr/local/lib/libhello.a
ranlib /usr/local/lib/libhello.a
a23#
Note that the libtool library libhello.la is also installed, to help libtool with uninstallation (see Uninstall mode) and linking (see Linking executables) and to help programs with dlopening (see Dlopened modules).
Here is the shared library example:
burger# libtool --mode=install install -c libhello.la \
/usr/local/lib/libhello.la
install -c .libs/libhello.so.0.0 /usr/local/lib/libhello.so.0.0
install -c libhello.la /usr/local/lib/libhello.la
install -c .libs/libhello.a /usr/local/lib/libhello.a
ranlib /usr/local/lib/libhello.a
burger#
It is safe to specify the -s (strip symbols) flag if you use a BSD-compatible install program when installing libraries. Libtool will either ignore the -s flag, or will run a program that will strip only debugging and compiler symbols from the library.
Once the libraries have been put in place, there may be some additional configuration that you need to do before using them. First, you must make sure that where the library is installed actually agrees with the -rpath flag you used to build it.
Then, running libtool -n --mode=finish libdir can give you further hints on what to do (see Finish mode):
burger# libtool -n --mode=finish /usr/local/lib
PATH="$PATH:/sbin" ldconfig -m /usr/local/lib
-----------------------------------------------------------------
Libraries have been installed in:
/usr/local/lib
To link against installed libraries in a given directory, LIBDIR,
you must use the `-LLIBDIR' flag during linking.
You will also need to do one of the following:
- add LIBDIR to the `LD_LIBRARY_PATH' environment variable
during execution
- add LIBDIR to the `LD_RUN_PATH' environment variable
during linking
- use the `-RLIBDIR' linker flag
See any operating system documentation about shared libraries for
more information, such as the ld and ld.so manual pages.
-----------------------------------------------------------------
burger#
After you have completed these steps, you can go on to begin using the installed libraries. You may also install any executables that depend on libraries you created.
If you used libtool to link any executables against uninstalled libtool libraries (see Linking executables), you need to use libtool to install the executables after the libraries have been installed (see Installing libraries).
So, for our Ultrix example, we would run:
a23# libtool install -c hell /usr/local/bin/hell
install -c hell /usr/local/bin/hell
a23#
On shared library systems, libtool just ignores the wrapper script and installs the correct binary:
burger# libtool install -c hell /usr/local/bin/hell
install -c .libs/hell /usr/local/bin/hell
burger#
Why return to ar and ranlib silliness when you've had a
taste of libtool? Well, sometimes it is desirable to create a static
archive that can never be shared. The most frequent case is when you
have a set of object files that you use to build several different
programs. You can create a “convenience library” out of those
objects, and link programs with the library, instead of listing all
object files for every program. This technique is often used to
overcome GNU automake's lack of support for linking object files built
from sources in other directories, because it supports linking with
libraries from other directories. This limitation applies to GNU
automake up to release 1.4; newer releases should support sources in
other directories.
If you just want to link this convenience library into programs, then
you could just ignore libtool entirely, and use the old ar and
ranlib commands (or the corresponding GNU automake
_LIBRARIES rules). You can even install a convenience library
(but you probably don't want to) using libtool:
burger$ libtool --mode=install ./install-sh -c libhello.a \
/local/lib/libhello.a
./install-sh -c libhello.a /local/lib/libhello.a
ranlib /local/lib/libhello.a
burger$
Using libtool for static library installation protects your library from
being accidentally stripped (if the installer used the -s flag),
as well as automatically running the correct ranlib command.
But libtool libraries are more than just collections of object files: they can also carry library dependency information, which old archives do not. If you want to create a libtool static convenience library, you can omit the -rpath flag and use -static to indicate that you're only interested in a static library. When you link a program with such a library, libtool will actually link all object files and dependency libraries into the program.
If you omit both -rpath and -static, libtool will create a convenience library that can be used to create other libtool libraries, even shared ones. Just like in the static case, the library behaves as an alias to a set of object files and dependency libraries, but in this case the object files are suitable for inclusion in shared libraries. But be careful not to link a single convenience library, directly or indirectly, into a single program or library, otherwise you may get errors about symbol redefinitions.
When GNU automake is used, you should use noinst_LTLIBRARIES
instead of lib_LTLIBRARIES for convenience libraries, so that
the -rpath option is not passed when they are linked.
As a rule of thumb, link a libtool convenience library into at most one libtool library, and never into a program, and link libtool static convenience libraries only into programs, and only if you need to carry library dependency information to the user of the static convenience library.
Another common situation where static linking is desirable is in creating a standalone binary. Use libtool to do the linking and add the -all-static flag.
libtool
The libtool program has the following synopsis:
libtool [option]... [mode-arg]...
and accepts the following options:
less (or
more) or redirect to a file.
mode must be set to one of the following:
The mode-args are a variable number of arguments, depending on the selected operation mode. In general, each mode-arg is interpreted by programs libtool invokes, rather than libtool itself.
For compile mode, mode-args is a compiler command to be used in creating a `standard' object file. These arguments should begin with the name of the C compiler, and contain the -c compiler flag so that only an object file is created.
Libtool determines the name of the output file by removing the directory component from the source file name, then substituting the source code suffix (e.g. .c for C source code) with the library object suffix, .lo.
If shared libraries are being built, any necessary PIC generation flags are substituted into the compilation command. You can pass link specific flags to the compiler driver using -XCClinker flag or pass linker flags with -Wl,flag and -Xlinker flag. You can also pass compile specific flags using -Wc,flag and -Xcompiler flag.
If both PIC and non-PIC objects are being built, libtool will normally suppress the compiler output for the PIC object compilation to save showing very similar, if not identical duplicate output for each object. If the -no-suppress option is given in compile mode, libtool will show the compiler output for both objects.
If the -static option is given, then a .o file is built, even if libtool was configured with --disable-static.
Note that the -o option is now fully supported. It is emulated on the platforms that don't support it (by locking and moving the objects), so it is really easy to use libtool, just with minor modifications to your Makefiles. Typing for example
libtool gcc -c foo/x.c -o foo/x.lo
will do what you expect.
Note, however, that, if the compiler does not support -c and -o, it is impossible to compile foo/x.c without overwriting an existing ./x.o. Therefore, if you do have a source file ./x.c, make sure you introduce dependencies in your Makefile to make sure ./x.o (or ./x.lo) is re-created after any sub-directory's x.lo:
x.o x.lo: foo/x.lo bar/x.lo
This will also ensure that make won't try to use a temporarily corrupted x.o to create a program or library. It may cause needless recompilation on platforms that support -c and -o together, but it's the only way to make it safe for those that don't.
Link mode links together object files (including library objects) to form another library or to create an executable program.
mode-args consist of a command using the C compiler to create an output file (with the -o flag) from several object files.
The following components of mode-args are treated specially:
self libtool will make
sure that the program can dlopen itself, either by enabling
-export-dynamic or by falling back to -dlpreopen self.
self, the symbols of the program itself will be added to
lt_preloaded_symbols.
If file is force libtool will make sure that
lt_preloaded_symbols is always defined, regardless of whether
it's empty or not.
dlsym
(see Dlopened modules).
gcc -ftest-coverage for example.
If the output-file ends in .la, then a libtool library is created, which must be built only from library objects (.lo files). The -rpath option is required. In the current implementation, libtool libraries may not depend on other uninstalled libtool libraries (see Inter-library dependencies).
If the output-file ends in .a, then a standard library is
created using ar and possibly ranlib.
If output-file ends in .o or .lo, then a reloadable object file is created from the input files (generally using ld -r). This method is often called partial linking.
Otherwise, an executable program is created.
For execute mode, the library path is automatically set, then a program is executed.
The first of the mode-args is treated as a program name, with the rest as arguments to that program.
The following components of mode-args are treated specially:
This mode sets the library path environment variable according to any -dlopen flags.
If any of the args are libtool executable wrappers, then they are translated into the name of their corresponding uninstalled binary, and any of their required library directories are added to the library path.
In install mode, libtool interprets most of the elements of
mode-args as an installation command beginning with
cp, or a BSD-compatible install program.
The following components of mode-args are treated specially:
automake uses
DESTDIR. For instance, if prefix is /usr/local,
but inst-prefix-dir is /tmp, then the object will be
installed under /tmp/usr/local/. If the installed object
is a libtool library, then the internal fields of that library
will reflect only prefix, not inst-prefix-dir:
# Directory that this library needs to be installed in:
libdir='/usr/local/lib'
not
# Directory that this library needs to be installed in:
libdir='/tmp/usr/local/lib'
inst-prefix is also used to insure that if the installed
object must be relinked upon installation, that it is relinked
against the libraries in inst-prefix-dir/prefix,
not prefix.
In truth, this option is not really intended for use when calling
libtool directly; it is automatically used when libtool --mode=install
calls libtool --mode=relink. Libtool does this by
analyzing the destination path given in the original
libtool --mode=install command and comparing it to the
expected installation path established during libtool --mode=link.
Thus, end-users need change nothing, and automake-style
make install DESTDIR=/tmp will Just Work(tm).
The rest of the mode-args are interpreted as arguments to the
cp or install command.
The command is run, and any necessary unprivileged post-installation commands are also completed.
Finish mode helps system administrators install libtool libraries so that they can be located and linked into user programs.
Each mode-arg is interpreted as the name of a library directory. Running this command may require superuser privileges, so the --dry-run option may be useful.
Uninstall mode deletes installed libraries, executables and objects.
The first mode-arg is the name of the program to use to delete files (typically /bin/rm).
The remaining mode-args are either flags for the deletion program (beginning with a `-'), or the names of files to delete.
Clean mode deletes uninstalled libraries, executables, objects and libtool's temporary files associated with them.
The first mode-arg is the name of the program to use to delete files (typically /bin/rm).
The remaining mode-args are either flags for the deletion program (beginning with a `-'), or the names of files to delete.
This chapter describes how to integrate libtool with your packages so that your users can install hassle-free shared libraries.
Libtool is fully integrated with Automake (see Introduction (The Automake Manual)), starting with Automake version 1.2.
If you want to use libtool in a regular Makefile (or Makefile.in), you are on your own. If you're not using Automake 1.2, and you don't know how to incorporate libtool into your package you need to do one of the following:
Libtool library support is implemented under the LTLIBRARIES primary.
Here are some samples from the Automake Makefile.am in the libtool distribution's demo subdirectory.
First, to link a program against a libtool library, just use the program_LDADD variable:
bin_PROGRAMS = hell hell.debug
# Build hell from main.c and libhello.la
hell_SOURCES = main.c
hell_LDADD = libhello.la
# Create an easier-to-debug version of hell.
hell_debug_SOURCES = main.c
hell_debug_LDADD = libhello.la
hell_debug_LDFLAGS = -static
The flags -dlopen or -dlpreopen (see Link mode) would fit better in the program_LDADD variable. Unfortunately, GNU automake, up to release 1.4, doesn't accept these flags in a program_LDADD variable, so you have the following alternatives:
program_LDADD = "-dlopen" libfoo.la
program_DEPENDENCIES = libfoo.la
You may use the program_LDFLAGS variable to stuff in any flags you want to pass to libtool while linking program (such as -static to avoid linking uninstalled shared libtool libraries).
Building a libtool library is almost as trivial... note the use of libhello_la_LDFLAGS to pass the -version-info (see Versioning) option to libtool:
# Build a libtool library, libhello.la for installation in libdir.
lib_LTLIBRARIES = libhello.la
libhello_la_SOURCES = hello.c foo.c
libhello_la_LDFLAGS = -version-info 3:12:1
The -rpath option is passed automatically by Automake (except for
libraries listed as noinst_LTLIBRARIES), so you
should not specify it.
See Building a Shared Library (The Automake Manual), for more information.
Libtool requires intimate knowledge of your compiler suite and operating system in order to be able to create shared libraries and link against them properly. When you install the libtool distribution, a system-specific libtool script is installed into your binary directory.
However, when you distribute libtool with your own packages (see Distributing), you do not always know which compiler suite and operating system are used to compile your package.
For this reason, libtool must be configured before it can be
used. This idea should be familiar to anybody who has used a GNU
configure script. configure runs a number of tests for
system features, then generates the Makefiles (and possibly a
config.h header file), after which you can run make and
build the package.
Libtool adds its own tests to your configure script in order to
generate a libtool script for the installer's host machine.
AC_PROG_LIBTOOL macroIf you are using GNU Autoconf (or Automake), you should add a call to
AC_PROG_LIBTOOL to your configure.in file. This macro
adds many new tests to the configure script so that the generated
libtool script will understand the characteristics of the host:
Add support for the --enable-shared and --disable-shared
configureflags.4AM_PROG_LIBTOOLwas the old name for this macro, and although supported at the moment is deprecated.By default, this macro turns on shared libraries if they are available, and also enables static libraries if they don't conflict with the shared libraries. You can modify these defaults by calling either the
AC_DISABLE_SHAREDorAC_DISABLE_STATICmacros:# Turn off shared libraries during beta-testing, since they # make the build process take too long. AC_DISABLE_SHARED AC_PROG_LIBTOOLThe user may specify modified forms of the configure flags --enable-shared and --enable-static to choose whether shared or static libraries are built based on the name of the package. For example, to have shared bfd and gdb libraries built, but not shared libg++, you can run all three
configurescripts as follows:trick$ ./configure --enable-shared=bfd,gdbIn general, specifying --enable-shared=pkgs is the same as configuring with --enable-shared every package named in the comma-separated pkgs list, and every other package with --disable-shared. The --enable-static=pkgs flag behaves similarly, but it uses --enable-static and --disable-static. The same applies to the --enable-fast-install=pkgs flag, which uses --enable-fast-install and --disable-fast-install.
The package name default matches any packages which have not set their name in the
PACKAGEenvironment variable.This macro also sets the shell variable LIBTOOL_DEPS, that you can use to automatically update the libtool script if it becomes out-of-date. In order to do that, add to your configure.in:
AC_PROG_LIBTOOL AC_SUBST(LIBTOOL_DEPS)and, to Makefile.in or Makefile.am:
LIBTOOL_DEPS = @LIBTOOL_DEPS@ libtool: $(LIBTOOL_DEPS) $(SHELL) ./config.status --recheckIf you are using GNU automake, you can omit the assignment, as automake will take care of it. You'll obviously have to create some dependency on libtool.
Enable checking for dlopen support. This macro should be used if the package makes use of the -dlopen and -dlpreopen flags, otherwise libtool will assume that the system does not support dlopening. The macro must be called before
AC_PROG_LIBTOOL.
This macro should be used if the package has been ported to build clean dlls on win32 platforms. Usually this means that any library data items are exported with
__declspec(dllexport)and imported with__declspec(dllimport). If this macro is not used, libtool will assume that the package libraries are not dll clean and will build only static libraries on win32 hosts.This macro must be called before
AC_PROG_LIBTOOL, and provision must be made to pass -no-undefined tolibtoolin link mode from the packageMakefile. Naturally, if you pass -no-undefined, you must ensure that all the library symbols really are defined at link time!
Change the default behaviour for
AC_PROG_LIBTOOLto disable optimization for fast installation. The user may still override this default, depending on platform support, by specifying --enable-fast-install.
Change the default behaviour for
AC_PROG_LIBTOOLto disable shared libraries. The user may still override this default by specifying --enable-shared.
Change the default behaviour for
AC_PROG_LIBTOOLto disable static libraries. The user may still override this default by specifying --enable-static.
The tests in AC_PROG_LIBTOOL also recognize the following
environment variables:
The C compiler that will be used by the generated
libtool. If this is not set,AC_PROG_LIBTOOLwill look forgccorcc.
Compiler flags used to generate standard object files. If this is not set,
AC_PROG_LIBTOOLwill not use any such flags. It affects only the wayAC_PROG_LIBTOOLruns tests, not the producedlibtool.
C preprocessor flags. If this is not set,
AC_PROG_LIBTOOLwill not use any such flags. It affects only the wayAC_PROG_LIBTOOLruns tests, not the producedlibtool.
The system linker to use (if the generated
libtoolrequires one). If this is not set,AC_PROG_LIBTOOLwill try to find out what is the linker used by CC.
The flags to be used by
libtoolwhen it links a program. If this is not set,AC_PROG_LIBTOOLwill not use any such flags. It affects only the wayAC_PROG_LIBTOOLruns tests, not the producedlibtool.
The libraries to be used by
AC_PROG_LIBTOOLwhen it links a program. If this is not set,AC_PROG_LIBTOOLwill not use any such flags. It affects only the wayAC_PROG_LIBTOOLruns tests, not the producedlibtool.
A command that creates a link of a program, a soft-link if possible, a hard-link otherwise.
AC_PROG_LIBTOOLwill check for a suitable program if this variable is not set.
Program to use rather than checking for
dlltool. Only meaningful for Cygwin/MS-Windows.
Program to use rather than checking for
objdump. Only meaningful for Cygwin/MS-Windows.
Program to use rather than checking for
as. Only used on Cygwin/MS-Windows at the moment.
When you invoke the libtoolize program (see Invoking libtoolize), it will tell you where to find a definition of
AC_PROG_LIBTOOL. If you use Automake, the aclocal program
will automatically add AC_PROG_LIBTOOL support to your
configure script.
Nevertheless, it is advisable to include a copy of libtool.m4 in
acinclude.m4, so that, even if aclocal.m4 and
configure are rebuilt for any reason, the appropriate libtool
macros will be used. The alternative is to hope the user will have a
compatible version of libtool.m4 installed and accessible for
aclocal. This may lead to weird errors when versions don't
match.
In order to use libtool, you need to include the following files with your package:
Note that the libtool script itself should not be included with your package. See Configuring.
You should use the libtoolize program, rather than manually
copying these files into your package. Note however, that install-sh
is not copied by libtoolize; if you use Automake, it will take care
of that, otherwise you may obtain a copy from the package data directory
of the installed Libtool. This may change in a future Libtool version.
libtoolize
The libtoolize program provides a standard way to add libtool
support to your package. In the future, it may implement better usage
checking, or other features to make libtool even easier to use.
The libtoolize program has the following synopsis:
libtoolize [option]...
and accepts the following options:
libtoolize --automake is used by Automake to add libtool files to
your package, when AC_PROG_LIBTOOL appears in your
configure.in.
less (or
more) or redirect to a file.
libtoolize won't
overwrite existing files.
libtoolize version information and exit.
If libtoolize detects an explicit call to
AC_CONFIG_AUX_DIR (see The Autoconf Manual (The Autoconf Manual)) in your configure.in, it
will put the files in the specified directory.
libtoolize displays hints for adding libtool support to your
package, as well.
The Autoconf package comes with a few macros that run tests, then set a variable corresponding to the name of an object file. Sometimes it is necessary to use corresponding names for libtool objects.
Here are the names of variables that list libtool objects:
Substituted by
AC_FUNC_ALLOCA(see Particular Function Checks (The Autoconf Manual)). Is either empty, or contains alloca.lo.
Substituted by
AC_REPLACE_FUNCS(see Generic Function Checks (The Autoconf Manual)), and a few other functions.
Unfortunately, the stable release of Autoconf (2.13, at the time of
this writing) does not have any way for libtool to provide support for
these variables. So, if you depend on them, use the following code
immediately before the call to AC_OUTPUT in your
configure.in:
LTLIBOBJS=`echo "$LIBOBJS" | sed 's/\.[^.]* /.lo /g;s/\.[^.]*$/.lo/'`
AC_SUBST(LTLIBOBJS)
LTALLOCA=`echo "$ALLOCA" | sed 's/\.[^.]* /.lo /g;s/\.[^.]*$/.lo/'`
AC_SUBST(LTALLOCA)
AC_OUTPUT(...)
When you are developing a package, it is often worthwhile to configure
your package with the --disable-shared flag, or to override the
defaults for AC_PROG_LIBTOOL by using the
AC_DISABLE_SHARED Autoconf macro (see The AC_PROG_LIBTOOL macro). This prevents libtool from building
shared libraries, which has several advantages:
You may want to put a small note in your package README to let other developers know that --disable-shared can save them time. The following example note is taken from the GIMP5 distribution README:
The GIMP uses GNU Libtool in order to build shared libraries on a
variety of systems. While this is very nice for making usable
binaries, it can be a pain when trying to debug a program. For that
reason, compilation of shared libraries can be turned off by
specifying the --disable-shared option to configure.
The most difficult issue introduced by shared libraries is that of
creating and resolving runtime dependencies. Dependencies on programs
and libraries are often described in terms of a single name, such as
sed. So, one may say “libtool depends on sed,” and that is
good enough for most purposes.
However, when an interface changes regularly, we need to be more specific: “Gnus 5.1 requires Emacs 19.28 or above.” Here, the description of an interface consists of a name, and a “version number.”
Even that sort of description is not accurate enough for some purposes. What if Emacs 20 changes enough to break Gnus 5.1?
The same problem exists in shared libraries: we require a formal version system to describe the sorts of dependencies that programs have on shared libraries, so that the dynamic linker can guarantee that programs are linked only against libraries that provide the interface they require.
Interfaces for libraries may be any of the following (and more):
Note that static functions do not count as interfaces, because they are not directly available to the user of the library.
Libtool has its own formal versioning system. It is not as flexible as some, but it is definitely the simplest of the more powerful versioning systems.
Think of a library as exporting several sets of interfaces, arbitrarily represented by integers. When a program is linked against a library, it may use any subset of those interfaces.
Libtool's description of the interfaces that a program uses is simple: it encodes the least and the greatest interface numbers in the resulting binary (first-interface, last-interface).
The dynamic linker is guaranteed that if a library supports every interface number between first-interface and last-interface, then the program can be relinked against that library.
Note that this can cause problems because libtool's compatibility requirements are actually stricter than is necessary.
Say libhello supports interfaces 5, 16, 17, 18, and 19, and that libtool is used to link test against libhello.
Libtool encodes the numbers 5 and 19 in test, and the dynamic linker will only link test against libraries that support every interface between 5 and 19. So, the dynamic linker refuses to link test against libhello!
In order to eliminate this problem, libtool only allows libraries to declare consecutive interface numbers. So, libhello can declare at most that it supports interfaces 16 through 19. Then, the dynamic linker will link test against libhello.
So, libtool library versions are described by three integers:
-
age to current.
If two libraries have identical current and age numbers, then the dynamic linker chooses the library with the greater revision number.
If you want to use libtool's versioning system, then you must specify the version information to libtool using the -version-info flag during link mode (see Link mode).
This flag accepts an argument of the form current[:revision[:age]]. So, passing -version-info 3:12:1 sets current to 3, revision to 12, and age to 1.
If either revision or age are omitted, they default to 0. Also note that age must be less than or equal to the current interface number.
Here are a set of rules to help you update your library version information:
Never try to set the interface numbers so that they correspond to the release number of your package. This is an abuse that only fosters misunderstanding of the purpose of library versions. Instead, use the -release flag (see Release numbers), but be warned that every release of your package will not be binary compatible with any other release.
Often, people want to encode the name of the package release into the shared library so that it is obvious to the user which package their programs are linked against. This convention is used especially on GNU/Linux:
trick$ ls /usr/lib/libbfd*
/usr/lib/libbfd.a /usr/lib/libbfd.so.2.7.0.2
/usr/lib/libbfd.so
trick$
On trick, /usr/lib/libbfd.so is a symbolic link to libbfd.so.2.7.0.2, which was distributed as a part of binutils-2.7.0.2.
Unfortunately, this convention conflicts directly with libtool's idea of library interface versions, because the library interface rarely changes at the same time that the release number does, and the library suffix is never the same across all platforms.
So, in order to accommodate both views, you can use the -release flag in order to set release information for libraries which you do not want to use -version-info. For the libbfd example, the next release which uses libtool should be built with -release 2.9.0, which will produce the following files on GNU/Linux:
trick$ ls /usr/lib/libbfd*
/usr/lib/libbfd-2.9.0.so /usr/lib/libbfd.a
/usr/lib/libbfd.so
trick$
In this case, /usr/lib/libbfd.so is a symbolic link to libbfd-2.9.0.so. This makes it obvious that the user is dealing with binutils-2.9.0, without compromising libtool's idea of interface versions.
Note that this option causes a modification of the library name, so do not use it unless you want to break binary compatibility with any past library releases. In general, you should only use -release for package-internal libraries or for ones whose interfaces change very frequently.
Writing a good library interface takes a lot of practice and thorough understanding of the problem that the library is intended to solve.
If you design a good interface, it won't have to change often, you won't have to keep updating documentation, and users won't have to keep relearning how to use the library.
Here is a brief list of tips for library interface design, which may help you in your exploits:
This is essentially the same thing as using abstract data types and
inheritance in an object-oriented system.
static keyword (or equivalent) whenever possibleextern int foo[];. This is because
on i386 and some other SVR4/ELF systems, when an application
references data in a shared library the size of that data (whatever
its type) is included in the application executable. If you might
want to change the size of an array or string then provide a pointer
not the actual array.
Writing portable C header files can be difficult, since they may be read by different types of compilers:
extern "C" directive, so that the
names aren't mangled. See C++ libraries, for other issues relevant
to using C++ with libtool.
#included.
These complications mean that your library interface headers must use some C preprocessor magic in order to be usable by each of the above compilers.
foo.h in the demo subdirectory of the libtool distribution serves as an example for how to write a header file that can be safely installed in a system directory.
Here are the relevant portions of that file:
/* BEGIN_C_DECLS should be used at the beginning of your declarations,
so that C++ compilers don't mangle their names. Use END_C_DECLS at
the end of C declarations. */
#undef BEGIN_C_DECLS
#undef END_C_DECLS
#ifdef __cplusplus
# define BEGIN_C_DECLS extern "C" {
# define END_C_DECLS }
#else
# define BEGIN_C_DECLS /* empty */
# define END_C_DECLS /* empty */
#endif
/* PARAMS is a macro used to wrap function prototypes, so that
compilers that don't understand ANSI C prototypes still work,
and ANSI C compilers can issue warnings about type mismatches. */
#undef PARAMS
#if defined (__STDC__) || defined (_AIX) \
|| (defined (__mips) && defined (_SYSTYPE_SVR4)) \
|| defined(WIN32) || defined(__cplusplus)
# define PARAMS(protos) protos
#else
# define PARAMS(protos) ()
#endif
These macros are used in foo.h as follows:
#ifndef FOO_H
#define FOO_H 1
/* The above macro definitions. */
#include "..."
BEGIN_C_DECLS
int foo PARAMS((void));
int hello PARAMS((void));
END_C_DECLS
#endif /* !FOO_H */
Note that the #ifndef FOO_H prevents the body of foo.h from being read more than once in a given compilation.
Also the only thing that must go outside the
BEGIN_C_DECLS/END_C_DECLS pair are #include lines.
Strictly speaking it is only C symbol names that need to be protected,
but your header files will be more maintainable if you have a single
pair of of these macros around the majority of the header contents.
You should use these definitions of PARAMS, BEGIN_C_DECLS,
and END_C_DECLS into your own headers. Then, you may use them to
create header files that are valid for C++, ANSI, and non-ANSI
compilers6.
Do not be naive about writing portable code. Following the tips given above will help you miss the most obvious problems, but there are definitely other subtle portability issues. You may need to cope with some of the following issues:
void * generic
pointer type, and so need to use char * in its place.
const, inline and signed keywords are not
supported by some compilers, especially pre-ANSI compilers.
long double type is not supported by many compilers.
By definition, every shared library system provides a way for executables to depend on libraries, so that symbol resolution is deferred until runtime.
An inter-library dependency is one in which a library depends on
other libraries. For example, if the libtool library libhello
uses the cos function, then it has an inter-library dependency
on libm, the math library that implements cos.
Some shared library systems provide this feature in an internally-consistent way: these systems allow chains of dependencies of potentially infinite length.
However, most shared library systems are restricted in that they only allow a single level of dependencies. In these systems, programs may depend on shared libraries, but shared libraries may not depend on other shared libraries.
In any event, libtool provides a simple mechanism for you to declare
inter-library dependencies: for every library libname that
your own library depends on, simply add a corresponding
-lname option to the link line when you create your
library. To make an example of our
libhello that depends on libm:
burger$ libtool --mode=link gcc -g -O -o libhello.la foo.lo hello.lo \
-rpath /usr/local/lib -lm
burger$
When you link a program against libhello, you don't need to specify the same -l options again: libtool will do that for you, in order to guarantee that all the required libraries are found. This restriction is only necessary to preserve compatibility with static library systems and simple dynamic library systems.
Some platforms, such as AIX, do not even allow you this flexibility. In order to build a shared library, it must be entirely self-contained (that is, have references only to symbols that are found in the .lo files or the specified -l libraries), and you need to specify the -no-undefined flag. By default, libtool builds only static libraries on these kinds of platforms.
The simple-minded inter-library dependency tracking code of libtool releases prior to 1.2 was disabled because it was not clear when it was possible to link one library with another, and complex failures would occur. A more complex implementation of this concept was re-introduced before release 1.3, but it has not been ported to all platforms that libtool supports. The default, conservative behavior is to avoid linking one library with another, introducing their inter-dependencies only when a program is linked with them.
It can sometimes be confusing to discuss dynamic linking, because the term is used to refer to two different concepts:
dlopen,7 which load
arbitrary, user-specified modules at runtime. This type of dynamic
linking is explicitly controlled by the application.
To mitigate confusion, this manual refers to the second type of dynamic linking as dlopening a module.
The main benefit to dlopening object modules is the ability to access compiled object code to extend your program, rather than using an interpreted language. In fact, dlopen calls are frequently used in language interpreters to provide an efficient way to extend the language.
As of version 1.5.22, libtool provides support for dlopened modules. However, you should indicate that your package is willing to use such support, by using the macro AC_LIBTOOL_DLOPEN in configure.in. If this macro is not used (or it is used after AC_PROG_LIBTOOL), libtool will assume no dlopening mechanism is available, and will try to simulate it.
This chapter discusses how you as a dlopen application developer might use libtool to generate dlopen-accessible modules.
On some operating systems, a program symbol must be specially declared
in order to be dynamically resolved with the dlsym (or
equivalent) function.
Libtool provides the -export-dynamic and -module link flags (see Link mode), which do this declaration. You need to use these flags if you are linking an application program that dlopens other modules or a libtool library that will also be dlopened.
For example, if we wanted to build a shared library, libhello, that would later be dlopened by an application, we would add -module to the other link flags:
burger$ libtool --mode=link gcc -module -o libhello.la foo.lo \
hello.lo -rpath /usr/local/lib -lm
burger$
If symbols from your executable are needed to satisfy unresolved references in a library you want to dlopen you will have to use the flag -export-dynamic. You should use -export-dynamic while linking the executable that calls dlopen:
burger$ libtool --mode=link gcc -export-dynamic -o hell-dlopener main.o
burger$
Libtool provides special support for dlopening libtool object and
libtool library files, so that their symbols can be resolved even
on platforms without any dlopen and dlsym
functions.
Consider the following alternative ways of loading code into your program, in order of increasing “laziness”:
Libtool emulates -dlopen on static platforms by linking objects into the program at compile time, and creating data structures that represent the program's symbol table.
In order to use this feature, you must declare the objects you want your application to dlopen by using the -dlopen or -dlpreopen flags when you link your program (see Link mode).
The name attribute is a null-terminated character string of the symbol name, such as
"fprintf". The address attribute is a generic pointer to the appropriate object, such as&fprintf.
An array of lt_symbol structures, representing all the preloaded symbols linked into the program. For each -dlpreloaded file there is an element with the name of the file and a address of
0, followed by all symbols exported from this file. For the executable itself the special name @PROGRAM@ is used. The last element has a name and address of0.
Some compilers may allow identifiers which are not valid in ANSI C, such as dollar signs. Libtool only recognizes valid ANSI C symbols (an initial ASCII letter or underscore, followed by zero or more ASCII letters, digits, and underscores), so non-ANSI symbols will not appear in lt_preloaded_symbols.
After a library has been linked with -module, it can be dlopened. Unfortunately, because of the variation in library names, your package needs to determine the correct file to dlopen.
The most straightforward and flexible implementation is to determine the name at runtime, by finding the installed .la file, and searching it for the following lines:
# The name that we can dlopen.
dlname='dlname'
If dlname is empty, then the library cannot be dlopened. Otherwise, it gives the dlname of the library. So, if the library was installed as /usr/local/lib/libhello.la, and the dlname was libhello.so.3, then /usr/local/lib/libhello.so.3 should be dlopened.
If your program uses this approach, then it should search the
directories listed in the LD_LIBRARY_PATH8 environment variable, as well as
the directory where libraries will eventually be installed. Searching
this variable (or equivalent) will guarantee that your program can find
its dlopened modules, even before installation, provided you have linked
them using libtool.
The following problems are not solved by using libtool's dlopen support:
dlopen family, which do package-specific tricks when dlopening
is unsupported or not available on a given platform.
dlopen
family of functions. Some platforms do not even use the same function
names (notably HP-UX, with its shl_load family).
dlopen.
Libtool provides a small library, called libltdl, that aims at hiding the various difficulties of dlopening libraries from programmers. It consists of a header-file and a small C source file that can be distributed with applications that need dlopening functionality. On some platforms, whose dynamic linkers are too limited for a simple implementation of libltdl services, it requires GNU DLD, or it will only emulate dynamic linking with libtool's dlpreopening mechanism.
libltdl supports currently the following dynamic linking mechanisms:
dlopen (Solaris, Linux and various BSD flavors)
shl_load (HP-UX)
LoadLibrary (Win16 and Win32)
load_add_on (BeOS)
libltdl is licensed under the terms of the GNU Library General Public License, with the following exception:
As a special exception to the GNU Lesser General Public License, if you distribute this file as part of a program or library that is built using GNU libtool, you may include it under the same distribution terms that you use for the rest of that program.
The libltdl API is similar to the dlopen interface of Solaris and Linux, which is very simple but powerful.
To use libltdl in your program you have to include the header file ltdl.h:
#include <ltdl.h>
The last release of libltdl used some symbols that violated the posix namespace conventions. These symbols are now deprecated, and have been replaced by those described here. If you have code that relies on the old deprecated symbol names, defining LT_NON_POSIX_NAMESPACE before you include ltdl.h provides conversion macros. Whichever set of symbols you use, the new api is not binary compatible with the last, so you will need to recompile your application in order to use this version of libltdl.
Note that libltdl is not threadsafe, i.e. a multithreaded application
has to use a mutex for libltdl. It was reported that GNU/Linux's glibc
2.0's dlopen with RTLD_LAZY (which libltdl uses by
default) is not thread-safe, but this problem is supposed to be fixed in
glibc 2.1. On the other hand, RTLD_NOW was reported to introduce
problems in multi-threaded applications on FreeBSD. Working around
these problems is left as an exercise for the reader; contributions are
certainly welcome.
The following types are defined in ltdl.h:
lt_dlhandleis a module "handle". Every lt_dlopened module has a handle associated with it.
lt_dlsymlistis a symbol list for dlpreopened modules. This structure is described in see Dlpreopening.
libltdl provides the following functions:
Initialize libltdl. This function must be called before using libltdl and may be called several times. Return 0 on success, otherwise the number of errors.
Shut down libltdl and close all modules. This function will only then shut down libltdl when it was called as many times as
lt_dlinithas been successfully called. Return 0 on success, otherwise the number of errors.
Open the module with the file name filename and return a handle for it.
lt_dlopenis able to open libtool dynamic modules, preloaded static modules, the program itself and native dynamic libraries.Unresolved symbols in the module are resolved using its dependency libraries (not implemented yet) and previously dlopened modules. If the executable using this module was linked with the
-export-dynamicflag, then the global symbols in the executable will also be used to resolve references in the module.If filename is
NULLand the program was linked with-export-dynamicor-dlopen self,lt_dlopenwill return a handle for the program itself, which can be used to access its symbols.If libltdl cannot find the library and the file name filename does not have a directory component it will additionally search in the following search paths for the module (in the order as follows):
- user-defined search path: This search path can be changed by the program using the functions
lt_dlsetsearchpath,lt_dladdsearchdirandlt_dlinsertsearchdir.- libltdl's search path: This search path is the value of the environment variable LTDL_LIBRARY_PATH.
- system library search path: The system dependent library search path (e.g. on Linux it is LD_LIBRARY_PATH).
Each search path must be a colon-separated list of absolute directories, for example,
"/usr/lib/mypkg:/lib/foo".If the same module is loaded several times, the same handle is returned. If
lt_dlopenfails for any reason, it returnsNULL.
The same as
lt_dlopen, except that it tries to append different file name extensions to the file name. If the file with the file name filename cannot be found libltdl tries to append the following extensions:
- the libtool archive extension .la
- the extension used for native dynamic libraries on the host platform, e.g., .so, .sl, etc.
This lookup strategy was designed to allow programs that don't have knowledge about native dynamic libraries naming conventions to be able to
dlopensuch libraries as well as libtool modules transparently.
Decrement the reference count on the module handle. If it drops to zero and no other module depends on this module, then the module is unloaded. Return 0 on success.
Return the address in the module handle, where the symbol given by the null-terminated string name is loaded. If the symbol cannot be found,
NULLis returned.
Return a human readable string describing the most recent error that occurred from any of libltdl's functions. Return
NULLif no errors have occurred since initialization or since it was last called.
Register the list of preloaded modules preloaded. If preloaded is
NULL, then all previously registered symbol lists, except the list set bylt_dlpreload_default, are deleted. Return 0 on success.
Set the default list of preloaded modules to preloaded, which won't be deleted by
lt_dlpreload. Note that this function does not require libltdl to be initialized usinglt_dlinitand can be used in the program to register the default preloaded modules. Instead of calling this function directly, most programs will use the macroLTDL_SET_PRELOADED_SYMBOLS.Return 0 on success.
Set the default list of preloaded symbols. Should be used in your program to initialize libltdl's list of preloaded modules.
#include <ltdl.h> int main() { /* ... */ LTDL_SET_PRELOADED_SYMBOLS(); /* ... */ }
Append the search directory search_dir to the current user-defined library search path. Return 0 on success.
Insert the search directory search_dir into the user-defined library search path, immediately before the element starting at address before. If before is NULL, then search_dir is appending as if
lt_dladdsearchdirhad been called. Return 0 on success.
Replace the current user-defined library search path with search_path, which must be a colon-separated list of absolute directories. Return 0 on success.
Return the current user-defined library search path.
In some applications you may not want to load individual modules with known names, but rather find all of the modules in a set of directories and load them all during initialisation. With this function you can have libltdl scan the colon delimited directory list in search_path for candidates, and pass them, along with data to your own callback function, func. If seach_path is NULL, then search all of the standard locations that
lt_dlopenwould examine. This function will continue to make calls to func for each file that it discovers in search_path until one of these calls returns non-zero, or until the files are exhausted. lt_dlforeachfile returns value returned by the last call made to func.For example you could define func to build an ordered argv-like vector of files using data to hold the address of the start of the vector.
Mark a module so that it cannot be lt_dlclosed. This can be useful if a module implements some core functionality in your project, which would cause your code to crash if removed. Return 0 on success.
If you use lt_dlopen (NULL) to get a handle for the running binary, that handle will always be marked as resident, and consequently cannot be successfully lt_dlclosed.
Check whether a particular module has been marked as resident, returning 1 if it has or 0 otherwise. If there is an error while executing this function, return -1 and set an error message for retrieval with
lt_dlerror.
These variables are set to
malloc,reallocandfreeby default, but you can set them to any other functions that provide equivalent functionality. If you change any of these function pointers, you will almost certainly need to change all three to point into the same malloc library. Strange things will happen if you allocate memory from one library, and then pass it to an implementation offreethat doesn't know what book keeping the allocator used.You must not modify any of their values after calling any libltdl function other than
lt_dlpreopen_defaultor the macroLTDL_SET_PRELOADED_SYMBOLS.
dlopenedLibtool modules are like normal libtool libraries with a few exceptions:
You have to link the module with libtool's -module switch, and you should link any program that is intended to dlopen the module with -dlopen modulename.la so that libtool can dlpreopen the module on platforms which don't support dlopening. If the module depends on any other libraries, make sure you specify them either when you link the module or when you link programs that dlopen it. If you want to disable see Versioning for a specific module you should link it with the -avoid-version switch. Note that libtool modules don't need to have a "lib" prefix. However, automake 1.4 or higher is required to build such modules.
Usually a set of modules provide the same interface, i.e, exports the same symbols, so that a program can dlopen them without having to know more about their internals. In order to avoid symbol conflicts all exported symbols must be prefixed with "modulename_LTX_" (modulename is the name of the module). Internal symbols must be named in such a way that they won't conflict with other modules, for example, by prefixing them with "_modulename_". Although some platforms support having the same symbols defined more than once it is generally not portable and it makes it impossible to dlpreopen such modules. libltdl will automatically cut the prefix off to get the real name of the symbol. Additionally, it supports modules which don't use a prefix so that you can also dlopen non-libtool modules.
foo1.c gives an example of a portable libtool module. Exported symbols are prefixed with "foo1_LTX_", internal symbols with "_foo1_". Aliases are defined at the beginning so that the code is more readable.
/* aliases for the exported symbols */
#define foo foo1_LTX_foo
#define bar foo1_LTX_bar
/* a global variable definition */
int bar = 1;
/* a private function */
int _foo1_helper() {
return bar;
}
/* an exported function */
int foo() {
return _foo1_helper();
}
The Makefile.am contains the necessary rules to build the module foo1.la:
...
lib_LTLIBRARIES = foo1.la
foo1_la_SOURCES = foo1.c
foo1_la_LDFLAGS = -module
...
Using the lt_dlmutex_register() function, and by providing some
appropriate callback function definitions, libltdl can be used in a
multi-threaded environment.
This is the type of a function pointer holding the address of a function which will be called at the start of parts of the libltdl implementation code which require a mutex lock.
Because libltdl is inherently recursive, it is important that the locking mechanism employed by these callback functions are reentrant, or else strange problems will occur.
Many of the functions in the libltdl api have a special return value to indicate to the client that an error has occurred. Normally (in single threaded applications) a string describing that error can be retrieved from internal storage with
lt_dlerror().A function of this type must be registered with the library in order for it to work in a multi-threaded context. The function should store any error message passed in thread local storage.
The type of a matching callback function to retrieve the last stored error message from thread local storage.
When registered correctly this function will be used by
lt_dlerror())from all threads to retrieve error messages for the client.
Use this function to register one of each of function types described above in preparation for multi-threaded use of libltdl. All arguments must be valid non-
NULLfunction addresses, or else allNULLto return to single threaded operation.
Some of the internal information about each loaded module that is maintained by libltdl is available to the user, in the form of this structure:
lt_dlinfois used to store information about a module. The filename attribute is a null-terminated character string of the real module file name. If the module is a libtool module then name is its module name (e.g."libfoo"for"dir/libfoo.la"), otherwise it is set toNULL. The ref_count attribute is a reference counter that describes how often the same module is currently loaded.
The following function will return a pointer to libltdl's internal copy of this structure for the given handle:
Return a pointer to a struct that contains some information about the module handle. The contents of the struct must not be modified. Return
NULLon failure.
Furthermore, in order to save you from having to keep a list of the handles of all the modules you have loaded, these functions allow you to iterate over libltdl's list of loaded modules:
For each loaded module call the function func. The argument handle is the handle of one of the loaded modules, data is the data argument passed to
lt_dlforeach. As soon as func returns a non-zero value for one of the handles,lt_dlforeachwill stop calling func and immediately return 1. Otherwise 0 is returned.
Iterate over the loaded module handles, returning the first handle in the list if place is
NULL, and the next one on subsequent calls. If place is the last element in the list of loaded modules, this function returnsNULL.
Of course, you would still need to maintain your own list of loaded module handles to parallel the list maintained by libltdl if there are any other data that you need to associate with each handle for the purposes of your application. However, if you use the following api calls to associate your application data with individual module handles as they are loaded there is actually no need to do that. You must first obtain a unique caller id from libltdl which you subsequently use to retrieve the data you stored earlier. This allows for different libraries that each wish to store their own data against loaded modules to do so without interfering with one another's data.
Use this to obtain a unique key to store and retrieve individual sets of per module data.
Set data as the set of data uniquely associated with key and handle for later retrieval. This function returns the data previously associated with key and handle if any. A result of 0, may indicate that a diagnostic for the last error (if any) is available from
lt_dlerror().For example, to correctly remove some associated data:
lt_ptr stale = lt_dlcaller_set_data (key, handle, 0); if (stale == NULL) { char *error_msg = lt_dlerror (); if (error_msg != NULL) { my_error_handler (error_msg); return STATUS_FAILED; } } else { free (stale); }
Return the address of the data associated with key and handle, or else
NULLif there is none.
The preceding functions can be combined with lt_dlforeach to
implement search and apply operations without the need for your
application to track the modules that have been loaded and unloaded:
int
my_dlcaller_callback (lt_dlhandle handle, lt_ptr key_ptr)
{
struct my_module_data *my_data;
my_data = lt_dlcaller_get_data (handle, (lt_dlcaller_id) *key_ptr);
return process (my_data);
}
int
my_dlcaller_foreach (lt_dlcaller_id key)
{
lt_dlforeach (my_dlcaller_callback, (lt_ptr) &key);
}
Sometimes libltdl's many ways of gaining access to modules are not
sufficient for the purposes of a project. You can write your own
loader, and register it with libltdl so that lt_dlopen will be
able to use it.
Writing a loader involves writing at least three functions which can be
called by lt_dlopen, lt_dlsym and lt_dlclose.
Optionally, you can provide a finalisation function to perform any
cleanup operations when lt_dlexit executes, and a symbol prefix
string which will be prepended to any symbols passed to lt_dlsym.
These functions must match the function pointer types below, after
which they can be allocated to an instance of lt_user_dlloader
and registered.
Registering the loader requires that you choose a name for it, so that it
can be recognised by lt_dlloader_find and removed with
lt_dlloader_remove. The name you choose must be unique, and not
already in use by libltdl's builtin loaders:
lt_dlopening of preloaded static modules.
The prefix "dl" is reserved for loaders supplied with future versions of libltdl, so you should not use that for your own loader names.
The following types are defined in ltdl.h:
lt_moduleis a dlloader dependent module. The dynamic module loader extensions communicate using these low level types.
If you want to define a new way to open dynamic modules, and have the
lt_dlopenapi use it, you need to instantiate one of these structures and pass it tolt_dlloader_add. You can pass whatever you like in the dlloader_data field, and it will be passed back as the value of the first parameter to each of the functions specified in the function pointer fields.
The type of the loader function for an
lt_dlloadermodule loader. The value set in the dlloader_data field of thestruct lt_user_dlloaderstructure will be passed into this function in the loader_data parameter. Implementation of such a function should attempt to load the named module, and return anlt_modulesuitable for passing in to the associatedlt_module_closeandlt_sym_findfunction pointers. If the function fails it should returnNULL, and set the error message withlt_dlseterror.
The type of the unloader function for a user defined module loader. Implementation of such a function should attempt to release any resources tied up by the module module, and then unload it from memory. If the function fails for some reason, set the error message with
lt_dlseterrorand return non-zero.
The type of the symbol lookup function for a user defined module loader. Implementation of such a function should return the address of the named symbol in the module module, or else set the error message with
lt_dlseterrorand returnNULLif lookup fails.
The type of the finalisation function for a user defined module loader. Implementation of such a function should free any resources associated with the loader, including any user specified data in the
dlloader_datafield of thelt_user_dlloader. If non-NULL, the function will be called bylt_dlexit, andlt_dlloader_remove.
For example:
int
register_myloader (void)
{
lt_user_dlloader dlloader;
/* User modules are responsible for their own initialisation. */
if (myloader_init () != 0)
return MYLOADER_INIT_ERROR;
dlloader.sym_prefix = NULL;
dlloader.module_open = myloader_open;
dlloader.module_close = myloader_close;
dlloader.find_sym = myloader_find_sym.
dlloader.dlloader_exit = myloader_exit;
dlloader.dlloader_data = (lt_user_data)myloader_function;
/* Add my loader as the default module loader. */
if (lt_dlloader_add (lt_dlloader_next (NULL), &dlloader, "myloader") \
!= 0)
return ERROR;
return OK;
}
Note that if there is any initialisation required for the loader, it must be performed manually before the loader is registered – libltdl doesn't handle user loader initialisation.
Finalisation is handled by libltdl however, and it is important
to ensure the dlloader_exit callback releases any resources claimed
during the initialisation phase.
libltdl provides the following functions for writing your own module loaders:
Add a new module loader to the list of all loaders, either as the last loader (if place is
NULL), else immediately before the loader passed as place. loader_name will be returned bylt_dlloader_nameif it is subsequently passed a newly registered loader. These loader_names must be unique, orlt_dlloader_removeandlt_dlloader_findcannot work. Returns 0 for success.{ /* Make myloader be the last one. */ if (lt_dlloader_add (NULL, myloader) != 0) perror (lt_dlerror ()); }
Remove the loader identified by the unique name, loader_name. Before this can succeed, all modules opened by the named loader must have been closed. Returns 0 for success, otherwise an error message can be obtained from
lt_dlerror.{ /* Remove myloader. */ if (lt_dlloader_remove ("myloader") != 0) perror (lt_dlerror ()); }
Iterate over the module loaders, returning the first loader if place is
NULL, and the next one on subsequent calls. The handle is for use withlt_dlloader_add.{ /* Make myloader be the first one. */ if (lt_dlloader_add (lt_dlloader_next (NULL), myloader) != 0) return ERROR; }
Return the first loader with a matching loader_name identifier, or else
NULL, if the identifier is not found.The identifiers which may be used by libltdl itself, if the host architecture supports them are dlopen9, dld and dlpreload.
{ /* Add a user loader as the next module loader to be tried if the standard dlopen loader were to fail when lt_dlopening. */ if (lt_dlloader_add (lt_dlloader_find ("dlopen"), myloader) != 0) return ERROR; }
Return the identifying name of PLACE, as obtained from
lt_dlloader_nextorlt_dlloader_find. If this function fails, it will returnNULLand set an error for retrieval withlt_dlerror.
Return the address of the
dlloader_dataof PLACE, as obtained fromlt_dlloader_nextorlt_dlloader_find. If this function fails, it will returnNULLand set an error for retrieval withlt_dlerror.
This function allows you to integrate your own error messages into
lt_dlerror. Pass in a suitable diagnostic message for return bylt_dlerror, and an error identifier for use withlt_dlseterroris returned.If the allocation of an identifier fails, this function returns -1.
int myerror = lt_dladderror ("Doh!"); if (myerror < 0) perror (lt_dlerror ());
When writing your own module loaders, you should use this function to raise errors so that they are propagated through the
lt_dlerrorinterface. All of the standard errors used by libltdl are declared in ltdl.h, or you can add more of your own withlt_dladderror. This function returns 0 on success.if (lt_dlseterror (LTDL_ERROR_NO_MEMORY) != 0) perror (lt_dlerror ());
Even though libltdl is installed together with libtool, you may wish to
include libltdl in the distribution of your package, for the convenience
of users of your package that don't have libtool or libltdl installed.
In this case, you must decide whether to manually add the ltdl
objects to your package, or else which flavor of libltdl you want to use:
a convenience library or an installable libtool library.
The most simplistic way to add libltdl to your package is to copy
the source files, ltdl.c and ltdl.h, to a source directory
within your package and to build and link them along with the rest of
your sources. To help you do this, the m4 macros for autoconf are
available in ltdl.m4. You must ensure that they are available in
aclocal.m4 before you run Autoconf – by appending the contents
of ltdl.m4 to acinclude.m4, if you are using automake, or
to aclocal.m4 if you are not. Having made the macros available,
you must add a call to the AC_LIB_LTDL macro to your package's
configure.in to perform the configure time checks required to
build ltdl.o correctly. This method has problems if you then try
to link the package binaries with an installed libltdl, or a library
which depends on libltdl: you may have problems with duplicate symbol
definitions.
One advantage of the convenience library is that it is not installed, so the fact that you use libltdl will not be apparent to the user, and it will not overwrite a pre-installed version of libltdl a user might have. On the other hand, if you want to upgrade libltdl for any reason (e.g. a bugfix) you'll have to recompile your package instead of just replacing an installed version of libltdl. However, if your programs or libraries are linked with other libraries that use such a pre-installed version of libltdl, you may get linker errors or run-time crashes. Another problem is that you cannot link the convenience library into more than one libtool library, then link a single program with these libraries, because you may get duplicate symbols. In general you can safely use the convenience library in programs which don't depend on other libraries that might use libltdl too. In order to enable this flavor of libltdl, you should add the line AC_LIBLTDL_CONVENIENCE to your configure.in, before AC_PROG_LIBTOOL.
In order to select the installable version of libltdl, you should add a call of the macro AC_LIBLTDL_INSTALLABLE to your configure.in before AC_PROG_LIBTOOL. This macro will check whether libltdl is already installed and, if not, request the libltdl embedded in your package to be built and installed. Note, however, that no version checking is performed. The user may override the test and determine that the libltdl embedded must be installed, regardless of the existence of another version, using the configure switch --enable-ltdl-install.
In order to embed libltdl into your package, just add --ltdl to
the libtoolize command line. It will copy the libltdl sources
to a subdirectory libltdl in your package.
Both macros accept an optional argument to specify the location
of the libltdl directory. By the default both macros assume that it
is ${top_srcdir}/libltdl.
Whatever macro you use, it is up to you to ensure that your configure.in will configure libltdl, using AC_CONFIG_SUBDIRS, and that your Makefiles will start sub-makes within libltdl's directory, using automake's SUBDIRS, for example. Both macros define the shell variables LIBLTDL, to the link flag that you should use to link with libltdl, and LTDLINCL, to the preprocessor flag that you should use to compile with programs that include ltdl.h. It is up to you to use AC_SUBST to ensure that this variable will be available in Makefiles, or add them to variables that are AC_SUBSTed by default, such as LIBS and CPPFLAGS. Also note that you should not include libltdl/Makefile in the list of files to be configured from your toplevel configure.in; this is done by libltdl/configure.ac.
If you're using the convenience libltdl, LIBLTDL will be the pathname for the convenience version of libltdl and LTDLINCL will be -I followed by the directory that contains libltdl, both starting with ${top_builddir}/ or ${top_srcdir}/, respectively.
If you request an installed version of libltdl and one is found10, LIBLTDL will be set to -lltdl and LTDLINCL will be empty (which is just a blind assumption that ltdl.h is somewhere in the include path if libltdl is in the library path). If an installable version of libltdl must be built, its pathname, starting with ${top_builddir}/, will be stored in LIBLTDL, and LTDLINCL will be set just like in the case of convenience library.
So, when you want to link a program with libltdl, be it a convenience, installed or installable library, just compile with $(LTDLINCL) and link it with $(LIBLTDL), using libtool.
You should probably also add AC_LIBTOOL_DLOPEN to your configure.in before AC_PROG_LIBTOOL, otherwise libtool will assume no dlopening mechanism is supported, and revert to dlpreopening, which is probably not what you want.
Avoid using the -static or -all-static switches when
linking programs with libltdl. This will not work on all platforms,
because the dlopening functions may not be available for static linking.
The following example shows you how to embed the convenience libltdl in your package. In order to use the installable variant just replace AC_LIBLTDL_CONVENIENCE with AC_LIBLTDL_INSTALLABLE. We assume that libltdl was embedded using libtoolize --ltdl.
configure.in:
...
dnl Enable building of the convenience library
dnl and set LIBLTDL accordingly
AC_LIBLTDL_CONVENIENCE
dnl Check for dlopen support
AC_LIBTOOL_DLOPEN
dnl Configure libtool
AC_PROG_LIBTOOL
dnl Configure libltdl
AC_CONFIG_SUBDIRS(libltdl)
...
Makefile.am:
...
SUBDIRS = libltdl
INCLUDES = $(LTDLINCL)
myprog_LDFLAGS = -export-dynamic
# The quotes around -dlopen below fool automake <= 1.4 into accepting it
myprog_LDADD = $(LIBLTDL) "-dlopen" self "-dlopen" foo1.la
myprog_DEPENDENCIES = $(LIBLTDL) foo1.la
...
Libtool was first implemented in order to add support for writing shared libraries in the C language. However, over time, libtool is being integrated with other languages, so that programmers are free to reap the benefits of shared libraries in their favorite programming language.
This chapter describes how libtool interacts with other languages, and what special considerations you need to make if you do not use C.
Creating libraries of C++ code should be a fairly straightforward process, because its object files differ from C ones in only three ways:
Because of these three issues, Libtool has been designed to always use
the C++ compiler to compile and link C++ programs and libraries. In
some instances the main() function of a program must also be
compiled with the C++ compiler for static C++ objects to be properly
initialized.
Libtool is under constant development, changing to remain up-to-date with modern operating systems. If libtool doesn't work the way you think it should on your platform, you should read this chapter to help determine what the problem is, and how to resolve it.
Libtool comes with its own set of programs that test its capabilities, and report obvious bugs in the libtool program. These tests, too, are constantly evolving, based on past problems with libtool, and known deficiencies in other operating systems.
As described in the INSTALL file, you may run make check after you have built libtool (possibly before you install it) in order to make sure that it meets basic functional requirements.
Here is a list of the current programs in the test suite, and what they test for:
The cdemo subdirectory contains a demonstration of libtool convenience libraries, a mechanism that allows build-time static libraries to be created, in a way that their components can be later linked into programs or other libraries, even shared ones.
The tests cdemo-make.test and cdemo-exec.test are executed
three times, under three different libtool configurations:
cdemo-conf.test configures cdemo/libtool to build both
static and shared libraries (the default for platforms that support
both), cdemo-static.test builds only static libraries
(--disable-shared), and cdemo-shared.test builds only
shared libraries (--disable-static).
The demo subdirectory contains a demonstration of a trivial
package that uses libtool. The tests demo-make.test,
demo-exec.test, demo-inst.test and
demo-unst.test are executed four times, under four different
libtool configurations: demo-conf.test configures
demo/libtool to build both static and shared libraries,
demo-static.test builds only static libraries
(--disable-shared), and demo-shared.test builds only
shared libraries (--disable-static).
demo-nofast.test configures demo/libtool to
disable the fast-install mode (--enable-fast-install=no).
demo-pic.test configures demo/libtool to
prefer building PIC code (--with-pic), demo-nopic.test
to prefer non-PIC code (--without-pic).
deplibs_check_method to prevent such cases.
This tests checks whether libtool's deplibs_check_method
works properly.
The depdemo subdirectory contains a demonstration of inter-library dependencies with libtool. The test programs link some interdependent libraries.
The tests depdemo-make.test, depdemo-exec.test,
depdemo-inst.test and depdemo-unst.test are executed
four times, under four different libtool configurations:
depdemo-conf.test configures depdemo/libtool to build both
static and shared libraries, depdemo-static.test builds only static
libraries (--disable-shared), and depdemo-shared.test builds
only shared libraries (--disable-static).
depdemo-nofast.test configures depdemo/libtool to
disable the fast-install mode (--enable-fast-install=no.
The mdemo subdirectory contains a demonstration of a package that uses libtool and the system independent dlopen wrapper libltdl to load modules. The library libltdl provides a dlopen wrapper for various platforms (Linux, Solaris, HP/UX etc.) including support for dlpreopened modules (see Dlpreopening).
The tests mdemo-make.test, mdemo-exec.test,
mdemo-inst.test and mdemo-unst.test are executed
three times, under three different libtool configurations:
mdemo-conf.test configures mdemo/libtool to build both
static and shared libraries, mdemo-static.test builds only static
libraries (--disable-shared), and mdemo-shared.test builds
only shared libraries (--disable-static).
--dry-run mode works properly.
Each of the above tests are designed to produce no output when they are run via make check. The exit status of each program tells the Makefile whether or not the test succeeded.
If a test fails, it means that there is either a programming error in libtool, or in the test program itself.
To investigate a particular test, you may run it directly, as you would a normal program. When the test is invoked in this way, it produces output which may be useful in determining what the problem is.
Another way to have the test programs produce output is to set the VERBOSE environment variable to yes before running them. For example, env VERBOSE=yes make check runs all the tests, and has each of them display debugging information.
If you think you have discovered a bug in libtool, you should think twice: the libtool maintainer is notorious for passing the buck (or maybe that should be “passing the bug”). Libtool was invented to fix known deficiencies in shared library implementations, so, in a way, most of the bugs in libtool are actually bugs in other operating systems. However, the libtool maintainer would definitely be happy to add support for somebody else's buggy operating system. [I wish there was a good way to do winking smiley-faces in Texinfo.]
Genuine bugs in libtool include problems with shell script portability, documentation errors, and failures in the test suite (see Libtool test suite).
First, check the documentation and help screens to make sure that the behaviour you think is a problem is not already mentioned as a feature.
Then, you should read the Emacs guide to reporting bugs (see Reporting Bugs (The Emacs Manual)). Some of the details listed there are specific to Emacs, but the principle behind them is a general one.
Finally, send a bug report to the libtool bug reporting address bug-libtool@gnu.org with any appropriate facts, such as test suite output (see When tests fail), all the details needed to reproduce the bug, and a brief description of why you think the behaviour is a bug. Be sure to include the word “libtool” in the subject line, as well as the version number you are using (which can be found by typing libtool --version).
This chapter contains information that the libtool maintainer finds important. It will be of no use to you unless you are considering porting libtool to new systems, or writing your own libtool.
Before you embark on porting libtool to an unsupported system, it is worthwhile to send e-mail to the libtool mailing list libtool@gnu.org, to make sure that you are not duplicating existing work.
If you find that any porting documentation is missing, please complain! Complaints with patches and improvements to the documentation, or to libtool itself, are more than welcome.
Once it is clear that a new port is necessary, you'll generally need the following information:
config.guess for this system, so that you
can make changes to the libtool configuration process without affecting
other systems.
ld and ccld.so, rtld, or equivalentldconfig, or equivalentIf you know how to program the Bourne shell, then you can complete the port yourself; otherwise, you'll have to find somebody with the relevant skills who will do the work. People on the libtool mailing list are usually willing to volunteer to help you with new ports, so you can send the information to them.
To do the port yourself, you'll definitely need to modify the
libtool.m4 macros in order to make platform-specific changes to
the configuration process. You should search that file for the
PORTME keyword, which will give you some hints on what you'll
need to change. In general, all that is involved is modifying the
appropriate configuration variables (see libtool script contents).
Your best bet is to find an already-supported system that is similar to
yours, and make your changes based on that. In some cases, however,
your system will differ significantly from every other supported system,
and it may be necessary to add new configuration variables, and modify
the ltmain.in script accordingly. Be sure to write to the
mailing list before you make changes to ltmain.in, since they may
have advice on the most effective way of accomplishing what you want.
Since version 1.2c, libtool has re-introduced the ability to do inter-library dependency on some platforms, thanks to a patch by Toshio Kuratomi badger@prtr-13.ucsc.edu. Here's a shortened version of the message that contained his patch:
The basic architecture is this: in libtool.m4, the person who writes libtool makes sure $deplibs is included in $archive_cmds somewhere and also sets the variable $deplibs_check_method, and maybe $file_magic_cmd when deplibs_check_method is file_magic.
deplibs_check_method can be one of five things:
ldd. It is currently unused, and will probably be dropped in the
future.
Then in ltmain.in we have the real workhorse: a little initialization and postprocessing (to setup/release variables for use with eval echo libname_spec etc.) and a case statement that decides which method is being used. This is the real code... I wish I could condense it a little more, but I don't think I can without function calls. I've mostly optimized it (moved things out of loops, etc) but there is probably some fat left. I thought I should stop while I was ahead, work on whatever bugs you discover, etc before thinking about more than obvious optimizations.
This table describes when libtool was last known to be tested on platforms where it claims to support shared libraries:
-------------------------------------------------------
canonical host name compiler libtool results
(tools versions) release
-------------------------------------------------------
alpha-dec-osf5.1 cc 1.3e ok (1.910)
alpha-dec-osf4.0f gcc 1.3e ok (1.910)
alpha-dec-osf4.0f cc 1.3e ok (1.910)
alpha-dec-osf3.2 gcc 0.8 ok
alpha-dec-osf3.2 cc 0.8 ok
alpha-dec-osf2.1 gcc 1.2f NS
alpha*-unknown-linux-gnu gcc 1.3b ok
(egcs-1.1.2, GNU ld 2.9.1.0.23)
hppa2.0w-hp-hpux11.00 cc 1.2f ok
hppa2.0-hp-hpux10.20 cc 1.3.2 ok
hppa1.1-hp-hpux10.20 gcc 1.2f ok
hppa1.1-hp-hpux10.20 cc 1.3c ok (1.821)
hppa1.1-hp-hpux10.10 gcc 1.2f ok
hppa1.1-hp-hpux10.10 cc 1.2f ok
hppa1.1-hp-hpux9.07 gcc 1.2f ok
hppa1.1-hp-hpux9.07 cc 1.2f ok
hppa1.1-hp-hpux9.05 gcc 1.2f ok
hppa1.1-hp-hpux9.05 cc 1.2f ok
hppa1.1-hp-hpux9.01 gcc 1.2f ok
hppa1.1-hp-hpux9.01 cc 1.2f ok
i*86-*-beos gcc 1.2f ok
i*86-*-bsdi4.0.1 gcc 1.3c ok
(gcc-2.7.2.1)
i*86-*-bsdi4.0 gcc 1.2f ok
i*86-*-bsdi3.1 gcc 1.2e NS
i*86-*-bsdi3.0 gcc 1.2e NS
i*86-*-bsdi2.1 gcc 1.2e NS
i*86-pc-cygwin gcc 1.3b NS
(egcs-1.1 stock b20.1 compiler)
i*86-*-dguxR4.20MU01 gcc 1.2 ok
i*86-*-freebsd4.3 gcc 1.3e ok (1.912)
i*86-*-freebsdelf4.0 gcc 1.3c ok
(egcs-1.1.2)
i*86-*-freebsdelf3.2 gcc 1.3c ok
(gcc-2.7.2.1)
i*86-*-freebsdelf3.1 gcc 1.3c ok
(gcc-2.7.2.1)
i*86-*-freebsdelf3.0 gcc 1.3c ok
i*86-*-freebsd3.0 gcc 1.2e ok
i*86-*-freebsd2.2.8 gcc 1.3c ok
(gcc-2.7.2.1)
i*86-*-freebsd2.2.6 gcc 1.3b ok
(egcs-1.1 & gcc-2.7.2.1, native ld)
i*86-*-freebsd2.1.5 gcc 0.5 ok
i*86-*-netbsd1.5 gcc 1.3e ok (1.901)
(egcs-1.1.2)
i*86-*-netbsd1.4 gcc 1.3c ok
(egcs-1.1.1)
i*86-*-netbsd1.4.3A gcc 1.3e ok (1.901)
i*86-*-netbsd1.3.3 gcc 1.3c ok
(gcc-2.7.2.2+myc2)
i*86-*-netbsd1.3.2 gcc 1.2e ok
i*86-*-netbsd1.3I gcc 1.2e ok
(egcs 1.1?)
i*86-*-netbsd1.2 gcc 0.9g ok
i*86-*-linux-gnu gcc 1.3e ok (1.901)
(Red Hat 7.0, gcc "2.96")
i*86-*-linux-gnu gcc 1.3e ok (1.911)
(SuSE 7.0, gcc 2.95.2)
i*86-*-linux-gnulibc1 gcc 1.2f ok
i*86-*-openbsd2.5 gcc 1.3c ok
(gcc-2.8.1)
i*86-*-openbsd2.4 gcc 1.3c ok
(gcc-2.8.1)
i*86-*-solaris2.7 gcc 1.3b ok
(egcs-1.1.2, native ld)
i*86-*-solaris2.6 gcc 1.2f ok
i*86-*-solaris2.5.1 gcc 1.2f ok
i*86-ncr-sysv4.3.03 gcc 1.2f ok
i*86-ncr-sysv4.3.03 cc 1.2e ok
(cc -Hnocopyr)
i*86-pc-sco3.2v5.0.5 cc 1.3c ok
i*86-pc-sco3.2v5.0.5 gcc 1.3c ok
(gcc 95q4c)
i*86-pc-sco3.2v5.0.5 gcc 1.3c ok
(egcs-1.1.2)
i*86-sco-sysv5uw7.1.1 gcc 1.3e ok (1.901)
(gcc-2.95.2, SCO linker)
i*86-UnixWare7.1.0-sysv5 cc 1.3c ok
i*86-UnixWare7.1.0-sysv5 gcc 1.3c ok
(egcs-1.1.1)
m68k-next-nextstep3 gcc 1.2f NS
m68k-sun-sunos4.1.1 gcc 1.2f NS
(gcc-2.5.7)
m88k-dg-dguxR4.12TMU01 gcc 1.2 ok
m88k-motorola-sysv4 gcc 1.3 ok
(egcs-1.1.2)
mips-sgi-irix6.5 gcc 1.2f ok
(gcc-2.8.1)
mips-sgi-irix6.4 gcc 1.2f ok
mips-sgi-irix6.3 gcc 1.3b ok
(egcs-1.1.2, native ld)
mips-sgi-irix6.3 cc 1.3b ok
(cc 7.0)
mips-sgi-irix6.2 gcc 1.2f ok
mips-sgi-irix6.2 cc 0.9 ok
mips-sgi-irix5.3 gcc 1.2f ok
(egcs-1.1.1)
mips-sgi-irix5.3 gcc 1.2f NS
(gcc-2.6.3)
mips-sgi-irix5.3 cc 0.8 ok
mips-sgi-irix5.2 gcc 1.3b ok
(egcs-1.1.2, native ld)
mips-sgi-irix5.2 cc 1.3b ok
(cc 3.18)
mips-sni-sysv4 cc 1.3.5 ok
(Siemens C-compiler)
mips-sni-sysv4 gcc 1.3.5 ok
(gcc-2.7.2.3, GNU assembler 2.8.1, native ld)
mipsel-unknown-openbsd2.1 gcc 1.0 ok
powerpc-apple-darwin6.4 gcc 1.5 ok
(apple dev tools released 12/2002)
powerpc-ibm-aix4.3.1.0 gcc 1.2f ok
(egcs-1.1.1)
powerpc-ibm-aix4.2.1.0 gcc 1.2f ok
(egcs-1.1.1)
powerpc-ibm-aix4.1.5.0 gcc 1.2f ok
(egcs-1.1.1)
powerpc-ibm-aix4.1.5.0 gcc 1.2f NS
(gcc-2.8.1)
powerpc-ibm-aix4.1.4.0 gcc 1.0 ok
powerpc-ibm-aix4.1.4.0 xlc 1.0i ok
rs6000-ibm-aix4.1.5.0 gcc 1.2f ok
(gcc-2.7.2)
rs6000-ibm-aix4.1.4.0 gcc 1.2f ok
(gcc-2.7.2)
rs6000-ibm-aix3.2.5 gcc 1.0i ok
rs6000-ibm-aix3.2.5 xlc 1.0i ok
sparc-sun-solaris2.8 gcc 1.3e ok (1.913)
(gcc-2.95.3 & native ld)
sparc-sun-solaris2.7 gcc 1.3e ok (1.913)
(gcc-2.95.3 & native ld)
sparc-sun-solaris2.6 gcc 1.3e ok (1.913)
(gcc-2.95.3 & native ld)
sparc-sun-solaris2.5.1 gcc 1.3e ok (1.911)
sparc-sun-solaris2.5 gcc 1.3b ok
(egcs-1.1.2, GNU ld 2.9.1 & native ld)
sparc-sun-solaris2.5 cc 1.3b ok
(SC 3.0.1)
sparc-sun-solaris2.4 gcc 1.0a ok
sparc-sun-solaris2.4 cc 1.0a ok
sparc-sun-solaris2.3 gcc 1.2f ok
sparc-sun-sunos4.1.4 gcc 1.2f ok
sparc-sun-sunos4.1.4 cc 1.0f ok
sparc-sun-sunos4.1.3_U1 gcc 1.2f ok
sparc-sun-sunos4.1.3C gcc 1.2f ok
sparc-sun-sunos4.1.3 gcc 1.3b ok
(egcs-1.1.2, GNU ld 2.9.1 & native ld)
sparc-sun-sunos4.1.3 cc 1.3b ok
sparc-unknown-bsdi4.0 gcc 1.2c ok
sparc-unknown-linux-gnulibc1 gcc 1.2f ok
sparc-unknown-linux-gnu gcc 1.3b ok
(egcs-1.1.2, GNU ld 2.9.1.0.23)
sparc64-unknown-linux-gnu gcc 1.2f ok
Notes:
- "ok" means "all tests passed".
- "NS" means "Not Shared", but OK for static libraries
Note: The vendor-distributed HP-UX sed(1) programs are horribly
broken, and cannot handle libtool's requirements, so users may report
unusual problems. There is no workaround except to install a working
sed (such as GNU sed) on these systems.
Note: The vendor-distributed NCR MP-RAS cc programs emits
copyright on standard error that confuse tests on size of
conftest.err. The workaround is to specify CC
when run configure with CC='cc -Hnocopyr'.
This section is dedicated to the sanity of the libtool maintainers. It describes the programs that libtool uses, how they vary from system to system, and how to test for them.
Because libtool is a shell script, it can be difficult to understand just by reading it from top to bottom. This section helps show why libtool does things a certain way. Combined with the scripts themselves, you should have a better sense of how to improve libtool, or write your own.
The following is a list of valuable documentation references:
The only compiler characteristics that affect libtool are the flags needed (if any) to generate PIC objects. In general, if a C compiler supports certain PIC flags, then any derivative compilers support the same flags. Until there are some noteworthy exceptions to this rule, this section will document only C compilers.
The following C compilers have standard command line options, regardless of the platform:
gccThe -fpic or -fPIC flags can be used to generate position-independent code. -fPIC is guaranteed to generate working code, but the code is slower on m68k, m88k, and Sparc chips. However, using -fpic on those chips imposes arbitrary size limits on the shared libraries.
The rest of this subsection lists compilers by the operating system that they are bundled with:
aix3*aix4*hpux10*osf3*solaris2*sunos4*On all known systems, a reloadable object can be created by running ld -r -o output.o input1.o input2.o. This reloadable object may be treated as exactly equivalent to other objects.
On most modern platforms the order that dependent libraries are listed has no effect on object generation. In theory, there are platforms which require libraries which provide missing symbols to other libraries to listed after those libraries whose symbols they provide.
Particularly, if a pair of static archives each resolve some of the other's symbols, it might be necessary to list one of those archives both before and after the other one. Libtool does not currently cope with this situation well, since duplicate libraries are removed from the link line by default. Libtool provides the command line option --preserve-dup-deps to preserve all duplicate dependencies in cases where it is necessary.
On all known systems, building a static library can be accomplished by running ar cru libname.a obj1.o obj2.o ..., where the .a file is the output library, and each .o file is an object file.
On all known systems, if there is a program named ranlib, then it
must be used to “bless” the created library before linking against it,
with the ranlib libname.a command. Some systems, like Irix,
use the ar ts command, instead.
libtool script contents
Since version 1.4, the libtool script is generated by
configure (see Configuring). In earlier versions,
configure achieved this by calling a helper script called
ltconfig. From libtool version 0.7 to 1.0, this script
simply set shell variables, then sourced the libtool backend,
ltmain.sh. ltconfig from libtool version 1.1 through 1.3
inlined the contents of ltmain.sh into the generated
libtool, which improved performance on many systems. The tests
that ltconfig used to perform are now kept in libtool.m4
where thay can be written using Autoconf. This has the runtime
performance benefits of inlined ltmain.sh, and improves
the build time a little while considerably easing the amount of raw
shell code that used to need maintaining.
The convention used for naming variables which hold shell commands for
delayed evaluation, is to use the suffix _cmd where a single
line of valid shell script is needed, and the suffix _cmds where
multiple lines of shell script may be delayed for later
evaluation. By convention, _cmds variables delimit the
evaluation units with the ~ character where necessary.
Here is a listing of each of the configuration variables, and how they
are used within ltmain.sh (see Configuring):
The name of the linker that libtool should use internally for reloadable linking and possibly shared libraries.
The name of a BSD-compatible
nmprogram, which produces listings of global symbols in one the following formats:address C global-variable-name address D global-variable-name address T global-function-name
The flag that is used by archive_cmds in order to declare that there will be unresolved symbols in the resulting shared library. Empty, if no such flag is required. Set to unsupported if there is no way to generate a shared library with references to symbols that aren't defined in that library.
Whether libtool should automatically generate a list of exported symbols using export_symbols_cmds before linking an archive. Set to yes or no. Default is no.
Commands used to create shared libraries, shared libraries with -export-symbols and static libraries, respectively.
If the shared library depends on a static library, old_archive_from_new_cmds contains the commands used to create that static library. If this variable is not empty, old_archive_cmds is not used.
If a static library must be created from the export symbol list in order to correctly link with a shared library, old_archive_from_expsyms_cmds contains the commands needed to create that static library. When these commands are executed, the variable soname contains the name of the shared library in question, and the $objdir/$newlib contains the path of the static library these commands should build. After executing these commands, libtool will proceed to link against $objdir/$newlib instead of soname.
Whether libtool should build shared libraries on this system. Set to yes or no.
Whether libtool should build static libraries on this system. Set to yes or no.
Whether the compiler supports the
-cand-ooptions simultaneously. Set to yes or no.
Whether the compiler supports compiling directly to a ".lo" file, i.e whether object files do not have to have the suffix ".o". Set to yes or no.
Whether it is possible to
dlopenthe executable itself, when it is linked statically (-all-static). Set to yes or no.
Compiler link flag that allows a dlopened shared library to reference symbols that are defined in the program.
Commands to extract exported symbols from libobjs to the file export_symbols.
Commands to extract the exported symbols list from a shared library. These commands are executed if there is no file $objdir/$soname-def, and should write the names of the exported symbols to that file, for the use of old_archive_from_expsyms_cmds.
Determines whether libtool will privilege the installer or the developer. The assumption is that installers will seldom run programs in the build tree, and the developer will seldom install. This is only meaningful on platforms in which shlibpath_overrides_runpath is not yes, so fast_install will be set to needless in this case. If fast_install set to yes, libtool will create programs that search for installed libraries, and, if a program is run in the build tree, a new copy will be linked on-demand to use the yet-to-be-installed libraries. If set to no, libtool will create programs that use the yet-to-be-installed libraries, and will link a new copy of the program at install time. The default value is yes or needless, depending on platform and configuration flags, and it can be turned from yes to no with the configure flag --disable-fast-install.
Commands to tell the dynamic linker how to find shared libraries in a specific directory.
A pipeline that takes the output of NM, and produces a listing of raw symbols followed by their C names. For example:
$ eval "$NM progname | $global_symbol_pipe" D symbol1 C-symbol1 T symbol2 C-symbol2 C symbol3 C-symbol3 ... $The first column contains the symbol type (used to tell data from code on some platforms), but its meaning is system dependent.
A pipeline that translates the output of global_symbol_pipe into proper C declarations. On platforms whose linkers differentiate code from data, such as HP/UX, data symbols will be declared as such, and code symbols will be declared as functions. On platforms that don't care, everything is assumed to be data.
Either immediate or relink, depending on whether shared library paths can be hardcoded into executables before they are installed, or if they need to be relinked.
Set to yes or no, depending on whether the linker hardcodes directories if a library is directly specified on the command line (such as dir/libname.a) when hardcode_libdir_flag_spec is specified.
Whether the platform supports hardcoding of run-paths into libraries. If enabled, linking of programs will be much simpler but libraries will need to be relinked during installation. Set to yes or no.
Flag to hardcode a libdir variable into a binary, so that the dynamic linker searches libdir for shared libraries at runtime. If it is empty, libtool will try to use some other hardcoding mechanism.
If the compiler only accepts a single hardcode_libdir_flag, then this variable contains the string that should separate multiple arguments to that flag.
Set to yes or no, depending on whether the linker hardcodes directories specified by -L flags into the resulting executable when hardcode_libdir_flag_spec is specified.
Set to yes or no, depending on whether the linker hardcodes directories by writing the contents of $shlibpath_var into the resulting executable when hardcode_libdir_flag_spec is specified. Set to unsupported if directories specified by $shlibpath_var are searched at run time, but not at link time.
For information purposes, set to the specified and canonical names of the system that libtool was configured for.
The format of a library name prefix. On all Unix systems, static libraries are called libname.a, but on some systems (such as OS/2 or MS-DOS), the library is just called name.a.
A list of shared library names. The first is the name of the file, the rest are symbolic links to the file. The name in the list is the file name that the linker finds when given -lname.
Whether libtool must link a program against all its dependency libraries. Set to yes or no. Default is unknown, which is a synonym for yes.
Linker flag (passed through the C compiler) used to prevent dynamic linking.
Whether libtool should automatically prefix module names with 'lib'. Set to yes or no. By default, it is unknown, which means the same as yes, but documents that we are not really sure about it. yes means that it is possible both to
dlopenand to link against a library without 'lib' prefix, i.e. it requires hardcode_direct to be yes.
Whether versioning is required for libraries, i.e. whether the dynamic linker requires a version suffix for all libraries. Set to yes or no. By default, it is unknown, which means the same as yes, but documents that we are not really sure about it.
Whether files must be locked to prevent conflicts when compiling simultaneously. Set to yes or no.
Compiler flag to disable builtin functions that conflict with declaring external global symbols as
char.
The flag that is used by archive_cmds in order to declare that there will be no unresolved symbols in the resulting shared library. Empty, if no such flag is required.
Commands run after installing a shared or static library, respectively.
Commands run after uninstalling a shared or static library, respectively.
The environment variable that tells the linker which directories to hardcode in the resulting executable.
Indicates whether it is possible to override the hard-coded library search path of a program with an environment variable. If this is set to no, libtool may have to create two copies of a program in the build tree, one to be installed and one to be run in the build tree only. When each of these copies is created depends on the value of
fast_install. The default value is unknown, which is equivalent to no.
The environment variable that tells the dynamic linker where to find shared libraries.
The name coded into shared libraries, if different from the real name of the file.
Command to strip a shared (
striplib) or static (old_striplib) library, respectively. If these variables are empty, the strip flag in the install mode will be ignored for libraries (see Install mode).
Expression to get the run-time system library search path. Directories that appear in this list are never hard-coded into executables.
Expression to get the compile-time system library search path. This variable is used by libtool when it has to test whether a certain library is shared or static. The directories listed in shlibpath_var are automatically appended to this list, every time libtool runs (i.e., not at configuration time), because some linkers use this variable to extend the library search path. Linker switches such as
-Lalso augment the search path.
Linker flag (passed through the C compiler) used to generate thread-safe libraries.
The library version numbering type. One of libtool, freebsd-aout, freebsd-elf, irix, linux, osf, sunos, windows, or none.
Compiler flag to generate shared objects from convenience archives.
The C compiler flag that allows libtool to pass a flag directly to the linker. Used as:
${wl}some-flag.
Variables ending in _cmds or _eval contain a
~-separated list of commands that are evaled one after
another. If any of the commands return a nonzero exit status, libtool
generally exits with an error message.
Variables ending in _spec are evaled before being used by
libtool.
Here are a few tricks that you can use in order to make maintainership easier:
ltmain.in, I keep a permanent libtool script in my
PATH, which sources ltmain.in directly.
The following steps describe how to create such a script, where
/home/src/libtool is the directory containing the libtool source
tree, /home/src/libtool/libtool is a libtool script that has been
configured for your platform, and ~/bin is a directory in your
PATH:
trick$ cd ~/bin
trick$ sed '/^# ltmain\.sh/q' /home/src/libtool/libtool > libtool
trick$ echo '. /home/src/libtool/ltmain.in' >> libtool
trick$ chmod +x libtool
trick$ libtool --version
ltmain.sh (GNU @PACKAGE@) @VERSION@@TIMESTAMP@
trick$
The output of the final libtool --version command shows that the
ltmain.in script is being used directly. Now, modify
~/bin/libtool or /home/src/libtool/ltmain.in directly in
order to test new changes without having to rerun configure.
Copyright (C) 2000 Free Software Foundation, Inc.
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
The purpose of this License is to make a manual, textbook, or other written document “free” in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others.
This License is a kind of “copyleft”, which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software.
We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.
This License applies to any manual or other work that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. The “Document”, below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as “you”.
A “Modified Version” of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language.
A “Secondary Section” is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document's overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (For example, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.
The “Invariant Sections” are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License.
The “Cover Texts” are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License.
A “Transparent” copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, whose contents can be viewed and edited directly and straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup has been designed to thwart or discourage subsequent modification by readers is not Transparent. A copy that is not “Transparent" is called "Opaque”.
Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML designed for human modification. Opaque formats include PostScript, PDF, proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML produced by some word processors for output purposes only.
The “Title Page” means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, “Title Page” means the text near the most prominent appearance of the work's title, preceding the beginning of the body of the text.
You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3.
You may also lend copies, under the same conditions stated above, and you may publicly display copies.
If you publish printed copies of the Document numbering more than 100, and the Document's license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects.
If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages.
If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a publicly-accessible computer-network location containing a complete Transparent copy of the Document, free of added material, which the general network-using public has access to download anonymously at no charge using public-standard network protocols. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public.
It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.
You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version:
If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version's license notice. These titles must be distinct from any other section titles.
You may add a section entitled “Endorsements”, provided it contains nothing but endorsements of your Modified Version by various parties–for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard.
You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one.
The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.
You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice.
The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work.
In the combination, you must combine any sections entitled “History” in the various original documents, forming one section entitled “History"; likewise combine any sections entitled "Acknowledgements”, and any sections entitled “Dedications”. You must delete all sections entitled “Endorsements.”
You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects.
You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.
A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, does not as a whole count as a Modified Version of the Document, provided no compilation copyright is claimed for the compilation. Such a compilation is called an “aggregate”, and this License does not apply to the other self-contained works thus compiled with the Document, on account of their being thus compiled, if they are not themselves derivative works of the Document.
If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one quarter of the entire aggregate, the Document's Cover Texts may be placed on covers that surround only the Document within the aggregate. Otherwise they must appear on covers around the whole aggregate.
Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License provided that you also include the original English version of this License. In case of a disagreement between the translation and the original English version of this License, the original English version will prevail.
You may not copy, modify, sublicense, or distribute the Document except as expressly provided for under this License. Any other attempt to copy, modify, sublicense or distribute the Document is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.
The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See http://www.gnu.org/copyleft/.
Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License “or any later version” applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation.
To use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page:
Copyright (c) YEAR YOUR NAME.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.1
or any later version published by the Free Software Foundation;
with the Invariant Sections being LIST THEIR TITLES, with the
Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.
A copy of the license is included in the section entitled "GNU
Free Documentation License".
If you have no Invariant Sections, write “with no Invariant Sections” instead of saying which ones are invariant. If you have no Front-Cover Texts, write “no Front-Cover Texts” instead of “Front-Cover Texts being LIST”; likewise for Back-Cover Texts.
If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software.
AC_CONFIG_AUX_DIR: Invoking libtoolizeAC_DISABLE_FAST_INSTALL: AC_PROG_LIBTOOLAC_DISABLE_SHARED: AC_PROG_LIBTOOLAC_DISABLE_STATIC: AC_PROG_LIBTOOLAC_FUNC_ALLOCA: Autoconf .o macrosAC_LIBTOOL_DLOPEN: AC_PROG_LIBTOOLAC_LIBTOOL_WIN32_DLL: AC_PROG_LIBTOOLAC_PROG_LIBTOOL: AC_PROG_LIBTOOLAC_REPLACE_FUNCS: Autoconf .o macrosaclocal: AC_PROG_LIBTOOLallow_undefined_flag: libtool script contentsalways_export_symbols: libtool script contentsAM_DISABLE_SHARED: AC_PROG_LIBTOOLAM_DISABLE_STATIC: AC_PROG_LIBTOOLAM_PROG_LIBTOOL: AC_PROG_LIBTOOLAR: libtool script contentsar: Linking librariesarchive_cmds: libtool script contentsarchive_expsym_cmds: libtool script contentsAS: AC_PROG_LIBTOOLassign.test: Test descriptionsbuild-relink.test: Test descriptionsbuild_libtool_libs: libtool script contentsbuild_old_libs: libtool script contentsCC: libtool script contentsCC: AC_PROG_LIBTOOLcdemo-conf.test: Test descriptionscdemo-exec.test: Test descriptionscdemo-make.test: Test descriptionscdemo-shared.test: Test descriptionscdemo-static.test: Test descriptionsCFLAGS: AC_PROG_LIBTOOLcompiler_c_o: libtool script contentscompiler_o_lo: libtool script contentsconfig.guess: Distributingconfig.sub: DistributingCPPFLAGS: AC_PROG_LIBTOOLdemo-conf.test: Test descriptionsdemo-exec.test: Test descriptionsdemo-inst.test: Test descriptionsdemo-make.test: Test descriptionsdemo-nofast.test: Test descriptionsdemo-nopic.test: Test descriptionsdemo-pic.test: Test descriptionsdemo-shared.test: Test descriptionsdemo-static.test: Test descriptionsdemo-unst.test: Test descriptionsdepdemo-conf.test: Test descriptionsdepdemo-exec.test: Test descriptionsdepdemo-inst.test: Test descriptionsdepdemo-make.test: Test descriptionsdepdemo-nofast.test: Test descriptionsdepdemo-shared.test: Test descriptionsdepdemo-static.test: Test descriptionsdepdemo-unst.test: Test descriptionsdeplibs.test: Test descriptionsdeplibs_check_method: Porting inter-library dependenciesdlclose: Using libltdldlclose: Dlopened modulesdlerror: Using libltdlDLLTOOL: AC_PROG_LIBTOOLdlopen: Using libltdldlopen: Dlopened modulesdlopen_self: libtool script contentsdlopen_self_static: libtool script contentsdlopen_support: libtool script contentsdlsym: Using libltdldlsym: Dlopened modulesdryrun.test: Test descriptionsecho: libtool script contentsexclude_expsyms: libtool script contentsexport_dynamic_flag_spec: libtool script contentsexport_symbols_cmds: libtool script contentsextract_expsyms_cmds: libtool script contentsfast_install: libtool script contentsfile_magic: Porting inter-library dependenciesfile_magic_cmd: Porting inter-library dependenciesfile_magic_test_file: Porting inter-library dependenciesfinish_cmds: libtool script contentsfinish_eval: libtool script contentsfix_srcfile_path: libtool script contentsglobal_symbol_pipe: libtool script contentsglobal_symbol_to_cdecl: libtool script contentshardcode.test: Test descriptionshardcode_action: libtool script contentshardcode_direct: libtool script contentshardcode_into_libs: libtool script contentshardcode_libdir_flag_spec: libtool script contentshardcode_libdir_separator: libtool script contentshardcode_minus_L: libtool script contentshardcode_shlibpath_var: libtool script contentshost: libtool script contentshost_alias: libtool script contentsinclude_expsyms: libtool script contentsinstall: Installing librariesinstall-sh: DistributingLD: libtool script contentsLD: AC_PROG_LIBTOOLLDFLAGS: AC_PROG_LIBTOOLlibext: libtool script contentslibltdl: Using libltdllibname_spec: libtool script contentslibrary_names_spec: libtool script contentsLIBS: AC_PROG_LIBTOOLlibtool: Invoking libtoollibtoolize: Invoking libtoolizelink-2.test: Test descriptionslink.test: Test descriptionslink_all_deplibs: libtool script contentslink_static_flag: libtool script contentsLN_S: AC_PROG_LIBTOOLlt_dladderror: Module loaders for libltdllt_dladdsearchdir: Libltdl interfacelt_dlcaller_get_data: User defined module datalt_dlcaller_id: User defined module datalt_dlcaller_register: User defined module datalt_dlcaller_set_data: User defined module datalt_dlclose: Libltdl interfacelt_dlerror: Libltdl interfacelt_dlexit: Libltdl interfacelt_dlforeach: User defined module datalt_dlforeachfile: Libltdl interfacelt_dlfree: Libltdl interfacelt_dlgetinfo: User defined module datalt_dlgetsearchpath: Libltdl interfacelt_dlhandle: Libltdl interfacelt_dlhandle_next: User defined module datalt_dlinfo: User defined module datalt_dlinit: Libltdl interfacelt_dlinsertsearchdir: Libltdl interfacelt_dlisresident: Libltdl interfacelt_dlloader: Module loaders for libltdllt_dlloader_add: Module loaders for libltdllt_dlloader_data: Module loaders for libltdllt_dlloader_exit: Module loaders for libltdllt_dlloader_find: Module loaders for libltdllt_dlloader_name: Module loaders for libltdllt_dlloader_next: Module loaders for libltdllt_dlloader_remove: Module loaders for libltdllt_dlmakeresident: Libltdl interfacelt_dlmalloc: Libltdl interfacelt_dlmutex_geterror: Thread Safety in libltdllt_dlmutex_lock: Thread Safety in libltdllt_dlmutex_register: Thread Safety in libltdllt_dlmutex_seterror: Thread Safety in libltdllt_dlmutex_unlock: Thread Safety in libltdllt_dlopen: Libltdl interfacelt_dlopenext: Libltdl interfacelt_dlpreload: Libltdl interfacelt_dlpreload_default: Libltdl interfacelt_dlrealloc: Libltdl interfacelt_dlseterror: Module loaders for libltdllt_dlsetsearchpath: Libltdl interfacelt_dlsym: Libltdl interfacelt_dlsymlist: Libltdl interfacelt_dlsymlist: Dlpreopeninglt_find_sym: Module loaders for libltdllt_module: Module loaders for libltdllt_module_close: Module loaders for libltdllt_module_open: Module loaders for libltdllt_preloaded_symbols: Dlpreopeninglt_ptr: Libltdl interfacelt_user_data: Module loaders for libltdllt_user_dlloader: Module loaders for libltdlLTALLOCA: Autoconf .o macrosLTDL_SET_PRELOADED_SYMBOLS: Libltdl interfaceLTLIBOBJS: Autoconf .o macrosLTLIBRARIES: Using Automakeltmain.sh: Distributingmdemo-conf.test: Test descriptionsmdemo-exec.test: Test descriptionsmdemo-inst.test: Test descriptionsmdemo-make.test: Test descriptionsmdemo-shared.test: Test descriptionsmdemo-static.test: Test descriptionsmdemo-unst.test: Test descriptionsneed_lib_prefix: libtool script contentsneed_locks: libtool script contentsneed_version: libtool script contentsNM: libtool script contentsNM: AC_PROG_LIBTOOLno_builtin_flag: libtool script contentsno_undefined_flag: libtool script contentsnoinst-link.test: Test descriptionsnomode.test: Test descriptionsnone: Porting inter-library dependenciesobjdir: libtool script contentsOBJDUMP: AC_PROG_LIBTOOLobjext: libtool script contentsold_archive_cmds: libtool script contentsold_archive_from_expsyms_cmds: libtool script contentsold_archive_from_new_cmds: libtool script contentsold_postinstall_cmds: libtool script contentsold_postuninstall_cmds: libtool script contentsold_striplib: libtool script contentspass_all: Porting inter-library dependenciespic_flag: libtool script contentspostinstall_cmds: libtool script contentspostuninstall_cmds: libtool script contentsquote.test: Test descriptionsRANLIB: libtool script contentsRANLIB: AC_PROG_LIBTOOLranlib: Linking librariesreload_cmds: libtool script contentsreload_flag: libtool script contentsrunpath_var: libtool script contentssh.test: Test descriptionsshl_load: Using libltdlshl_load: Dlopened modulesshlibpath_overrides_runpath: libtool script contentsshlibpath_var: libtool script contentssoname_spec: libtool script contentsstrip: Installing librariesstriplib: libtool script contentssu: Installing librariessuffix.test: Test descriptionssys_lib_dlsearch_path_spec: libtool script contentssys_lib_search_path_spec: libtool script contentstest_compile: Porting inter-library dependenciesthread_safe_flag_spec: libtool script contentsunknown: Porting inter-library dependenciesversion_type: libtool script contentswhole_archive_flag_spec: libtool script contentswl: libtool script contentslibtool
[1] If you don't
specify an rpath, then libtool builds a libtool convenience
archive, not a shared library (see Static libraries).
[2] However, you should avoid using -L or -l flags to link against an uninstalled libtool library. Just specify the relative path to the .la file, such as ../intl/libintl.la. This is a design decision to eliminate any ambiguity when linking against uninstalled shared libraries.
[3] Don't accidentally strip the libraries, though, or they will be unusable.
[4] AC_PROG_LIBTOOL requires that
you define the Makefile variable top_builddir in your
Makefile.in. Automake does this automatically, but Autoconf
users should set it to the relative path to the top of your build
directory (../.., for example).
[5] GNU Image Manipulation Program, for those who haven't taken the plunge. See http://www.gimp.org/.
[6] We used to recommend __P,
__BEGIN_DECLS and __END_DECLS. This was bad advice since
symbols (even preprocessor macro names) that begin with an underscore
are reserved for the use of the compiler.
[7] HP-UX,
to be different, uses a function named shl_load.
[8] LIBPATH
on AIX, and SHLIB_PATH on HP-UX.
[9] This is used for
the host dependent module loading api – shl_load and
LoadLibrary for example
[10] Even if libltdl is installed, AC_LIBLTDL_INSTALLABLE may fail to detect it, if libltdl depends on symbols provided by libraries other than the C library. In this case, it will needlessly build and install libltdl.
[11] All code compiled
for the PowerPC and RS/6000 chips (powerpc-*-*, powerpcle-*-*,
and rs6000-*-*) is position-independent, regardless of the operating
system or compiler suite. So, “regular objects” can be used to build
shared libraries on these systems and no special PIC compiler flags are
required.