1.1 Motivation for writing libtool

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:

1. The system must be as elegant as possible.
2. The system must be fully integrated with the GNU Autoconf and Automake utilities, so that it will be easy for GNU maintainers to use. However, the system must not require these tools, so that it can be used by non-GNU packages.
3. Portability to other (non-GNU) architectures and tools is desirable.

1.2 Implementation issues

The following issues need to be addressed in any reusable shared library system, specifically libtool:

1. The package installer should be able to control what sort of libraries are built.
2. It can be tricky to run dynamically linked programs whose libraries have not yet been installed. LD_LIBRARY_PATH must be set properly (if it is supported), or programs fail to run.
3. The system must operate consistently even on hosts which don’t support shared libraries.
4. The commands required to build shared libraries may differ wildly from host to host. These need to be determined at configure time in a consistent way.
5. It is not always obvious with which suffix a shared library should be installed. This makes it difficult for Makefile rules, since they generally assume that file names are the same from host to host.
6. The system needs a simple library version number abstraction, so that shared libraries can be upgraded in place. The programmer should be informed how to design the interfaces to the library to maximize binary compatibility.
7. The install Makefile target should warn the package installer to set the proper environment variables (LD_LIBRARY_PATH or equivalent), or run ldconfig.

1.3 Other implementations

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.

1.4 A postmortem analysis of other implementations

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.

3.1 Creating object files

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 gcc -g -O -c foo.c
gcc -g -O -c foo.c
echo timestamp > foo.lo
a23$ libtool 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 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 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.

3.2 Linking libraries

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 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)¹:

a23$ libtool 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 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.

3.3 Linking executables

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 same² (see Link mode):

a23$ libtool 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 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 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.

3.4 Debugging executables

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 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$

3.5 Installing libraries

Installing libraries on a non-libtool system is quite straightforward… just copy them into place:³

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 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 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 --finish libdir’ can give you further hints on what to do (see Finish mode):

burger# libtool -n --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.

3.6 Installing executables

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#

3.7 Linking static libraries

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 ./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 create a libtool 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.

4.1 Compile mode

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.

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.

4.2 Link mode

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:

‘-all-static’

If output-file is a program, then do not link it against any shared libraries at all. If output-file is a library, then only create a static library.

‘-avoid-version’

Tries to avoid versioning (see Library interface versions) for libraries and modules, i.e. no version information is stored and no symbolic links are created. If the platform requires versioning, this option has no effect.

‘-dlopen file’

Same as ‘-dlpreopen file’, if native dlopening is not supported on the host platform (see Dlopened modules) or if the program is linked with ‘-static’ or ‘-all-static’. Otherwise, no effect. If file is self libtool will make sure that the program can dlopen itself, either by enabling -export-dynamic or by falling back to ‘-dlpreopen self’.

‘-dlpreopen file’

Link file into the output program, and add its symbols to lt_preloaded_symbols (see Dlpreopening). If file is 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.

‘-export-dynamic’

Allow symbols from output-file to be resolved with dlsym (see Dlopened modules).

‘-export-symbols symfile’

Tells the linker to export only the symbols listed in symfile. The symbol file should end in ‘.sym’ and must contain the name of one symbol per line. This option has no effect on some platforms. By default all symbols are exported.

‘-export-symbols-regex regex’

Same as ‘-export-symbols’, except that only symbols matching the regular expression regex are exported. By default all symbols are exported.

‘-Llibdir’

Search libdir for required libraries that have already been installed.

‘-lname’

output-file requires the installed library libname. This option is required even when output-file is not an executable.

‘-module’

Creates a library that can be dlopened (see Dlopened modules). This option doesn’t work for programs. Module names don’t need to be prefixed with ’lib’. In order to prevent name clashes, however, ’libname’ and ’name’ must not be used at the same time in your package.

‘-no-undefined’

Declare that output-file does not depend on any other libraries. Some platforms cannot create shared libraries that depend on other libraries (see Inter-library dependencies).

‘-o output-file’

Create output-file from the specified objects and libraries.

‘-release release’

Specify that the library was generated by release release of your package, so that users can easily tell which versions are newer than others. Be warned that no two releases of your package will be binary compatible if you use this flag. If you want binary compatibility, use the ‘-version-info’ flag instead (see Library interface versions).

‘-rpath libdir’

If output-file is a library, it will eventually be installed in libdir. If output-file is a program, add libdir to the run-time path of the program.

‘-R libdir’

If output-file is a program, add libdir to its run-time path. If output-file is a library, add -Rlibdir to its dependency_libs, so that, whenever the library is linked into a program, libdir will be added to its run-time path.

‘-static’

If output-file is a program, then do not link it against any uninstalled shared libtool libraries. If output-file is a library, then only create a static library.

‘-version-info current[:revision[:age]]’

If output-file is a libtool library, use interface version information current, revision, and age to build it (see Library interface versions). Do not use this flag to specify package release information, rather see the ‘-release’ flag.

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.

4.3 Execute mode

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:

‘-dlopen file’

Add the directory containing file to the library path.

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.

4.4 Install mode

In install mode, libtool interprets mode-args as an installation command beginning with cp, or a BSD-compatible install program.

The rest of the mode-args are interpreted as arguments to that command.

The command is run, and any necessary unprivileged post-installation commands are also completed.

4.5 Finish mode

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.

4.6 Uninstall mode

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.

5.1 Writing Makefile rules for libtool

Libtool is fully integrated with Automake (see Introduction in 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:

1. Download Automake (version 1.2 or later) from your nearest GNU mirror, install it, and start using it.
2. Learn how to write Makefile rules by hand. They’re sometimes complex, but if you’re clever enough to write rules for compiling your old libraries, then you should be able to figure out new rules for libtool libraries (hint: examine the Makefile.in in the demo subdirectory of the libtool distribution… note especially that it was automatically generated from the Makefile.am by Automake).

5.2 Using Automake with libtool

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:

• add them to program_LDFLAGS, and list the libraries in program_DEPENDENCIES, then wait for a release of GNU automake that accepts these flags where they belong;
• surround the flags between quotes, but then you must set program_DEPENDENCIES too:

  program_LDADD = "-dlopen" libfoo.la
  program_DEPENDENCIES = libfoo.la
  

• set and ‘AC_SUBST’ variables DLOPEN and DLPREOPEN in configure.in and use ‘@DLOPEN@’ and ‘@DLPREOPEN@’ as replacements for the explicit flags ‘-dlopen’ and ‘-dlpreopen’ in ‘program_LDADD’. Automake will discard ‘AC_SUBST’ed variables from dependencies, so it will behave exactly as we expect it to behave when it accepts these flags in ‘program_LDADD’. But hey!, this is ugly!

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 Library interface versions) 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 The Automake Manual in The Automake Manual, for more information.

5.3 Configuring libtool

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 Including libtool in your package), 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 has its own equivalent to the configure script, ltconfig.

• Invoking ltconfig
• Using ltconfig
• The AM_PROG_LIBTOOL macro

ltconfig [option]… ltmain [host]

burger$ ./ltconfig ltmain.sh
checking host system type... i386-unknown-netbsd1.2
checking for ranlib... ranlib
checking for gcc... gcc
checking whether we are using GNU C... yes
checking for gcc option to produce PIC... -fPIC -DPIC
checking for gcc option to statically link programs... -static
checking if ld is GNU ld... no
checking if ld supports shared libraries... yes
checking dynamic linker characteristics... netbsd1.2 ld.so
checking if libtool supports shared libraries... yes
checking whether to build shared libraries... yes
creating libtool
burger$

burger$ export PATH=/local/i486-gnu/bin:$PATH
burger$ ./ltconfig ltmain.sh i486-gnu0.1
checking host system type... i486-unknown-gnu0.1
checking for ranlib... ranlib
checking for gcc... gcc
checking whether we are using GNU C... yes
checking for gcc option to produce PIC... -fPIC -DPIC
checking for gcc option to statically link programs... -static
checking if ld is GNU ld... yes
checking if GNU ld supports shared libraries... yes
checking dynamic linker characteristics... gnu0.1 ld.so
checking if libtool supports shared libraries... yes
checking whether to build shared libraries... yes
creating libtool
burger$

5.4 Including libtool in your package

In order to use libtool, you need to include the following files with your package:

config.guess ¶

Attempt to guess a canonical system name.

config.sub ¶

Canonical system name validation subroutine script.

ltconfig

Generate a libtool script for a given system.

ltmain.sh ¶

A generic script implementing basic libtool functionality.

Note that the libtool script itself should not be included with your package. See Configuring libtool.

You should use the libtoolize program, rather than manually copying these files into your package.

• Invoking libtoolize
• Autoconf ‘.o’ macros

libtoolize [option]…

LTLIBOBJS=`echo "$LIBOBJS" | sed 's/\.o/.lo/g'`
AC_SUBST(LTLIBOBJS)
LTALLOCA=`echo "$ALLOCA" | sed 's/\.o/.lo/g'`
AC_SUBST(LTALLOCA)
AC_OUTPUT(…)

5.5 Static-only libraries

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 AM_PROG_LIBTOOL by using the AM_DISABLE_SHARED Autoconf macro (see The AM_PROG_LIBTOOL macro). This prevents libtool from building shared libraries, which has several advantages:

• compilation is twice as fast, which can speed up your development cycle,
• debugging is easier because you don’t need to deal with any complexities added by shared libraries, and
• you can see how libtool behaves on static-only platforms.

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 GIMP⁵ 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.

6.1 What are library interfaces?

Interfaces for libraries may be any of the following (and more):

• global variables: both names and types
• global functions: argument types and number, return types, and function names
• standard input, standard output, standard error, and file formats
• sockets, pipes, and other inter-process communication protocol formats

Note that static functions do not count as interfaces, because they are not directly available to the user of the library.

6.2 Libtool’s versioning system

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:

current

The most recent interface number that this library implements.

revision

The implementation number of the current interface.

age

The difference between the newest and oldest interfaces that this library implements. In other words, the library implements all the interface numbers in the range from number current - age to current.

If two libraries have identical current and age numbers, then the dynamic linker chooses the library with the greater revision number.

6.3 Updating library version information

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:

1. Start with version information of ‘0:0:0’ for each libtool library.
2. Update the version information only immediately before a public release of your software. More frequent updates are unnecessary, and only guarantee that the current interface number gets larger faster.
3. If the library source code has changed at all since the last update, then increment revision (‘c:r:a’ becomes ‘c:r+1:a’).
4. If any interfaces have been added, removed, or changed since the last update, increment current, and set revision to 0.
5. If any interfaces have been added since the last public release, then increment age.
6. If any interfaces have been removed since the last public release, then set age to 0.

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 Managing release information), but be warned that every release of your package will not be binary compatible with any other release.

6.4 Managing release information

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.

7.1 Writing C header files

Writing portable C header files can be difficult, since they may be read by different types of compilers:

C++ compilers

C++ compilers require that functions be declared with full prototypes, since C++ is more strongly typed than C. C functions and variables also need to be declared with the extern "C" directive, so that the names aren’t mangled. See Writing libraries for C++, for other issues relevant to using C++ with libtool.

ANSI C compilers

ANSI C compilers are not as strict as C++ compilers, but functions should be prototyped to avoid unnecessary warnings when the header file is #included.

non-ANSI C compilers

Non-ANSI compilers will report errors if functions are prototyped.

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_DECLS should be used at the beginning of your declarations,
   so that C++ compilers don't mangle their names.  Use __END_DECLS at
   the end of C declarations. */
#undef __BEGIN_DECLS
#undef __END_DECLS
#ifdef __cplusplus
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
#else
# define __BEGIN_DECLS /* empty */
# define __END_DECLS /* empty */
#endif

/* __P 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 __P
#if defined (__STDC__) || defined (_AIX) \
        || (defined (__mips) && defined (_SYSTYPE_SVR4)) \
        || defined(WIN32) || defined(__cplusplus)
# define __P(protos) protos
#else
# define __P(protos) ()
#endif

These macros are used in foo.h as follows:

#ifndef _FOO_H_
#define _FOO_H_ 1

/* The above macro definitions. */
…

__BEGIN_DECLS
int foo __P((void));
int hello __P((void));
__END_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.

Feel free to copy the definitions of __P, __BEGIN_DECLS, and __END_DECLS into your own headers. Then, you may use them to create header files that are valid for C++, ANSI, and non-ANSI compilers.

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:

• Pre-ANSI compilers do not always support the void * generic pointer type, and so need to use char * in its place.
• The const and signed keywords are not supported by some compilers, especially pre-ANSI compilers.
• The long double type is not supported by many compilers.

9.1 Building modules to dlopen

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 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 gcc -export-dynamic -o hell-dlopener main.o
burger$

9.2 Dlpreopening

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”:

1. Linking against object files that become part of the program executable, whether or not they are referenced. If an object file cannot be found, then the linker refuses to create the executable.
2. Declaring a static library to the linker, so that it is searched at link time in order to satisfy any undefined references in the above object files. If the static library cannot be found, then the linker refuses to link the executable.
3. Declaring a shared library to the runtime linker, so that it is searched at runtime in order to satisfy any undefined references in the above files. If the shared library cannot be found, then the dynamic linker aborts the program before it runs.
4. Dlopening a module, so that the application can resolve its own, dynamically-computed references. If there is an error opening the module, or the module is not found, then the application can recover without crashing.

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).

Structure: struct lt_dlsymlist { const char *name; lt_ptr_t address; } ¶

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.

Variable: const lt_dlsymlist * lt_preloaded_symbols ¶

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 of 0.

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.

9.3 Finding the correct name to dlopen

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_PATH⁸ 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.

9.4 Unresolved dlopen issues

The following problems are not solved by using libtool’s dlopen support:

• Dlopen functions are generally only available on shared library platforms. If you want your package to be portable to static platforms, you have to use either libltdl (see Using libltdl) or develop your own alternatives to dlopening dynamic code. Most reasonable solutions involve writing wrapper functions for the dlopen family, which do package-specific tricks when dlopening is unsupported or not available on a given platform.
• There are major differences in implementations of the dlopen family of functions. Some platforms do not even use the same function names (notably HP-UX, with its shl_load family).
• The application developer must write a custom search function in order to discover the correct module filename to supply to dlopen.

10.1 How to use libltdl in your programs

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>

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:

Type: lt_ptr_t ¶

lt_ptr_t is a generic pointer.

Type: lt_dlhandle ¶

lt_dlhandle is a module "handle". Every dlopened module has a handle associated with it.

Type: lt_dlsymlist ¶

lt_dlsymlist is a symbol list for dlpreopened modules. This structure is described in see Dlpreopening.

libltdl provides the following functions:

Function: int lt_dlinit (void) ¶

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.

Function: int lt_dlexit (void) ¶

Shut down libltdl and close all modules. This function will only then shut down libltdl when it was called as many times as lt_dlinit has been successfully called. Return 0 on success, otherwise the number of errors.

Function: lt_dlhandle lt_dlopen (const char *filename) ¶

Open the module with the file name filename and return a handle for it. lt_dlopen is 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-dynamic flag, then the global symbols in the executable will also be used to resolve references in the module.

If filename is NULL and the program was linked with -export-dynamic or -dlopen self, lt_dlopen will 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):

1. user-defined search path: This search path can be set by the program using the functions lt_dlsetsearchpath and lt_dladdsearchdir.
2. libltdl’s search path: This search path is the value of the environment variable LTDL_LIBRARY_PATH.
3. 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_dlopen fails for any reason, it returns NULL.

Function: lt_dlhandle lt_dlopenext (const char *filename) ¶

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:

1. the libtool archive extension ‘.la’
2. 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 dlopen such libraries as well as libtool modules transparently.

Function: int lt_dlclose (lt_dlhandle handle) ¶

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.

Function: lt_ptr_t lt_dlsym (lt_dlhandle handle, const char *name) ¶

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, NULL is returned.

Function: const char * lt_dlerror (void) ¶

Return a human readable string describing the most recent error that occurred from any of libltdl’s functions. Return NULL if no errors have occurred since initialization or since it was last called.

Function: int lt_dlpreload (const lt_dlsymlist *preloaded) ¶

Register the list of preloaded modules preloaded. If preloaded is NULL, then all previously registered symbol lists, except the list set by lt_dlpreload_default, are deleted. Return 0 on success.

Function: int lt_dlpreload_default (const lt_dlsymlist *preloaded) ¶

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 using lt_dlinit and can be used in the program to register the default preloaded modules. Instead of calling this function directly, most programs will use the macro LTDL_SET_PRELOADED_SYMBOLS.

Return 0 on success.

Macro: LTDL_SET_PRELOADED_SYMBOLS() ¶

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();
  /* ... */
}

Function: int lt_dladdsearchdir (const char *search_dir) ¶

Add the search directory search_dir to the user-defined library search path. Return 0 on success.

Function: int lt_dlsetsearchpath (const char *search_path) ¶

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.

Function: const char * lt_dlgetsearchpath (void) ¶

Return the current user-defined library search path.

Variable: lt_ptr_t (* lt_dlmalloc ) (size_t size) ¶

Variable: void (* lt_dlfree ) (lt_ptr_t ptr) ¶

These variables are set to malloc and free, by default, but you can set them to any other functions that provides equivalent functionality. However, you must not modify their values after calling any libltdl function other than lt_dlpreopen_default or the macro LTDL_SET_PRELOADED_SYMBOLS.

10.2 Creating modules that can be dlopened

Libtool 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 Library interface versions 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 _foo_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
...

10.3 How to distribute libltdl with your package

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 may decide which flavor of libltdl you want to use: a convenience library or an installable libtool library.

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 ‘AM_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 ‘AM_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_builddir}/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 INCLTDL, 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_SUBST’ed by default, such as LIBS and CPPFLAGS.

If you’re using the convenience libltdl, LIBLTDL will be the pathname for the convenience version of libltdl and INCLTDL will be ‘-I’ followed by the directory that contains libltdl, both starting with ‘${top_builddir}/’.

If you request an installed version of libltdl and one is found⁹, LIBLTDL will be set to ‘-lltdl’ and INCLTDL 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 INCLTDL 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 ‘$(INCLTDL)’ and link it with ‘$(LIBLTDL)’, using libtool.

You should probably also add ‘AC_LIBTOOL_DLOPEN’ to your configure.in before ‘AM_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 Substitute INCLTDL and LIBLTDL in the Makefiles
AC_SUBST(INCLTDL)
AC_SUBST(LIBLTDL)
dnl Check for dlopen support
AC_LIBTOOL_DLOPEN
dnl Configure libtool
AM_PROG_LIBTOOL
dnl Configure libltdl
AC_CONFIG_SUBDIRS(libltdl)
...

Makefile.am:

...
SUBDIRS = libltdl

INCLUDES = $(INCLTDL)

myprog_LDFLAGS = -export-dynamic
# The quotes around -dlopen below fool automake into accepting it
myprog_LDADD = $(LIBLTDL) "-dlopen" self "-dlopen" libfoo.la
myprog_DEPENDENCIES = $(LIBLTDL) libfoo.la
...

11.1 Writing libraries for C++

Creating libraries of C++ code should be a fairly straightforward process, because its object files differ from C ones in only three ways:

1. Because of name mangling, C++ libraries are only usable by the C++ compiler that created them. This decision was made by the designers of C++ in order to protect users from conflicting implementations of features such as constructors, exception handling, and RTTI.
2. On some systems, the C++ compiler must take special actions for the dynamic linker to run dynamic (i.e., run-time) initializers. This means that we should not call ld directly to link such libraries, and we should use the C++ compiler instead.
3. C++ compilers will link some Standard C++ library in by default, but libtool does not know which are these libraries, so it cannot even run the inter-library dependence analyzer to check how to link it in. Therefore, running ld to link a C++ program or library is deemed to fail. However, running the C++ compiler directly may lead to problems related with inter-library dependencies.

The conclusion is that libtool is not ready for general use for C++ libraries. You should avoid any global or static variable initializations that would cause an “initializer element is not constant” error if you compiled them with a standard C compiler.

There are other ways of working around this problem, but they are beyond the scope of this manual.

Furthermore, you’d better find out, at configure time, what are the C++ Standard libraries that the C++ compiler will link in by default, and explicitly list them in the link command line. Hopefully, in the future, libtool will be able to do this job by itself.

12.1 The libtool test suite

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.

• Description of test suite
• When tests fail

12.2 Reporting bugs

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 The 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 in 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 ltconfig --version).

13.1 Porting libtool to new systems

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.

• Information sources
• Porting inter-library dependencies support

13.2 Tested platforms

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-osf4.0*               gcc      1.3.3    ok
  (egcs-1.1.2)
alpha-dec-osf4.0*               cc       1.3.3    ok
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.3.3    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.4    ok
hppa1.1-hp-hpux10.20            gcc      1.3.4    ok
hppa1.1-hp-hpux10.20            cc       1.3.4    ok
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                  gcc      1.2f     ok
i*86-*-bsdi4.0.1                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.3.4    NS
  (egcs-1.1 stock b20.1 compiler)
i*86-*-dguxR4.20MU01            gcc      1.2      ok
i*86-*-freebsdelf4.0            gcc      1.2f     ok
i*86-*-freebsdelf3.1            gcc      1.2f     ok
i*86-*-freebsd3.0               gcc      1.2e     ok
i*86-*-freebsd2.2.8             gcc      1.2f     ok
i*86-*-freebsd2.2.6             gcc      1.3.3    ok
  (egcs-1.1 & gcc-2.7.2.1, native ld)
i*86-*-freebsd2.1.5             gcc      0.5      ok
i*86-*-gnu                      gcc      1.3.3    ok
i*86-*-netbsd1.4                gcc      1.3      ok
  (egcs-1.1.1)
i*86-*-netbsd1.3.3              gcc      1.3      ok
  (gcc-2.7.2.2)
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.3.4    ok
  (gcc-2.95.2, GNU ld 2.9.5)
i*86-*-linux-gnulibc1           gcc      1.2f     ok
i*86-*-openbsd2.4               gcc      1.2f     ok
i*86-*-solaris2.7               gcc      1.3.3    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)
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.3.3    ok
  (egcs-1.1.2, native ld)
mips-sgi-irix6.3                cc       1.3.3    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.3.3    ok
  (egcs-1.1.2, native ld)
mips-sgi-irix5.2                cc       1.3.3    ok
  (cc 3.18)
mipsel-unknown-openbsd2.1       gcc      1.0      ok
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.7            gcc      1.3.3    ok
  (egcs-1.1.2, GNU ld 2.9.1 & native ld)
sparc-sun-solaris2.6            gcc      1.3.2    ok
  (egcs-1.1.2, GNU ld 2.9.1 & native ld)
sparc-sun-solaris2.5.1          gcc      1.2f     ok
sparc-sun-solaris2.5            gcc      1.3.3    ok
  (egcs-1.1.2, GNU ld 2.9.1 & native ld)
sparc-sun-solaris2.5            cc       1.3.3    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.3.3    ok
  (egcs-1.1.2, GNU ld 2.9.1 & native ld)
sparc-sun-sunos4.1.3            cc       1.3.3    ok
sparc-unknown-bsdi4.0           gcc      1.2c     ok
sparc-unknown-linux-gnulibc1    gcc      1.2f     ok
sparc-unknown-linux-gnu         gcc      1.3.3    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'.

13.3 Platform quirks

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.

• References
• Compilers
• Reloadable objects
• Archivers

13.4 libtool script contents

The libtool script is generated by ltconfig (see Configuring libtool). 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 and later inlines the contents of ltmain.sh into the generated libtool, which improves performance on many systems.

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:

Variable: AR ¶

The name of the system library archiver.

Variable: CC ¶

The name of the C compiler used to configure libtool.

Variable: LD ¶

The name of the linker that libtool should use internally for reloadable linking and possibly shared libraries.

Variable: LTCONFIG_VERSION ¶

This is set to the version number of the ltconfig script, to prevent mismatches between the configuration information in libtool, and how that information is used in ltmain.sh.

Variable: NM ¶

The name of a BSD-compatible nm program, 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

Variable: RANLIB ¶

Set to the name of the ranlib program, if any.

Variable: allow_undefined_flag ¶

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.

Variable: always_export_symbols ¶

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’.

Variable: archive_cmds ¶

Variable: archive_expsym_cmds ¶

Variable: old_archive_cmds ¶

Commands used to create shared libraries, shared libraries with ‘-export-symbols’ and static libraries, respectively.

Variable: old_archive_from_new_cmds ¶

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.

Variable: build_libtool_libs ¶

Whether libtool should build shared libraries on this system. Set to ‘yes’ or ‘no’.

Variable: build_old_libs ¶

Whether libtool should build static libraries on this system. Set to ‘yes’ or ‘no’.

Variable: compiler_c_o ¶

Whether the compiler supports the -c and -o options simultaneously. Set to ‘yes’ or ‘no’.

Variable: compiler_o_lo ¶

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’.

Variable: dlopen ¶

Whether dlopen is supported on the platform. Set to ‘yes’ or ‘no’.

Variable: dlopen_self ¶

Whether it is possible to dlopen the executable itself. Set to ‘yes’ or ‘no’.

Variable: dlopen_self_static ¶

Whether it is possible to dlopen the executable itself, when it is linked statically (‘-all-static’). Set to ‘yes’ or ‘no’.

Variable: echo ¶

An echo program which does not interpret backslashes as an escape character.

Variable: exclude_expsyms ¶

List of symbols that should not be listed in the preloaded symbols.

Variable: export_dynamic_flag_spec ¶

Compiler link flag that allows a dlopened shared library to reference symbols that are defined in the program.

Variable: export_symbols_cmds ¶

Commands to extract exported symbols from libobjs to the file export_symbols.

Variable: fast_install ¶

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’.

Variable: finish_cmds ¶

Commands to tell the dynamic linker how to find shared libraries in a specific directory.

Variable: finish_eval ¶

Same as finish_cmds, except the commands are not displayed.

Variable: fix_srcfile_path ¶

Expression to fix the shell variable $srcfile for the compiler.

Variable: global_symbol_pipe ¶

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.

Variable: global_symbol_to_cdecl ¶

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.

Variable: hardcode_action ¶

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.

Variable: hardcode_direct ¶

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.

Variable: hardcode_libdir_flag_spec ¶

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.

Variable: hardcode_libdir_separator ¶

If the compiler only accepts a single hardcode_libdir_flag, then this variable contains the string that should separate multiple arguments to that flag.

Variable: hardcode_minus_L ¶

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.

Variable: hardcode_shlibpath_var ¶

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.

Variable: host ¶

Variable: host_alias ¶

For information purposes, set to the specified and canonical names of the system that libtool was configured for.

Variable: include_expsyms ¶

List of symbols that must always be exported when using export_symbols.

Variable: libext ¶

The standard old archive suffix (normally "a").

Variable: libname_spec ¶

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’.

Variable: library_names_spec ¶

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’.

Variable: link_static_flag ¶

Linker flag (passed through the C compiler) used to prevent dynamic linking.

Variable: need_lib_prefix ¶

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 dlopen and to link against a library without ’lib’ prefix, i.e. it requires hardcode_direct to be ‘yes’.

Variable: need_version ¶

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.

Variable: need_locks ¶

Whether files must be locked to prevent conflicts when compiling simultaneously. Set to ‘yes’ or ‘no’.

Variable: no_builtin_flag ¶

Compiler flag to disable builtin functions that conflict with declaring external global symbols as char.

Variable: no_undefined_flag ¶

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.

Variable: objdir ¶

The name of the directory that contains temporary libtool files.

Variable: objext ¶

The standard object file suffix (normally "o").

Variable: pic_flag ¶

Any additional compiler flags for building library object files.

Variable: postinstall_cmds ¶

Variable: old_postinstall_cmds ¶

Commands run after installing a shared or static library, respectively.

Variable: postuninstall_cmds ¶

Variable: old_postuninstall_cmds ¶

Commands run after uninstalling a shared or static library, respectively.

Variable: reload_cmds ¶

Variable: reload_flag ¶

Commands to create a reloadable object.

Variable: runpath_var ¶

The environment variable that tells the linker which directories to hardcode in the resulting executable.

Variable: shlibpath_overrides_runpath ¶

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’.

Variable: shlibpath_var ¶

The environment variable that tells the dynamic linker where to find shared libraries.

Variable: soname_spec ¶

The name coded into shared libraries, if different from the real name of the file.

Variable: sys_lib_dlsearch_path_spec ¶

Expression to get the run-time system library search path. Directories that appear in this list are never hard-coded into executables.

Variable: sys_lib_search_path_spec ¶

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 -L also augment the search path.

Variable: thread_safe_flag_spec ¶

Linker flag (passed through the C compiler) used to generate thread-safe libraries.

Variable: version_type ¶

The library version numbering type. One of ‘libtool’, ‘linux’, ‘osf’, ‘sunos’, or ‘none’.

Variable: whole_archive_flag_spec ¶

Compiler flag to generate shared objects from convenience archives.

Variable: wl ¶

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 semicolon-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.

13.5 Cheap tricks

Here are a few tricks that you can use in order to make maintainership easier:

• When people report bugs, ask them to use the ‘--config’, ‘--debug’, or ‘--features’ flags, if you think they will help you. These flags are there to help you get information directly, rather than having to trust second-hand observation.
• Rather than reconfiguring libtool every time I make a change to ltconfig.in or 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$ cat >> libtool
  LTCONFIG_VERSION="@VERSION@"
  . /home/src/libtool/ltmain.in
  ^D
  trick$ chmod +x libtool
  trick$ libtool --version
  ltmain.sh (GNU @PACKAGE@) @VERSION@
  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 ltconfig.