     [file version.texi not included]

This file documents GNU Libtool VERSION

Copyright (C) 1996-1998 Free Software Foundation, Inc.

Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.

Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.

Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Foundation.

Shared library support for GNU
******************************

This file documents GNU Libtool, a script that allows package developers to provide generic shared library support.  This edition documents version VERSION.

See Reporting bugs, for information on how to report problems with libtool.

Introduction
************

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.

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 I propose that 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.

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

Other implementations
=====================

I have investigated several different implementations of systems that build shared libraries as part of a free software package.  At first, I made notes on the features of each of these packages for comparison purposes.

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.

A postmortem analysis of other implementations
==============================================

In all fairness, each of the implementations that I 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 for me to use (much less modify) without understanding exactly what the implementation does, and they were generally not documented.

I think the main problem is that different vendors have different views of what libraries are, and none of the packages I 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, I don't have the time or power to convince operating system developers to mend their evil ways, and I want to build shared libraries right now, even on buggy, broken, confused operating systems.

For this reason, I have designed libtool 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.

I hope that libtool will be useful to and used by the GNU community, and that the lessons I've learned in writing it will be taken up and implemented by designers of library systems.

The libtool paradigm
********************

At first, libtool was designed to support an arbitrary number of library object types.  After porting libtool to more platforms, I discovered a new paradigm 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.

Using libtool
*************

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:

a23
     An Ultrix 4.2 platform with only static libraries.

burger
     A NetBSD/i386 1.2 platform with shared libraries.

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(3) math library function, which is usually found in the standalone math library, and not the C library.  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.

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
     ln -s foo.o foo.lo
     a23$ libtool gcc -g -O -c hello.c
     gcc -g -O -c hello.c
     ln -s hello.o hello.lo
     a23$

Note that libtool creates two object files for each invocation.  The .lo file is a library object, and the .o file is a standard object file.  On a23, these files are identical, 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
     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
     burger$

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

     burger$ libtool gcc -g -O -o libhello.la foo.o hello.o
     libtool: cannot build libtool library `libhello.la' from non-libtool \
                     objects
     burger$

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 that we need to add -lm to the link command line because foo.c uses the cos(3) math library function.  See Using libtool.)

     a23$ libtool gcc -g -O -o libhello.la foo.lo hello.lo -lm
     libtool: you must specify an installation directory with `-rpath'
     a23$

Argh.  Another complication in building shared libraries is that we need to specify the path to the directory in which they (eventually) will be installed.  So, we try again, with an rpath setting of /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.

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 (However, you should never use -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.) (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$

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.

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 it the libtool wrapper script makes it possible to run the program directly, but unfortunately, it 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 absolutely no warranty for GDB; type "show warranty" for details.
     GDB 4.16 (i386-unknown-netbsd), Copyright 1996 Free Software Foundation, Inc...

     "hell": not in executable format: File format not recognized

     (gdb) quit
     burger$

Sad.  It doesn't work because GDB isn't 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 absolutely no warranty for GDB; type "show warranty" for details.
     GDB 4.16 (i386-unknown-netbsd), Copyright 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 absolutely no warranty for GDB; type "show warranty" for details.
     GDB 4.16 (i386-unknown-netbsd), Copyright 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
====================

Installing libraries on a non-libtool system is quite straightforward... just copy them into place: (Don't accidentally strip the libraries, though, or they will be unusable.)

     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, for informational purposes, and to help libtool with uninstallation (see Uninstall mode).

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
     ldconfig -m /usr/local/lib
     To link against installed libraries in LIBDIR, users may have to:
        - add LIBDIR to their `LD_LIBRARY_PATH' environment variable
        - use the `-LLIBDIR' linker flag
     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.

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#

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 ``convenience library'' that is a collection of related object files without a really nice interface.

To do this, you should ignore libtool entirely, and just use the old ar and ranlib commands to create a static library.

If you want to install the library (but you probably don't), then you may use libtool if you want:

     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.

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.

Invoking libtool
****************

The libtool program has the following synopsis:

     libtool [OPTION]... [MODE-ARG]...

and accepts the following options:

-n
--dry-run
     Don't create, modify, or delete any files, just show what commands would be executed by libtool.

--features
     Display libtool configuration information and exit.  This provides a way for packages to determine whether shared or static libraries will be built.

--finish
     Same as --mode=finish.

--help
     Display a help message and exit.  If --mode=MODE is specified, then detailed help for MODE is displayed.

--mode=MODE
     Use MODE as the operation mode.  By default, the operation mode is inferred from the contents of MODE-ARGS.

     If MODE is specified, it must be one of the following:

     compile
          Compile a source file into a libtool object.

     execute
          Automatically set the library path so that another program can use uninstalled libtool-generated programs or libraries.

     finish
          Complete the installation of libtool libraries on the system.

     install
          Install libraries or executables.

     link
          Create a library or an executable.

     uninstall
          Delete libraries or executables.

--version
     Print libtool version information and exit.

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 C source code suffix .c with the library object suffix, .lo.

If shared libraries are being built, any necessary PIC generation flags are substituted into the compilation command.

Note that the -o option is not supported for compile mode, because it cannot be implemented properly for all platforms.  It is far easier just to change your Makefiles to create all the output files in the current working directory.

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.

-dlopen FILE
     Same as -dlpreopen FILE, if native dlopening is not supported on the host platform (see Dlopened modules).  Otherwise, no effect.

-dlpreopen FILE
     Link FILE into the output program, and add its symbols to DLD_PRELOADED_SYMBOLS (see Dlpreopening).

-export-dynamic
     Allow symbols from OUTPUT-FILE to be resolved with dlsym(3) (see Dlopened modules).

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

-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 (see Versioning).

-rpath LIBDIR
     If OUTPUT-FILE is a library, it will eventually be installed in LIBDIR.

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

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.

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.

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.

Uninstall mode
==============

This mode deletes installed libraries (and other files).

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.

Integrating libtool with your own packages
******************************************

This chapter describes how to integrate libtool with your packages so that your users can install hassle-free shared libraries.

Writing Makefile rules for libtool
==================================

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:

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

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

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, so you should not specify it.

See The Automake Manual, for more information.

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 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 has its own equivalent to the configure script, ltconfig.

Invoking ltconfig
-----------------

ltconfig runs a series of configuration tests, then creates a system-specific libtool in the current directory.  The ltconfig program has the following synopsis:

     ltconfig [OPTION]... LTMAIN [HOST]

and accepts the following options:

--disable-shared
     Create a libtool that only builds static libraries.

--disable-static
     Create a libtool that builds only shared libraries if they are available.  If only static libraries can be built, then this flag has no effect.

--help
     Display a help message and exit.

--no-verify
     Do not use config.sub to verify that HOST is a valid canonical host system name.

--quiet
--silent
     Do not print informational messages when running configuration tests.

--srcdir=DIR
     Look for config.guess and config.sub in DIR.

--version
     Print ltconfig version information and exit.

--with-gcc
     Assume that the GNU C compiler will be used when invoking the created libtool to compile and link object files.

LTMAIN is the ltmain.sh shell script fragment that provides the basic libtool functionality (see Distributing).

HOST is the canonical host system name, which by default is guessed by running config.guess.

ltconfig also recognizes the following environment variables:

 -- Variable: CC
     The C compiler that will be used by the generated libtool.

 -- Variable: CFLAGS
     Compiler flags used to generate standard object files.

 -- Variable: CPPFLAGS
     C preprocessor flags.

 -- Variable: LD
     The system linker to use (if the generated libtool requires one).

 -- Variable: RANLIB
     Program to use rather than checking for ranlib.

Using ltconfig
--------------

Here is a simple example of using ltconfig to configure libtool on my NetBSD/i386 1.2 system:

     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$

This example shows how to configure libtool for cross-compiling to a i486 GNU/Hurd 0.1 system (assuming compiler tools reside in /local/i486-gnu/bin):

     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$

The AM_PROG_LIBTOOL macro
-------------------------

If you are using GNU Autoconf (or Automake), you should add a call to AM_PROG_LIBTOOL to your configure.in file.  This macro offers seamless integration between the configure script and ltconfig:

 -- Macro: AM_PROG_LIBTOOL
     Add support for the --enable-shared and --disable-shared configure flags.  Invoke ltconfig with the correct arguments to configure the package (see Invoking ltconfig). (AM_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).)

     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 setting calling either the AM_DISABLE_SHARED or AM_DISABLE_STATIC macros:

          # Turn off shared libraries during beta-testing, since they make the
          # build process take too long.
          AM_DISABLE_SHARED
          AM_PROG_LIBTOOL

     The user may specify a modified form of --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 configure scripts as follows:

          trick$ ./configure --enable-shared=bfd,gdb

     In general, specifying --enable-shared=PKGS is the same as specifying --enable-shared to every package named in the PKGS list, and --disable-shared to every other package. The --enable-static=PKGS flag behaves similarly, except it translates into --enable-static and --disable-static.

     The package name default matches any packages which have not set their name in the PACKAGE environment variable.

 -- Macro: AM_DISABLE_SHARED
     Change the default behaviour for AM_PROG_LIBTOOL to disable shared libraries.  The user may still override this default by specifying --enable-shared.

 -- Macro: AM_DISABLE_STATIC
     Change the default behaviour for AM_PROG_LIBTOOL to disable static libraries.  The user may still override this default by specifying --enable-static.

When you invoke the libtoolize program (see Invoking libtoolize), it will tell you where to find a definition of AM_PROG_LIBTOOL.  If you use Automake, the aclocal program will automatically add AM_PROG_LIBTOOL support to your configure script.

Including libtool with 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.

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

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

--automake
     Work silently, and assume that Automake libtool support is used.

     libtoolize --automake is used by Automake to add libtool files to your package, when AM_PROG_LIBTOOL appears in your configure.in.

--copy
-c
     Copy files from the libtool data directory rather than creating symlinks.

--dry-run
-n
     Don't run any commands that modify the file system, just print them out.

--force
-f
     Replace existing libtool files.  By default, libtoolize won't overwrite existing files.

--help
     Display a help message and exit.

--version
     Print libtoolize version information and exit.

If libtoolize detects an explicit call to AC_CONFIG_AUX_DIR (see 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.

Autoconf .o macros
------------------

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:

 -- Variable: LTALLOCA
     Substituted by AC_FUNC_ALLOCA (see The Autoconf Manual).  Is either empty, or contains alloca.lo.

 -- Variable: LTLIBOBJS
     Substituted by AC_REPLACE_FUNCS (see The Autoconf Manual), and a few other functions.

Unfortunately, the most recent version of Autoconf (2.12, 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/\.o/.lo/g'`
     AC_SUBST(LTLIBOBJS)
     LTALLOCA=`echo "$ALLOCA" | sed 's/\.o/.lo/g'`
     AC_SUBST(LTALLOCA)
     AC_OUTPUT(...)

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

  * 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 (GNU Image Manipulation Program, for those who haven't taken the plunge.  See http://www.gimp.org/.) 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.

Library interface versions
**************************

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, I 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.

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.

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.

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

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 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 just a symbolic link to /usr/lib/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 accomodate 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 Linux:

     trick$ ls /usr/lib/libbfd*
     /usr/lib/libbfd-2.9.0.so.0         /usr/lib/libbfd.so
     /usr/lib/libbfd-2.9.0.so.0.0.0     /usr/lib/libbfd.a
     trick$

In this case, /usr/lib/libbfd.so is a symbolic link to /usr/lib/libbfd-2.9.0.so.0.0.0.  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 actually causes a modification of the library name, so do not use it if unless you want to break binary compatibility with any past library releases.  In general, you should only use -release for libraries whose interfaces change very frequently.

Tips for interface design
*************************

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:

Plan ahead
     Try to make every interface truly minimal, so that you won't need to delete entry points very often.

Avoid interface changes
     Some people love redesigning and changing entry points just for the heck of it (note: renaming a function is considered changing an entry point).  Don't be one of those people.  If you must redesign an interface, then try to leave compatibility functions behind so that users don't need to rewrite their existing code.

Use opaque data types
     The fewer data type definitions a library user has access to, the better.  If possible, design your functions to accept a generic pointer (which you can cast to an internal data type), and provide access functions rather than allowing the library user to directly manipulate the data. That way, you have the freedom to change the data structures without changing the interface.

     This is essentially the same thing as using abstract data types and inheritance in an object-oriented system.

Use header files
     If you are careful to document each of your library's global functions and variables in header files, and include them in your library source files, then the compiler will let you know if you make any interface changes by accident (see C header files).

Use the static keyword (or equivalent) whenever possible
     The fewer global functions your library has, the more flexibility you'll have in changing them.  Static functions and variables may change forms as often as you like... your users cannot access them, so they aren't interface changes.

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 C++ libraries, 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.

Inter-library dependencies
**************************

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(3) function, then it has an inter-library dependency on libm, the math library that implements cos(3).

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. (Unfortunately, as of libtool version VERSION,
there is no way to specify inter-library dependencies on libtool
libraries that have not yet been installed.)  To make an example of our libhello that depends on libm:

     burger$ libtool gcc -g -O -o libhello.la foo.lo hello.lo \
                     -rpath /usr/local/lib -lm
     burger$

In order to link a program against libhello, you need to specify the same -l options, 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 no references to external symbols), and you need to specify the -NO-UNDEFINED flag to allow a shared library to be built.  By default, libtool builds only static libraries on these kinds of platforms.

Dlopened modules
****************

It can sometimes be confusing to discuss dynamic linking, because the term is used to refer to two different concepts:

 1. Compiling and linking a program against a shared library, which is resolved automatically at run time by the dynamic linker.  In this process, dynamic linking is transparent to the application.

 2. The application calling functions such as dlopen(3), (HP-UX, to be different, uses a function named shl_load(3).) 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 VERSION, libtool provides experimental support for dlopened modules, which does not radically simplify the development of dlopening applications.  However, this support is designed to be a portable foundation for generic, higher-level dlopen functions.

This chapter discusses the preliminary support that libtool offers, and how you as a dlopen application developer might use libtool to generate dlopen-accessible modules.  It is important to remember that these are experimental features, and not to rely on them for easy answers to the problems associated with dlopened modules.

Building modules to dlopen
==========================

On some operating systems, a program symbol must be specially declared in order to be dynamically resolved with the dlsym(3) (or equivalent) function.

Libtool provides the -export-dynamic link flag (see Link mode), which does this declaration.  You need to use this flag 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 -export-dynamic to the other link flags:

     burger$ libtool gcc -export-dynamic -o libhello.la foo.lo \
                     hello.lo -rpath /usr/local/lib -lm
     burger$

Another situation where you would use -export-dynamic is if symbols from your executable are needed to satisfy unresolved references in a library you want to dlopen.  In this case, you should use -export-dynamic while linking the executable that calls dlopen:

     burger$ libtool gcc -export-dynamic -o hell-dlopener main.o
     burger$

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(3) and dlsym(3) 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 -export-dynamic 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: dld_symbol name address
     The NAME attribute is a 0-terminated character string of the symbol name, such as "fprintf".  The ADDRESS attribute is a generic pointer to the appropriate object, which is &fprintf in this example.

 -- Variable: dld_symbol * dld_preloaded_symbols
     An array of DLD_SYMBOL structures, representing all the preloaded symbols linked into the program.  The last element has a NAME of 0.

 -- Variable: int dld_preloaded_symbol_count
     The number of elements in DLD_PRELOADED_SYMBOLS, if it is sorted in ascending order by NAME.  Otherwise, -1, to indicate that the application needs to sort and count DLD_PRELOADED_SYMBOLS itself, or search it linearly.

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

Finding the correct name to dlopen
==================================

After a library has been linked with -export-dynamic, 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(3).
     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 (LIBPATH on AIX, and SHLIB_PATH on HP-UX.) 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.

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 develop your own alternatives to dlopening dynamic code. Most reasonable solutions involve writing wrapper functions for the dlopen(3) 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(3) family of functions.  Some platforms do not even use the same function names (notably HP-UX, with its shl_load(3) family).

  * The application developer must write a custom search function in order to discover the correct module filename to supply to dlopen(3).

Each of these limitations will be addressed in GNU DLD 4. (Unfortunately, the DLD maintainer is also the libtool maintainer, so time spent on one of these projects takes time away from the other.  When libtool is reasonably stable, DLD 4 development will proceed.)

Using libtool with other languages
**********************************

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.

Writing libraries for C++
=========================

Creating libraries of C++ code is a fairly straightforward process, and differs from C code in only two 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, notably SunOS 4, the dynamic linker does not call non-constant initializers.  This can lead to hard-to-pinpoint bugs in your library.  GCC 2.7 and later versions work around this problem, but previous versions and other compilers do not.

This second issue is complex.  Basically, 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.

Troubleshooting
***************

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.

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

Here is a list of the current programs in the test suite, and what they test for:

demo-conf.test
demo-exec.test
demo-inst.test
demo-make.test
demo-unst.test
     These programs check to see that the demo subdirectory of the libtool distribution can be configured, built, installed, and uninstalled correctly.

     The demo subdirectory contains a demonstration of a trivial package that uses libtool.

hardcode.test
     On all systems with shared libraries, the location of the library can be encoded in executables that are linked against it see Linking executables.  This test checks the conditions under which your system linker hardcodes the library location, and guarantees that they correspond to libtool's own notion of how your linker behaves.

link.test
     This test guarantees that linking directly against a non-libtool static library works properly.

link-2.test
     This test makes sure that files ending in .lo are never linked directly into a program file.

suffix.test
     When other programming languages are used with libtool (see Other languages), the source files may end in suffixes other than .c. This test validates that libtool can handle suffixes for all the file types that it supports, and that it fails when the suffix is invalid.

test-e.test
     This program checks that the test -e construct is never used in the libtool scripts.  Checking for the existence of a file can only be done in a portable way by using test -f.

When tests fail
---------------

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.

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

Please include the generated libtool script with your bug report, so that I can see what values ltconfig guessed for your system.

Maintenance notes for libtool
*****************************

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.

Porting libtool to new systems
==============================

To port libtool to a new system, you'll generally need the following information:

man pages for ld(1) and cc(1)
     These generally describe what flags are used to generate PIC, to create shared libraries, and to link against only static libraries.  You may need to follow some cross references to find the information that is required.

man pages for ld.so(8), rtld(8), or equivalent
     These are a valuable resource for understanding how shared libraries are loaded on the system.

man page for ldconfig(8), or equivalent
     This page usually describes how to install shared libraries.

output from ls -l /lib /usr/lib
     This shows the naming convention for shared libraries on the system, including which names should be symbolic links.

any additional documentation
     Some systems have special documentation on how to build and install shared libraries.

Tested platforms
================

This table describes when libtool was last known to be tested on platforms where it claims to support shared libraries:

          [file PLATFORMS not included]

Platform quirks
===============

This section is dedicated to the sanity of the libtool maintainer.  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 is difficult to understand just by reading it from top to bottom.  This section helps show why libtool does things a certain way.  After reading it, then reading the scripts themselves, you should have a better sense of how to improve libtool, or write your own.

References
----------

The following is a list of valuable documentation references:

  * SGI's IRIX Manual Pages, http://techpubs.sgi.com/cgi-bin/infosrch.cgi?cmd=browse&db=man.

  * Sun's free service area (http://www.sun.com/service/online/free.html) and documentation server (http://docs.sun.com/).

Compilers
---------

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:

gcc

     This is the GNU C compiler, which is also the system compiler for many free operating systems (FreeBSD, GNU/Hurd, Linux/GNU, Lites, NetBSD, and OpenBSD, to name a few).

     The -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*
     AIX compilers have no PIC flags, since AIX has been ported only to PowerPC and RS/6000 chips.  (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.)

hpux10*
     Use +Z to generate PIC.

osf3*
     Digital/UNIX 3.x does not have PIC flags, at least not on the PowerPC platform.

solaris2*
     Use -KPIC to generate PIC.

sunos4*
     Use -PIC to generate PIC.

Reloadable objects
------------------

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.

Archivers
---------

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.

libtool script contents
=======================

The libtool script is generated by ltconfig (see Configuring).  Ever since libtool version 0.7, this script simply sets shell variables, then sources the libtool backend, ltmain.sh.

Here is a listing of each of these 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: archive_cmds
 -- Variable: old_archive_cmds
     Commands used to create shared and static libraries, respectively.

 -- 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: echo
     An echo(1) program which does not interpret backslashes as an escape character.

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

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

          $ $NM | $global_symbol_pipe
          SYMBOL1 C-SYMBOL1
          SYMBOL2 C-SYMBOL2
          SYMBOL3 C-SYMBOL3
          ...
          $

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

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

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

 -- 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.  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: 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: 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: 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: 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_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: version_type
     The library version numbering type.  One of libtool, linux, osf, sunos, or none.

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