Google Git
Sign in
gnu / libtool / 24b4e24af2735393c7d85e9b8715a086ef847268 / . / doc / libtool.texi
blob: 149b905d79712c7c67ae84abeb9d7e76a99a642e [file] [log] [blame]
\input texinfo @c -*-texinfo-*-
@c %**start of header
@setfilename libtool.info
@settitle Libtool
@c For double-sided printing, uncomment:
@c @setchapternewpage odd
@c %**end of header
@include version.texi
@set BUGADDR the libtool mailing list @code{<bug-libtool@@gnu.ai.mit.edu>}
@dircategory GNU programming tools
@direntry
* Libtool: (libtool). Generic shared library support script.
@end direntry
@dircategory Individual utilities
@direntry
* libtoolize: (libtool)Invoking libtoolize. Adding libtool support.
@end direntry
@ifinfo
This file documents GNU Libtool @value{VERSION}
Copyright (C) 1996, 1997 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.
@ignore
Permission is granted to process this file through TeX and print the
results, provided the printed document carries copying permission notice
identical to this one except for the removal of this paragraph
@end ignore
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.
@end ifinfo
@titlepage
@title GNU Libtool
@subtitle For version @value{VERSION}, @value{UPDATED}
@author Gordon Matzigkeit
@page
@vskip 0pt plus 1filll
Copyright @copyright{} 1996, 1997 Free Software Foundation, Inc.
@sp 2
This is the first edition of the GNU Libtool documentation,@*
and is consistent with GNU Libtool @value{VERSION}.@*
@sp 2
Published by the Free Software Foundation @*
59 Temple Place, Suite 330, @*
Boston, MA 02111-1307 USA @*
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 Free Software Foundation.
@end titlepage
@c Put everything in one index (arbitrarily chosen to be the concept index).
@syncodeindex vr cp
@syncodeindex fn cp
@synindex pg cp
@ifinfo
@node Top, Introduction, (dir), (dir)
@comment node-name, next, previous, up
@top 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 @value{VERSION}.
@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 @code{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:: @code{dlopen}ing libtool-created libraries.
* 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.
@detailmenu
--- The Detailed Node Listing ---
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.
* Installing libraries:: Making libraries available to users.
* Installing executables:: Making programs available to users.
* Static libraries:: When shared libraries are not wanted.
Invoking @code{libtool}
* Compile mode:: Creating library object files.
* Link mode:: Generating executables and libraries.
* Dlname mode:: Obtaining a file name to @code{dlopen(3)}.
* Install mode:: Making libraries and executables public.
* Finish mode:: Completing a library installation.
* Uninstall mode:: Removing executables and libraries.
Integrating libtool with your own packages
* Makefile rules:: Writing @file{Makefile} rules for libtool.
* Using Automake:: Automatically supporting libtool.
* Configuring:: Configuring libtool for a host system.
* Distributing:: What files to distribute with your package.
Configuring libtool
* Invoking ltconfig:: @code{ltconfig} command line options.
* ltconfig example:: Manually configuring a @code{libtool}.
* AM_PROG_LIBTOOL:: Configuring @code{libtool} in @file{configure.in}.
Including libtool with your package
* Invoking libtoolize:: @code{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.
Tips for interface design
* C header files:: How to write portable include files.
Dlopened modules
* Exporting dynamic symbols:: Preparing files to be dlopened.
* Finding the dlname:: Choosing the right file to @code{dlopen(3)}.
* Dlopen issues:: Unresolved problems that need your attention.
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.
Maintainance 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.
Platform quirks
* Compilers:: Creating object files from source files.
* Reloadable objects:: Binding object files together.
* Archivers:: Programs that create static archives.
* Strip:: Removing unnecessary linkage information.
@end detailmenu
@end menu
@end ifinfo
@node Introduction
@chapter 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@dots{} users don't need
to read obscure documentation in order to have their favorite source
package build shared libraries. They just run your package
@code{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, @file{libhello}, in a
generic way.
@file{libhello} could be a shared library, a static library, or
both@dots{} 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.
@end menu
@node Motivation
@section Motivation for writing libtool
@cindex Motivation for writing libtool
@cindex Design philosophy
Since early 1995, several different GNU developers have recognized the
importance of having shared library support for their packages. The
primary motivation for such a change is to encourage modularity and
reuse of code (both conceptually and physically) in GNU programs.
Such a demand means that the way libraries are built in GNU packages
needs to be general, to allow for any library type the package installer
might want.
The problem is compounded by the absence of a standard procedure for
creating shared libraries on different platforms.
The following sections outline the major issues facing shared library
support in GNU, and how I propose that shared library support could be
standardized with libtool.
@cindex Specifications for libtool
@cindex Libtool specifications
The following specifications were used in developing and evaluating this
system:
@enumerate
@item
The system must be as elegant as possible.
@item
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.
@item
Portability to other (non-GNU) architectures and tools is desirable.
@end enumerate
@node Issues
@section Implementation issues
@cindex Tricky design issues
@cindex Design issues
The following issues need to be addressed in any reusable shared library
system, specifically libtool:
@enumerate
@item
The package installer should be able to control what sort of libraries
are built.
@item
It can be tricky to run dynamically linked programs whose libraries have
not yet been installed. @var{LD_LIBRARY_PATH} must be set properly (if
it is supported), or programs fail to run.
@item
The system must operate consistently even on hosts which don't support
shared libraries.
@item
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.
@item
It is not always obvious with which suffix a shared library should be
installed. This makes it difficult for @file{Makefile} rules, since they
generally assume that file names are the same from host to host.
@item
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.
@item
The install @file{Makefile} target should warn the package installer to set
the proper environment variables (@var{LD_LIBRARY_PATH} or equivalent),
or run @code{ldconfig(8)}.
@end enumerate
@node Other implementations
@section Other implementations
I have investigated several different implementations of systems that
build shared
libraries as part of a freeware package. At first, I made notes on the
features of each of these packages for comparison purposes.
Now it is clear that none of these packages have documented the details
of shared library systems that libtool requires. So, other packages
have been more or less abandoned as influences.
@node Postmortem
@section A postmortem analysis of other implementations
@cindex Other implementations, flaws in
@cindex Reusability of library systems
In all fairness, each of the implementations that I examined do the job
that they were intended to do, for a number of different host systems.
However, none of these solutions seem to function well as a generalized,
reusable component.
@cindex Complexity of library systems
Most were too complex for me to use (much less modify) without
understanding exactly what the implementation does, and they were
generally not documented.
I think the main problem is that different vendors have different views
of what libraries are, and none of the packages I examined seemed to be
confident enough to settle on a single paradigm that just @emph{works}.
Ideally, libtool would be a standard that would be implemented as series
of extensions and modifications to existing library systems to make them
work consistently. However, I don't have the time or power to convince
operating system developers to mend their evil ways, and I want to build
shared libraries right now, even on buggy, broken, confused operating
systems.
For this reason, I have designed libtool as an independent shell script.
It isolates the problems and inconsistencies in library building that
plague @file{Makefile} writers by wrapping the compiler suite on different
platforms with a consistent, powerful interface.
I hope that libtool will be useful to and used by the GNU community, and
that the lessons I've learned in writing it will be taken up and
implemented by designers of library systems.
@node Libtool paradigm
@chapter The libtool paradigm
At first, libtool was designed to support an arbitrary number of library
object types. After porting libtool to more platforms, I discovered a
new paradigm for describing the relationship between libraries and
programs.
@cindex Definition of libraries
@cindex Libraries, definition of
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.
@node Using libtool
@chapter Using libtool
@cindex Examples of using libtool
@cindex Libtool examples
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:
@table @samp
@item a23
An Ultrix 4.2 platform with only static libraries.
@item burger
A NetBSD/i386 1.2 platform with shared libraries.
@end table
You can follow these examples on your own platform, using the
preconfigured libtool script that was installed with libtool
(@pxref{Configuring}).
Source files for the following examples are taken from the @file{demo}
subdirectory of the libtool distribution. Assume that we are building a
library, @file{libhello}, out of the files @file{foo.c} and
@file{hello.c}.
Note that the @file{foo.c} source file uses the @code{cos(3)} math library
function, which is usually found in the standalone math library, and not
the C library. So, we need to add @kbd{-lm} to the end of
the link line whenever we link @file{foo.o} or @file{foo.lo} into an
executable or a library (@pxref{Inter-library dependencies}).
The same rule applies whenever you use functions that don't appear in
the standard C library@dots{} you need to add the appropriate
@kbd{-l@var{name}} 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
@file{main.o} against @file{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.
* Installing libraries:: Making libraries available to users.
* Installing executables:: Making programs available to users.
* Static libraries:: When shared libraries are not wanted.
@end menu
@node Creating object files
@section Creating object files
@cindex Compiling object files
@cindex Object files, compiling
To create an object file from a source file, the compiler is invoked
with the `-c' flag (and any other desired flags):
@example
burger$ @kbd{gcc -g -O -c main.c}
burger$
@end example
The above compiler command produces an object file, @file{main.o}, from
the source file @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:
@example
burger$ @kbd{gcc -g -O -c foo.c}
burger$ @kbd{gcc -g -O -c hello.c}
burger$
@end example
@cindex Position-independent code
@cindex PIC (position-independent code)
Shared libraries, however, may only be built from
@dfn{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.
@cindex Library object file
@cindex @samp{.lo} files
@cindex Object files, library
Since this is a library implementation detail, libtool hides the
complexity of PIC compiler flags by using separate library object files
(which end in @samp{.lo} instead of @samp{.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 @file{foo.c} and @file{hello.c},
simply invoke libtool with the standard compilation command as
arguments:
@example
a23$ @kbd{libtool gcc -g -O -c foo.c}
gcc -g -O -c foo.c
ln -s foo.o foo.lo
a23$ @kbd{libtool gcc -g -O -c hello.c}
gcc -g -O -c hello.c
ln -s hello.o hello.lo
a23$
@end example
Note that libtool creates two object files for each invocation. The
@samp{.lo} file is a library object, and the @samp{.o} file is a standard object
file. On @samp{a23}, these files are identical, because only static
libraries are supported.
On shared library systems, libtool automatically inserts the PIC
generation flags into the compilation command, so that the library
object and the standard object differ:
@example
burger$ @kbd{libtool gcc -g -O -c foo.c}
gcc -g -O -c -fPIC -DPIC foo.c
mv -f foo.o foo.lo
gcc -g -O -c foo.c
burger$ @kbd{libtool gcc -g -O -c hello.c}
gcc -g -O -c -fPIC -DPIC hello.c
mv -f hello.o hello.lo
gcc -g -O -c hello.c
burger$
@end example
@node Linking libraries
@section Linking libraries
@pindex ar
Without libtool, the programmer would invoke the @code{ar} command to
create a static library:
@example
burger$ @kbd{ar cru libhello.a hello.o foo.o}
burger$
@end example
@pindex ranlib
But of course, that would be too simple, so many systems require that
you run the @code{ranlib} command on the resulting library (to give it
better karma, or something):
@example
burger$ @kbd{ranlib libhello.a}
burger$
@end example
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
@code{ar} (and possibly @code{ranlib}) commands.
@cindex Libtool libraries
@cindex @samp{.la} files
Again, the libtool library name differs from the standard name (it has a
@samp{.la} suffix instead of a @samp{.a} suffix). The arguments to libtool are
the same ones you would use to produce an executable named
@file{libhello.la} with your compiler:
@example
burger$ @kbd{libtool gcc -g -O -o libhello.la foo.o hello.o}
libtool: cannot build libtool library `libhello.la' from non-libtool \
objects
burger$
@end example
Aha! Libtool caught a common error@dots{} 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:@footnote{Remember that we need to add @kbd{-lm} to the link
command line because @file{foo.c} uses the @code{cos(3)} math library
function. @xref{Using libtool}.}
@example
a23$ @kbd{libtool gcc -g -O -o libhello.la foo.lo hello.lo -lm}
libtool: you must specify an installation directory with `-rpath'
a23$
@end example
Argh. Another complication in building shared libraries is that we need
to specify the path to the directory in which they (eventually) will be
installed. So, we try again, with an @code{rpath} setting of
@file{/usr/local/lib}:
@example
a23$ @kbd{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$
@end example
Now, let's try the same trick on the shared library platform:
@example
burger$ @kbd{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$
@end example
Now that's significantly cooler@dots{} libtool just ran an obscure
@code{ld} command to create a shared library, as well as the static
library.
@cindex @file{.libs} subdirectory
Note how libtool creates extra files in the @file{.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.
@node Linking executables
@section Linking executables
@cindex Linking against installed libraries
If you choose at this point to @dfn{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
@samp{-L} and @samp{-l} flags to specify the library's location.
@cindex Buggy system linkers
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.
@cindex Security problems with buggy linkers
@cindex Bugs, subtle ones caused by buggy linkers
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.
@cindex Linking against uninstalled libraries
Here's the old way of linking against an uninstalled library:
@example
burger$ @kbd{gcc -g -O -o hell.old main.o libhello.a -lm}
burger$
@end example
Libtool's way is almost the same@footnote{However, you should never use
@samp{-L} or @samp{-l} flags to link against an uninstalled libtool
library. Just specify the relative path to the @samp{.la} file, such as
@file{../intl/libintl.la}. This is a design decision to eliminate
any ambiguity when linking against uninstalled shared libraries.}:
@example
a23$ @kbd{libtool gcc -g -O -o hell main.o libhello.la -lm}
gcc -g -O -o hell main.o ./.libs/libhello.a -lm
a23$
@end example
That looks too simple to be true. All libtool did was transform
@file{libhello.la} to @file{./.libs/libhello.a}, but remember that
@samp{a23} has no shared libraries.
On @samp{burger} the situation is different:
@example
burger$ @kbd{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$
@end example
@cindex Wrapper scripts for programs
@cindex Program wrapper scripts
Notice that the executable, @code{hell}, was actually created in the
@file{.libs} subdirectory. Then, a wrapper script was created in the
current directory.
On NetBSD 1.2, libtool encodes the installation directory of
@file{libhello}, by using the @samp{-R/usr/local/lib} compiler
flag. Then, the wrapper script guarantees that the executable finds the
correct shared library (the one in @file{./.libs}) until it is properly
installed.
Let's compare the two different programs:
@example
burger$ @kbd{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$ @kbd{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$
@end example
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?
@example
burger$ @kbd{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$ @kbd{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$
@end example
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 @file{libhello} won't be an advantage
until we link it against at least a few more programs.
@node Installing libraries
@section Installing libraries
@pindex strip
Installing libraries on a non-libtool system is quite
straightforward@dots{} just copy them into place:@footnote{Don't
accidentally strip the libraries, though, or they will be unusable.}
@pindex su
@example
burger$ @kbd{su}
Password: @kbd{********}
burger# @kbd{cp libhello.a /usr/local/lib/libhello.a}
burger#
@end example
Oops, don't forget the @code{ranlib} command:
@example
burger# @kbd{ranlib /usr/local/lib/libhello.a}
burger#
@end example
@pindex install
Libtool installation is quite simple, as well. Just use the
@code{install} or @code{cp} command that you normally would:
@example
a23# @kbd{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#
@end example
Note that the libtool library @file{libhello.la} is also installed, for
informational purposes, and to help libtool with uninstallation
(@pxref{Uninstall mode}).
Here is the shared library example:
@example
burger# @kbd{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#
@end example
@cindex Stripping libraries
@cindex Libraries, stripping
It is safe to specify the @samp{-s} (strip symbols) flag if you use a
BSD-compatible install program when installing libraries.
Libtool will either ignore the @samp{-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
@samp{-rpath} flag you used to build it.
@cindex Postinstallation
@cindex Installation, finishing
@cindex Libraries, finishing installation
Then, running @samp{libtool -n --finish @var{libdir}} can give you
further hints on what to do:
@example
burger# @kbd{libtool -n --finish /usr/local/lib}
ldconfig -m /usr/local/lib
To link against installed libraries in LIBDIR, users may have to:
- add LIBDIR to their `LD_LIBRARY_PATH' environment variable
- use the `-LLIBDIR' linker flag
burger#
@end example
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.
@node Installing executables
@section Installing executables
If you used libtool to link any executables against uninstalled libtool
libraries (@pxref{Linking executables}), you need to use libtool to
install the executables after the libraries have been installed
(@pxref{Installing libraries}).
So, for our Ultrix example, we would run:
@example
a23# libtool install -c hell /usr/local/bin/hell
install -c hell /usr/local/bin/hell
a23#
@end example
On shared library systems, libtool just ignores the wrapper script and
installs the correct binary:
@example
burger# libtool install -c hell /usr/local/bin/hell
install -c .libs/hell /usr/local/bin/hell
burger#
@end example
@node Static libraries
@section Linking static libraries
@cindex Static linking
@cindex Convenience libraries
Why return to @code{ar} and @code{ranlib} silliness when you've had a
taste of libtool? Well, sometimes it is desirable to create a static
archive that can never be shared. The most frequent case is when you
have a ``convenience library'' that is a collection of related object
files without a really nice interface.
To do this, you should ignore libtool entirely, and just use the old
@code{ar} and @code{ranlib} commands to create a static library.
If you want to install the library (but you probably don't), then you
may use libtool if you want:
@example
burger$ @kbd{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$
@end example
Using libtool for static library installation protects your library from
being accidentally stripped (if the installer used the @samp{-s} flag),
as well as automatically running the correct @code{ranlib} command.
@cindex Standalone binaries
Another common situation where static linking is desirable is in
creating a standalone binary. Use libtool to do the linking and add the
@samp{-static} flag.
@node Invoking libtool
@chapter Invoking @code{libtool}
@pindex libtool
@cindex libtool command options
@cindex Options, libtool command
@cindex Command options, libtool
The @code{libtool} program has the following synopsis:
@example
libtool [@var{option}]@dots{} [@var{mode-arg}]...
@end example
@noindent
and accepts the following options:
@table @samp
@item -n
@itemx --dry-run
Don't create, modify, or delete any files, just show what commands would
be executed by libtool.
@item --features
Display libtool configuration information and exit. This provides a way
for packages to determine whether shared or static libraries will be
built.
@item --finish
Same as @samp{--mode=finish}.
@item --help
Display a help message and exit. If @samp{--mode=@var{mode}} is
specified, then detailed help for @var{mode} is
displayed.
@item --mode=@var{mode}
Use @var{mode} as the operation mode. By default, the operation mode is
inferred from the contents of @var{mode-args}.
If @var{mode} is specified, it must be one of the following:
@table @samp
@item compile
Compile a source file into a libtool object.
@item dlname
Find the correct name that programs should @code{dlopen(3)}.
@item finish
Complete the installation of libtool libraries on the system.
@item install
Install libraries or executables.
@item link
Create a library or an executable.
@item uninstall
Delete libraries or executables.
@end table
@item --version
Print libtool version information and exit.
@end table
@menu
* Compile mode:: Creating library object files.
* Link mode:: Generating executables and libraries.
* Dlname mode:: Obtaining a file name to @code{dlopen(3)}.
* Install mode:: Making libraries and executables public.
* Finish mode:: Completing a library installation.
* Uninstall mode:: Removing executables and libraries.
@end menu
@node Compile mode
@section Compile mode
@cindex Mode, compile
@cindex Compile mode
For @samp{compile} mode, @var{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 @samp{-c} compiler flag
so that only an object file is created.
Libtool determines the name of the output file by removing the directory
component from the source file name, then substituting the C source code
suffix @samp{.c} with the library object suffix, @samp{.lo}.
If shared libraries are being built, any necessary PIC generation flags
are substituted into the compilation command.
@node Link mode
@section Link mode
@cindex Link mode
@cindex Mode, link
@samp{link} mode links together object files (including library
objects) to form another library or to create an executable program.
@var{mode-args} consist of a command using the C compiler to create an
output file (with the @samp{-o} flag) from several object files.
The following components of @var{mode-args} are treated specially:
@table @samp
@cindex Undefined symbols, allowing
@cindex Unresolved symbols, allowing
@item -allow-undefined
If @var{output-file} is a libtool library, allow it to contain
references to symbols that aren't defined in that library or its
dependencies (@pxref{Inter-library dependencies}).
@item -export-dynamic
Allow symbols from @var{output-file} to be resolved with @code{dlsym(3)}
(@pxref{Dlopened modules}).
@item -L@var{libdir}
Search @var{libdir} for required libraries that have already been
installed.
@item -l@var{name}
@var{output-file} requires the installed library @file{lib@var{name}}.
This option is required even when @var{output-file} is not an
executable.
@item -o @var{output-file}
Create @var{output-file} from the specified objects and libraries.
@item -rpath @var{libdir}
If @var{output-file} is a library, it will eventually be installed in
@var{libdir}.
@item -static
If @var{output-file} is a program, then do not link it against any
shared libraries. If @var{output-file} is a library, then only create a
static library.
@item -version-info @var{current}[:@var{revision}[:@var{age}]]
If @var{output-file} is a libtool library, use library version
information @var{current}, @var{revision}, and @var{age} to build it.
If not specified, each of these variables defaults to 0
(@pxref{Versioning}).
@end table
If the @var{output-file} ends in @samp{.la}, then a libtool library is
created, which must be built only from library objects (@samp{.lo} files).
The @samp{-rpath} option is required. In the current implementation,
libtool libraries may not depend on other uninstalled libtool libraries
(@pxref{Inter-library dependencies}).
If the @var{output-file} ends in @samp{.a}, then a standard library is
created using @code{ar} and possibly @code{ranlib}.
@cindex Partial linking
@cindex Linking, partial
If @var{output-file} ends in @samp{.o} or @samp{.lo}, then a reloadable object
file is created from the input files (generally using @samp{ld -r}).
This method is often called @dfn{partial linking}.
Otherwise, an executable program is created.
@node Dlname mode
@section Dlname mode
@cindex Dlname mode
@cindex Mode, dlname
The @samp{dlname} mode simply prints the name of a libtool library that
can be passed to the @code{dlopen(3)} function call (@pxref{Dlopened
modules}).
Each of the @var{mode-args} specifies a libtool library linked
using the @samp{-export-dynamic} option (@pxref{Link mode}). The names
of the modules to load are printed to standard output, one per line.
If one of the @var{mode-args} was not linked with
@samp{-export-dynamic}, then an error is displayed.
@node Install mode
@section Install mode
@cindex Install mode
@cindex Mode, install
In @samp{install} mode, libtool interprets @var{mode-args} as an
installation command beginning with @code{cp}, or a BSD-compatible
@code{install} program.
The rest of the @var{mode-args} are interpreted as arguments to that
command.
The command is run, and any necessary unprivileged post-installation
commands are also completed.
@node Finish mode
@section Finish mode
@cindex Finish mode
@cindex Mode, finish
@samp{finish} mode helps system administrators install libtool
libraries so that they can be located and linked into user programs.
Each @var{mode-arg} is interpreted as the name of a library directory.
Running this command may require superuser privileges, so the
@samp{--dry-run} option may be useful.
@node Uninstall mode
@section Uninstall mode
@cindex Uninstall mode
@cindex Mode, uninstall
This mode deletes installed libraries (and other files).
The first @var{mode-arg} is the name of the program to use to delete
files (typically @file{/bin/rm}).
The remaining @var{mode-args} are either flags for the deletion program
(beginning with a `-'), or the names of files to delete.
@node Integrating libtool
@chapter Integrating libtool with your own packages
This chapter describes how to integrate libtool with your packages so
that your users can install hassle-free shared libraries.
@menu
* Makefile rules:: Writing @file{Makefile} rules for libtool.
* Using Automake:: Automatically supporting libtool.
* Configuring:: Configuring libtool for a host system.
* Distributing:: What files to distribute with your package.
@end menu
@node Makefile rules
@section Writing @file{Makefile} rules for libtool
@cindex Makefile
@cindex Makefile.am
@cindex Makefile.in
Libtool is fully integrated with Automake (@pxref{Top,, Introduction,
automake, The Automake Manual}), starting with Automake version 1.2.
If you want to use libtool in a regular @file{Makefile} (or
@file{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:
@enumerate 1
@item
Download Automake (version 1.2 or later) from your nearest GNU mirror,
install it, and start using it.
@item
Learn how to write @file{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 @file{Makefile.in} in the @file{demo}
subdirectory of the libtool distribution@dots{} note especially that it
was automatically generated from the @file{Makefile.am} by Automake).
@end enumerate
@node Using Automake
@section Using Automake with libtool
@vindex LTLIBRARIES
Libtool library support is implemented under the @samp{LTLIBRARIES}
primary.
Here are some samples from the Automake @file{Makefile.am} in the
libtool distribution's @file{demo} subdirectory.
First, to link a program against a libtool library, just use the
@samp{program_LDADD} variable:
@example
bin_PROGRAMS = hell hell.static
# Build hell from main.c and libhello.la
hell_SOURCES = main.c
hell_LDADD = libhello.la
# Create a statically-linked version of hell.
hell_static_SOURCES = main.c
hell_static_LDADD = libhello.la
hell_static_LDFLAGS = -static
@end example
You may use the @samp{program_LDFLAGS} variable to stuff in any flags
you want to pass to libtool while linking @samp{program} (such as
@samp{-static} to create a statically-linked executable).
Building a libtool library is almost as trivial@dots{} note the use of
@samp{libhello_la_LDFLAGS} to pass the @samp{-version-info}
(@pxref{Versioning}) option to libtool:
@example
# 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
@end example
The @samp{-rpath} option is passed automatically by Automake, so you
should not specify it.
@xref{A Shared Library, Building a Shared Library, The Automake Manual,
automake, The Automake Manual}, for more information.
@node Configuring
@section Configuring libtool
@cindex 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
(@pxref{Distributing}), you do not always know which compiler suite and
operating system are used to compile your package.
For this reason, libtool must be @dfn{configured} before it can be
used. This idea should be familiar to anybody who has used a GNU
@code{configure} script. @code{configure} runs a number of tests for
system features, then generates the @file{Makefiles} (and possibly a
@file{config.h} header file), after which you can run @code{make} and
build the package.
Libtool has its own equivalent to the @code{configure} script,
@code{ltconfig}.
@menu
* Invoking ltconfig:: @code{ltconfig} command line options.
* ltconfig example:: Manually configuring a @code{libtool}.
* AM_PROG_LIBTOOL:: Configuring @code{libtool} in @file{configure.in}.
@end menu
@node Invoking ltconfig
@subsection Invoking @code{ltconfig}
@pindex ltconfig
@cindex ltconfig command options
@cindex Options, ltconfig command
@cindex Command options, ltconfig
@code{ltconfig} runs a series of configuration tests, then creates a
system-specific @code{libtool} in the current directory. The
@code{ltconfig} program has the following synopsis:
@example
ltconfig [@var{option}]@dots{} @var{ltmain} [@var{host}]
@end example
@noindent
and accepts the following options:
@table @samp
@item --disable-shared
Create a @code{libtool} that only builds static libraries.
@item --disable-static
Create a @code{libtool} that builds only shared libraries if they are
available. If only static libraries can be built, then this flag has
no effect.
@item --help
Display a help message and exit.
@item --no-verify
Do not use @code{config.sub} to verify that @var{host} is a valid
canonical host system name.
@item --quiet
@itemx --silent
Do not print informational messages when running configuration tests.
@item --srcdir=@var{dir}
Look for @code{config.guess} and @code{config.sub} in @var{dir}.
@item --version
Print @code{ltconfig} version information and exit.
@item --with-gcc
Assume that the GNU C compiler will be used when invoking the created
@code{libtool} to compile and link object files.
@end table
@var{ltmain} is the @code{ltmain.sh} shell script fragment that provides
the basic libtool functionality (@pxref{Distributing}).
@var{host} is the canonical host system name, which by default is
guessed by running @code{config.guess}.
@code{ltconfig} also recognizes the following environment variables:
@defvar CC
The C compiler that will be used by the generated @code{libtool}.
@end defvar
@defvar CFLAGS
Compiler flags used to generate standard object files.
@end defvar
@defvar CPPFLAGS
C preprocessor flags.
@end defvar
@defvar LD
The system linker to use (if the generated @code{libtool} requires one).
@end defvar
@defvar RANLIB
Program to use rather than checking for @code{ranlib}.
@end defvar
@node ltconfig example
@subsection Using @code{ltconfig}
Here is a simple example of using @code{ltconfig} to configure libtool
on my NetBSD/i386 1.2 system:
@example
burger$ @kbd{./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$
@end example
This example shows how to configure @code{libtool} for cross-compiling
to a i486 GNU/Hurd 0.1 system (assuming compiler tools reside in
@file{/local/i486-gnu/bin}):
@example
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$
@end example
@node AM_PROG_LIBTOOL
@subsection The @code{AM_PROG_LIBTOOL} macro
If you are using GNU Autoconf (or Automake), you should add a call to
@code{AM_PROG_LIBTOOL} to your @file{configure.in} file. This macro
offers seamless integration between the @code{configure} script and
@code{ltconfig}:
@defmac AM_PROG_LIBTOOL
Add support for the @samp{--enable-shared} and @samp{--disable-shared}
@code{configure} flags. Invoke @code{ltconfig} with the correct
arguments to configure the package.@footnote{@code{AM_PROG_LIBTOOL}
requires that you define the @file{Makefile} variable @code{top_builddir} in
your @file{Makefile.in}. Automake does this automatically, but Autoconf
users should set it to the relative path to the top of your build
directory (@file{../..}, for example).}
@end defmac
@pindex aclocal
When you invoke the @code{libtoolize} program (@pxref{Invoking
libtoolize}), it will tell you where to find a definition of
@code{AM_PROG_LIBTOOL}. If you use Automake, the @code{aclocal} program
will automatically add @code{AM_PROG_LIBTOOL} support to your
@code{configure} script.
@node Distributing
@section Including libtool with your package
In order to use libtool, you need to include the following files with
your package:
@table @file
@item config.guess
@pindex config.guess
Attempt to guess a canonical system name.
@item config.sub
@pindex config.sub
Canonical system name validation subroutine script.
@item ltconfig
Generate a libtool script for a given system.
@item ltmain.sh
@pindex ltmain.sh
A generic script implementing basic libtool functionality.
@end table
Note that the libtool script itself should @emph{not} be included with
your package. @xref{Configuring}.
You should use the @code{libtoolize} program, rather than manually
copying these files into your package.
@menu
* Invoking libtoolize:: @code{libtoolize} command line options.
* Autoconf .o macros:: Autoconf macros that set object file names.
@end menu
@node Invoking libtoolize
@subsection Invoking @code{libtoolize}
@pindex libtoolize
@cindex libtoolize command options
@cindex Command options, libtoolize
@cindex Options, libtoolize command
The @code{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 @code{libtoolize} program has the following synopsis:
@example
libtoolize [@var{option}]@dots{}
@end example
@noindent
and accepts the following options:
@table @samp
@item --automake
Work silently, and assume that Automake libtool support is used.
@samp{libtoolize --automake} is used by Automake to add libtool files to
your package, when @samp{AM_PROG_LIBTOOL} appears in your
@file{configure.in}.
@item --copy
@itemx -c
Copy files from the libtool data directory rather than creating
symlinks.
@item --dry-run
@itemx -n
Don't run any commands that modify the file system, just print them
out.
@item --force
@itemx -f
Replace existing libtool files. By default, @code{libtoolize} won't
overwrite existing files.
@item --help
Display a help message and exit.
@item --version
Print @code{libtoolize} version information and exit.
@end table
@findex AC_CONFIG_AUX_DIR
If @code{libtoolize} detects an explicit call to
@code{AC_CONFIG_AUX_DIR} (@pxref{Input, , The Autoconf Manual,
autoconf, The Autoconf Manual}) in your @file{configure.in}, it
will put the files in the specified directory.
@code{libtoolize} displays hints for adding libtool support to your
package, as well.
@node Autoconf .o macros
@subsection Autoconf @samp{.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:
@defvar LTALLOCA
@findex AC_FUNC_ALLOCA
Substituted by @code{AC_FUNC_ALLOCA} (@pxref{Particular Functions, Particular
Function Checks, The Autoconf Manual, autoconf, The Autoconf
Manual}). Is either empty, or contains @samp{alloca.lo}.
@end defvar
@defvar LTLIBOBJS
@findex AC_REPLACE_FUNCS
Substituted by @code{AC_REPLACE_FUNCS} (@pxref{Generic Functions, Generic
Function Checks, The Autoconf Manual, autoconf, The Autoconf
Manual}), and a few other functions.
@end defvar
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 @code{AC_OUTPUT} in your
@file{configure.in}:
@example
LTLIBOBJS=`echo "$LIBOBJS" | sed 's/\.o/.lo/g'`
AC_SUBST(LTLIBOBJS)
LTALLOCA=`echo "$ALLOCA" | sed 's/\.o/.lo/g'`
AC_SUBST(LTALLOCA)
AC_OUTPUT(@dots{})
@end example
@node Versioning
@chapter Library interface versions
@cindex Dynamic dependencies
@cindex Dependency versioning
@cindex Shared library 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
@code{sed}. So, I may say ``libtool depends on sed,'' and that is good
enough for most purposes.
However, when an interface changes regularly, we need to be more
specific: ``Gnus 5.1 requires Emacs 19.28 or above.'' Here, the
description of an interface consists of a name, and a ``version
number.''
Even that sort of description is not accurate enough for some purposes.
What if Emacs 20 changes enough to break Gnus 5.1?
The same problem exists in shared libraries: we require a formal version
system to describe the sorts of dependencies that programs have on
shared libraries, so that the dynamic linker can guarantee that programs
are linked only against libraries that provide the interface they
require.
@menu
* Interfaces:: What are library interfaces?
* Libtool versioning:: Libtool's versioning system.
* Updating version info:: Changing version information before releases.
@end menu
@node Interfaces
@section What are library interfaces?
@cindex Library interfaces
Interfaces for libraries may be any of the following (and more):
@itemize @bullet
@item
global variables: both names and types
@item
global functions: argument types and number, return types, and function names
@item
standard input, standard output, standard error, and file formats
@item
sockets, pipes, and other inter-process communication protocol formats
@end itemize
Note that static functions do not count as interfaces, because they are
not directly available to the user of the library.
@node Libtool versioning
@section Libtool's versioning system
@cindex Libtool library versions
@cindex Formal versioning
@cindex Versioning, formal
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 very
simple: it encodes the least and the greatest interface numbers in the
resulting binary (@var{first-interface}, @var{last-interface}).
Then, the dynamic linker is guaranteed that if a library supports
@emph{every} interface number between @var{first-interface} and
@var{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 @file{libhello} supports interfaces 5, 16, 17, 18, and 19, and that
libtool is used to link @file{test} against @file{libhello}.
Libtool encodes the numbers 5 and 19 in @file{test}, and the dynamic
linker will only link @file{test} against libraries that support
@emph{every} interface between 5 and 19. So, the dynamic linker refuses
to link @file{test} against @file{libhello}!
In order to eliminate this problem, libtool only allows libraries to
declare consecutive interface numbers. So, @file{libhello} can declare at
most that it supports interfaces 16 through 19. Then, the dynamic
linker will link @file{test} against @file{libhello}.
So, libtool library versions are described by three integers:
@table @var
@item current
The most recent interface number that this library implements.
@item age
The difference between the oldest and newest interfaces that this
library implements. In other words, the library implements all the
interface numbers in the range from number @code{@var{current} -
@var{age}} to @code{@var{current}}.
@item revision
The implementation number of the @var{current} interface.
@end table
If two libraries have identical @var{current} and @var{age} numbers,
then the dynamic linker chooses the library with the greater
@var{revision} number.
@node Updating version info
@section Updating library version information
If you want to use libtool's versioning system, then you must specify
the version information to libtool using the @samp{-version-info} flag
during link mode (@pxref{Link mode}).
This flag accepts an argument of the form
@samp{@var{current}[:@var{revision}[:@var{age}]]}. So, passing
@samp{-version-info 3:12:1} sets @var{current} to 3, @var{revision} to
12, and @var{age} to 1.
If either @var{age} or @var{revision} are omitted, they default to 0.
Also note that @var{age} must be less than or equal to the @var{current}
interface number.
Here are a set of rules to help you update your library version
information:
@enumerate 1
@item
Start with version information of @samp{0:0:0} for each libtool library.
@item
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.
@item
If the library source code has changed at all since the last update,
then increment @var{revision} (@samp{@var{c}:@var{r}:@var{a}} becomes
@samp{@var{c}:@var{r+1}:@var{a}}).
@item
If any interfaces have been added, removed, or changed since the last
update, increment @var{current}, and set @var{revision} to 0.
@item
If any interfaces have been added since the last public release, then
increment @var{age}.
@item
If any interfaces have been removed since the last public release, then
set @var{age} to 0.
@end enumerate
@strong{@emph{Never}} try to set library version 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.
@node Library tips
@chapter Tips for interface design
@cindex Library interfaces, design
@cindex Design of library interfaces
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:
@table @asis
@item Plan ahead
Try to make every interface truly minimal, so that you won't need to
delete entry points very often.
@item Avoid interface changes
@cindex Renaming interface functions
Some people love redesigning and changing entry points just for the heck
of it (note: @emph{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.
@item Use opaque data types
@cindex 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.
@item Use header files
@cindex 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 (@pxref{C header files}).
@item Use the @code{static} keyword (or equivalent) whenever possible
@cindex Global functions
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@dots{} your users cannot access them, so they
aren't interface changes.
@end table
@menu
* C header files:: How to write portable include files.
@end menu
@node C header files
@section Writing C header files
@cindex Portable C headers
@cindex C header files, portable
@cindex Include files, portable
Writing portable C header files can be difficult, since they may be read
by different types of compilers:
@table @asis
@item 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 @code{extern "C"} directive, so that the
names aren't mangled. @xref{C++ libraries}, for other issues relevant
to using C++ with libtool.
@item 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 @code{#include}d.
@item non-ANSI C compilers
Non-ANSI compilers will report errors if functions are prototyped.
@end table
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.
@file{foo.h} in the @file{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:
@example
/* __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
@end example
These macros are used in @file{foo.h} as follows:
@example
#ifndef _FOO_H_
#define _FOO_H_ 1
/* The above macro definitions. */
@dots{}
__BEGIN_DECLS
int foo __P((void));
int hello __P((void));
__END_DECLS
#endif /* !_FOO_H_ */
@end example
Note that the @file{#ifndef _FOO_H_} prevents the body of @file{foo.h}
from being read more than once in a given compilation.
Feel free to copy the definitions of @code{__P}, @code{__BEGIN_DECLS},
and @code{__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:
@itemize @bullet
@item
Pre-ANSI compilers do not always support the @code{void *} generic
pointer type, and so need to use @code{char *} in its place.
@item
The @code{const} and @code{signed} keywords are not supported by some
compilers, especially pre-ANSI compilers.
@item
The @code{long double} type is not supported by many compilers.
@end itemize
@node Inter-library dependencies
@chapter Inter-library dependencies
@cindex Dependencies between libraries
@cindex 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 @dfn{inter-library dependency} is one in which a library depends on
other libraries. For example, if the libtool library @file{libhello}
uses the @code{cos(3)} function, then it has an inter-library dependency
on @file{libm}, the math library that implements @code{cos(3)}.
Some shared library systems provide this feature in an
internally-consistent way: these systems allow chains of dependencies of
potentially infinite length.
However, most shared library systems are restricted in that they only
allow a single level of dependencies. In these systems, programs may
depend on shared libraries, but shared libraries may not depend on other
shared libraries.
In any event, libtool provides a simple mechanism for you to declare
inter-library dependencies: for every library @file{lib@var{name}} that
your own library depends on, simply add a corresponding
@code{-l@var{name}} option to the link line when you create your
library.@footnote{Unfortunately, as of libtool version @value{VERSION},
there is no way to specify inter-library dependencies on libtool
libraries that have not yet been installed.} To make an example of our
@file{libhello} that depends on @file{libm}:
@example
burger$ @kbd{libtool gcc -g -O -o libhello.la foo.lo hello.lo \
-rpath /usr/local/lib -lm}
burger$
@end example
In order to link a program against @file{libhello}, you need to specify
the same @samp{-l} options, in order to guarantee that all the required
libraries are found. This restriction is only necessary to preserve
compatibility with static library systems and simple dynamic library
systems.
If your library depends on symbols that are defined in executables or
static libraries, then you cannot express the dependency with a
@samp{-l@var{name}} flag,@footnote{For static libraries, you
@emph{could} use a @samp{-l} flag, but it would cause conflicts
on systems which have non-PIC objects.} so you need to use the
@samp{-allow-undefined} link flag (@pxref{Link mode}).
@node Dlopened modules
@chapter Dlopened modules
@findex dlopen(3)
@findex dlsym(3)
@findex dlclose(3)
@findex shl_load(3)
@cindex Dynamic linking, applications
@cindex dlopening modules
@cindex Modules, dynamic
@cindex Application-level dynamic linking
It can sometimes be confusing to discuss @dfn{dynamic linking}, because
the term is used to refer to two different concepts:
@enumerate 1
@item
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.
@item
The application calling functions such as
@code{dlopen(3)},@footnote{HP-UX, to be different, uses a function named
@code{shl_load(3)}.} which load arbitrary, user-specified modules at
runtime. This type of dynamic linking is explicitly controlled by the
application.
@end enumerate
To mitigate confusion, this manual refers to the second type of dynamic
linking as @dfn{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.
On most operating systems, dlopened modules must be compiled as PIC.
This restriction simplifies the implementation of the @code{dlopen(3)}
family of functions by avoiding symbol relocation. ``True'' dlopen
implementations, such as the unportable GNU DLD 3 implementation
(@pxref{Top,, Introduction, dld, The DLD Manual}), don't have this
restriction, as they can perform relocation at runtime.
As of version @value{VERSION}, libtool provides only minimal support for
dlopened modules, and this support is guaranteed to change and be
redesigned in the near future. Because there is not a very high
proportion of applications that use dlopening, adding this support to
libtool was not deemed a priority for the 1.0 release.
This chapter discusses the preliminary support that libtool offers, and
how you as a dlopen application developer might use libtool to generate
dlopen-accessible modules. It is important to remember that these are
experimental features, and not to rely on them for easy answers to the
problems associated with dlopened modules.
@menu
* Exporting dynamic symbols:: Preparing files to be dlopened.
* Finding the dlname:: Choosing the right file to @code{dlopen(3)}.
* Dlopen issues:: Unresolved problems that need your attention.
@end menu
@node Exporting dynamic symbols
@section Exporting dynamic symbols
In order for a symbol to be dynamically resolved (typically using the
@code{dlsym(3)} function), it must be specially declared in the object
module where it is defined.
Libtool provides the @samp{-export-dynamic} link flag (@pxref{Link
mode}), which does this declaration. You need to use this flag if you
are linking a shared library that will be dlopened.
For example, if we wanted to build a shared library, @file{libhello},
that would later be dlopened by an application, we would add
@samp{-export-dynamic} to the other link flags:
@example
burger$ @kbd{libtool gcc -export-dynamic -o libhello.la foo.lo \
hello.lo -rpath /usr/local/lib -lm}
burger$
@end example
Another situation where you would use @samp{-export-dynamic} is if
symbols from your @emph{executable} are needed to satisfy unresolved
references in a library you want to dlopen. In this case, you should
use @samp{-export-dynamic} while linking the executable that calls
dlopen:
@example
burger$ @kbd{libtool gcc -export-dynamic -o hell-dlopener main.o}
burger$
@end example
@node Finding the dlname
@section Finding the correct name to dlopen
@cindex Names of dynamic modules
@cindex Dynamic modules, names
After a library has been linked with @samp{-export-dynamic}, it can be
dlopened. Unfortunately, because of the variation in library names,
your package needs to determine the correct file to dlopen.
Dlname mode (@pxref{Dlname mode}) was designed for this purpose. It
returns the name that should be given as the first argument to a
@code{dlopen(3)} function call.
For example, on NetBSD 1.2:
@example
burger$ @kbd{libtool --mode=dlname libhello.la}
libhello.so.3.12
burger$
@end example
The trick is in finding a way to hardcode this name into your program at
compilation time, so that it opens the correct library.
An alternative implementation that avoids hardcoding is to determine the
name at runtime, by finding the installed @samp{.la} file, and searching
it for the following lines:
@example
# The name that we can @code{dlopen(3)}.
dlname='@var{dlname}'
@end example
If @var{dlname} is empty, then the library cannot be dlopened.
Otherwise, it gives the dlname of the library. So, if the library was
installed as @file{/usr/local/lib/libhello.la}, and the @var{dlname} was
@file{libhello.so.3}, then @file{/usr/local/lib/libhello.so.3} should be
dlopened.
If your program uses this approach, then it should search the
directories listed in the @var{LD_LIBRARY_PATH}@footnote{@var{LIBPATH}
on AIX, and @var{SHLIB_PATH} on HP-UX.} environment variable, as well as
the directory where libraries will eventually be installed. Searching
this variable (or equivalent) will guarantee that your program can find
its dlopened modules, even before installation, provided you have linked
them using libtool.
@node Dlopen issues
@section Unresolved dlopen issues
@cindex Pitfalls with dlopen
@cindex Dlopening, pitfalls
@cindex Trouble with dlopen
The following problems are not solved by using libtool's dlopen support:
@itemize @bullet
@item
Dlopen functions are generally only available on shared library
platforms. If you want your package to be portable to static platforms,
you have to develop your own alternatives to dlopening dynamic code.
Most reasonable solutions involve writing wrapper functions for the
@code{dlopen(3)} family, which do package-specific tricks when dlopening
is unsupported or not available on a given platform.
@item
There are major differences in implementations of the @code{dlopen(3)}
family of functions. Some platforms do not even use the same function
names (notably HP-UX, with its @samp{shl_load(3)} family).
@item
It is the burden of the libtool user to find a way to get the results of
dlname mode (@pxref{Dlname mode}) into the call to @code{dlopen(3)}.
@end itemize
Each of these limitations will be addressed in GNU DLD
4.@footnote{Unfortunately, the DLD maintainer is also the libtool
maintainer, so time spent on one of these projects takes time away from
the other. When libtool is reasonably stable, DLD 4 development will
proceed.}
@node Other languages
@chapter Using libtool with other languages
@cindex C, not using
@cindex Languages, non-C
@cindex C++, using
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::
@end menu
@node C++ libraries
@section Writing libraries for C++
@c FIXME: in the TOC, the ++ is too large (seems to be math mode)
@cindex Trouble with C++
@cindex Pitfalls using C++
@cindex C++, pitfalls
Creating libraries of C++ code is a fairly straightforward process, and
differs from C code in only two ways:
@enumerate 1
@item
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.
@item
On some systems, notably SunOS 4, the dynamic linker does not call
non-constant initializers. This can lead to hard-to-pinpoint bugs in
your library. GCC 2.7 and later versions work around this problem, but
previous versions and other compilers do not.
@end enumerate
This second issue is very complex. Basically, you should avoid any
global or static variable initializations that would cause an
``initializer element is not constant'' error if you compiled them with
a standard C compiler.
There are other ways of working around this problem, but they are beyond
the scope of this manual.
@node Troubleshooting
@chapter Troubleshooting
@cindex Troubleshooting
@cindex Problems, solving
@cindex Solving problems
@cindex Problems, blaming somebody else for
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.
@end menu
@node Libtool test suite
@section The libtool test suite
@cindex 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 @file{INSTALL} file, you may run @kbd{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.
@end menu
@node Test descriptions
@subsection Description of test suite
Here is a list of the current programs in the test suite, and what they
test for:
@table @code
@item demo-conf.test
@itemx demo-exec.test
@itemx demo-inst.test
@itemx demo-make.test
@itemx demo-unst.test
@pindex demo-conf.test
@pindex demo-exec.test
@pindex demo-inst.test
@pindex demo-make.test
@pindex demo-unst.test
These programs check to see that the @file{demo} subdirectory of the
libtool distribution can be configured, built, installed, and
uninstalled correctly.
The @file{demo} subdirectory contains a demonstration of a trivial
package that uses libtool.
@item hardcode.test
@pindex hardcode.test
On all systems with shared libraries, the location of the library can be
encoded in executables that are linked against it @pxref{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.
@item link.test
@pindex link.test
This test guarantees that linking directly against a non-libtool static
library works properly.
@item link-2.test
@pindex link-2.test
This test makes sure that files ending in @samp{.lo} are never linked
directly into a program file.
@item suffix.test
@pindex suffix.test
When other programming languages are used with libtool (@pxref{Other
languages}), the source files may end in suffixes other than @samp{.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.
@item test-e.test
@pindex test-e.test
This program checks that the @code{test -e} construct is @emph{never}
used in the libtool scripts. Checking for the existence of a file can
only be done in a portable way by using @code{test -f}.
@end table
@node When tests fail
@subsection When tests fail
@cindex Failed tests
@cindex Tests, failed
Each of the above tests are designed to produce no output when they are
run via @kbd{make check}. The exit status of each program tells the
@file{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
@var{VERBOSE} environment variable to @samp{yes} before running them.
For example, @kbd{env VERBOSE=yes make check} runs all the tests, and
has each of them display debugging information.
@node Reporting bugs
@section Reporting bugs
@cindex Bug reports
@cindex Reporting bugs
@cindex Problem reports
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 (@pxref{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 (@pxref{Bugs, ,
Reporting Bugs, emacs, The Emacs Manual}). Some of the details
listed there are specific to Emacs, but the principle behind them is a
general one.
Finally, send a bug report to @value{BUGADDR} with any appropriate
@emph{facts}, such as test suite output (@pxref{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 @kbd{ltconfig --version}).
Please include the generated @code{libtool} script with your bug report,
so that I can see what values @code{ltconfig} guessed for your system.
@node Maintaining
@chapter Maintainance 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.
@end menu
@node New ports
@section Porting libtool to new systems
To port libtool to a new system, you'll generally need the following
information:
@table @asis
@item man pages for @code{ld(1)} and @code{cc(1)}
These generally describe what flags are used to generate PIC, to create
shared libraries, and to link against only static libraries. You may
need to follow some cross references to find the information that is
required.
@item man pages for @code{ld.so(8)}, @code{rtld(8)}, or equivalent
These are a valuable resource for understanding how shared libraries are
loaded on the system.
@item man page for @code{ldconfig(8)}, or equivalent
This page usually describes how to install shared libraries.
@item output from @kbd{ls -l /lib /usr/lib}
This shows the naming convention for shared libraries on the system,
including which names should be symbolic links.
@item any additional documentation
Some systems have special documentation on how to build and install
shared libraries.
@end table
@node Tested platforms
@section Tested platforms
This table describes when libtool was last known to be tested on
platforms where it claims to support shared libraries:
@example
@include platforms.texi
@end example
@node Platform quirks
@section Platform quirks
This section is dedicated to the sanity of the libtool maintainer. It
describes the programs that libtool uses, how they vary from system to
system, and how to test for them.
Because libtool is a shell script, it is @emph{very} difficult to
understand just by reading it from top to bottom. This section helps
show why libtool does things a certain way. After reading it, then
reading the scripts themselves, you should have a better sense of how to
improve libtool, or write your own.
@menu
* Compilers:: Creating object files from source files.
* Reloadable objects:: Binding object files together.
* Archivers:: Programs that create static archives.
* Strip:: Removing unnecessary linkage information.
@end menu
@node Compilers
@subsection 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:
@table @code
@item gcc
This is the GNU C compiler, which is also the system compiler for many
free operating systems (FreeBSD, GNU/Hurd, Linux/GNU, Lites, NetBSD, and
OpenBSD, to name a few).
The @samp{-fpic} or @samp{-fPIC} flags can be used to generate
position-independent code. @samp{-fPIC} is guaranteed to generate
working code, but the code is slower on m68k, m88k, and Sparc chips.
However, using @samp{-fpic} on those chips imposes arbitrary size limits
on the shared libraries.
@end table
The rest of this subsection lists compilers by the operating system that
they are bundled with:
@c FIXME these should all be better-documented
@table @code
@item aix3*
@itemx aix4*
AIX compilers have no PIC flags, since AIX has been ported only to
PowerPC and RS/6000 chips. @footnote{All code compiled for the PowerPC
and RS/6000 chips (@code{powerpc-*-*}, @code{powerpcle-*-*}, and
@code{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.}
@item hpux10*
Use @samp{+Z} to generate PIC.
@item osf3*
Digital/UNIX 3.x does not have PIC flags, at least not on the PowerPC
platform.
@item solaris2*
Use @samp{-KPIC} to generate PIC.
@item sunos4*
Use @samp{-PIC} to generate PIC.
@end table
@node Reloadable objects
@subsection Reloadable objects
On all known systems, a reloadable object can be created by running
@kbd{ld -r -o @var{output}.o @var{input1}.o @var{input2}.o}. This
reloadable object may be treated as exactly equivalent to other
objects.
@node Archivers
@subsection Archivers
On all known systems, building a static library can be accomplished by
running @kbd{ar cru lib@var{name}.a @var{obj1}.o @var{obj2}.o @dots{}},
where the @samp{.a} file is the output library, and each @samp{.o} file is an
object file.
On all known systems, if there is a program named @code{ranlib}, then it
must be used to ``bless'' the created library before linking against it,
with the @kbd{ranlib lib@var{name}.a} command.
@node Strip
@subsection The @code{strip} program
Stripping a library is essentially the same problem as stripping an
object file. Only local and debugging symbols must be removed, or else
linking against a stripped library will fail.
With GNU @code{strip}, the @samp{--discard-all} (or equivalent
@samp{-x}) flag will do the appropriate stripping, for both shared and
static libraries.
Here is a list of some other operating systems, and what their bundled
@code{strip} programs will do:
@c FIXME complete this section
@table @code
@item netbsd*
The @samp{-x} flag works for shared libraries, but fails with
``Inappropriate file type or format'' when used on static libraries.
@item hpux10*
HP-UX @code{strip} requires the @samp{-r} and @samp{-x} flags in order
to strip libraries.
@end table
@node libtool script contents
@section @code{libtool} script contents
@cindex Implementation of libtool
@cindex libtool implementation
The @code{libtool} script is generated by @code{ltconfig}
(@pxref{Configuring}). Ever since libtool version 0.7, this script
simply sets shell variables, then sources the libtool backend,
@code{ltmain.sh}.
Here is a listing of each of these variables, and how they are used
within @code{ltmain.sh}:
@defvar AR
The name of the system library archiver.
@end defvar
@defvar LD
The name of the linker that libtool should use internally for reloadable
linking and possibly shared libraries.
@end defvar
@defvar LTCONFIG_VERSION
This is set to the version number of the @code{ltconfig} script, to
prevent mismatches between the configuration information in
@code{libtool}, and how that information is used in @code{ltmain.sh}.
@end defvar
@defvar RANLIB
Set to the name of the ranlib program, if any.
@end defvar
@defvar allow_undefined_flag
The flag that is used by @samp{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 @samp{unsupported} if there
is no way to generate a shared library with references to symbols that
aren't defined in that library.
@end defvar
@defvar archive_cmds
@defvarx old_archive_cmds
Commands used to create shared and static libraries, respectively.
@end defvar
@defvar build_libtool_libs
Whether libtool should build shared libraries on this system. Set to
@samp{yes} or @samp{no}.
@end defvar
@defvar build_old_libs
Whether libtool should build static libraries on this system. Set to
@samp{yes} or @samp{no}.
@end defvar
@defvar export_dynamic_flag
Compiler link flag that allows a dlopened shared library to reference
symbols that are defined in the program.
@end defvar
@defvar finish_cmds
Commands to tell the dynamic linker how to find shared libraries in a
specific directory.
@end defvar
@defvar hardcode_action
Either @samp{immediate} or @samp{relink}, depending on whether shared
library paths can be hardcoded into executables before they are installed,
or if they need to be relinked.
@end defvar
@defvar hardcode_direct
Set to @samp{yes} or @samp{no}, depending on whether the linker
hardcodes directories if a library is directly specified on the command
line (such as @samp{@var{dir}/lib@var{name}.a}).
@end defvar
@defvar hardcode_libdir_flag_spec
Flag to hardcode a @var{libdir} variable into a binary, so that the
dynamic linker searches @var{libdir} for shared libraries at runtime.
@end defvar
@defvar hardcode_libdir_separator
If the compiler only accepts a single @var{hardcode_libdir_flag}, then
this variable contains the string that should separate multiple
arguments to that flag.
@end defvar
@defvar hardcode_minus_L
Set to @samp{yes} or @samp{no}, depending on whether the linker
hardcodes directories specified by @samp{-L} flags into the resulting
executable.
@end defvar
@defvar hardcode_runpath_var
Set to @samp{yes} or @samp{no}, depending on whether the linker
hardcodes directories by writing the contents of @samp{$runpath_var}
into the resulting executable.
@end defvar
@defvar hardcode_shlibpath_var
Set to @samp{yes} or @samp{no}, depending on whether the linker
hardcodes directories by writing the contents of @samp{$shlibpath_var}
into the resulting executable. Set to @samp{unsupported} if directories
specified by @samp{$shlibpath_var} are searched at run time, but not at
link time.
@end defvar
@defvar host
@defvarx host_alias
For information purposes, set to the specified and canonical names of
the system that libtool was configured for.
@end defvar
@defvar 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 @samp{-l@var{name}}.
@end defvar
@defvar link_static_flag
Linker flag (passed through the C compiler) used to prevent dynamic
linking.
@end defvar
@defvar pic_flag
Any additional compiler flags for building library object files.
@end defvar
@defvar postinstall_cmds
@defvarx old_postinstall_cmds
Commands run after installing a shared or static library, respectively.
@end defvar
@defvar reload_cmds
@defvarx reload_flag
Commands to create a reloadable object.
@end defvar
@defvar runpath_var
The environment variable that tells the linker which directories to
hardcode in the resulting executable.
@end defvar
@defvar shlibpath_var
The environment variable that tells the dynamic linker where to find
shared libraries.
@end defvar
@defvar soname_spec
The name coded into shared libraries, if different from the real name of
the file.
@end defvar
@defvar striplib
@defvarx old_striplib
Programs to strip shared and static libraries, respectively.@footnote{In
the current implementation, libtool does not use any programs to strip
libraries. Support will be added after it is clear how to write a
portable test for library stripping programs.}
@end defvar
@defvar version_type
The library version numbering type. One of @samp{libtool},
@samp{linux}, @samp{osf}, @samp{sunos}, or @samp{none}.
@end defvar
@defvar wl
The C compiler flag that allows libtool to pass a flag directly to the
linker. Used as: @samp{$@{wl@}@var{some-flag}}.
@end defvar
Variables ending in @samp{_cmds} contain a semicolon-separated list of
commands that are @code{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 @samp{_spec} are @code{eval}ed before being used by
libtool.
@page
@node Index
@unnumbered Index
@printindex cp
@c summarycontents
@contents
@bye