This file documents GNU Libtool 2.2 Copyright (C) 1996-2008 Free Software Foundation, Inc. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License". 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 2.2. *Note Reporting bugs::, for information on how to report problems with GNU Libtool. 1 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. 1.1 Motivation for writing libtool ================================== Since early 1995, several different GNU developers have recognized the importance of having shared library support for their packages. The primary motivation for such a change is to encourage modularity and reuse of code (both conceptually and physically) in GNU programs. Such a demand means that the way libraries are built in GNU packages needs to be general, to allow for any library type the package installer might want. The problem is compounded by the absence of a standard procedure for creating shared libraries on different platforms. The following sections outline the major issues facing shared library support in GNU, and how shared library support could be standardized with libtool. The following specifications were used in developing and evaluating this system: 1. The system must be as elegant as possible. 2. The system must be fully integrated with the GNU Autoconf and Automake utilities, so that it will be easy for GNU maintainers to use. However, the system must not require these tools, so that it can be used by non-GNU packages. 3. Portability to other (non-GNU) architectures and tools is desirable. 1.2 Implementation issues ========================= The following issues need to be addressed in any reusable shared library system, specifically libtool: 1. The package installer should be able to control what sort of libraries are built. 2. It can be tricky to run dynamically linked programs whose libraries have not yet been installed. `LD_LIBRARY_PATH' must be set properly (if it is supported), or programs fail to run. 3. The system must operate consistently even on hosts that 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 what prefix or suffix a shared library should be installed. This makes it difficult for `Makefile' rules, since they generally assume that file names are the same from host to host. 6. The system needs a simple library version number abstraction, so that shared libraries can be upgraded in place. The programmer should be informed how to design the interfaces to the library to maximize binary compatibility. 7. The install `Makefile' target should warn the package installer to set the proper environment variables (`LD_LIBRARY_PATH' or equivalent), or run `ldconfig'. 1.3 Other implementations ========================= Even before libtool was developed, many free software packages built and installed their own shared libraries. At first, these packages were examined to avoid reinventing existing features. Now it is clear that none of these packages have documented the details of shared library systems that libtool requires. So, other packages have been more or less abandoned as influences. 1.4 A postmortem analysis of other implementations ================================================== In all fairness, each of the implementations that were examined do the job that they were intended to do, for a number of different host systems. However, none of these solutions seem to function well as a generalized, reusable component. Most were too complex to use (much less modify) without understanding exactly what the implementation does, and they were generally not documented. The main difficulty is that different vendors have different views of what libraries are, and none of the packages that 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. 2 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. 3 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.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'. 3.1 Creating object files ========================= To create an object file from a source file, the compiler is invoked with the `-c' flag (and any other desired flags): burger$ gcc -g -O -c main.c burger$ The above compiler command produces an object file, usually named `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 and uses separate library object files (the PIC one lives in the `.libs' subdirectory and the static one lives in the current directory). On systems without shared libraries, the PIC library object files are not created, whereas on systems where all code is PIC, such as AIX, the static ones are not created. 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 --mode=compile gcc -g -O -c foo.c gcc -g -O -c foo.c -o foo.o a23$ libtool --mode=compile gcc -g -O -c hello.c gcc -g -O -c hello.c -o hello.o a23$ Note that libtool silently creates an additional control file on each `compile' invocation. The `.lo' file is the libtool object, which Libtool uses to determine what object file may be built into a shared library. On `a23', only static libraries are supported so the library objects look like this: # foo.lo - a libtool object file # Generated by ltmain.sh (GNU libtool) 2.2 # # Please DO NOT delete this file! # It is necessary for linking the library. # Name of the PIC object. pic_object=none # Name of the non-PIC object. non_pic_object='foo.o' On shared library systems, libtool automatically generates an additional PIC object by inserting the appropriate PIC generation flags into the compilation command: burger$ libtool --mode=compile gcc -g -O -c foo.c mkdir .libs gcc -g -O -c foo.c -fPIC -DPIC -o .libs/foo.o gcc -g -O -c foo.c -o foo.o >/dev/null 2>&1 burger$ Note that Libtool automatically created `.libs' directory upon its first execution, where PIC library object files will be stored. Since `burger' supports shared libraries, and requires PIC objects to build them, Libtool has compiled a PIC object this time, and made a note of it in the libtool object: # foo.lo - a libtool object file # Generated by ltmain.sh (GNU libtool) 2.2 # # Please DO NOT delete this file! # It is necessary for linking the library. # Name of the PIC object. pic_object='.libs/foo.o' # Name of the non-PIC object. non_pic_object='foo.o' Notice that the second run of GCC has its output discarded. This is done so that compiler warnings aren't annoyingly duplicated. If you need to see both sets of warnings (you might have conditional code inside `#ifdef PIC' for example), you can turn off suppression with the `-no-suppress' option to libtool's compile mode: burger$ libtool --mode=compile gcc -no-suppress -g -O -c hello.c gcc -g -O -c hello.c -fPIC -DPIC -o .libs/hello.o gcc -g -O -c hello.c -o hello.o burger$ 3.2 Linking libraries ===================== Without libtool, the programmer would invoke the `ar' command to create a static library: burger$ ar cru libhello.a hello.o foo.o burger$ But of course, that would be too simple, so many systems require that you run the `ranlib' command on the resulting library (to give it better karma, or something): burger$ ranlib libhello.a burger$ It seems more natural to use the C compiler for this task, given libtool's "libraries are programs" approach. So, on platforms without shared libraries, libtool simply acts as a wrapper for the system `ar' (and possibly `ranlib') commands. Again, the libtool control file name (`.la' suffix) differs from the standard library name (`.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 --mode=link gcc -g -O -o libhello.la foo.o hello.o *** Warning: Linking the shared library libhello.la against the non-libtool *** objects foo.o hello.o is not portable! ar cru .libs/libhello.a ranlib .libs/libhello.a creating libhello.la (cd .libs && rm -f libhello.la && ln -s ../libhello.la libhello.la) a23$ Aha! Libtool caught a common error... trying to build a library from standard objects instead of special `.lo' object files. This doesn't matter so much for static libraries, but on shared library systems, it is of great importance. (Note that you may replace `libhello.la' with `libhello.a' in which case libtool won't issue the warning any more. But although this method works, this is not intended to be used because it makes you lose the benefits of using Libtool.) 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 --mode=link gcc -g -O -o libhello.la foo.lo hello.lo \ -rpath /usr/local/lib -lm ar cru .libs/libhello.a foo.o hello.o ranlib .libs/libhello.a creating libhello.la (cd .libs && rm -f libhello.la && ln -s ../libhello.la libhello.la) a23$ Now, let's try the same trick on the shared library platform: burger$ libtool --mode=link gcc -g -O -o libhello.la foo.lo hello.lo \ -rpath /usr/local/lib -lm rm -fr .libs/libhello.a .libs/libhello.la ld -Bshareable -o .libs/libhello.so.0.0 .libs/foo.o .libs/hello.o -lm ar cru .libs/libhello.a foo.o hello.o ranlib .libs/libhello.a creating libhello.la (cd .libs && rm -f libhello.la && ln -s ../libhello.la 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. Again, you may want to have a look at the `.la' file in order to see what Libtool stores in it. In particular, you will see that Libtool uses this file to remember the destination directory for the library (the argument to `-rpath') as well as the dependency on the math library (`-lm'). ---------- Footnotes ---------- (1) If you don't specify an `rpath', then libtool builds a libtool convenience archive, not a shared library (*note Static libraries::). 3.3 Linking executables ======================= If you choose at this point to "install" the library (put it in a permanent location) before linking executables against it, then you don't need to use libtool to do the linking. Simply use the appropriate `-L' and `-l' flags to specify the library's location. Some system linkers insist on encoding the full directory name of each shared library in the resulting executable. Libtool has to work around this misfeature by special magic to ensure that only permanent directory names are put into installed executables. The importance of this bug must not be overlooked: it won't cause programs to crash in obvious ways. It creates a security hole, and possibly even worse, if you are modifying the library source code after you have installed the package, you will change the behaviour of the installed programs! So, if you want to link programs against the library before you install it, you must use libtool to do the linking. Here's the old way of linking against an uninstalled library: burger$ gcc -g -O -o hell.old main.o libhello.a -lm burger$ Libtool's way is almost the same(1) (*note Link mode::): a23$ libtool --mode=link gcc -g -O -o hell main.o libhello.la 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. Notice that Libtool also remembered that `libhello.la' depends on `-lm', so even though we didn't specify `-lm' on the libtool command line(2) Libtool has added it to the `gcc' link line for us. On `burger' Libtool links against the uninstalled shared library: burger$ libtool --mode=link gcc -g -O -o hell main.o libhello.la 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 -lm However, unless `/usr/local/lib' is in the standard library search path, you won't be able to run `test'. However, if you use libtool to link the already-installed libtool library, it will do The Right Thing (TM) for you: burger$ libtool --mode=link gcc -g -O -o test test.o \ /usr/local/lib/libhello.la gcc -g -O -o .libs/test test.o -Wl,--rpath \ -Wl,/usr/local/lib /usr/local/lib/libhello.a -lm creating test burger$ Note that libtool added the necessary run-time path flag, as well as `-lm', the library libhello.la depended upon. Nice, huh? Notice that the executable, `hell', was actually created in the `.libs' subdirectory. Then, a wrapper script was created in the current directory. 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. 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. (2) And why should we? `main.o' doesn't directly depend on `-lm' after all. 3.4 Debugging executables ========================= If `hell' was a complicated program, you would certainly want to test and debug it before installing it on your system. In the above section, you saw how the libtool wrapper script makes it possible to run the program directly, but unfortunately, this mechanism interferes with the debugger: burger$ gdb hell GDB is free software and you are welcome to distribute copies of it under certain conditions; type "show copying" to see the conditions. There is no warranty for GDB; type "show warranty" for details. GDB 4.16 (i386-unknown-netbsd), (C) 1996 Free Software Foundation, Inc. "hell": not in executable format: File format not recognized (gdb) quit burger$ Sad. It doesn't work because GDB doesn't know where the executable lives. So, let's try again, by invoking GDB directly on the executable: burger$ gdb .libs/hell GNU gdb 5.3 (i386-unknown-netbsd) Copyright 2002 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or 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) 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.0' 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 --mode=execute gdb hell GNU gdb 5.3 (i386-unknown-netbsd) Copyright 2002 Free Software Foundation, Inc. GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or 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) break main Breakpoint 1 at 0x8048547: file main.c, line 29. (gdb) run Starting program: /home/src/libtool/demo/.libs/hell Breakpoint 1, main (argc=1, argv=0xbffffc40) at main.c:29 29 printf ("Welcome to GNU Hell!\n"); (gdb) quit The program is running. Quit anyway (and kill it)? (y or n) y burger$ 3.5 Installing libraries ======================== Installing libraries on a non-libtool system is quite straightforward... just copy them into place:(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 --mode=install cp libhello.la /usr/local/lib/libhello.la cp libhello.la /usr/local/lib/libhello.la cp .libs/libhello.a /usr/local/lib/libhello.a ranlib /usr/local/lib/libhello.a a23# Note that the libtool library `libhello.la' is also installed, to help libtool with uninstallation (*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 --mode=install install -c libhello.la \ /usr/local/lib/libhello.la install -c .libs/libhello.so.0.0 /usr/local/lib/libhello.so.0.0 install -c libhello.la /usr/local/lib/libhello.la install -c .libs/libhello.a /usr/local/lib/libhello.a ranlib /usr/local/lib/libhello.a burger# It is safe to specify the `-s' (strip symbols) flag if you use a BSD-compatible install program when installing libraries. Libtool will either ignore the `-s' flag, or will run a program that will strip only debugging and compiler symbols from the library. Once the libraries have been put in place, there may be some additional configuration that you need to do before using them. First, you must make sure that where the library is installed actually agrees with the `-rpath' flag you used to build it. Then, running `libtool -n 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 strip static libraries though, or they will be unusable. 3.6 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 --mode=install -c hell /usr/local/bin/hell install -c hell /usr/local/bin/hell a23# On shared library systems that require wrapper scripts, libtool just ignores the wrapper script and installs the correct binary: burger# libtool --mode=install -c hell /usr/local/bin/hell install -c .libs/hell /usr/local/bin/hell burger# 3.7 Linking static libraries ============================ Why return to `ar' and `ranlib' silliness when you've had a taste of libtool? Well, sometimes it is desirable to create a static archive that can never be shared. The most frequent case is when you have a set of object files that you use to build several different libraries. You can create a "convenience library" out of those objects, and link against that with the other libraries, instead of listing all the object files every time. 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 using GNU Libtool, though you probably don't want to and hence GNU Automake doesn't allow you to do so. burger$ libtool --mode=install ./install-sh -c libhello.a \ /local/lib/libhello.a ./install-sh -c libhello.a /local/lib/libhello.a ranlib /local/lib/libhello.a burger$ Using libtool for static library installation protects your library from being accidentally stripped (if the installer used the `-s' flag), as well as automatically running the correct `ranlib' command. But libtool libraries are more than just collections of object files: they can also carry library dependency information, which old archives do not. If you want to create a libtool static convenience library, you can omit the `-rpath' flag and use `-static' to indicate that you're only interested in a static library. When you link a program with such a library, libtool will actually link all object files and dependency libraries into the program. If you omit both `-rpath' and `-static', libtool will create a convenience library that can be used to create other libtool libraries, even shared ones. Just like in the static case, the library behaves as an alias to a set of object files and dependency libraries, but in this case the object files are suitable for inclusion in shared libraries. But be careful not to link a single convenience library, directly or indirectly, into a single program or library, otherwise you may get errors about symbol redefinitions. The key is remembering that a convenience library contains PIC objects, and can be linked where a list of PIC objects makes sense; i.e. into a shared library. A static convenience library contains non-PIC objects, so can be linked into an old static library, or a program. When GNU Automake is used, you should use `noinst_LTLIBRARIES' instead of `lib_LTLIBRARIES' for convenience libraries, so that the `-rpath' option is not passed when they are linked. As a rule of thumb, link a libtool convenience library into at most one libtool library, and never into a program, and link libtool static convenience libraries only into programs, and only if you need to carry library dependency information to the user of the static convenience library. Another common situation where static linking is desirable is in creating a standalone binary. Use libtool to do the linking and add the `-all-static' flag. 4 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. When using libtool from the command line, you can give just MODE (or a unique abbreviation of it) as the first argument as a shorthand for the full `--mode=MODE'. MODE must be set to 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 installed libraries or executables. `clean' Delete uninstalled libraries or executables. `--tag=TAG' Use configuration variables from tag TAG (*note Tags::). `--preserve-dup-deps' Do not remove duplicate dependencies in libraries. When building packages with static libraries, the libraries may depend circularly on each other (shared libs can too, but for those it doesn't matter), so there are situations, where -la -lb -la is required, and the second -la may not be stripped or the link will fail. In cases where these duplications are required, this option will preserve them, only stripping the libraries that libtool knows it can safely. `--quiet' `--silent' Do not print out any progress or informational messages. `-v' `--verbose' Print out progress and informational messages (enabled by default). `--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. 4.1 Compile mode ================ For "compile" mode, MODE-ARGS is a compiler command to be used in creating a "standard" object file. These arguments should begin with the name of the C compiler, and contain the `-c' compiler flag so that only an object file is created. Libtool determines the name of the output file by removing the directory component from the source file name, then substituting the source code suffix (e.g. `.c' for C source code) with the library object suffix, `.lo'. If shared libraries are being built, any necessary PIC generation flags are substituted into the compilation command. The following components of MODE-ARGS are treated specially: `-o' 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 --mode=compile 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. `-no-suppress' If both PIC and non-PIC objects are being built, libtool will normally suppress the compiler output for the PIC object compilation to save showing very similar, if not identical duplicate output for each object. If the `-no-suppress' option is given in compile mode, libtool will show the compiler output for both objects. `-prefer-pic' Libtool will try to build only PIC objects. `-prefer-non-pic' Libtool will try to build only non-PIC objects. `-shared' Even if Libtool was configured with `--enable-static', the object file Libtool builds will not be suitable for static linking. Libtool will signal an error if it was configured with `--disable-shared', or if the host does not support shared libraries. `-static' Even if libtool was configured with `--disable-static', the object file Libtool builds *will* be suitable for static linking. `-Wc,FLAG' `-Xcompiler FLAG' Pass a linker specific flag directly to the compiler. `-Wl,FLAG' `-Xlinker FLAG' Pass a linker specific flag directly to the linker. `-XCClinker FLAG' Pass a link specific flag to the compiler driver (CC) during linking. 4.2 Link mode ============= "Link" mode links together object files (including library objects) to form another library or to create an executable program. MODE-ARGS consist of a command using the C compiler to create an output file (with the `-o' flag) from several object files. The following components of MODE-ARGS are treated specially: `-all-static' If OUTPUT-FILE is a program, then do not link it against any shared libraries at all. If OUTPUT-FILE is a library, then only create a static library. `-avoid-version' Tries to avoid versioning (*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', `-static-libtool-libs', 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 the list of preloaded symbols (*note Dlpreopening::). If FILE is `self', the symbols of the program itself will be added to preloaded symbol lists. If FILE is `force' Libtool will make sure that a preloaded symbol list 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-fast-install' Disable fast-install mode for the executable OUTPUT-FILE. Useful if the program won't be necessarily installed. `-no-install' Link an executable OUTPUT-FILE that can't be installed and therefore doesn't need a wrapper script on systems that allow hardcoding of library paths. Useful if the program is only used in the build tree, e.g., for testing or generating other files. `-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. `-objectlist FILE' Use a list of object files found in FILE to specify objects. `-precious-files-regex REGEX' Prevents removal of files from the temporary output directory whose names match this regular expression. You might specify `\.bbg?$' to keep those files created with `gcc -ftest-coverage' for example. `-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. `-shared' If OUTPUT-FILE is a program, then link it against any uninstalled shared libtool libraries (this is the default behavior). If OUTPUT-FILE is a library, then only create a shared library. In the later case, libtool will signal an error if it was configured with `--disable-shared', or if the host does not support shared libraries. `-shrext SUFFIX' If OUTPUT-FILE is a libtool library, replace the system's standard file name extension for shared libraries with SUFFIX (most systems use `.so' here). This option is helpful in certain cases where an application requires that shared libraries (typically modules) have an extension other than the default one. Please note you must supply the full file name extension including any leading dot. `-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. `-static-libtool-libs' If OUTPUT-FILE is a program, then do not link it against any 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. `-version-number MAJOR[:MINOR[:REVISION]]' If OUTPUT-FILE is a libtool library, compute interface version information so that the resulting library uses the specified major, minor and revision numbers. This is designed to permit libtool to be used with existing projects where identical version numbers are already used across operating systems. New projects should use the `-version-info' flag instead. `-weak LIBNAME' if OUTPUT-FILE is a libtool library, declare that it provides a weak LIBNAME interface. This is a hint to libtool that there is no need to append LIBNAME to the list of dependency libraries of OUTPUT-FILE, because linking against OUTPUT-FILE already supplies the same interface (*note Linking with dlopened modules::). `-Wl,FLAG' `-Xlinker FLAG' Pass a linker specific flag directly to the linker. `-XCClinker FLAG' Pass a link specific flag to the compiler driver (CC) during linking. 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. 4.3 Execute mode ================ For "execute" mode, the library path is automatically set, then a program is executed. The first of the MODE-ARGS is treated as a program name, with the rest as arguments to that program. The following components of MODE-ARGS are treated specially: `-dlopen FILE' Add the directory containing FILE to the library path. This mode sets the library path environment variable according to any `-dlopen' flags. If any of the ARGS are libtool executable wrappers, then they are translated into the name of their corresponding uninstalled binary, and any of their required library directories are added to the library path. 4.4 Install mode ================ In "install" mode, libtool interprets most of the elements of MODE-ARGS as an installation command beginning with `cp', or a BSD-compatible `install' program. The following components of MODE-ARGS are treated specially: `-inst-prefix INST-PREFIX-DIR' When installing into a temporary staging area, rather than the final PREFIX, this argument is used to reflect the temporary path, in much the same way `automake' uses DESTDIR. For instance, if PREFIX is `/usr/local', but INST-PREFIX-DIR is `/tmp', then the object will be installed under `/tmp/usr/local/'. If the installed object is a libtool library, then the internal fields of that library will reflect only PREFIX, not INST-PREFIX-DIR: # Directory that this library needs to be installed in: libdir='/usr/local/lib' not # Directory that this library needs to be installed in: libdir='/tmp/usr/local/lib' `inst-prefix' is also used to insure that if the installed object must be relinked upon installation, that it is relinked against the libraries in INST-PREFIX-DIR/PREFIX, not PREFIX. In truth, this option is not really intended for use when calling libtool directly; it is automatically used when `libtool --mode=install' calls `libtool --mode=relink'. Libtool does this by analyzing the destination path given in the original `libtool --mode=install' command and comparing it to the expected installation path established during `libtool --mode=link'. Thus, end-users need change nothing, and `automake'-style `make install DESTDIR=/tmp' will Just Work(tm) most of the time. For systems where fast installation can not be turned on, relinking may be needed. In this case, a `DESTDIR' install will fail. Currently it is not generally possible to install into a temporary staging area that contains needed third-party libraries which are not yet visible at their final location. The rest of the MODE-ARGS are interpreted as arguments to the `cp' or `install' command. The command is run, and any necessary unprivileged post-installation commands are also completed. 4.5 Finish mode =============== "Finish" mode helps system administrators install libtool libraries so that they can be located and linked into user programs. Each MODE-ARG is interpreted as the name of a library directory. Running this command may require superuser privileges, so the `--dry-run' option may be useful. 4.6 Uninstall mode ================== "Uninstall" mode deletes installed libraries, executables and objects. The first MODE-ARG is the name of the program to use to delete files (typically `/bin/rm'). The remaining MODE-ARGS are either flags for the deletion program (beginning with a `-'), or the names of files to delete. 4.7 Clean mode ============== "Clean" mode deletes uninstalled libraries, executables, objects and libtool's temporary files associated with them. The first MODE-ARG is the name of the program to use to delete files (typically `/bin/rm'). The remaining MODE-ARGS are either flags for the deletion program (beginning with a `-'), or the names of files to delete. 5 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. 5.1 Autoconf macros exported by libtool ======================================= Libtool uses a number of macros to interrogate the host system when it is being built, and you can use some of them yourself too. Although there are a great many other macros in the libtool installed m4 files, these do not form part of the published interface, and are subject to change between releases. Macros in the `LT_CMD_' namespace check for various shell commands: -- Macro: LT_CMD_MAX_LEN Finds the longest command line that can be safely passed to `$SHELL' without being truncated, and store in the shell variable `$max_cmd_len'. It is only an approximate value, but command lines of this length or shorter are guaranteed not to be truncated. Macros in the `LT_FUNC_' namespace check characteristics of library functions: -- Macro: LT_FUNC_DLSYM_USCORE `AC_DEFINE' the preprocessor symbol `DLSYM_USCORE' if we have to add an underscore to symbol-names passed in to `dlsym'. Macros in the `LT_LIB_' namespace check characteristics of system libraries: -- Macro: LT_LIB_M Set `LIBM' to the math library or libraries required on this machine, if any. -- Macro: LT_LIB_DLLOAD This is the macro used by `libltdl' to determine which dlloaders to use on this machine, if any. Several shell variables are set (and `AC_SUBST'ed) depending on the dlload interfaces are available on this machine. `LT_DLLOADERS' contains a list of libtool libraries that can be used, and if necessary also sets `LIBADD_DLOPEN' if additional system libraries are required by the `dlopen' loader, and `LIBADD_SHL_LOAD' if additional system libraries are required by the `shl_load' loader, respectively. Finally some symbols are set in `config.h' depending on the loaders that are found to work: `HAVE_LIBDL', `HAVE_SHL_LOAD', `HAVE_DYLD', `HAVE_DLD'. Macros in the `LT_PATH_' namespace search the system for the full path to particular system commands: -- Macro: LT_PATH_LD Add a `--with-gnu-ld' option to `configure'. Try to find the path to the linker used by `$CC', and whether it is the GNU linker. The result is stored in the shell variable `$LD', which is `AC_SUBST'ed. -- Macro: LT_PATH_NM Try to find a BSD compatible `nm' or a MS compatible `dumpbin' command on this machine. The result is stored in the shell variable `$NM', which is `AC_SUBST'ed. Macros in the `LT_SYS_' namespace probe for system characteristics: -- Macro: LT_SYS_DLOPEN_SELF Tests whether a program can dlopen itself, and then also whether the same program can still dlopen itself when statically linked. Results are stored in the shell variables `$enable_dlopen_self' and `enable_dlopen_self_static' respectively. -- Macro: LT_SYS_DLOPEN_DEPLIBS Define the preprocessor symbol `LTDL_DLOPEN_DEPLIBS' if the OS needs help to load dependent libraries for `dlopen' (or equivalent). -- Macro: LT_SYS_DLSEARCH_PATH Define the preprocessor symbol `LT_DLSEARCH_PATH' to the system default library search path. -- Macro: LT_SYS_MODULE_EXT Define the preprocessor symbol `LT_MODULE_EXT' to the extension used for runtime loadable modules. If you use libltdl to open modules, then you can simply use the libtool library extension, `.la'. -- Macro: LT_SYS_MODULE_PATH Define the preprocessor symbol `LT_MODULE_PATH_VAR' to the name of the shell environment variable that determines the run-time module search path. -- Macro: LT_SYS_SYMBOL_USCORE Set the shell variable `sys_symbol_underscore' to `no' unless the compiler prefixes global symbols with an underscore. 5.2 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, and you don't know how to incorporate libtool into your package you need to do one of the following: 1. Download the latest Automake distribution 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 `tests/demo' subdirectory of the libtool distribution... note especially that it was automatically generated from the `Makefile.am' by Automake). 5.3 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'(1) variable: 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 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. ---------- Footnotes ---------- (1) Since GNU Automake 1.5, the flags `-dlopen' or `-dlpreopen' (*note Link mode::) can be employed with the PROGRAM_LDADD variable. Unfortunately, older releases didn't accept these flags, so if you are stuck with an ancient Automake, we recommend quoting the flag itself, and setting PROGRAM_DEPENDENCIES too: program_LDADD = "-dlopen" libfoo.la program_DEPENDENCIES = libfoo.la 5.4 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 the compiler suite and operating system that 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 `Makefile's (and possibly a `config.h' header file), after which you can run `make' and build the package. Libtool adds its own tests to your `configure' script in order to generate a libtool script for the installer's host machine. 5.4.1 The `LT_INIT' macro ------------------------- If you are using GNU Autoconf (or Automake), you should add a call to `LT_INIT' to your `configure.ac' file. This macro adds many new tests to the `configure' script so that the generated libtool script will understand the characteristics of the host. It's the most important of a number of macros defined by Libtool: -- Macro: LT_PREREQ (VERSION) Ensure that a recent enough version of Libtool is being used. If the version of Libtool used for `LT_INIT' is earlier than VERSION, print an error message to the standard error output and exit with failure (exit status is 63). For example: LT_PREREQ([2.2]) -- Macro: LT_INIT (OPTIONS) -- Macro: AC_PROG_LIBTOOL -- Macro: AM_PROG_LIBTOOL Add support for the `--enable-shared' and `--disable-shared' `configure' flags.(1) `AC_PROG_LIBTOOL' and `AM_PROG_LIBTOOL' are deprecated names for older versions of this macro; `autoupdate' will upgrade your `configure.ac' files. 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 passing either `disable-shared' or `disable-static' in the option list to `LT_INIT', or using `AC_DISABLE_SHARED' or `AC_DISABLE_STATIC'. # Turn off shared libraries during beta-testing, since they # make the build process take too long. LT_INIT([disable-shared]) 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 that 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.ac': LT_INIT 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'. Aside from `disable-static' and `disable-shared', there are other options that you can pass to `LT_INIT' to modify its behaviour. Here is a full list: `dlopen' Enable checking for dlopen support. This option should be used if the package makes use of the `-dlopen' and `-dlpreopen' libtool flags, otherwise libtool will assume that the system does not support dlopening. `win32-dll' This option 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. Provision must be made to pass `-no-undefined' to `libtool' in link mode from the package `Makefile'. Naturally, if you pass `-no-undefined', you must ensure that all the library symbols *really are* defined at link time! `disable-fast-install' Change the default behaviour for `LT_INIT' to disable optimization for fast installation. The user may still override this default, depending on platform support, by specifying `--enable-fast-install' to `configure'. `shared' Change the default behaviour for `LT_INIT' to enable shared libraries. This is the default on all systems where Libtool knows how to create shared libraries. The user may still override this default by specifying `--disable-shared' to `configure'. `disable-shared' Change the default behaviour for `LT_INIT' to disable shared libraries. The user may still override this default by specifying `--enable-shared' to `configure'. `static' Change the default behaviour for `LT_INIT' to enable static libraries. This is the default on all systems where shared libraries have been disabled for some reason, and on most systems where shared libraries have been enabled. If shared libraries are enabled, the user may still override this default by specifying `--disable-static' to `configure'. `disable-static' Change the default behaviour for `LT_INIT' to disable static libraries. The user may still override this default by specifying `--enable-static' to `configure'. `pic-only' Change the default behaviour for `libtool' to try to use only PIC objects. The user may still override this default by specifying `--without-pic' to `configure'. `no-pic' Change the default behaviour of `libtool' to try to use only non-PIC objects. The user may still override this default by specifying `--with-pic' to `configure'. -- Macro: LT_LANG (LANGUAGE) Enable `libtool' support for the language given if it has not yet already been enabled. Languages accepted are "C++", "Fortran 77", "Java" and "Windows Resource". If Autoconf language support macros such as `AC_PROG_CXX' are used in your `configure.ac', Libtool language support will automatically be enabled. Conversely using `LT_LANG' to enable language support for Libtool will automatically enable Autoconf language support as well. Both of the following examples are therefore valid ways of adding C++ language support to Libtool. LT_INIT LT_LANG([C++]) LT_INIT AC_PROG_CXX -- Macro: AC_LIBTOOL_DLOPEN This macro is deprecated, the `dlopen' option to `LT_INIT' should be used instead. -- Macro: AC_LIBTOOL_WIN32_DLL This macro is deprecated, the `win32-dll' option to `LT_INIT' should be used instead. -- Macro: AC_DISABLE_FAST_INSTALL This macro is deprecated, the `disable-fast-install' option to `LT_INIT' should be used instead. -- Macro: AC_DISABLE_SHARED -- Macro: AM_DISABLE_SHARED Change the default behaviour for `LT_INIT' to disable shared libraries. The user may still override this default by specifying `--enable-shared'. The option `disable-shared' to `LT_INIT' is a shorthand for this. `AM_DISABLE_SHARED' is a deprecated alias for `AC_DISABLE_SHARED'. -- Macro: AC_ENABLE_SHARED -- Macro: AM_ENABLE_SHARED Change the default behaviour for `LT_INIT' to enable shared libraries. This is the default on all systems where Libtool knows how to create shared libraries. The user may still override this default by specifying `--disable-shared'. The option `shared' to `LT_INIT' is a shorthand for this. `AM_ENABLE_SHARED' is a deprecated alias for `AC_ENABLE_SHARED'. -- Macro: AC_DISABLE_STATIC -- Macro: AM_DISABLE_STATIC Change the default behaviour for `LT_INIT' to disable static libraries. The user may still override this default by specifying `--enable-static'. The option `disable-static' to `LT_INIT' is a shorthand for this. `AM_DISABLE_STATIC' is a deprecated alias for `AC_DISABLE_STATIC'. -- Macro: AC_ENABLE_STATIC -- Macro: AM_ENABLE_STATIC Change the default behaviour for `LT_INIT' to enable static libraries. This is the default on all systems where shared libraries have been disabled for some reason, and on most systems where shared libraries have been enabled. If shared libraries are enabled, the user may still override this default by specifying `--disable-static'. The option `static' to `LT_INIT' is a shorthand for this. `AM_ENABLE_STATIC' is a deprecated alias for `AC_ENABLE_STATIC'. The tests in `LT_INIT' also recognize the following environment variables: -- Variable: CC The C compiler that will be used by the generated `libtool'. If this is not set, `LT_INIT' will look for `gcc' or `cc'. -- Variable: CFLAGS Compiler flags used to generate standard object files. If this is not set, `LT_INIT' will not use any such flags. It affects only the way `LT_INIT' runs tests, not the produced `libtool'. -- Variable: CPPFLAGS C preprocessor flags. If this is not set, `LT_INIT' will not use any such flags. It affects only the way `LT_INIT' runs tests, not the produced `libtool'. -- Variable: LD The system linker to use (if the generated `libtool' requires one). If this is not set, `LT_INIT' will try to find out what is the linker used by CC. -- Variable: LDFLAGS The flags to be used by `libtool' when it links a program. If this is not set, `LT_INIT' will not use any such flags. It affects only the way `LT_INIT' runs tests, not the produced `libtool'. -- Variable: LIBS The libraries to be used by `LT_INIT' when it links a program. If this is not set, `LT_INIT' will not use any such flags. It affects only the way `LT_INIT' 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. `LT_INIT' will check for a suitable program if this variable is not set. -- 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 used on Cygwin/MS-Windows at the moment. With 1.3 era libtool, if you wanted to know any details of what libtool had discovered about your architecture and environment, you had to run the script with `--config' and grep through the results. This idiom was supported up to and including 1.5.x era libtool, where it was possible to call the generated libtool script from `configure.ac' as soon as `LT_INIT' had completed. However, one of the features of libtool 1.4 was that the libtool configuration was migrated out of a separate `ltconfig' file, and added to the `LT_INIT' macro (nee `AC_PROG_LIBTOOL'), so the results of the configuration tests were available directly to code in `configure.ac', rendering the call out to the generated libtool script obsolete. Starting with libtool 2.0, the multipass generation of the libtool script has been consolidated into a single `config.status' pass, which happens after all the code in `configure.ac' has completed. The implication of this is that the libtool script does not exist during execution of code from `configure.ac', and so obviously it cannot be called for `--config' details anymore. If you are upgrading projects that used this idiom to libtool 2.0 or newer, you should replace those calls with direct references to the equivalent Autoconf shell variables that are set by the configure time tests before being passed to `config.status' for inclusion in the generated libtool script. -- Macro: LT_OUTPUT By default, the configured `libtool' script is generated by the call to `AC_OUTPUT' command, and there is rarely any need to use `libtool' from `configure'. However, sometimes it is necessary to run configure time compile and link tests using `libtool'. You can add `LT_OUTPUT' to your `configure.ac' any time after `LT_INIT' and any `LT_LANG' calls; that done, `libtool' will be created by a specially generated `config.lt' file, and available for use in later tests. Also, when `LT_OUTPUT' is used, for backwards compatibility with Automake regeneration rules, `config.status' will call `config.lt' to regenerate `libtool', rather than generating the file itself. When you invoke the `libtoolize' program (*note Invoking libtoolize::), it will tell you where to find a definition of `LT_INIT'. If you use Automake, the `aclocal' program will automatically add `LT_INIT' support to your `configure' script when it sees the invocation of `LT_INIT' in `configure.ac'. Because of these changes, and the runtime version compatibility checks Libtool now executes, we now advise *against* including a copy of `libtool.m4' (and brethren) in `acinclude.m4'. Instead, you should set your project macro directory with `AC_CONFIG_MACRO_DIR'. When you `libtoolize' your project, a copy of the relevant macro definitions will be placed in your `AC_CONFIG_MACRO_DIR', where `aclocal' can reference them directly from `aclocal.m4'. ---------- Footnotes ---------- (1) `LT_INIT' requires that you define the `Makefile' variable `top_builddir' in your `Makefile.in'. Automake does this automatically, but Autoconf users should set it to the relative path to the top of your build directory (`../..', for example). 5.4.2 Platform-specific configuration notes ------------------------------------------- While Libtool tries to hide as many platform-specific features as possible, some have to be taken into account when configuring either the Libtool package or a libtoolized package. * You currently need GNU make to build the Libtool package itself. * On AIX there are two different styles of shared linking, one in which symbols are bound at link-time and one in which symbols are bound at runtime only, similar to ELF. In case of doubt use `LDFLAGS=-Wl,-brtl' for the latter style. * On AIX, native tools are to be preferred over binutils; especially for C++ code, if using the AIX Toolbox GCC 4.0 and binutils, configure with `AR=/usr/bin/ar LD=/usr/bin/ld NM='/usr/bin/nm -B''. * On AIX, the `/bin/sh' is very slow due to its inefficient handling of here-documents. A modern shell is preferable: CONFIG_SHELL=/bin/bash; export $CONFIG_SHELL $CONFIG_SHELL ./configure [...] * For C++ code with templates, it may be necessary to specify the way the compiler will generate the instantiations. For Portland pgCC version5, use `CXX='pgCC --one_instantiation_per_object'' and avoid parallel `make'. * On Darwin, for C++ code with templates you need two level shared libraries. Libtool builds these by default if `MACOSX_DEPLOYMENT_TARGET' is set to 10.3 or later at `configure' time. See `rdar://problem/4135857' for more information on this issue. * The default shell on UNICOS 9, a ksh 88e variant, is too buggy to correctly execute the libtool script. Users are advised to install a modern shell such as GNU bash. * Some HP-UX `sed' 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. * 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''. * Any earlier DG/UX system with ELF executables, such as R3.10 or R4.10, is also likely to work, but hasn't been explicitly tested. * On Reliant Unix libtool has only been tested with the Siemens C-compiler and an old version of `gcc' provided by Marco Walther. * `libtool.m4', `ltdl.m4' and the `configure.ac' files are marked to use autoconf-mode, which is distributed with GNU Emacs 21, Autoconf itself, and all recent releases of XEmacs. * When building on some linux systems for multilib targets `libtool' sometimes guesses the wrong paths that the linker and dynamic linker search by default. If this occurs, you may override libtool's guesses at `configure' time by setting the `autoconf' cache variables `lt_cv_sys_lib_search_path_spec' and `lt_cv_sys_lib_dlsearch_path_spec' respectively to the correct search paths. 5.5 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. `install-sh' BSD-compatible `install' replacement script. `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. 5.5.1 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: `--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 [TARGET-DIRECTORY-NAME]' Install libltdl in the TARGET-DIRECTORY-NAME subdirectory of your package. Normally, the directory is extracted from the argument to `LT_CONFIG_LTDL_DIR' in `configure.ac', though you can also specify a subdirectory name here if you are not using Autoconf for example. If `libtoolize' can't determine the target directory, `libltdl' is used as the default. `--nonrecursive' If passed in conjunction with `--ltdl', this option will cause the `libltdl' installed by `libtoolize' to be set up for use with a non-recursive `automake' build. To make use of it, you will need to add the following to the `Makefile.am' of the parent project: ## libltdl/Makefile.inc appends to the following variables ## so we set them here before including it: BUILT_SOURCES = AM_CPPFLAGS = AM_LDFLAGS = include_HEADERS = noinst_LTLIBRARIES = lib_LTLIBRARIES = EXTRA_LTLIBRARIES = EXTRA_DIST = CLEANFILES = MOSTLYCLEANFILES = include libltdl/Makefile.inc `--quiet' `-q' Work silently. `libtoolize --quiet' is used by GNU Automake to add libtool files to your package if necessary. `--recursive' If passed in conjunction with `--ltdl', this option will cause the `libtoolize' installed `libltdl' to be set up for use with a recursive `automake' build. To make use of it, you will need to adjust the parent project's `configure.ac': AC_CONFIG_FILES([libltdl/Makefile]) and `Makefile.am': SUBDIRS += libltdl `--subproject' If passed in conjunction with `--ltdl', this option will cause the `libtoolize' installed `libltdl' to be set up for independent configuration and compilation as a self-contained subproject. To make use of it, you should arrange for your build to call `libltdl/configure', and then run `make' in the `libltdl' directory (or the subdirectory you put libltdl into). If your project uses Autoconf, you can use the supplied `LT_WITH_LTDL' macro, or else call `AC_CONFIG_SUBDIRS' directly. Previous releases of `libltdl' built exclusively in this mode, but now it is the default mode both for backwards compatibility and because, for example, it is suitable for use in projects that wish to use `libltdl', but not use the Autotools for their own build process. `--verbose' `-v' Work noisily! Give a blow by blow account of what `libtoolize' is doing. `--version' Print `libtoolize' version information and exit. If `libtoolize' detects an explicit call to `AC_CONFIG_MACRO_DIR' (*note The Autoconf Manual: (autoconf)Input.) in your `configure.ac', it will put the Libtool macros in the specified directory. In the future other Autotools will automatically check the contents of `AC_CONFIG_MACRO_DIR', but at the moment it is more portable to add the macro directory to `ACLOCAL_AMFLAGS' in `Makefile.am', which is where the tools currently look. If `libtoolize' doesn't see `AC_CONFIG_MACRO_DIR', it too will honour the first `-I' argument in `ACLOCAL_AMFLAGS' when choosing a directory to store libtool configuration macros in. It is perfectly sensible to use both `AC_CONFIG_MACRO_DIR' and `ACLOCAL_AMFLAGS', as long as they are kept in synchronisation. ACLOCAL_AMFLAGS = -I m4 When you bootstrap your project with `aclocal', then you will need to explicitly pass the same macro directory with `aclocal''s `-I' flag: trick$ aclocal -I m4 If `libtoolize' detects an explicit call to `AC_CONFIG_AUX_DIR' (*note The Autoconf Manual: (autoconf)Input.) in your `configure.ac', it will put the other support files in the specified directory. Otherwise they too end up in the project root directory. `libtoolize' displays hints for adding libtool support to your package, as well. 5.5.2 Autoconf and `LTLIBOBJS' ------------------------------ People used to add code like the following to their `configure.ac': LTLIBOBJS=`echo "$LIBOBJS" | sed 's/\.[^.]* /.lo /g;s/\.[^.]*$/.lo/'` AC_SUBST([LTLIBOBJS]) This is no longer required (since Autoconf 2.54), and doesn't take Automake's deansification support into account either, so doesn't work correctly even with ancient Autoconfs! Provided you are using a recent (2.54 or better) incarnation of Autoconf, the call to `AC_OUTPUT' takes care of setting `LTLIBOBJS' up correctly, so you can simply delete such snippets from your `configure.ac' if you had them. 5.6 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 `LT_INIT' by using the `disable-shared' option (*note The `LT_INIT' macro: LT_INIT.). 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/'. 6 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. 6.1 Writing libraries for C++ ============================= Creating libraries of C++ code should be a fairly straightforward process, because its object files differ from C ones in only three ways: 1. Because of name mangling, C++ libraries are only usable by the C++ compiler that created them. This decision was made by the designers of C++ in order to protect users from conflicting implementations of features such as constructors, exception handling, and RTTI. 2. On some systems, the C++ compiler must take special actions for the dynamic linker to run dynamic (i.e., run-time) initializers. This means that we should not call `ld' directly to link such libraries, and we should use the C++ compiler instead. 3. C++ compilers will link some Standard C++ library in by default, but libtool does not know which are these libraries, so it cannot even run the inter-library dependence analyzer to check how to link it in. Therefore, running `ld' to link a C++ program or library is deemed to fail. Because of these three issues, Libtool has been designed to always use the C++ compiler to compile and link C++ programs and libraries. In some instances the `main()' function of a program must also be compiled with the C++ compiler for static C++ objects to be properly initialized. 6.2 Tags ======== Libtool supports multiple languages through the use of tags. Technically a tag corresponds to a set of configuration variables associated with a language. These variables tell `libtool' how it should create objects and libraries for each language. Tags are defined at `configure'-time for each language activated in the package (see `LT_LANG' in *note LT_INIT::). Here is the correspondence between language names and tags names. Language name Tag name C CC C++ CXX Java GCJ Fortran 77 F77 Fortran FC Windows Resource RC `libtool' tries to automatically infer which tag to use from the compiler command being used to compile or link. If it can't infer a tag, then it defaults to the configuration for the `C' language. The tag can also be specified using `libtool''s `--tag=TAG' option (*note Invoking libtool::). It is a good idea to do so in `Makefile' rules, because that will allow users to substitute the compiler without relying on `libtool' inference heuristics. When no tag is specified, `libtool' will default to `CC'; this tag always exists. Finally, the set of tags available in a particular project can be retrieved by tracing for the `LT_SUPPORTED_TAG' macro (*note Trace interface::). 7 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. 7.1 What are library interfaces? ================================ Interfaces for libraries may be any of the following (and more): * global variables: both names and types * global functions: argument types and number, return types, and function names * standard input, standard output, standard error, and file formats * sockets, pipes, and other inter-process communication protocol formats Note that static functions do not count as interfaces, because they are not directly available to the user of the library. 7.2 Libtool's versioning system =============================== Libtool has its own formal versioning system. It is not as flexible as some, but it is definitely the simplest of the more powerful versioning systems. Think of a library as exporting several sets of interfaces, arbitrarily represented by integers. When a program is linked against a library, it may use any subset of those interfaces. Libtool's description of the interfaces that a program uses is simple: it encodes the least and the greatest interface numbers in the resulting binary (FIRST-INTERFACE, LAST-INTERFACE). The dynamic linker is guaranteed that if a library supports _every_ interface number between FIRST-INTERFACE and LAST-INTERFACE, then the program can be relinked against that library. Note that this can cause problems because libtool's compatibility requirements are actually stricter than is necessary. Say `libhello' supports interfaces 5, 16, 17, 18, and 19, and that libtool is used to link `test' against `libhello'. Libtool encodes the numbers 5 and 19 in `test', and the dynamic linker will only link `test' against libraries that support _every_ interface between 5 and 19. So, the dynamic linker refuses to link `test' against `libhello'! In order to eliminate this problem, libtool only allows libraries to declare consecutive interface numbers. So, `libhello' can declare at most that it supports interfaces 16 through 19. Then, the dynamic linker will link `test' against `libhello'. So, libtool library versions are described by three integers: CURRENT The most recent interface number that this library implements. REVISION The implementation number of the CURRENT interface. AGE The difference between the newest and oldest interfaces that this library implements. In other words, the library implements all the interface numbers in the range from number `CURRENT - AGE' to `CURRENT'. If two libraries have identical CURRENT and AGE numbers, then the dynamic linker chooses the library with the greater REVISION number. 7.3 Updating library version information ======================================== If you want to use libtool's versioning system, then you must specify the version information to libtool using the `-version-info' flag during link mode (*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. 7.4 Managing release information ================================ Often, people want to encode the name of the package release into the shared library so that it is obvious to the user which package their programs are linked against. This convention is used especially on GNU/Linux: trick$ ls /usr/lib/libbfd* /usr/lib/libbfd.a /usr/lib/libbfd.so.2.7.0.2 /usr/lib/libbfd.so trick$ On `trick', `/usr/lib/libbfd.so' is a symbolic link to `libbfd.so.2.7.0.2', which was distributed as a part of `binutils-2.7.0.2'. Unfortunately, this convention conflicts directly with libtool's idea of library interface versions, because the library interface rarely changes at the same time that the release number does, and the library suffix is never the same across all platforms. So, in order to accommodate both views, you can use the `-release' flag in order to set release information for libraries for which you do not want to use `-version-info'. For the `libbfd' example, the next release that 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. 8 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 that 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 (that 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. Be careful with array dimensions The number of elements in a global array is part of an interface, even if the header just declares `extern int foo[];'. This is because on i386 and some other SVR4/ELF systems, when an application references data in a shared library the size of that data (whatever its type) is included in the application executable. If you might want to change the size of an array or string then provide a pointer not the actual array. 8.1 Writing C header files ========================== Writing portable C header files can be difficult, since they may be read by different types of compilers: C++ compilers C++ compilers require that functions be declared with full prototypes, since C++ is more strongly typed than C. C functions and variables also need to be declared with the `extern "C"' directive, so that the names aren't mangled. *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 `tests/demo' subdirectory of the libtool distribution serves as an example for how to write a header file that can be safely installed in a system directory. Here are the relevant portions of that file: /* BEGIN_C_DECLS should be used at the beginning of your declarations, so that C++ compilers don't mangle their names. Use END_C_DECLS at the end of C declarations. */ #undef BEGIN_C_DECLS #undef END_C_DECLS #ifdef __cplusplus # define BEGIN_C_DECLS extern "C" { # define END_C_DECLS } #else # define BEGIN_C_DECLS /* empty */ # define END_C_DECLS /* empty */ #endif /* PARAMS is a macro used to wrap function prototypes, so that compilers that don't understand ANSI C prototypes still work, and ANSI C compilers can issue warnings about type mismatches. */ #undef PARAMS #if defined (__STDC__) || defined (_AIX) \ || (defined (__mips) && defined (_SYSTYPE_SVR4)) \ || defined(WIN32) || defined(__cplusplus) # define PARAMS(protos) protos #else # define PARAMS(protos) () #endif These macros are used in `foo.h' as follows: #ifndef FOO_H #define FOO_H 1 /* The above macro definitions. */ #include "..." BEGIN_C_DECLS int foo PARAMS((void)); int hello PARAMS((void)); END_C_DECLS #endif /* !FOO_H */ Note that the `#ifndef FOO_H' prevents the body of `foo.h' from being read more than once in a given compilation. Also the only thing that must go outside the `BEGIN_C_DECLS'/`END_C_DECLS' pair are `#include' lines. Strictly speaking it is only C symbol names that need to be protected, but your header files will be more maintainable if you have a single pair of of these macros around the majority of the header contents. You should use these definitions of `PARAMS', `BEGIN_C_DECLS', and `END_C_DECLS' into your own headers. Then, you may use them to create header files that are valid for C++, ANSI, and non-ANSI compilers(1). 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', `inline' and `signed' keywords are not supported by some compilers, especially pre-ANSI compilers. * The `long double' type is not supported by many compilers. ---------- Footnotes ---------- (1) We used to recommend `__P', `__BEGIN_DECLS' and `__END_DECLS'. This was bad advice since symbols (even preprocessor macro names) that begin with an underscore are reserved for the use of the compiler. 9 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. To make an example of our `libhello' that depends on `libm': burger$ libtool --mode=link gcc -g -O -o libhello.la foo.lo hello.lo \ -rpath /usr/local/lib -lm burger$ When you link a program against `libhello', you don't need to specify the same `-l' options again: libtool will do that for you, in order to guarantee that all the required libraries are found. This restriction is only necessary to preserve compatibility with static library systems and simple dynamic library systems. Some platforms, such as AIX, do not even allow you this flexibility. In order to build a shared library, it must be entirely self-contained (that is, have references only to symbols that are found in the `.lo' files or the specified `-l' libraries), and you need to specify the `-no-undefined' flag. By default, libtool builds only static libraries on these kinds of platforms. The simple-minded inter-library dependency tracking code of libtool releases prior to 1.2 was disabled because it was not clear when it was possible to link one library with another, and complex failures would occur. A more complex implementation of this concept was re-introduced before release 1.3, but it has not been ported to all platforms that libtool supports. The default, conservative behavior is to avoid linking one library with another, introducing their inter-dependencies only when a program is linked with them. 10 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' that 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 2.2, libtool provides support for dlopened modules. However, you should indicate that your package is willing to use such support, by using the `LT_INIT' option `dlopen' in `configure.ac'. If this option is not given, 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. 10.1 Building modules to dlopen =============================== On some operating systems, a program symbol must be specially declared in order to be dynamically resolved with the `dlsym' (or equivalent) function. Libtool provides the `-export-dynamic' and `-module' link flags (*note Link mode::), for you to make that 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, `hello', that would later be dlopened by an application, we would add `-module' to the other link flags: burger$ libtool --mode=link gcc -module -o hello.la foo.lo \ hello.lo -rpath /usr/local/lib -lm burger$ If symbols from your _executable_ are needed to satisfy unresolved references in a library you want to dlopen you will have to use the flag `-export-dynamic'. You should use `-export-dynamic' while linking the executable that calls dlopen: burger$ libtool --mode=link gcc -export-dynamic -o helldl main.o burger$ 10.2 Dlpreopening ================= Libtool provides special support for dlopening libtool object and libtool library files, so that their symbols can be resolved _even on platforms without any `dlopen' and `dlsym' functions_. Consider the following alternative ways of loading code into your program, in order of increasing "laziness": 1. Linking against object files that become part of the program executable, whether or not they are referenced. If an object file cannot be found, then the compile time 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 compile time linker refuses to create 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_dlsymbol { const char *NAME; void *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'. -- Structure: struct lt_dlsymlist { const char *ORIGINATOR; const lt_dlsymbol SYMBOLS[]; } The ORIGINATOR attribute is a null-terminated character string, naming the compilation unit that SYMBOLS were preloaded on behalf of. This is usually the basename of a library, `libltdl.la' has a corresponding ORIGINATOR value of `libltdl'; if the SYMBOLS are for the benefit of the application proper, then ORIGINATOR is `@PROGRAM@', though Libtool takes care of that detail if you use `LTDL_SET_PRELOADED_SYMBOLS'. -- Variable: const lt_dlsymlist * lt_preloaded_symbols An array of LT_SYMBOL structures, representing all the preloaded symbols linked into the program proper. For each module `-dlpreopen'ed by the Libtool linked program there is an element with the NAME of the module 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 of all has a NAME and ADDRESS of `0'. Some compilers may allow identifiers that 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. -- 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 int main() { /* ... */ LTDL_SET_PRELOADED_SYMBOLS(); /* ... */ } -- Function Type: int lt_dlpreload_callback_func (lt_dlhandle HANDLE) Functions of this type can be passed to `lt_dlpreload_open', which in turn will call back into a function thus passed for each preloaded module that it opens. -- Function: int lt_dlpreload_open (const char *ORIGINATOR, lt_dlpreload_callback_func *FUNC) Load all of the preloaded modules for ORIGINATOR. For every module opened in this way, call FUNC. To open all of the modules preloaded into `libhell.la' (presumably from within the `libhell.a' initialisation code): #define preloaded_symbols lt_libhell_LTX_preloaded_symbols static int hell_preload_callback (lt_dlhandle handle); int hell_init (void) { ... if (lt_dlpreload (&preloaded_symbols) == 0) { lt_dlpreload_open ("libhell", preload_callback); } ... } Note that to prevent clashes between multiple preloaded modules, the preloaded symbols are accessed via a mangled symbol name: to get the symbols preloaded into `libhell', you must prefix `preloaded_symbols' with `lt_'; the originator name, `libhell' in this case; and `_LTX_'. That is, `lt_libhell_LTX_preloaded_symbols' here. 10.3 Linking with dlopened modules ================================== When, say, an interpreter application uses dlopened modules to extend the list of methods it provides, an obvious abstraction for the maintainers of the interpreter is to have all methods (including the built in ones supplied with the interpreter) accessed through dlopen. For one thing, the dlopening functionality will be tested even during routine invocations. For another, only one subsystem has to be written for getting methods into the interpreter. The downside of this abstraction is, of course, that environments that provide only static linkage can't even load the intrinsic interpreter methods. Not so! We can statically link those methods by *dlpreopening* them. Unfortunately, since platforms such as AIX and cygwin require that all library symbols must be resolved at compile time, the interpreter maintainers will need to provide a library to both its own dlpreopened modules, and third-party modules loaded by dlopen. In itself, that is not so bad, except that the interpreter too must provide those same symbols otherwise it will be impossible to resolve all the symbols required by the modules as they are loaded. Things are even worse if the code that loads the modules for the interpreter is itself in a library - and that is usually the case for any non-trivial application. Modern platforms take care of this by automatically loading all of a module's dependency libraries as the module is loaded (libltdl can do this even on platforms that can't do it by themselves). In the end, this leads to problems with duplicated symbols and prevents modules from loading, and prevents the application from compiling when modules are preloaded. ,-------------. ,------------------. ,-----------------. | Interpreter |----> Module------------> Third-party | `-------------' | Loader | |Dlopened Modules | | | | `-----------------' |,-------v--------.| | || Dlpreopened || | || Modules || | |`----------------'| | | | | | |,-------v--------.| ,--------v--------. ||Module Interface|| |Module Interface | || Library || | Library | |`----------------'| `-----------------' `------------------' Libtool has the concept of "weak library interfaces" to circumvent this problem. Recall that the code that dlopens method-provider modules for the interpreter application resides in a library: All of the modules and the dlopener library itself should be linked against the common library that resolves the module symbols at compile time. To guard against duplicate symbol definitions, and for dlpreopened modules to work at all in this scenario, the dlopener library must declare that it provides a weak library interface to the common symbols in the library it shares with the modules. That way, when `libtool' links the *Module Loader* library with some *Dlpreopened Modules* that were in turn linked against the *Module Interface Library*, it knows that the *Module Loader* provides an already loaded *Module Interface Library* to resolve symbols for the *Dlpreopened Modules*, and doesn't ask the compiler driver to link an identical *Module Interface Library* dependency library too. In conjunction with Automake, the `Makefile.am' for the *Module Loader* might look like this: lib_LTLIBRARIES = libinterface.la libloader.la libinterface_la_SOURCES = interface.c interface.h libinterface_la_LDFLAGS = -version-info 3:2:1 libloader_la_SOURCES = loader.c libloader_la_LDFLAGS = -weak libinterface.la \ -version-info 3:2:1 \ -dlpreopen ../modules/intrinsics.la libloader_la_LIBADD = $(libinterface_la_OBJECTS) And the `Makefile.am' for the `intrinsics.la' module in a sibling `modules' directory might look like this: AM_CPPFLAGS = -I$(srcdir)/../libloader AM_LDFLAGS = -no-undefined -module -avoid-version \ -export-dynamic noinst_LTLIBRARIES = intrinsics.la intrinsics_la_LIBADD = ../libloader/libinterface.la ../libloader/libinterface.la: cd ../libloader && $(MAKE) $(AM_MAKEFLAGS) libinterface.la For a more complex example, see the sources of `libltdl' in the Libtool distribution, which is built with the help of the `-weak' option. 10.4 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. 10.5 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'. 11 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 few headers and small C source files 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) * `NSAddImage' or `NSLinkModule' (Darwin and Mac OS X) * 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 Lesser General Public License, if you distribute this file as part of a program or library that is built using GNU Libtool, you may include it under the same distribution terms that you use for the rest of that program. 11.1 How to use libltdl in your programs ======================================== The libltdl API is similar to the dlopen interface of Solaris and Linux, which is very simple but powerful. To use libltdl in your program you have to include the header file `ltdl.h': #include The early releases of libltdl used some symbols that violated the POSIX namespace conventions. These symbols are now deprecated, and have been replaced by those described here. If you have code that relies on the old deprecated symbol names, defining `LT_NON_POSIX_NAMESPACE' before you include `ltdl.h' provides conversion macros. Whichever set of symbols you use, the new API is not binary compatible with the last, so you will need to recompile your application in order to use this version of libltdl. Note that libltdl is not well tested in a multithreaded environment, though the intention is that it should work (*note Using libltdl in a multi threaded environment: Thread Safety in 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 macros are defined by including `ltdl.h': -- Macro: LT_PATHSEP_CHAR `LT_PATHSEP_CHAR' is the system-dependent path separator, that is, `;' on Windows and `:' everywhere else. -- Macro: LT_DIRSEP_CHAR If `LT_DIRSEP_CHAR' is defined, it can be used as directory separator in addition to `/'. On Windows, this contains `\'. The following types are defined in `ltdl.h': -- Type: lt_dlhandle `lt_dlhandle' is a module "handle". Every lt_dlopened module has a handle associated with it. -- Type: lt_dladvise `lt_dladvise' is used to control optional module loading modes. If it is not used, the default mode of the underlying system module loader is used. -- 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 modules(1). Unresolved symbols in the module are resolved using its dependency libraries 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 look in the following search paths for the module (in the following order): 1. user-defined search path: This search path can be changed by the program using the functions `lt_dlsetsearchpath', `lt_dladdsearchdir' and `lt_dlinsertsearchdir'. 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 list of absolute directories separated by `LT_PATHSEP_CHAR', for example, `"/usr/lib/mypkg:/lib/foo"'. The directory names may not contain the path separator. 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 dynamically loadable modules 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_dladvise_init (lt_dladvise *ADVISE) The ADVISE parameter can be used to pass hints to the module loader when using `lt_dlopenadvise' to perform the loading. The ADVISE parameter needs to be initialised by this function before it can be used. Any memory used by ADVISE needs to be recycled with `lt_dladvise_destroy' when it is no longer needed. On failure, `lt_dladvise_init' returns non-zero and sets an error message that can be retrieved with `lt_dlerror'. -- Function: int lt_dladvise_destroy (lt_dladvise *ADVISE) Recycle the memory used by ADVISE. For an example, see the documentation for `lt_dladvise_ext'. On failure, `lt_dladvise_destroy' returns non-zero and sets an error message that can be retrieved with `lt_dlerror'. -- Function: int lt_dladvise_ext (lt_dladvise *ADVISE) Set the `ext' hint on ADVISE. Passing an ADVISE parameter to `lt_dlopenadvise' with this hint set causes it to try to append different file name extensions like `lt_dlopenext'. The following example is equivalent to calling `lt_dlopenext (filename)': lt_dlhandle my_dlopenext (const char *filename) { lt_dlhandle handle = 0; lt_dladvise advise; if (!lt_dladvise_init (&advise) && !lt_dladvise_ext (&advise)) handle = lt_dlopenadvise (filename, &advise); lt_dladvise_destroy (&advise); return handle; } On failure, `lt_dladvise_ext' returns non-zero and sets an error message that can be retrieved with `lt_dlerror'. -- Function: int lt_dladvise_global (lt_dladvise *ADVISE) Set the `symglobal' hint on ADVISE. Passing an ADVISE parameter to `lt_dlopenadvise' with this hint set causes it to try to make the loaded module's symbols globally available for resolving unresolved symbols in subsequently loaded modules. If neither the `symglobal' nor the `symlocal' hints are set, or if a module is loaded without using the `lt_dlopenadvise' call in any case, then the visibility of the module's symbols will be as per the default for the underlying module loader and OS. Even if a suitable hint is passed, not all loaders are able to act upon it in which case `lt_dlgetinfo' will reveal whether the hint was actually followed. On failure, `lt_dladvise_global' returns non-zero and sets an error message that can be retrieved with `lt_dlerror'. -- Function: int lt_dladvise_local (lt_dladvise *ADVISE) Set the `symlocal' hint on ADVISE. Passing an ADVISE parameter to `lt_dlopenadvise' with this hint set causes it to try to keep the loaded module's symbols hidden so that they are not visible to subsequently loaded modules. If neither the `symglobal' nor the `symlocal' hints are set, or if a module is loaded without using the `lt_dlopenadvise' call in any case, then the visibility of the module's symbols will be as per the default for the underlying module loader and OS. Even if a suitable hint is passed, not all loaders are able to act upon it in which case `lt_dlgetinfo' will reveal whether the hint was actually followed. On failure, `lt_dladvise_local' returns non-zero and sets an error message that can be retrieved with `lt_dlerror'. -- Function: int lt_dladvise_resident (lt_dladvise *ADVISE) Set the `resident' hint on ADVISE. Passing an ADVISE parameter to `lt_dlopenadvise' with this hint set causes it to try to make the loaded module resident in memory, so that it cannot be unloaded with a later call to `lt_dlclose'. On failure, `lt_dladvise_resident' returns non-zero and sets an error message that can be retrieved with `lt_dlerror'. -- 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: void * 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_dladdsearchdir (const char *SEARCH_DIR) Append the search directory SEARCH_DIR to the current user-defined library search path. Return 0 on success. -- Function: int lt_dlinsertsearchdir (const char *BEFORE, const char *SEARCH_DIR) Insert the search directory SEARCH_DIR into the user-defined library search path, immediately before the element starting at address BEFORE. If BEFORE is `NULL', then SEARCH_DIR is appending as if `lt_dladdsearchdir' had been called. 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 list of absolute directories separated by `LT_PATHSEP_CHAR'. Return 0 on success. -- Function: const char * lt_dlgetsearchpath (void) Return the current user-defined library search path. -- Function: int lt_dlforeachfile (const char *SEARCH_PATH, int (*FUNC) (const char *FILENAME, void * DATA), void * DATA) In some applications you may not want to load individual modules with known names, but rather find all of the modules in a set of directories and load them all during initialisation. With this function you can have libltdl scan the `LT_PATHSEP_CHAR'-delimited directory list in SEARCH_PATH for candidates, and pass them, along with DATA to your own callback function, FUNC. If SEARCH_PATH is `NULL', then search all of the standard locations that `lt_dlopen' would examine. This function will continue to make calls to FUNC for each file that it discovers in SEARCH_PATH until one of these calls returns non-zero, or until the files are exhausted. `lt_dlforeachfile' returns the value returned by the last call made to FUNC. For example you could define FUNC to build an ordered "argv"-like vector of files using DATA to hold the address of the start of the vector. -- Function: int lt_dlmakeresident (lt_dlhandle HANDLE) Mark a module so that it cannot be `lt_dlclose'd. This can be useful if a module implements some core functionality in your project that would cause your code to crash if removed. Return 0 on success. If you use `lt_dlopen (NULL)' to get a HANDLE for the running binary, that handle will always be marked as resident, and consequently cannot be successfully `lt_dlclose'd. -- Function: int lt_dlisresident (lt_dlhandle HANDLE) Check whether a particular module has been marked as resident, returning 1 if it has or 0 otherwise. If there is an error while executing this function, return -1 and set an error message for retrieval with `lt_dlerror'. ---------- Footnotes ---------- (1) Some platforms, notably Mac OS X, differentiate between a runtime library that cannot be opened by `lt_dlopen' and a dynamic module that can. For maximum portability you should try to ensure that you only pass `lt_dlopen' objects that have been compiled with libtool's `-module' flag. 11.2 Creating modules that can be `dlopen'ed ============================================ Libtool modules are created like normal libtool libraries with a few