This is libtool.info, produced by makeinfo version 4.0 from
libtool.texi.

INFO-DIR-SECTION Programming & development tools
START-INFO-DIR-ENTRY
* Libtool: (libtool).           Generic shared library support script.
END-INFO-DIR-ENTRY

INFO-DIR-SECTION Individual utilities
START-INFO-DIR-ENTRY
* libtoolize: (libtool)Invoking libtoolize.     Adding libtool support.
END-INFO-DIR-ENTRY

   This file documents GNU Libtool 1.3.4

   Copyright (C) 1996-1999 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.


File: libtool.info,  Node: Top,  Next: Introduction,  Prev: (dir),  Up: (dir)

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

   *Note Reporting bugs::, for information on how to report problems
with libtool.

* Menu:

* Introduction::                What the heck is libtool?
* Libtool paradigm::            How libtool's view of libraries is different.
* Using libtool::               Example of using libtool to build libraries.
* Invoking libtool::            Running the `libtool' script.
* Integrating libtool::         Using libtool in your own packages.
* Versioning::                  Using library interface versions.
* Library tips::                Tips for library interface design.
* Inter-library dependencies::  Libraries that depend on other libraries.
* Dlopened modules::            `dlopen'ing libtool-created libraries.
* Using libltdl::               Libtool's portable `dlopen' wrapper library.
* Other languages::             Using libtool without a C compiler.
* Troubleshooting::             When libtool doesn't work as advertised.
* Maintaining::                 Information used by the libtool maintainer.
* Index::                       Full index.


Introduction

* Motivation::                  Why does GNU need a libtool?
* Issues::                      The problems that need to be addressed.
* Other implementations::       How other people have solved these issues.
* Postmortem::                  Learning from past difficulties.

Using libtool

* Creating object files::       Compiling object files for libraries.
* Linking libraries::           Creating libraries from object files.
* Linking executables::         Linking object files against libtool libraries.
* Debugging executables::       Running GDB on libtool-generated programs.
* Installing libraries::        Making libraries available to users.
* Installing executables::      Making programs available to users.
* Static libraries::            When shared libraries are not wanted.

Invoking `libtool'

* Compile mode::                Creating library object files.
* Link mode::                   Generating executables and libraries.
* Execute mode::                Debugging libtool-generated programs.
* Install mode::                Making libraries and executables public.
* Finish mode::                 Completing a library installation.
* Uninstall mode::              Removing executables and libraries.

Integrating libtool with your package

* Makefile rules::              Writing `Makefile' rules for libtool.
* Using Automake::              Automatically supporting libtool.
* Configuring::                 Configuring libtool for a host system.
* Distributing::                What files to distribute with your package.
* Static-only libraries::       Sometimes shared libraries are just a pain.

Configuring libtool

* Invoking ltconfig::           `ltconfig' command line options.
* ltconfig example::            Manually configuring a `libtool'.
* AM_PROG_LIBTOOL::             Configuring `libtool' in `configure.in'.

Including libtool in your package

* Invoking libtoolize::         `libtoolize' command line options.
* Autoconf .o macros::          Autoconf macros that set object file names.

Library interface versions

* Interfaces::                  What are library interfaces?
* Libtool versioning::          Libtool's versioning system.
* Updating version info::       Changing version information before releases.
* Release numbers::             Breaking binary compatibility for aesthetics.

Tips for interface design

* C header files::              How to write portable include files.

Dlopened modules

* Building modules::            Creating dlopenable objects and libraries.
* Dlpreopening::                Dlopening that works on static platforms.
* Finding the dlname::          Choosing the right file to `dlopen'.
* Dlopen issues::               Unresolved problems that need your attention.

Using libltdl

* Libltdl interface::           How to use libltdl in your programs.
* Modules for libltdl::         Creating modules that can be `dlopen'ed.
* Distributing libltdl::        How to distribute libltdl with your package.

Using libtool with other languages

* C++ libraries::

Troubleshooting

* Libtool test suite::          Libtool's self-tests.
* Reporting bugs::              How to report problems with libtool.

The libtool test suite

* Test descriptions::           The contents of the test suite.
* When tests fail::             What to do when a test fails.

Maintenance notes for libtool

* New ports::                   How to port libtool to new systems.
* Tested platforms::            When libtool was last tested.
* Platform quirks::             Information about different library systems.
* libtool script contents::     Configuration information that libtool uses.
* Cheap tricks::                Making libtool maintainership easier.

Porting libtool to new systems

* Information sources::         Where to find relevant documentation
* Porting inter-library dependencies::  Implementation details explained

Platform quirks

* References::                  Finding more information.
* Compilers::                   Creating object files from source files.
* Reloadable objects::          Binding object files together.
* Archivers::                   Programs that create static archives.


File: libtool.info,  Node: Introduction,  Next: Libtool paradigm,  Prev: Top,  Up: Top

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.

* Menu:

* Motivation::                  Why does GNU need a libtool?
* Issues::                      The problems that need to be addressed.
* Other implementations::       How other people have solved these issues.
* Postmortem::                  Learning from past difficulties.


File: libtool.info,  Node: Motivation,  Next: Issues,  Up: Introduction

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.


File: libtool.info,  Node: Issues,  Next: Other implementations,  Prev: Motivation,  Up: Introduction

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


File: libtool.info,  Node: Other implementations,  Next: Postmortem,  Prev: Issues,  Up: Introduction

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.


File: libtool.info,  Node: Postmortem,  Prev: Other implementations,  Up: Introduction

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.


File: libtool.info,  Node: Libtool paradigm,  Next: Using libtool,  Prev: Introduction,  Up: Top

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

   At first, libtool was designed to support an arbitrary number of
library object types.  After libtool was ported to more platforms, a new
paradigm gradually developed for describing the relationship between
libraries and programs.

   In summary, "libraries are programs with multiple entry points, and
more formally defined interfaces."

   Version 0.7 of libtool was a complete redesign and rewrite of
libtool to reflect this new paradigm.  So far, it has proved to be
successful: libtool is simpler and more useful than before.

   The best way to introduce the libtool paradigm is to contrast it with
the paradigm of existing library systems, with examples from each.  It
is a new way of thinking, so it may take a little time to absorb, but
when you understand it, the world becomes simpler.


File: libtool.info,  Node: Using libtool,  Next: Invoking libtool,  Prev: Libtool paradigm,  Up: Top

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 (*note
Configuring::).

   Source files for the following examples are taken from the `demo'
subdirectory of the libtool distribution.  Assume that we are building a
library, `libhello', out of the files `foo.c' and `hello.c'.

   Note that the `foo.c' source file uses the `cos' math library
function, which is usually found in the standalone math library, and not
the C library (*note Trigonometric Functions: (libc)Trig Functions.).
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 (*note
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'.

* Menu:

* Creating object files::       Compiling object files for libraries.
* Linking libraries::           Creating libraries from object files.
* Linking executables::         Linking object files against libtool libraries.
* Debugging executables::       Running GDB on libtool-generated programs.
* Installing libraries::        Making libraries available to users.
* Installing executables::      Making programs available to users.
* Static libraries::            When shared libraries are not wanted.


File: libtool.info,  Node: Creating object files,  Next: Linking libraries,  Up: Using libtool

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
(*note 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.


File: libtool.info,  Node: Linking libraries,  Next: Linking executables,  Prev: Creating object files,  Up: Using libtool

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 (*note 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 (*note Using libtool::).

   Another complication in building shared libraries is that we need to
specify the path to the directory in which they (eventually) will be
installed (in this case, `/usr/local/lib')(1):

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

   ---------- Footnotes ----------

   (1) If you don't specify an `rpath', then libtool builds a libtool
convenience archive, not a shared library (*note Static libraries::).


File: libtool.info,  Node: Linking executables,  Next: Debugging executables,  Prev: Linking libraries,  Up: Using libtool

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(1) (*note 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.

   ---------- Footnotes ----------

   (1) However, you should avoid using `-L' or `-l' flags to link
against an uninstalled libtool library.  Just specify the relative path
to the `.la' file, such as `../intl/libintl.la'.  This is a design
decision to eliminate any ambiguity when linking against uninstalled
shared libraries.


File: libtool.info,  Node: Debugging executables,  Next: Installing libraries,  Prev: Linking executables,  Up: Using libtool

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 (*note 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$


File: libtool.info,  Node: Installing libraries,  Next: Installing executables,  Prev: Debugging executables,  Up: Using libtool

Installing libraries
====================

   Installing libraries on a non-libtool system is quite
straightforward... just copy them into place:(1)

     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 (*note 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 (*note Uninstall mode::) and linking
(*note Linking executables::) and to help programs with dlopening
(*note 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 (*note 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.

   ---------- Footnotes ----------

   (1) Don't accidentally strip the libraries, though, or they will be
unusable.


File: libtool.info,  Node: Installing executables,  Next: Static libraries,  Prev: Installing libraries,  Up: Using libtool

Installing executables
======================

   If you used libtool to link any executables against uninstalled
libtool libraries (*note Linking executables::), you need to use
libtool to install the executables after the libraries have been
installed (*note 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#


File: libtool.info,  Node: Static libraries,  Prev: Installing executables,  Up: Using libtool

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.


File: libtool.info,  Node: Invoking libtool,  Next: Integrating libtool,  Prev: Using libtool,  Up: Top

Invoking `libtool'
******************

   The `libtool' program has the following synopsis:

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

and accepts the following options:

`--config'
     Display libtool configuration variables and exit.

`--debug'
     Dump a trace of shell script execution to standard output.  This
     produces a lot of output, so you may wish to pipe it to `less' (or
     `more') or redirect to a file.

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

`--features'
     Display basic configuration options.  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 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.

   The MODE-ARGS are a variable number of arguments, depending on the
selected operation mode.  In general, each MODE-ARG is interpreted by
programs libtool invokes, rather than libtool itself.

* Menu:

* Compile mode::                Creating library object files.
* Link mode::                   Generating executables and libraries.
* Execute mode::                Debugging libtool-generated programs.
* Install mode::                Making libraries and executables public.
* Finish mode::                 Completing a library installation.
* Uninstall mode::              Removing executables and libraries.


File: libtool.info,  Node: Compile mode,  Next: Link mode,  Up: Invoking libtool

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.


File: libtool.info,  Node: Link mode,  Next: Execute mode,  Prev: Compile mode,  Up: Invoking libtool

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 (*note Versioning::) 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 (*note 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 (*note 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' (*note
     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 (*note 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 (*note 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 (*note
     Versioning::).

`-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 (*note
     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 (*note
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.


File: libtool.info,  Node: Execute mode,  Next: Install mode,  Prev: Link mode,  Up: Invoking libtool

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.


File: libtool.info,  Node: Install mode,  Next: Finish mode,  Prev: Execute mode,  Up: Invoking libtool

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.


File: libtool.info,  Node: Finish mode,  Next: Uninstall mode,  Prev: Install mode,  Up: Invoking libtool

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.


File: libtool.info,  Node: Uninstall mode,  Prev: Finish mode,  Up: Invoking libtool

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.


File: libtool.info,  Node: Integrating libtool,  Next: Versioning,  Prev: Invoking libtool,  Up: Top

Integrating libtool with your package
*************************************

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

* Menu:

* Makefile rules::              Writing `Makefile' rules for libtool.
* Using Automake::              Automatically supporting libtool.
* Configuring::                 Configuring libtool for a host system.
* Distributing::                What files to distribute with your package.
* Static-only libraries::       Sometimes shared libraries are just a pain.


File: libtool.info,  Node: Makefile rules,  Next: Using Automake,  Up: Integrating libtool

Writing `Makefile' rules for libtool
====================================

   Libtool is fully integrated with Automake (*note Introduction:
(automake)Top.), 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).


File: libtool.info,  Node: Using Automake,  Next: Configuring,  Prev: Makefile rules,  Up: Integrating libtool

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' (*note 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' (*note Versioning::)
option to libtool:

     # Build a libtool library, libhello.la for installation in libdir.
     lib_LTLIBRARIES = libhello.la
     libhello_la_SOURCES = hello.c foo.c
     libhello_la_LDFLAGS = -version-info 3:12:1

   The `-rpath' option is passed automatically by Automake (except for
libraries listed as `noinst_LTLIBRARIES'), so you should not specify it.

   *Note Building a Shared Library: (automake)A Shared Library, for
more information.


File: libtool.info,  Node: Configuring,  Next: Distributing,  Prev: Using Automake,  Up: Integrating libtool

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 (*note
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'.

* Menu:

* Invoking ltconfig::           `ltconfig' command line options.
* ltconfig example::            Manually configuring a `libtool'.
* AM_PROG_LIBTOOL::             Configuring `libtool' in `configure.in'.


File: libtool.info,  Node: Invoking ltconfig,  Next: ltconfig example,  Up: Configuring

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:

`--debug'
     Dump a trace of shell script execution to standard output.  This
     produces a lot of output, so you may wish to pipe it to `less' (or
     `more') or redirect to a file.

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

`--disable-fast-install'
     On platforms in which installable executables, that are created by
     default, are not suitable for execution in the build directory,
     create a `libtool' that links executables that search for
     uninstalled libraries by default, and relinks them at install
     time.  It is ignored on platforms in which a single executable is
     enough.

`--enable-dlopen'
     Test whether some dlopening mechanism is supported.  If this flag
     is not given, or no working dlopening mechanism is found, create a
     `libtool' that performs dlpreopening of all dlopened modules.

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

`--output=FILE'

`-o FILE'
     Instead of creating a libtool script called `libtool', create one
     called FILE.  This can be useful if you want to create libtool
     scripts for cross-compilers, or you want to have more than one
     libtool in the same directory.

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

`--with-gnu-ld'
     Assume that the C compiler uses the GNU linker.

`--disable-lock'
     Create a `libtool' that does not perform locking to ensure proper
     parallel compilation if the C compiler does not support `-c' and
     `-o' together.

`--cache-file=FILE'
     Use this FILE as a cache for results of a few tests.  This is
     usually `config.cache' used by `configure'.  By default, no cache
     file is used.

   LTMAIN is the `ltmain.sh' shell script fragment that provides the
basic libtool functionality (*note 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'.  If
     this is not set, `ltconfig' will look for `gcc' or `cc'.

 - Variable: CFLAGS
     Compiler flags used to generate standard object files.  If this is
     not set, `ltconfig' will not use any such flags.  It affects only
     the way `ltconfig' runs tests, not the produced `libtool'.

 - Variable: CPPFLAGS
     C preprocessor flags.  If this is not set, `ltconfig' will not use
     any such flags.  It affects only the way `ltconfig' runs tests, not
     the produced `libtool'.

 - Variable: LD
     The system linker to use (if the generated `libtool' requires one).
     If this is not set, `ltconfig' will try to find out what is the
     linker used by CC.

 - Variable: LDFLAGS
     The flags to be used by `ltconfig' when it links a program.  If
     this is not set, `ltconfig' will not use any such flags.  It
     affects only the way `ltconfig' runs tests, not the produced
     `libtool'.

 - Variable: LIBS
     The libraries to be used by `ltconfig' when it links a program.  If
     this is not set, `ltconfig' will not use any such flags.  It
     affects only the way `ltconfig' runs tests, not the produced
     `libtool'.

 - Variable: NM
     Program to use rather than checking for `nm'.

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

 - Variable: LN_S
     A command that creates a link of a program, a soft-link if
     possible, a hard-link otherwise.

 - Variable: DLLTOOL
     Program to use rather than checking for `dlltool'.  Only meaningful
     for Cygwin/MS-Windows.

 - Variable: OBJDUMP
     Program to use rather than checking for `objdump'.  Only meaningful
     for Cygwin/MS-Windows.

 - Variable: AS
     Program to use rather than checking for `as'.  Only meaningful for
     Cygwin/MS-Windows.


File: libtool.info,  Node: ltconfig example,  Next: AM_PROG_LIBTOOL,  Prev: Invoking ltconfig,  Up: Configuring

Using `ltconfig'
----------------

   Here is a simple example of using `ltconfig' to configure libtool on
a 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$


File: libtool.info,  Node: AM_PROG_LIBTOOL,  Prev: ltconfig example,  Up: Configuring

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 (*note Invoking ltconfig::).(1)

     By default, this macro turns on shared libraries if they are
     available, and also enables static libraries if they don't
     conflict with the shared libraries.  You can modify these defaults
     by calling either the `AC_DISABLE_SHARED' or `AC_DISABLE_STATIC'
     macros:

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

     The user may specify modified forms of the configure flags
     `--enable-shared' and `--enable-static' to choose whether shared
     or static libraries are built based on the name of the package.
     For example, to have shared `bfd' and `gdb' libraries built, but
     not shared `libg++', you can run all three `configure' scripts as
     follows:

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

     In general, specifying `--enable-shared=PKGS' is the same as
     configuring with `--enable-shared' every package named in the
     comma-separated PKGS list, and every other package with
     `--disable-shared'.  The `--enable-static=PKGS' flag behaves
     similarly, but it uses `--enable-static' and `--disable-static'.
     The same applies to the `--enable-fast-install=PKGS' flag, which
     uses `--enable-fast-install' and `--disable-fast-install'.

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

     This macro also sets the shell variable LIBTOOL_DEPS, that you can
     use to automatically update the libtool script if it becomes
     out-of-date.  In order to do that, add to your `configure.in':

          AM_PROG_LIBTOOL
          AC_SUBST(LIBTOOL_DEPS)

     and, to `Makefile.in' or `Makefile.am':

          LIBTOOL_DEPS = @LIBTOOL_DEPS@
          libtool: $(LIBTOOL_DEPS)
                  $(SHELL) ./config.status --recheck

     If you are using GNU automake, you can omit the assignment, as
     automake will take care of it.  You'll obviously have to create
     some dependency on `libtool'.


 - Macro: AC_LIBTOOL_DLOPEN
     Enable checking for dlopen support. This macro should be used if
     the package makes use of the `-dlopen' and `-dlpreopen' flags,
     otherwise libtool will assume that the system does not support
     dlopening.  The macro must be called *before* `AM_PROG_LIBTOOL'.

 - Macro: AC_LIBTOOL_WIN32_DLL
     This macro should be used if the package has been ported to build
     clean dlls on win32 platforms.  Usually this means that any
     library data items are exported with `__declspec(dllexport)' and
     imported with `__declspec(dllimport)'.  If this macro is not used,
     libtool will assume that the package libraries are not dll clean
     and will build only static libraries on win32 hosts.

     `AM_PROG_LIBTOOL' must be called *after* this macro, and provision
     must be made to pass `-no-undefined' to `libtool' in link mode
     from the package `Makefile'.  Naturally, passing `-no-undefined'
     means that all the library symbols *really are* defined at link
     time!

 - Macro: AC_DISABLE_FAST_INSTALL
     Change the default behaviour for `AM_PROG_LIBTOOL' to disable
     optimization for fast installation.  The user may still override
     this default, depending on platform support, by specifying
     `--enable-fast-install'.

 - Macro: AC_DISABLE_SHARED
 - 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: AC_DISABLE_STATIC
 - 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 (*note 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.

   Nevertheless, it is advisable to include a copy of `libtool.m4' in
`acinclude.m4', so that, even if `aclocal.m4' and `configure' are
rebuilt for any reason, the appropriate libtool macros will be used.
The alternative is to hope the user will have a compatible version of
`libtool.m4' installed and accessible for `aclocal'.  This may lead to
weird errors when versions don't match.

   ---------- Footnotes ----------

   (1) `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).


File: libtool.info,  Node: Distributing,  Next: Static-only libraries,  Prev: Configuring,  Up: Integrating libtool

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.  *Note Configuring::.

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

* Menu:

* Invoking libtoolize::         `libtoolize' command line options.
* Autoconf .o macros::          Autoconf macros that set object file names.


File: libtool.info,  Node: Invoking libtoolize,  Next: Autoconf .o macros,  Up: Distributing

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.

`--debug'
     Dump a trace of shell script execution to standard output.  This
     produces a lot of output, so you may wish to pipe it to `less' (or
     `more') or redirect to a file.

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

`--ltdl'
     Install libltdl in a subdirectory of your package.

`--ltdl-tar'
     Add the file libltdl.tar.gz to your package.

`--version'
     Print `libtoolize' version information and exit.

   If `libtoolize' detects an explicit call to `AC_CONFIG_AUX_DIR'
(*note The Autoconf Manual: (autoconf)Input.) 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.


File: libtool.info,  Node: Autoconf .o macros,  Prev: Invoking libtoolize,  Up: Distributing

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' (*note Particular Function Checks:
     (autoconf)Particular Functions.).  Is either empty, or contains
     `alloca.lo'.

 - Variable: LTLIBOBJS
     Substituted by `AC_REPLACE_FUNCS' (*note Generic Function Checks:
     (autoconf)Generic Functions.), 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(...)


File: libtool.info,  Node: Static-only libraries,  Prev: Distributing,  Up: Integrating libtool

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 (*note The `AM_PROG_LIBTOOL' macro: 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, 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(1) 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'.

   ---------- Footnotes ----------

   (1) GNU Image Manipulation Program, for those who haven't taken the
plunge.  See <http://www.gimp.org/>.


File: libtool.info,  Node: Versioning,  Next: Library tips,  Prev: Integrating libtool,  Up: Top

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, one may say "libtool depends on sed," and that is good
enough for most purposes.

   However, when an interface changes regularly, we need to be more
specific: "Gnus 5.1 requires Emacs 19.28 or above."  Here, the
description of an interface consists of a name, and a "version number."

   Even that sort of description is not accurate enough for some
purposes.  What if Emacs 20 changes enough to break Gnus 5.1?

   The same problem exists in shared libraries: we require a formal
version system to describe the sorts of dependencies that programs have
on shared libraries, so that the dynamic linker can guarantee that
programs are linked only against libraries that provide the interface
they require.

* Menu:

* Interfaces::                  What are library interfaces?
* Libtool versioning::          Libtool's versioning system.
* Updating version info::       Changing version information before releases.
* Release numbers::             Breaking binary compatibility for aesthetics.


File: libtool.info,  Node: Interfaces,  Next: Libtool versioning,  Up: Versioning

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.


File: libtool.info,  Node: Libtool versioning,  Next: Updating version info,  Prev: Interfaces,  Up: Versioning

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.


File: libtool.info,  Node: Updating version info,  Next: Release numbers,  Prev: Libtool versioning,  Up: Versioning

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


File: libtool.info,  Node: Release numbers,  Prev: Updating version info,  Up: Versioning

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.


File: libtool.info,  Node: Library tips,  Next: Inter-library dependencies,  Prev: Versioning,  Up: Top

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 (*note 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.

* Menu:

* C header files::              How to write portable include files.


File: libtool.info,  Node: C header files,  Up: Library tips

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.  *Note 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 `#include'd.

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.


File: libtool.info,  Node: Inter-library dependencies,  Next: Dlopened modules,  Prev: Library tips,  Up: Top

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

   Some shared library systems provide this feature in an
internally-consistent way: these systems allow chains of dependencies of
potentially infinite length.

   However, most shared library systems are restricted in that they only
allow a single level of dependencies.  In these systems, programs may
depend on shared libraries, but shared libraries may not depend on other
shared libraries.

   In any event, libtool provides a simple mechanism for you to declare
inter-library dependencies: for every library `libNAME' that your own
library depends on, simply add a corresponding `-lNAME' option to the
link line when you create your library.(1)  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$

   When you link a program against `libhello', you don't need to
specify the same `-l' options again: libtool will do that for you, in
order to guarantee that all the required libraries are found.  This
restriction is only necessary to preserve compatibility with static
library systems and simple dynamic library systems.

   Some platforms, such as AIX, do not even allow you this flexibility.
In order to build a shared library, it must be entirely self-contained
(that is, have references only to symbols that are found in the `.lo'
files or the specified `-l' libraries), and you need to specify the
-NO-UNDEFINED flag.  By default, libtool builds only static libraries
on these kinds of platforms.

   The simple-minded inter-library dependency tracking code of libtool
releases prior to 1.2 was disabled because it was not clear when it was
possible to link one library with another, and complex failures would
occur.  A more complex implementation of this concept was re-introduced
before release 1.3, but it has not been ported to all platforms that
libtool supports.  The default, conservative behavior is to avoid
linking one library with another, introducing their inter-dependencies
only when a program is linked with them.

   ---------- Footnotes ----------

   (1) Unfortunately, as of libtool version 1.3.4, there is no way to
specify inter-library dependencies on libtool libraries that have not
yet been installed.  Libtool 1.4 will support this feature.


File: libtool.info,  Node: Dlopened modules,  Next: Using libltdl,  Prev: Inter-library dependencies,  Up: Top

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',(1) which load
     arbitrary, user-specified modules at runtime.  This type of dynamic
     linking is explicitly controlled by the application.

   To mitigate confusion, this manual refers to the second type of
dynamic linking as "dlopening" a module.

   The main benefit to dlopening object modules is the ability to access
compiled object code to extend your program, rather than using an
interpreted language.  In fact, dlopen calls are frequently used in
language interpreters to provide an efficient way to extend the
language.

   As of version 1.3.4, libtool provides support for dlopened modules.
However, you should indicate that your package is willing to use such
support, by using the macro `AC_LIBTOOL_DLOPEN' in `configure.in'.  If
this macro is not used (or it is used _after_ `AM_PROG_LIBTOOL'),
libtool will assume no dlopening mechanism is available, and will try
to simulate it.

   This chapter discusses how you as a dlopen application developer
might use libtool to generate dlopen-accessible modules.

* Menu:

* Building modules::            Creating dlopenable objects and libraries.
* Dlpreopening::                Dlopening that works on static platforms.
* Finding the dlname::          Choosing the right file to `dlopen'.
* Dlopen issues::               Unresolved problems that need your attention.

   ---------- Footnotes ----------

   (1) HP-UX, to be different, uses a function named `shl_load'.


File: libtool.info,  Node: Building modules,  Next: Dlpreopening,  Up: 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' (or
equivalent) function.

   Libtool provides the `-export-dynamic' and `-module' link flags
(*note 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$


File: libtool.info,  Node: Dlpreopening,  Next: Finding the dlname,  Prev: Building modules,  Up: Dlopened modules

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 (*note 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.


File: libtool.info,  Node: Finding the dlname,  Next: Dlopen issues,  Prev: Dlpreopening,  Up: Dlopened modules

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'(1) 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.

   ---------- Footnotes ----------

   (1) `LIBPATH' on AIX, and `SHLIB_PATH' on HP-UX.


File: libtool.info,  Node: Dlopen issues,  Prev: Finding the dlname,  Up: Dlopened modules

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 (*note 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'.


File: libtool.info,  Node: Using libltdl,  Next: Other languages,  Prev: Dlopened modules,  Up: Top

Using libltdl
*************

   Libtool provides a small library, called `libltdl', that aims at
hiding the various difficulties of dlopening libraries from programmers.
It consists of a header-file and a small C source file that can be
distributed with applications that need dlopening functionality.  On
some platforms, whose dynamic linkers are too limited for a simple
implementation of `libltdl' services, it requires GNU DLD, or it will
only emulate dynamic linking with libtool's dlpreopening mechanism.

libltdl supports currently the following dynamic linking mechanisms:

   * `dlopen' (Solaris, Linux and various BSD flavors)

   * `shl_load' (HP-UX)

   * `LoadLibrary' (Win16 and Win32)

   * `load_add_on' (BeOS)

   * GNU DLD (emulates dynamic linking for static libraries)

   * libtool's dlpreopen (see *note Dlpreopening::)

libltdl is licensed under the terms of the GNU Library General Public
License, with the following exception:

     As a special exception to the GNU Library General Public License,
     if you distribute this file as part of a program that uses GNU
     libtool to create libraries and programs, you may include it under
     the same distribution terms that you use for the rest of that
     program.

* Menu:

* Libltdl interface::           How to use libltdl in your programs.
* Modules for libltdl::         Creating modules that can be `dlopen'ed.
* Distributing libltdl::        How to distribute libltdl with your package.


File: libtool.info,  Node: Libltdl interface,  Next: Modules for libltdl,  Up: Using libltdl

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 *note 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'.


File: libtool.info,  Node: Modules for libltdl,  Next: Distributing libltdl,  Prev: Libltdl interface,  Up: Using libltdl

Creating modules that can be `dlopen'ed
=======================================

   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 *note Versioning:: for a specific module you should link it
with the `-avoid-version' switch.  Note that libtool modules don't need
to have a "lib" prefix.  However, automake 1.4 or higher is required to
build such modules.

   Usually a set of modules provide the same interface, i.e, exports
the same symbols, so that a program can dlopen them without having to
know more about their internals.  In order to avoid symbol conflicts
all exported symbols must be prefixed with "modulename_LTX_"
(`modulename' is the name of the module).  Internal symbols must be
named in such a way that they won't conflict with other modules, for
example, by prefixing them with "_modulename_".  Although some
platforms support having the same symbols defined more than once it is
generally not portable and it makes it impossible to dlpreopen such
modules.  libltdl will automatically cut the prefix off to get the real
name of the symbol.  Additionally, it supports modules which don't use
a prefix so that you can also dlopen non-libtool modules.

   `foo1.c' gives an example of a portable libtool module.  Exported
symbols are prefixed with "foo1_LTX_", internal symbols with "_foo1_".
Aliases are defined at the beginning so that the code is more readable.

     /* aliases for the exported symbols */
     #define foo	foo1_LTX_foo
     #define bar	foo1_LTX_bar
     
     /* a global variable definition */
     int bar = 1;
     
     /* a private function */
     int _foo1_helper() {
       return bar;
     }
     
     /* an exported function */
     int foo() {
       return _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
     ...


File: libtool.info,  Node: Distributing libltdl,  Prev: Modules for libltdl,  Up: Using libltdl

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 `Makefile's 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
`Makefile's, 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(1),
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
     ...

   ---------- Footnotes ----------

   (1) Even if libltdl is installed, `AC_LIBLTDL_INSTALLABLE' may fail
to detect it, if libltdl depends on symbols provided by libraries other
than the C library.  In this case, it will needlessly build and install
libltdl.


File: libtool.info,  Node: Other languages,  Next: Troubleshooting,  Prev: Using libltdl,  Up: Top

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.

* Menu:

* C++ libraries::


File: libtool.info,  Node: C++ libraries,  Up: Other languages

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.


File: libtool.info,  Node: Troubleshooting,  Next: Maintaining,  Prev: Other languages,  Up: Top

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.

* Menu:

* Libtool test suite::          Libtool's self-tests.
* Reporting bugs::              How to report problems with libtool.


File: libtool.info,  Node: Libtool test suite,  Next: Reporting bugs,  Up: Troubleshooting

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.

* Menu:

* Test descriptions::           The contents of the test suite.
* When tests fail::             What to do when a test fails.


File: libtool.info,  Node: Test descriptions,  Next: When tests fail,  Up: Libtool test suite

Description of test suite
-------------------------

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

`cdemo-conf.test'
`cdemo-exec.test'
`cdemo-make.test'
`cdemo-static.test'
`cdemo-shared.test'
     These programs check to see that the `cdemo' subdirectory of the
     libtool distribution can be configured and built correctly.

     The `cdemo' subdirectory contains a demonstration of libtool
     convenience libraries, a mechanism that allows build-time static
     libraries to be created, in a way that their components can be
     later linked into programs or other libraries, even shared ones.

     The tests `cdemo-make.test' and `cdemo-exec.test' are executed
     three times, under three different libtool configurations:
     `cdemo-conf.test' configures `cdemo/libtool' to build both static
     and shared libraries (the default for platforms that support
     both), `cdemo-static.test' builds only static libraries
     (`--disable-shared'), and `cdemo-shared.test' builds only shared
     libraries (`--disable-static').

`demo-conf.test'
`demo-exec.test'
`demo-inst.test'
`demo-make.test'
`demo-unst.test'
`demo-static.test'
`demo-shared.test'
`demo-nofast.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.  The tests `demo-make.test',
     `demo-exec.test', `demo-inst.test' and `demo-unst.test' are
     executed four times, under four different libtool configurations:
     `demo-conf.test' configures `demo/libtool' to build both static
     and shared libraries, `demo-static.test' builds only static
     libraries (`--disable-shared'), and `demo-shared.test' builds only
     shared libraries (`--disable-static').  `demo-nofast.test'
     configures `demo/libtool' to disable the fast-install mode
     (`--enable-fast-install=no'.

`deplibs.test'
     Many systems cannot link static libraries into shared libraries.
     libtool uses a `deplibs_check_method' to prevent such cases.  This
     tests checks whether libtool's `deplibs_check_method' works
     properly.

`hardcode.test'
     On all systems with shared libraries, the location of the library
     can be encoded in executables that are linked against it *note
     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.

`build-relink.test'
     Checks whether variable SHLIBPATH_OVERRIDES_RUNPATH is properly
     set.  If the test fails and VERBOSE is set, it will indicate what
     the variable should have been set to.

`noinst-link.test'
     Checks whether libtool will not try to link with a previously
     installed version of a library when it should be linking with a
     just-built one.

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

     The `mdemo' subdirectory contains a demonstration of a package that
     uses libtool and the system independent dlopen wrapper `libltdl' to
     load modules.  The library `libltdl' provides a dlopen wrapper for
     various platforms (Linux, Solaris, HP/UX etc.) including support
     for dlpreopened modules (*note Dlpreopening::).

     The tests `mdemo-make.test', `mdemo-exec.test', `mdemo-inst.test'
     and `mdemo-unst.test' are executed three times, under three
     different libtool configurations: `mdemo-conf.test' configures
     `mdemo/libtool' to build both static and shared libraries,
     `mdemo-static.test' builds only static libraries
     (`--disable-shared'), and `mdemo-shared.test' builds only shared
     libraries (`--disable-static').

`dryrun.test'
     This test checks whether libtool's `--dry-run' mode works properly.

`assign.test'
     Checks whether we don't put break or continue on the same line as
     an assignment in the libtool script.

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

`nomode.test'
     Check whether we can actually get help for libtool.

`quote.test'
     This program checks libtool's metacharacter quoting.

`sh.test'
     Checks whether a `test' command was forgotten in libtool.

`suffix.test'
     When other programming languages are used with libtool (*note
     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.


File: libtool.info,  Node: When tests fail,  Prev: Test descriptions,  Up: Libtool test suite

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.


File: libtool.info,  Node: Reporting bugs,  Prev: Libtool test suite,  Up: Troubleshooting

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
(*note 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 (*note
Reporting Bugs: (emacs)Bugs.).  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 (*note 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').


File: libtool.info,  Node: Maintaining,  Next: Index,  Prev: Troubleshooting,  Up: Top

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.

* Menu:

* New ports::                   How to port libtool to new systems.
* Tested platforms::            When libtool was last tested.
* Platform quirks::             Information about different library systems.
* libtool script contents::     Configuration information that libtool uses.
* Cheap tricks::                Making libtool maintainership easier.


File: libtool.info,  Node: New ports,  Next: Tested platforms,  Up: Maintaining

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.

* Menu:

* Information sources::         Where to find relevant documentation
* Porting inter-library dependencies::  Implementation details explained


File: libtool.info,  Node: Information sources,  Next: Porting inter-library dependencies,  Up: New ports

Information sources
-------------------

   Once it is clear that a new port is necessary, you'll generally need
the following information:

canonical system name
     You need the output of `config.guess' for this system, so that you
     can make changes to the libtool configuration process without
     affecting other systems.

man pages for `ld' and `cc'
     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', `rtld', or equivalent
     These are a valuable resource for understanding how shared
     libraries are loaded on the system.

man page for `ldconfig', 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.

   If you know how to program the Bourne shell, then you can complete
the port yourself; otherwise, you'll have to find somebody with the
relevant skills who will do the work.  People on the libtool mailing
list are usually willing to volunteer to help you with new ports, so
you can send the information to them.

   To do the port yourself, you'll definitely need to modify the
`ltconfig' script in order to make platform-specific changes to the
configuration process.  You should search the script for the `PORTME'
keyword, which will give you some hints on what you'll need to change.
In general, all that is involved is modifying the appropriate
configuration variables (*note libtool script contents::).

   Your best bet is to find an already-supported system that is similar
to yours, and make your changes based on that.  In some cases, however,
your system will differ significantly from every other supported system,
and it may be necessary to add new configuration variables, and modify
the `ltmain.sh' script accordingly.  Be sure to write to the mailing
list before you make changes to `ltmain.sh', since they may have advice
on the most effective way of accomplishing what you want.


File: libtool.info,  Node: Porting inter-library dependencies,  Prev: Information sources,  Up: New ports

Porting inter-library dependencies support
------------------------------------------

   Since version 1.2c, libtool has re-introduced the ability to do
inter-library dependency on some platforms, thanks to a patch by Toshio
Kuratomi <badger@prtr-13.ucsc.edu>.  Here's a shortened version of the
message that contained his patch:

   The basic architecture is this: in `ltconfig.in', the person who
writes libtool makes sure `$deplibs' is included in `$archive_cmds'
somewhere and also sets the variable `$deplibs_check_method', and maybe
`$file_magic_cmd' when `deplibs_check_method' is file_magic.

   `deplibs_check_method' can be one of five things:
`file_magic [REGEX]'
     looks in the library link path for libraries that have the right
     libname.  Then it runs `$file_magic_cmd' on the library and checks
     for a match against `regex' using `egrep'.  When
     FILE_MAGIC_TEST_FILE is set in `ltconfig', it is used as an
     argument to `$file_magic_cmd' in order to verify whether the
     regular expression matches its output, and warn the user otherwise.

`test_compile'
     just checks whether it is possible to link a program out of a list
     of libraries, and checks which of those are listed in the output of
     `ldd'.  It is currently unused, and will probably be dropped in the
     future.

`pass_all'
     will pass everything without any checking.  This may work on
     platforms in which code is position-independent by default and
     inter-library dependencies are properly supported by the dynamic
     linker, for example, on DEC OSF/1 3 and 4.

`none'
     It causes deplibs to be reassigned deplibs="".  That way
     `archive_cmds' can contain deplibs on all platforms, but not have
     deplibs used unless needed.

`unknown'
     is the default for all systems unless overridden in `ltconfig.in'.
     It is the same as `none', but it documents that we really don't
     know what the correct value should be, and we welcome patches that
     improve it.

   Then in `ltmain.in' we have the real workhorse: a little
initialization and postprocessing (to setup/release variables for use
with eval echo libname_spec etc.) and a case statement that decides
which method is being used.  This is the real code... I wish I could
condense it a little more, but I don't think I can without function
calls.  I've mostly optimized it (moved things out of loops, etc) but
there is probably some fat left.  I thought I should stop while I was
ahead, work on whatever bugs you discover, etc before thinking about
more than obvious optimizations.


File: libtool.info,  Node: Tested platforms,  Next: Platform quirks,  Prev: New ports,  Up: Maintaining

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


File: libtool.info,  Node: Platform quirks,  Next: libtool script contents,  Prev: Tested platforms,  Up: Maintaining

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.

* Menu:

* References::                  Finding more information.
* Compilers::                   Creating object files from source files.
* Reloadable objects::          Binding object files together.
* Archivers::                   Programs that create static archives.


File: libtool.info,  Node: References,  Next: Compilers,  Up: Platform quirks

References
----------

   The following is a list of valuable documentation references:

   * SGI's IRIX Manual Pages, which can be found at
     <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/>).


File: libtool.info,  Node: Compilers,  Next: Reloadable objects,  Prev: References,  Up: Platform quirks

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, GNU/Linux, 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. (1)

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

   ---------- Footnotes ----------

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


File: libtool.info,  Node: Reloadable objects,  Next: Archivers,  Prev: Compilers,  Up: Platform quirks

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.


File: libtool.info,  Node: Archivers,  Prev: Reloadable objects,  Up: Platform quirks

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.  Some systems, like Irix, use the
`ar ts' command, instead.


File: libtool.info,  Node: libtool script contents,  Next: Cheap tricks,  Prev: Platform quirks,  Up: Maintaining

`libtool' script contents
=========================

   The `libtool' script is generated by `ltconfig' (*note
Configuring::).  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 `eval'ed 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 `eval'ed before being used by
libtool.


File: libtool.info,  Node: Cheap tricks,  Prev: libtool script contents,  Up: Maintaining

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


File: libtool.info,  Node: Index,  Prev: Maintaining,  Up: Top

Index
*****

* Menu:

* .la files:                             Linking libraries.
* .libs subdirectory:                    Linking libraries.
* .lo files:                             Creating object files.
* AC_CONFIG_AUX_DIR:                     Invoking libtoolize.
* AC_DISABLE_FAST_INSTALL:               AM_PROG_LIBTOOL.
* AC_DISABLE_SHARED:                     AM_PROG_LIBTOOL.
* AC_DISABLE_STATIC:                     AM_PROG_LIBTOOL.
* AC_FUNC_ALLOCA:                        Autoconf .o macros.
* AC_LIBTOOL_DLOPEN:                     AM_PROG_LIBTOOL.
* AC_LIBTOOL_WIN32_DLL:                  AM_PROG_LIBTOOL.
* AC_REPLACE_FUNCS:                      Autoconf .o macros.
* aclocal:                               AM_PROG_LIBTOOL.
* allow_undefined_flag:                  libtool script contents.
* always_export_symbols:                 libtool script contents.
* AM_DISABLE_SHARED:                     AM_PROG_LIBTOOL.
* AM_DISABLE_STATIC:                     AM_PROG_LIBTOOL.
* AM_PROG_LIBTOOL:                       AM_PROG_LIBTOOL.
* application-level dynamic linking <1>: Dlopened modules.
* application-level dynamic linking:     Using libltdl.
* ar:                                    Linking libraries.
* AR:                                    libtool script contents.
* archive_cmds:                          libtool script contents.
* archive_expsym_cmds:                   libtool script contents.
* AS:                                    Invoking ltconfig.
* assign.test:                           Test descriptions.
* avoiding shared libraries:             Static-only libraries.
* bug reports:                           Reporting bugs.
* buggy system linkers:                  Linking executables.
* bugs, subtle ones caused by buggy linkers: Linking executables.
* build-relink.test:                     Test descriptions.
* build_libtool_libs:                    libtool script contents.
* build_old_libs:                        libtool script contents.
* C header files, portable:              C header files.
* C++, pitfalls:                         C++ libraries.
* C++, using:                            Other languages.
* C, not using:                          Other languages.
* CC <1>:                                Invoking ltconfig.
* CC:                                    libtool script contents.
* cdemo-conf.test:                       Test descriptions.
* cdemo-exec.test:                       Test descriptions.
* cdemo-make.test:                       Test descriptions.
* cdemo-shared.test:                     Test descriptions.
* cdemo-static.test:                     Test descriptions.
* CFLAGS:                                Invoking ltconfig.
* command options, libtool:              Invoking libtool.
* command options, libtoolize:           Invoking libtoolize.
* command options, ltconfig:             Invoking ltconfig.
* compile mode:                          Compile mode.
* compiler_c_o:                          libtool script contents.
* compiler_o_lo:                         libtool script contents.
* compiling object files:                Creating object files.
* complexity of library systems:         Postmortem.
* config.guess:                          Distributing.
* config.sub:                            Distributing.
* configuring libtool:                   Configuring.
* convenience libraries:                 Static libraries.
* CPPFLAGS:                              Invoking ltconfig.
* debugging libraries:                   Static-only libraries.
* definition of libraries:               Libtool paradigm.
* demo-conf.test:                        Test descriptions.
* demo-exec.test:                        Test descriptions.
* demo-inst.test:                        Test descriptions.
* demo-make.test:                        Test descriptions.
* demo-nofast.test:                      Test descriptions.
* demo-shared.test:                      Test descriptions.
* demo-static.test:                      Test descriptions.
* demo-unst.test:                        Test descriptions.
* dependencies between libraries:        Inter-library dependencies.
* dependency versioning:                 Versioning.
* deplibs.test:                          Test descriptions.
* deplibs_check_method:                  Porting inter-library dependencies.
* design issues:                         Issues.
* design of library interfaces:          Library tips.
* design philosophy:                     Motivation.
* developing libraries:                  Static-only libraries.
* dlclose <1>:                           Using libltdl.
* dlclose:                               Dlopened modules.
* dlerror:                               Using libltdl.
* DLLTOOL:                               Invoking ltconfig.
* dlopen <1>:                            Using libltdl.
* dlopen <2>:                            libtool script contents.
* dlopen:                                Dlopened modules.
* dlopen_self:                           libtool script contents.
* dlopen_self_static:                    libtool script contents.
* dlopening modules <1>:                 Using libltdl.
* dlopening modules:                     Dlopened modules.
* dlopening, pitfalls:                   Dlopen issues.
* dlsym <1>:                             Using libltdl.
* dlsym:                                 Dlopened modules.
* double-compilation, avoiding:          Static-only libraries.
* dryrun.test:                           Test descriptions.
* dynamic dependencies:                  Versioning.
* dynamic linking, applications <1>:     Using libltdl.
* dynamic linking, applications:         Dlopened modules.
* dynamic modules, names:                Finding the dlname.
* echo:                                  libtool script contents.
* eliding shared libraries:              Static-only libraries.
* examples of using libtool:             Using libtool.
* exclude_expsyms:                       libtool script contents.
* execute mode:                          Execute mode.
* export_dynamic_flag_spec:              libtool script contents.
* export_symbols_cmds:                   libtool script contents.
* failed tests:                          When tests fail.
* fast_install:                          libtool script contents.
* file_magic:                            Porting inter-library dependencies.
* file_magic_cmd:                        Porting inter-library dependencies.
* file_magic_test_file:                  Porting inter-library dependencies.
* finish mode:                           Finish mode.
* finish_cmds:                           libtool script contents.
* finish_eval:                           libtool script contents.
* fix_srcfile_path:                      libtool script contents.
* formal versioning:                     Libtool versioning.
* global functions:                      Library tips.
* global_symbol_pipe:                    libtool script contents.
* global_symbol_to_cdecl:                libtool script contents.
* hardcode.test:                         Test descriptions.
* hardcode_action:                       libtool script contents.
* hardcode_direct:                       libtool script contents.
* hardcode_libdir_flag_spec:             libtool script contents.
* hardcode_libdir_separator:             libtool script contents.
* hardcode_minus_L:                      libtool script contents.
* hardcode_shlibpath_var:                libtool script contents.
* header files:                          Library tips.
* host:                                  libtool script contents.
* host_alias:                            libtool script contents.
* implementation of libtool:             libtool script contents.
* include files, portable:               C header files.
* include_expsyms:                       libtool script contents.
* install:                               Installing libraries.
* install mode:                          Install mode.
* installation, finishing:               Installing libraries.
* inter-library dependencies:            Inter-library dependencies.
* inter-library dependency:              Porting inter-library dependencies.
* languages, non-C:                      Other languages.
* LD <1>:                                libtool script contents.
* LD:                                    Invoking ltconfig.
* LDFLAGS:                               Invoking ltconfig.
* libext:                                libtool script contents.
* libltdl:                               Using libltdl.
* libname_spec:                          libtool script contents.
* libraries, definition of:              Libtool paradigm.
* libraries, finishing installation:     Installing libraries.
* libraries, stripping:                  Installing libraries.
* library interfaces:                    Interfaces.
* library interfaces, design:            Library tips.
* library object file:                   Creating object files.
* library_names_spec:                    libtool script contents.
* LIBS:                                  Invoking ltconfig.
* libtool:                               Invoking libtool.
* libtool command options:               Invoking libtool.
* libtool examples:                      Using libtool.
* libtool implementation:                libtool script contents.
* libtool libraries:                     Linking libraries.
* libtool library versions:              Libtool versioning.
* libtool specifications:                Motivation.
* libtoolize:                            Invoking libtoolize.
* libtoolize command options:            Invoking libtoolize.
* link mode:                             Link mode.
* link-2.test:                           Test descriptions.
* link.test:                             Test descriptions.
* link_static_flag:                      libtool script contents.
* linking against installed libraries:   Linking executables.
* linking against uninstalled libraries: Linking executables.
* linking with installed libtool libraries: Linking executables.
* linking, partial:                      Link mode.
* LN_S:                                  Invoking ltconfig.
* lt_dladdsearchdir:                     Libltdl interface.
* lt_dlclose:                            Libltdl interface.
* lt_dlerror:                            Libltdl interface.
* lt_dlexit:                             Libltdl interface.
* lt_dlfree:                             Libltdl interface.
* lt_dlgetsearchpath:                    Libltdl interface.
* lt_dlhandle:                           Libltdl interface.
* lt_dlinit:                             Libltdl interface.
* lt_dlmalloc:                           Libltdl interface.
* lt_dlopen:                             Libltdl interface.
* lt_dlopenext:                          Libltdl interface.
* lt_dlpreload:                          Libltdl interface.
* lt_dlpreload_default:                  Libltdl interface.
* lt_dlsetsearchpath:                    Libltdl interface.
* lt_dlsym:                              Libltdl interface.
* lt_dlsymlist <1>:                      Dlpreopening.
* lt_dlsymlist:                          Libltdl interface.
* lt_preloaded_symbols:                  Dlpreopening.
* lt_ptr_t:                              Libltdl interface.
* LTALLOCA:                              Autoconf .o macros.
* ltconfig:                              Invoking ltconfig.
* ltconfig command options:              Invoking ltconfig.
* LTCONFIG_VERSION:                      libtool script contents.
* LTDL_SET_PRELOADED_SYMBOLS:            Libltdl interface.
* LTLIBOBJS:                             Autoconf .o macros.
* LTLIBRARIES:                           Using Automake.
* ltmain.sh:                             Distributing.
* Makefile:                              Makefile rules.
* Makefile.am:                           Makefile rules.
* Makefile.in:                           Makefile rules.
* mdemo-conf.test:                       Test descriptions.
* mdemo-exec.test:                       Test descriptions.
* mdemo-inst.test:                       Test descriptions.
* mdemo-make.test:                       Test descriptions.
* mdemo-shared.test:                     Test descriptions.
* mdemo-static.test:                     Test descriptions.
* mdemo-unst.test:                       Test descriptions.
* mode, compile:                         Compile mode.
* mode, execute:                         Execute mode.
* mode, finish:                          Finish mode.
* mode, install:                         Install mode.
* mode, link:                            Link mode.
* mode, uninstall:                       Uninstall mode.
* modules, dynamic <1>:                  Dlopened modules.
* modules, dynamic:                      Using libltdl.
* motivation for writing libtool:        Motivation.
* names of dynamic modules:              Finding the dlname.
* need_lib_prefix:                       libtool script contents.
* need_locks:                            libtool script contents.
* need_version:                          libtool script contents.
* NM <1>:                                libtool script contents.
* NM:                                    Invoking ltconfig.
* no_builtin_flag:                       libtool script contents.
* no_undefined_flag:                     libtool script contents.
* noinst-link.test:                      Test descriptions.
* nomode.test:                           Test descriptions.
* none:                                  Porting inter-library dependencies.
* objdir:                                libtool script contents.
* OBJDUMP:                               Invoking ltconfig.
* object files, compiling:               Creating object files.
* object files, library:                 Creating object files.
* objext:                                libtool script contents.
* old_archive_cmds:                      libtool script contents.
* old_archive_from_new_cmds:             libtool script contents.
* old_postinstall_cmds:                  libtool script contents.
* old_postuninstall_cmds:                libtool script contents.
* opaque data types:                     Library tips.
* options, libtool command:              Invoking libtool.
* options, libtoolize command:           Invoking libtoolize.
* options, ltconfig command:             Invoking ltconfig.
* other implementations, flaws in:       Postmortem.
* partial linking:                       Link mode.
* pass_all:                              Porting inter-library dependencies.
* PIC (position-independent code):       Creating object files.
* pic_flag:                              libtool script contents.
* pitfalls using C++:                    C++ libraries.
* pitfalls with dlopen:                  Dlopen issues.
* portable C headers:                    C header files.
* position-independent code:             Creating object files.
* postinstall_cmds:                      libtool script contents.
* postinstallation:                      Installing libraries.
* postuninstall_cmds:                    libtool script contents.
* problem reports:                       Reporting bugs.
* problems, blaming somebody else for:   Troubleshooting.
* problems, solving:                     Troubleshooting.
* program wrapper scripts:               Linking executables.
* quote.test:                            Test descriptions.
* RANLIB <1>:                            libtool script contents.
* RANLIB:                                Invoking ltconfig.
* ranlib:                                Linking libraries.
* reload_cmds:                           libtool script contents.
* reload_flag:                           libtool script contents.
* renaming interface functions:          Library tips.
* reporting bugs:                        Reporting bugs.
* reusability of library systems:        Postmortem.
* runpath_var:                           libtool script contents.
* saving time:                           Static-only libraries.
* security problems with buggy linkers:  Linking executables.
* sh.test:                               Test descriptions.
* shared libraries, not using:           Static-only libraries.
* shared library versions:               Versioning.
* shl_load <1>:                          Dlopened modules.
* shl_load:                              Using libltdl.
* shlibpath_overrides_runpath:           libtool script contents.
* shlibpath_var:                         libtool script contents.
* solving problems:                      Troubleshooting.
* soname_spec:                           libtool script contents.
* specifications for libtool:            Motivation.
* standalone binaries:                   Static libraries.
* static linking:                        Static libraries.
* strip:                                 Installing libraries.
* stripping libraries:                   Installing libraries.
* su:                                    Installing libraries.
* suffix.test:                           Test descriptions.
* sys_lib_dlsearch_path_spec:            libtool script contents.
* sys_lib_search_path_spec:              libtool script contents.
* test suite:                            Libtool test suite.
* test_compile:                          Porting inter-library dependencies.
* tests, failed:                         When tests fail.
* thread_safe_flag_spec:                 libtool script contents.
* time, saving:                          Static-only libraries.
* tricky design issues:                  Issues.
* trouble with C++:                      C++ libraries.
* trouble with dlopen:                   Dlopen issues.
* troubleshooting:                       Troubleshooting.
* undefined symbols, allowing:           Link mode.
* uninstall mode:                        Uninstall mode.
* unknown:                               Porting inter-library dependencies.
* unresolved symbols, allowing:          Link mode.
* using shared libraries, not:           Static-only libraries.
* version_type:                          libtool script contents.
* versioning, formal:                    Libtool versioning.
* whole_archive_flag_spec:               libtool script contents.
* wl:                                    libtool script contents.
* wrapper scripts for programs:          Linking executables.



Tag Table:
Node: Top1148
Node: Introduction6691
Node: Motivation8512
Node: Issues9827
Node: Other implementations11292
Node: Postmortem11830
Node: Libtool paradigm13446
Node: Using libtool14390
Node: Creating object files16503
Node: Linking libraries18952
Ref: Linking libraries-Footnote-121843
Node: Linking executables21984
Ref: Linking executables-Footnote-126929
Node: Debugging executables27222
Node: Installing libraries29930
Ref: Installing libraries-Footnote-133053
Node: Installing executables33135
Node: Static libraries33923
Node: Invoking libtool37143
Node: Compile mode39479
Node: Link mode41254
Node: Execute mode46288
Node: Install mode47063
Node: Finish mode47514
Node: Uninstall mode47944
Node: Integrating libtool48361
Node: Makefile rules49043
Node: Using Automake50114
Node: Configuring52687
Node: Invoking ltconfig53931
Node: ltconfig example58749
Node: AM_PROG_LIBTOOL60483
Ref: AM_PROG_LIBTOOL-Footnote-165585
Node: Distributing65846
Node: Invoking libtoolize66760
Node: Autoconf .o macros68486
Node: Static-only libraries69690
Ref: Static-only libraries-Footnote-171044
Node: Versioning71153
Node: Interfaces72524
Node: Libtool versioning73152
Node: Updating version info75360
Node: Release numbers77233
Node: Library tips79075
Node: C header files81390
Node: Inter-library dependencies84687
Ref: Inter-library dependencies-Footnote-187375
Node: Dlopened modules87576
Ref: Dlopened modules-Footnote-189487
Node: Building modules89553
Node: Dlpreopening90732
Node: Finding the dlname93572
Ref: Finding the dlname-Footnote-194866
Node: Dlopen issues94919
Node: Using libltdl95967
Node: Libltdl interface97545
Node: Modules for libltdl104517
Node: Distributing libltdl107012
Ref: Distributing libltdl-Footnote-1112466
Node: Other languages112691
Node: C++ libraries113320
Node: Troubleshooting115197
Node: Libtool test suite115729
Node: Test descriptions116455
Node: When tests fail121634
Node: Reporting bugs122518
Node: Maintaining124130
Node: New ports124845
Node: Information sources125531
Node: Porting inter-library dependencies127987
Node: Tested platforms130677
Node: Platform quirks137826
Node: References138726
Node: Compilers139159
Ref: Compilers-Footnote-1140697
Node: Reloadable objects141013
Node: Archivers141349
Node: libtool script contents141901
Node: Cheap tricks155138
Node: Index156698

End Tag Table
