This is Info file libtool.info, produced by Makeinfo version 1.67 from the input file libtool.texi. INFO-DIR-SECTION GNU programming tools START-INFO-DIR-ENTRY * Libtool: (libtool). Generic shared library support script. END-INFO-DIR-ENTRY INFO-DIR-SECTION Individual utilities START-INFO-DIR-ENTRY * libtoolize: (libtool)Invoking libtoolize. Adding libtool support. END-INFO-DIR-ENTRY This file documents GNU Libtool 1.2 Copyright (C) 1996-1998 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the Foundation.  File: libtool.info, Node: AM_PROG_LIBTOOL, Prev: ltconfig example, Up: Configuring The `AM_PROG_LIBTOOL' macro --------------------------- If you are using GNU Autoconf (or Automake), you should add a call to `AM_PROG_LIBTOOL' to your `configure.in' file. This macro offers seamless integration between the `configure' script and `ltconfig': - Macro: AM_PROG_LIBTOOL Add support for the `--enable-shared' and `--disable-shared' `configure' flags. Invoke `ltconfig' with the correct arguments to configure the package (*note Invoking ltconfig::.).(1) By default, this macro turns on shared libraries if they are available, and also enables static libraries if they don't conflict with the shared libraries. You can modify these defaults by setting calling either the `AM_DISABLE_SHARED' or `AM_DISABLE_STATIC' macros: # Turn off shared libraries during beta-testing, since they make the # build process take too long. AM_DISABLE_SHARED AM_PROG_LIBTOOL The user may specify a modified form of `--enable-shared' and `--enable-static' to choose whether shared or static libraries are built based on the name of the package. For example, to have shared `bfd' and `gdb' libraries built, but not shared `libg++', you can run all three `configure' scripts as follows: trick$ ./configure --enable-shared=bfd,gdb In general, specifying `--enable-shared=PKGS' is the same as specifying `--enable-shared' to every package named in the PKGS list, and `--disable-shared' to every other package. The `--enable-static=PKGS' flag behaves similarly, except it translates into `--enable-static' and `--disable-static'. The package name `default' matches any packages which have not set their name in the `PACKAGE' environment variable. - Macro: AM_DISABLE_SHARED Change the default behaviour for `AM_PROG_LIBTOOL' to disable shared libraries. The user may still override this default by specifying `--enable-shared'. - Macro: AM_DISABLE_STATIC Change the default behaviour for `AM_PROG_LIBTOOL' to disable static libraries. The user may still override this default by specifying `--enable-static'. When you invoke the `libtoolize' program (*note Invoking libtoolize::.), it will tell you where to find a definition of `AM_PROG_LIBTOOL'. If you use Automake, the `aclocal' program will automatically add `AM_PROG_LIBTOOL' support to your `configure' script. ---------- Footnotes ---------- (1) `AM_PROG_LIBTOOL' requires that you define the `Makefile' variable `top_builddir' in your `Makefile.in'. Automake does this automatically, but Autoconf users should set it to the relative path to the top of your build directory (`../..', for example).  File: libtool.info, Node: Distributing, Next: Static-only libraries, Prev: Configuring, Up: Integrating libtool Including libtool with your package =================================== In order to use libtool, you need to include the following files with your package: `config.guess' Attempt to guess a canonical system name. `config.sub' Canonical system name validation subroutine script. `ltconfig' Generate a libtool script for a given system. `ltmain.sh' A generic script implementing basic libtool functionality. Note that the libtool script itself should *not* be included with your package. *Note Configuring::. You should use the `libtoolize' program, rather than manually copying these files into your package. * Menu: * Invoking libtoolize:: `libtoolize' command line options. * Autoconf .o macros:: Autoconf macros that set object file names.  File: libtool.info, Node: Invoking libtoolize, Next: Autoconf .o macros, Up: Distributing Invoking `libtoolize' --------------------- The `libtoolize' program provides a standard way to add libtool support to your package. In the future, it may implement better usage checking, or other features to make libtool even easier to use. The `libtoolize' program has the following synopsis: libtoolize [OPTION]... and accepts the following options: `--automake' Work silently, and assume that Automake libtool support is used. `libtoolize --automake' is used by Automake to add libtool files to your package, when `AM_PROG_LIBTOOL' appears in your `configure.in'. `--copy' `-c' Copy files from the libtool data directory rather than creating symlinks. `--dry-run' `-n' Don't run any commands that modify the file system, just print them out. `--force' `-f' Replace existing libtool files. By default, `libtoolize' won't overwrite existing files. `--help' Display a help message and exit. `--version' Print `libtoolize' version information and exit. If `libtoolize' detects an explicit call to `AC_CONFIG_AUX_DIR' (*note The Autoconf Manual: (autoconf)Input.) in your `configure.in', it will put the files in the specified directory. `libtoolize' displays hints for adding libtool support to your package, as well.  File: libtool.info, Node: Autoconf .o macros, Prev: Invoking libtoolize, Up: Distributing Autoconf `.o' macros -------------------- The Autoconf package comes with a few macros that run tests, then set a variable corresponding to the name of an object file. Sometimes it is necessary to use corresponding names for libtool objects. Here are the names of variables that list libtool objects: - Variable: LTALLOCA Substituted by `AC_FUNC_ALLOCA' (*note Particular Function Checks: (autoconf)Particular Functions.). Is either empty, or contains `alloca.lo'. - Variable: LTLIBOBJS Substituted by `AC_REPLACE_FUNCS' (*note Generic Function Checks: (autoconf)Generic Functions.), and a few other functions. Unfortunately, the most recent version of Autoconf (2.12, at the time of this writing) does not have any way for libtool to provide support for these variables. So, if you depend on them, use the following code immediately before the call to `AC_OUTPUT' in your `configure.in': LTLIBOBJS=`echo "$LIBOBJS" | sed 's/\.o/.lo/g'` AC_SUBST(LTLIBOBJS) LTALLOCA=`echo "$ALLOCA" | sed 's/\.o/.lo/g'` AC_SUBST(LTALLOCA) AC_OUTPUT(...)  File: libtool.info, Node: Static-only libraries, Prev: Distributing, Up: Integrating libtool Static-only libraries ===================== When you are developing a package, it is often worthwhile to configure your package with the `--disable-shared' flag, or to override the defaults for `AM_PROG_LIBTOOL' by using the `AM_DISABLE_SHARED' Autoconf macro (*note AM_PROG_LIBTOOL::.). This prevents libtool from building shared libraries, which has several advantages: * compilation is twice as fast, which can speed up your development cycle * debugging is easier because you don't need to deal with any complexities added by shared libraries * you can see how libtool behaves on static-only platforms You may want to put a small note in your package `README' to let other developers know that `--disable-shared' can save them time. The following example note is taken from the GIMP(1) distribution `README': The GIMP uses GNU Libtool in order to build shared libraries on a variety of systems. While this is very nice for making usable binaries, it can be a pain when trying to debug a program. For that reason, compilation of shared libraries can be turned off by specifying the `--disable-shared' option to `configure'. ---------- Footnotes ---------- (1) GNU Image Manipulation Program, for those who haven't taken the plunge. See `http://www.gimp.org/'.  File: libtool.info, Node: Versioning, Next: Library tips, Prev: Integrating libtool, Up: Top Library interface versions ************************** The most difficult issue introduced by shared libraries is that of creating and resolving runtime dependencies. Dependencies on programs and libraries are often described in terms of a single name, such as `sed'. So, I may say "libtool depends on sed," and that is good enough for most purposes. However, when an interface changes regularly, we need to be more specific: "Gnus 5.1 requires Emacs 19.28 or above." Here, the description of an interface consists of a name, and a "version number." Even that sort of description is not accurate enough for some purposes. What if Emacs 20 changes enough to break Gnus 5.1? The same problem exists in shared libraries: we require a formal version system to describe the sorts of dependencies that programs have on shared libraries, so that the dynamic linker can guarantee that programs are linked only against libraries that provide the interface they require. * Menu: * Interfaces:: What are library interfaces? * Libtool versioning:: Libtool's versioning system. * Updating version info:: Changing version information before releases. * Release numbers:: Breaking binary compatibility for aesthetics.  File: libtool.info, Node: Interfaces, Next: Libtool versioning, Up: Versioning What are library interfaces? ============================ Interfaces for libraries may be any of the following (and more): * global variables: both names and types * global functions: argument types and number, return types, and function names * standard input, standard output, standard error, and file formats * sockets, pipes, and other inter-process communication protocol formats Note that static functions do not count as interfaces, because they are not directly available to the user of the library.  File: libtool.info, Node: Libtool versioning, Next: Updating version info, Prev: Interfaces, Up: Versioning Libtool's versioning system =========================== Libtool has its own formal versioning system. It is not as flexible as some, but it is definitely the simplest of the more powerful versioning systems. Think of a library as exporting several sets of interfaces, arbitrarily represented by integers. When a program is linked against a library, it may use any subset of those interfaces. Libtool's description of the interfaces that a program uses is simple: it encodes the least and the greatest interface numbers in the resulting binary (FIRST-INTERFACE, LAST-INTERFACE). The dynamic linker is guaranteed that if a library supports *every* interface number between FIRST-INTERFACE and LAST-INTERFACE, then the program can be relinked against that library. Note that this can cause problems because libtool's compatibility requirements are actually stricter than is necessary. Say `libhello' supports interfaces 5, 16, 17, 18, and 19, and that libtool is used to link `test' against `libhello'. Libtool encodes the numbers 5 and 19 in `test', and the dynamic linker will only link `test' against libraries that support *every* interface between 5 and 19. So, the dynamic linker refuses to link `test' against `libhello'! In order to eliminate this problem, libtool only allows libraries to declare consecutive interface numbers. So, `libhello' can declare at most that it supports interfaces 16 through 19. Then, the dynamic linker will link `test' against `libhello'. So, libtool library versions are described by three integers: CURRENT The most recent interface number that this library implements. REVISION The implementation number of the CURRENT interface. AGE The difference between the newest and oldest interfaces that this library implements. In other words, the library implements all the interface numbers in the range from number `CURRENT - AGE' to `CURRENT'. If two libraries have identical CURRENT and AGE numbers, then the dynamic linker chooses the library with the greater REVISION number.  File: libtool.info, Node: Updating version info, Next: Release numbers, Prev: Libtool versioning, Up: Versioning Updating library version information ==================================== If you want to use libtool's versioning system, then you must specify the version information to libtool using the `-version-info' flag during link mode (*note Link mode::.). This flag accepts an argument of the form `CURRENT[:REVISION[:AGE]]'. So, passing `-version-info 3:12:1' sets CURRENT to 3, REVISION to 12, and AGE to 1. If either REVISION or AGE are omitted, they default to 0. Also note that AGE must be less than or equal to the CURRENT interface number. Here are a set of rules to help you update your library version information: 1. Start with version information of `0:0:0' for each libtool library. 2. Update the version information only immediately before a public release of your software. More frequent updates are unnecessary, and only guarantee that the current interface number gets larger faster. 3. If the library source code has changed at all since the last update, then increment REVISION (`C:R:A' becomes `C:R+1:A'). 4. If any interfaces have been added, removed, or changed since the last update, increment CURRENT, and set REVISION to 0. 5. If any interfaces have been added since the last public release, then increment AGE. 6. If any interfaces have been removed since the last public release, then set AGE to 0. **Never** try to set the interface numbers so that they correspond to the release number of your package. This is an abuse that only fosters misunderstanding of the purpose of library versions. Instead, use the `-release' flag (*note Release numbers::.), but be warned that every release of your package will not be binary compatibility with any other release.  File: libtool.info, Node: Release numbers, Prev: Updating version info, Up: Versioning Managing release information ============================ Often, people want to encode the name of the package release into the shared library so that it is obvious to the user which package their programs are linked against. This convention is used especially on Linux: trick$ ls /usr/lib/libbfd* /usr/lib/libbfd.a /usr/lib/libbfd.so.2.7.0.2 /usr/lib/libbfd.so trick$ On `trick', `/usr/lib/libbfd.so' is just a symbolic link to `/usr/lib/libbfd.so.2.7.0.2', which was distributed as a part of `binutils-2.7.0.2'. Unfortunately, this convention conflicts directly with libtool's idea of library interface versions, because the library interface rarely changes at the same time that the release number does, and the library suffix is never the same across all platforms. So, in order to accomodate both views, you can use the `-release' flag in order to set release information for libraries which you do not want to use `-version-info'. For the `libbfd' example, the next release which uses libtool should be built with `-release 2.9.0', which will produce the following files on Linux: trick$ ls /usr/lib/libbfd* /usr/lib/libbfd-2.9.0.so.0 /usr/lib/libbfd.so /usr/lib/libbfd-2.9.0.so.0.0.0 /usr/lib/libbfd.a trick$ In this case, `/usr/lib/libbfd.so' is a symbolic link to `/usr/lib/libbfd-2.9.0.so.0.0.0'. This makes it obvious that the user is dealing with `binutils-2.9.0', without compromising libtool's idea of interface versions. Note that this option actually causes a modification of the library name, so do not use it if unless you want to break binary compatibility with any past library releases. In general, you should only use `-release' for libraries whose interfaces change very frequently.  File: libtool.info, Node: Library tips, Next: Inter-library dependencies, Prev: Versioning, Up: Top Tips for interface design ************************* Writing a good library interface takes a lot of practice and thorough understanding of the problem that the library is intended to solve. If you design a good interface, it won't have to change often, you won't have to keep updating documentation, and users won't have to keep relearning how to use the library. Here is a brief list of tips for library interface design, which may help you in your exploits: Plan ahead Try to make every interface truly minimal, so that you won't need to delete entry points very often. Avoid interface changes Some people love redesigning and changing entry points just for the heck of it (note: *renaming* a function is considered changing an entry point). Don't be one of those people. If you must redesign an interface, then try to leave compatibility functions behind so that users don't need to rewrite their existing code. Use opaque data types The fewer data type definitions a library user has access to, the better. If possible, design your functions to accept a generic pointer (which you can cast to an internal data type), and provide access functions rather than allowing the library user to directly manipulate the data. That way, you have the freedom to change the data structures without changing the interface. This is essentially the same thing as using abstract data types and inheritance in an object-oriented system. Use header files If you are careful to document each of your library's global functions and variables in header files, and include them in your library source files, then the compiler will let you know if you make any interface changes by accident (*note C header files::.). Use the `static' keyword (or equivalent) whenever possible The fewer global functions your library has, the more flexibility you'll have in changing them. Static functions and variables may change forms as often as you like... your users cannot access them, so they aren't interface changes. * Menu: * C header files:: How to write portable include files.  File: libtool.info, Node: C header files, Up: Library tips Writing C header files ====================== Writing portable C header files can be difficult, since they may be read by different types of compilers: C++ compilers C++ compilers require that functions be declared with full prototypes, since C++ is more strongly typed than C. C functions and variables also need to be declared with the `extern "C"' directive, so that the names aren't mangled. *Note C++ libraries::, for other issues relevant to using C++ with libtool. ANSI C compilers ANSI C compilers are not as strict as C++ compilers, but functions should be prototyped to avoid unnecessary warnings when the header file is `#include'd. non-ANSI C compilers Non-ANSI compilers will report errors if functions are prototyped. These complications mean that your library interface headers must use some C preprocessor magic in order to be usable by each of the above compilers. `foo.h' in the `demo' subdirectory of the libtool distribution serves as an example for how to write a header file that can be safely installed in a system directory. Here are the relevant portions of that file: /* __BEGIN_DECLS should be used at the beginning of your declarations, so that C++ compilers don't mangle their names. Use __END_DECLS at the end of C declarations. */ #undef __BEGIN_DECLS #undef __END_DECLS #ifdef __cplusplus # define __BEGIN_DECLS extern "C" { # define __END_DECLS } #else # define __BEGIN_DECLS /* empty */ # define __END_DECLS /* empty */ #endif /* __P is a macro used to wrap function prototypes, so that compilers that don't understand ANSI C prototypes still work, and ANSI C compilers can issue warnings about type mismatches. */ #undef __P #if defined (__STDC__) || defined (_AIX) \ || (defined (__mips) && defined (_SYSTYPE_SVR4)) \ || defined(WIN32) || defined(__cplusplus) # define __P(protos) protos #else # define __P(protos) () #endif These macros are used in `foo.h' as follows: #ifndef _FOO_H_ #define _FOO_H_ 1 /* The above macro definitions. */ ... __BEGIN_DECLS int foo __P((void)); int hello __P((void)); __END_DECLS #endif /* !_FOO_H_ */ Note that the `#ifndef _FOO_H_' prevents the body of `foo.h' from being read more than once in a given compilation. Feel free to copy the definitions of `__P', `__BEGIN_DECLS', and `__END_DECLS' into your own headers. Then, you may use them to create header files that are valid for C++, ANSI, and non-ANSI compilers. Do not be naive about writing portable code. Following the tips given above will help you miss the most obvious problems, but there are definitely other subtle portability issues. You may need to cope with some of the following issues: * Pre-ANSI compilers do not always support the `void *' generic pointer type, and so need to use `char *' in its place. * The `const' and `signed' keywords are not supported by some compilers, especially pre-ANSI compilers. * The `long double' type is not supported by many compilers.  File: libtool.info, Node: Inter-library dependencies, Next: Dlopened modules, Prev: Library tips, Up: Top Inter-library dependencies ************************** By definition, every shared library system provides a way for executables to depend on libraries, so that symbol resolution is deferred until runtime. An "inter-library dependency" is one in which a library depends on other libraries. For example, if the libtool library `libhello' uses the `cos(3)' function, then it has an inter-library dependency on `libm', the math library that implements `cos(3)'. Some shared library systems provide this feature in an internally-consistent way: these systems allow chains of dependencies of potentially infinite length. However, most shared library systems are restricted in that they only allow a single level of dependencies. In these systems, programs may depend on shared libraries, but shared libraries may not depend on other shared libraries. In any event, libtool provides a simple mechanism for you to declare inter-library dependencies: for every library `libNAME' that your own library depends on, simply add a corresponding `-lNAME' option to the link line when you create your library.(1) To make an example of our `libhello' that depends on `libm': burger$ libtool gcc -g -O -o libhello.la foo.lo hello.lo \ -rpath /usr/local/lib -lm burger$ In order to link a program against `libhello', you need to specify the same `-l' options, in order to guarantee that all the required libraries are found. This restriction is only necessary to preserve compatibility with static library systems and simple dynamic library systems. Some platforms, such as AIX, do not even allow you this flexibility. In order to build a shared library, it must be entirely self-contained (that is, have no references to external symbols), and you need to specify the -NO-UNDEFINED flag to allow a shared library to be built. By default, libtool builds only static libraries on these kinds of platforms. ---------- Footnotes ---------- (1) Unfortunately, as of libtool version 1.2, there is no way to specify inter-library dependencies on libtool libraries that have not yet been installed.  File: libtool.info, Node: Dlopened modules, Next: Other languages, Prev: Inter-library dependencies, Up: Top Dlopened modules **************** It can sometimes be confusing to discuss "dynamic linking", because the term is used to refer to two different concepts: 1. Compiling and linking a program against a shared library, which is resolved automatically at run time by the dynamic linker. In this process, dynamic linking is transparent to the application. 2. The application calling functions such as `dlopen(3)',(1) which load arbitrary, user-specified modules at runtime. This type of dynamic linking is explicitly controlled by the application. To mitigate confusion, this manual refers to the second type of dynamic linking as "dlopening" a module. The main benefit to dlopening object modules is the ability to access compiled object code to extend your program, rather than using an interpreted language. In fact, dlopen calls are frequently used in language interpreters to provide an efficient way to extend the language. As of version 1.2, libtool provides experimental support for dlopened modules, which does not radically simplify the development of dlopening applications. However, this support is designed to be a portable foundation for generic, higher-level dlopen functions. This chapter discusses the preliminary support that libtool offers, and how you as a dlopen application developer might use libtool to generate dlopen-accessible modules. It is important to remember that these are experimental features, and not to rely on them for easy answers to the problems associated with dlopened modules. * Menu: * Building modules:: Creating dlopenable objects and libraries. * Dlpreopening:: Dlopening that works on static platforms. * Finding the dlname:: Choosing the right file to `dlopen(3)'. * Dlopen issues:: Unresolved problems that need your attention. ---------- Footnotes ---------- (1) HP-UX, to be different, uses a function named `shl_load(3)'.  File: libtool.info, Node: Building modules, Next: Dlpreopening, Up: Dlopened modules Building modules to dlopen ========================== On some operating systems, a program symbol must be specially declared in order to be dynamically resolved with the `dlsym(3)' (or equivalent) function. Libtool provides the `-export-dynamic' link flag (*note Link mode::.), which does this declaration. You need to use this flag if you are linking an application program that dlopens other modules or a libtool library that will also be dlopened. For example, if we wanted to build a shared library, `libhello', that would later be dlopened by an application, we would add `-export-dynamic' to the other link flags: burger$ libtool gcc -export-dynamic -o libhello.la foo.lo \ hello.lo -rpath /usr/local/lib -lm burger$ Another situation where you would use `-export-dynamic' is if symbols from your *executable* are needed to satisfy unresolved references in a library you want to dlopen. In this case, you should use `-export-dynamic' while linking the executable that calls dlopen: burger$ libtool gcc -export-dynamic -o hell-dlopener main.o burger$  File: libtool.info, Node: Dlpreopening, Next: Finding the dlname, Prev: Building modules, Up: Dlopened modules Dlpreopening ============ Libtool provides special support for dlopening libtool object and libtool library files, so that their symbols can be resolved *even on platforms without any `dlopen(3)' and `dlsym(3)' functions.*. Consider the following alternative ways of loading code into your program, in order of increasing "laziness": 1. Linking against object files that become part of the program executable, whether or not they are referenced. If an object file cannot be found, then the linker refuses to create the executable. 2. Declaring a static library to the linker, so that it is searched at link time in order to satisfy any undefined references in the above object files. If the static library cannot be found, then the linker refuses to link the executable. 3. Declaring a shared library to the runtime linker, so that it is searched at runtime in order to satisfy any undefined references in the above files. If the shared library cannot be found, then the dynamic linker aborts the program before it runs. 4. Dlopening a module, so that the application can resolve its own, dynamically-computed references. If there is an error opening the module, or the module is not found, then the application can recover without crashing. Libtool emulates `-export-dynamic' on static platforms by linking objects into the program at compile time, and creating data structures that represent the program's symbol table. In order to use this feature, you must declare the objects you want your application to dlopen by using the `-dlopen' or `-dlpreopen' flags when you link your program (*note Link mode::.). - Structure: dld_symbol name address The NAME attribute is a 0-terminated character string of the symbol name, such as `"fprintf"'. The ADDRESS attribute is a generic pointer to the appropriate object, which is `&fprintf' in this example. - Variable: dld_symbol * dld_preloaded_symbols An array of DLD_SYMBOL structures, representing all the preloaded symbols linked into the program. The last element has a NAME of `0'. - Variable: int dld_preloaded_symbol_count The number of elements in DLD_PRELOADED_SYMBOLS, if it is sorted in ascending order by NAME. Otherwise, `-1', to indicate that the application needs to sort and count DLD_PRELOADED_SYMBOLS itself, or search it linearly. Some compilers may allow identifiers which are not valid in ANSI C, such as dollar signs. Libtool only recognizes valid ANSI C symbols (an initial ASCII letter or underscore, followed by zero or more ASCII letters, digits, and underscores), so non-ANSI symbols will not appear in DLD_PRELOADED_SYMBOLS.  File: libtool.info, Node: Finding the dlname, Next: Dlopen issues, Prev: Dlpreopening, Up: Dlopened modules Finding the correct name to dlopen ================================== After a library has been linked with `-export-dynamic', it can be dlopened. Unfortunately, because of the variation in library names, your package needs to determine the correct file to dlopen. The most straightforward and flexible implementation is to determine the name at runtime, by finding the installed `.la' file, and searching it for the following lines: # The name that we can `dlopen(3)'. dlname='DLNAME' If DLNAME is empty, then the library cannot be dlopened. Otherwise, it gives the dlname of the library. So, if the library was installed as `/usr/local/lib/libhello.la', and the DLNAME was `libhello.so.3', then `/usr/local/lib/libhello.so.3' should be dlopened. If your program uses this approach, then it should search the directories listed in the LD_LIBRARY_PATH(1) environment variable, as well as the directory where libraries will eventually be installed. Searching this variable (or equivalent) will guarantee that your program can find its dlopened modules, even before installation, provided you have linked them using libtool. ---------- Footnotes ---------- (1) LIBPATH on AIX, and SHLIB_PATH on HP-UX.  File: libtool.info, Node: Dlopen issues, Prev: Finding the dlname, Up: Dlopened modules Unresolved dlopen issues ======================== The following problems are not solved by using libtool's dlopen support: * Dlopen functions are generally only available on shared library platforms. If you want your package to be portable to static platforms, you have to develop your own alternatives to dlopening dynamic code. Most reasonable solutions involve writing wrapper functions for the `dlopen(3)' family, which do package-specific tricks when dlopening is unsupported or not available on a given platform. * There are major differences in implementations of the `dlopen(3)' family of functions. Some platforms do not even use the same function names (notably HP-UX, with its `shl_load(3)' family). * The application developer must write a custom search function in order to discover the correct module filename to supply to `dlopen(3)'. Each of these limitations will be addressed in GNU DLD 4.(1) ---------- Footnotes ---------- (1) Unfortunately, the DLD maintainer is also the libtool maintainer, so time spent on one of these projects takes time away from the other. When libtool is reasonably stable, DLD 4 development will proceed.  File: libtool.info, Node: Other languages, Next: Troubleshooting, Prev: Dlopened modules, Up: Top Using libtool with other languages ********************************** Libtool was first implemented in order to add support for writing shared libraries in the C language. However, over time, libtool is being integrated with other languages, so that programmers are free to reap the benefits of shared libraries in their favorite programming language. This chapter describes how libtool interacts with other languages, and what special considerations you need to make if you do not use C. * Menu: * C++ libraries::  File: libtool.info, Node: C++ libraries, Up: Other languages Writing libraries for C++ ========================= Creating libraries of C++ code is a fairly straightforward process, and differs from C code in only two ways: 1. Because of name mangling, C++ libraries are only usable by the C++ compiler that created them. This decision was made by the designers of C++ in order to protect users from conflicting implementations of features such as constructors, exception handling, and RTTI. 2. On some systems, notably SunOS 4, the dynamic linker does not call non-constant initializers. This can lead to hard-to-pinpoint bugs in your library. GCC 2.7 and later versions work around this problem, but previous versions and other compilers do not. This second issue is complex. Basically, you should avoid any global or static variable initializations that would cause an "initializer element is not constant" error if you compiled them with a standard C compiler. There are other ways of working around this problem, but they are beyond the scope of this manual.  File: libtool.info, Node: Troubleshooting, Next: Maintaining, Prev: Other languages, Up: Top Troubleshooting *************** Libtool is under constant development, changing to remain up-to-date with modern operating systems. If libtool doesn't work the way you think it should on your platform, you should read this chapter to help determine what the problem is, and how to resolve it. * Menu: * Libtool test suite:: Libtool's self-tests. * Reporting bugs:: How to report problems with libtool.  File: libtool.info, Node: Libtool test suite, Next: Reporting bugs, Up: Troubleshooting The libtool test suite ====================== Libtool comes with its own set of programs that test its capabilities, and report obvious bugs in the libtool program. These tests, too, are constantly evolving, based on past problems with libtool, and known deficiencies in other operating systems. As described in the `INSTALL' file, you may run `make check' after you have built libtool (possibly before you install it) in order to make sure that it meets basic functional requirements. * Menu: * Test descriptions:: The contents of the test suite. * When tests fail:: What to do when a test fails.  File: libtool.info, Node: Test descriptions, Next: When tests fail, Up: Libtool test suite Description of test suite ------------------------- Here is a list of the current programs in the test suite, and what they test for: `demo-conf.test' `demo-exec.test' `demo-inst.test' `demo-make.test' `demo-unst.test' These programs check to see that the `demo' subdirectory of the libtool distribution can be configured, built, installed, and uninstalled correctly. The `demo' subdirectory contains a demonstration of a trivial package that uses libtool. `hardcode.test' On all systems with shared libraries, the location of the library can be encoded in executables that are linked against it *note Linking executables::.. This test checks the conditions under which your system linker hardcodes the library location, and guarantees that they correspond to libtool's own notion of how your linker behaves. `link.test' This test guarantees that linking directly against a non-libtool static library works properly. `link-2.test' This test makes sure that files ending in `.lo' are never linked directly into a program file. `suffix.test' When other programming languages are used with libtool (*note Other languages::.), the source files may end in suffixes other than `.c'. This test validates that libtool can handle suffixes for all the file types that it supports, and that it fails when the suffix is invalid. `test-e.test' This program checks that the `test -e' construct is *never* used in the libtool scripts. Checking for the existence of a file can only be done in a portable way by using `test -f'.  File: libtool.info, Node: When tests fail, Prev: Test descriptions, Up: Libtool test suite When tests fail --------------- Each of the above tests are designed to produce no output when they are run via `make check'. The exit status of each program tells the `Makefile' whether or not the test succeeded. If a test fails, it means that there is either a programming error in libtool, or in the test program itself. To investigate a particular test, you may run it directly, as you would a normal program. When the test is invoked in this way, it produces output which may be useful in determining what the problem is. Another way to have the test programs produce output is to set the VERBOSE environment variable to `yes' before running them. For example, `env VERBOSE=yes make check' runs all the tests, and has each of them display debugging information.  File: libtool.info, Node: Reporting bugs, Prev: Libtool test suite, Up: Troubleshooting Reporting bugs ============== If you think you have discovered a bug in libtool, you should think twice: the libtool maintainer is notorious for passing the buck (or maybe that should be "passing the bug"). Libtool was invented to fix known deficiencies in shared library implementations, so, in a way, most of the bugs in libtool are actually bugs in other operating systems. However, the libtool maintainer would definitely be happy to add support for somebody else's buggy operating system. [I wish there was a good way to do winking smiley-faces in texinfo.] Genuine bugs in libtool include problems with shell script portability, documentation errors, and failures in the test suite (*note Libtool test suite::.). First, check the documentation and help screens to make sure that the behaviour you think is a problem is not already mentioned as a feature. Then, you should read the Emacs guide to reporting bugs (*note Reporting Bugs: (emacs)Bugs.). Some of the details listed there are specific to Emacs, but the principle behind them is a general one. Finally, send a bug report to the libtool mailing list <> with any appropriate *facts*, such as test suite output (*note When tests fail::.), all the details needed to reproduce the bug, and a brief description of why you think the behaviour is a bug. Be sure to include the word "libtool" in the subject line, as well as the version number you are using (which can be found by typing `ltconfig --version'). Please include the generated `libtool' script with your bug report, so that I can see what values `ltconfig' guessed for your system.  File: libtool.info, Node: Maintaining, Next: Index, Prev: Troubleshooting, Up: Top Maintenance notes for libtool ***************************** This chapter contains information that the libtool maintainer finds important. It will be of no use to you unless you are considering porting libtool to new systems, or writing your own libtool. * Menu: * New ports:: How to port libtool to new systems. * Tested platforms:: When libtool was last tested. * Platform quirks:: Information about different library systems. * libtool script contents:: Configuration information that libtool uses.  File: libtool.info, Node: New ports, Next: Tested platforms, Up: Maintaining Porting libtool to new systems ============================== To port libtool to a new system, you'll generally need the following information: man pages for `ld(1)' and `cc(1)' These generally describe what flags are used to generate PIC, to create shared libraries, and to link against only static libraries. You may need to follow some cross references to find the information that is required. man pages for `ld.so(8)', `rtld(8)', or equivalent These are a valuable resource for understanding how shared libraries are loaded on the system. man page for `ldconfig(8)', or equivalent This page usually describes how to install shared libraries. output from `ls -l /lib /usr/lib' This shows the naming convention for shared libraries on the system, including which names should be symbolic links. any additional documentation Some systems have special documentation on how to build and install shared libraries.  File: libtool.info, Node: Tested platforms, Next: Platform quirks, Prev: New ports, Up: Maintaining Tested platforms ================ This table describes when libtool was last known to be tested on platforms where it claims to support shared libraries: -------------------------------------------------------- canonical host name compiler libtool results release -------------------------------------------------------- alpha-dec-osf3.2 cc 0.8 ok alpha-dec-osf3.2 gcc 0.8 ok alpha-dec-osf4.0 cc 1.0f ok alpha-dec-osf4.0 gcc 1.0f ok alpha-unknown-linux-gnu gcc 0.9h ok hppa1.1-hp-hpux9.07 cc 1.0f ok hppa1.1-hp-hpux9.07 gcc 1.0f ok hppa1.1-hp-hpux10.10 cc 0.9h ok hppa1.1-hp-hpux10.10 gcc 0.9h ok i386-unknown-freebsd2.1.5 gcc 0.5 ok i386-unknown-gnu0.0 gcc 0.5 ok i386-unknown-netbsd1.2 gcc 0.9g ok i586-pc-linux-gnulibc1 gcc 1.0i ok i586-pc-linux-gnu gcc 1.0i ok mips-sgi-irix5.2 gcc 1.0i ok mips-sgi-irix5.3 cc 0.8 ok mips-sgi-irix5.3 gcc 0.8 ok mips-sgi-irix6.2 cc 0.9 ok mips-sgi-irix6.3 cc 1.0f ok mips-sgi-irix6.3 gcc 1.0i ok mips-sgi-irix6.3 irix5-gcc 1.0f ok mipsel-unknown-openbsd2.1 gcc 1.0 ok powerpc-ibm-aix4.1.4.0 xlc 1.0i ok powerpc-ibm-aix4.1.4.0 gcc 1.0 ok rs6000-ibm-aix3.2.5 xlc 1.0i ok rs6000-ibm-aix3.2.5 gcc 1.0i ok* sparc-sun-linux-gnu2.1.23 gcc 0.9h ok sparc-sun-sunos4.1.3 gcc 1.0i ok sparc-sun-sunos4.1.4 cc 1.0f ok sparc-sun-sunos4.1.4 gcc 1.0f ok sparc-sun-solaris2.4 cc 1.0a ok sparc-sun-solaris2.4 gcc 1.0a ok sparc-sun-solaris2.5 cc 1.0f ok sparc-sun-solaris2.5 gcc 1.0i ok sparc-sun-solaris2.6 gcc 1.0i ok -------------------------------------------------------- * Some versions of GCC's collect2 linker program cannot link trivial static binaries on AIX 3. For these configurations, libtool's `-static' flag has no effect.  File: libtool.info, Node: Platform quirks, Next: libtool script contents, Prev: Tested platforms, Up: Maintaining Platform quirks =============== This section is dedicated to the sanity of the libtool maintainer. It describes the programs that libtool uses, how they vary from system to system, and how to test for them. Because libtool is a shell script, it is difficult to understand just by reading it from top to bottom. This section helps show why libtool does things a certain way. After reading it, then reading the scripts themselves, you should have a better sense of how to improve libtool, or write your own. * Menu: * References:: Finding more information. * Compilers:: Creating object files from source files. * Reloadable objects:: Binding object files together. * Archivers:: Programs that create static archives.  File: libtool.info, Node: References, Next: Compilers, Up: Platform quirks References ---------- The following is a list of valuable documentation references: * SGI's IRIX Manual Pages, `http://techpubs.sgi.com/cgi-bin/infosrch.cgi?cmd=browse&db=man'. * Sun's free service area (`http://www.sun.com/service/online/free.html') and documentation server (`http://docs.sun.com/').  File: libtool.info, Node: Compilers, Next: Reloadable objects, Prev: References, Up: Platform quirks Compilers --------- The only compiler characteristics that affect libtool are the flags needed (if any) to generate PIC objects. In general, if a C compiler supports certain PIC flags, then any derivative compilers support the same flags. Until there are some noteworthy exceptions to this rule, this section will document only C compilers. The following C compilers have standard command line options, regardless of the platform: `gcc' This is the GNU C compiler, which is also the system compiler for many free operating systems (FreeBSD, GNU/Hurd, Linux/GNU, Lites, NetBSD, and OpenBSD, to name a few). The `-fpic' or `-fPIC' flags can be used to generate position-independent code. `-fPIC' is guaranteed to generate working code, but the code is slower on m68k, m88k, and Sparc chips. However, using `-fpic' on those chips imposes arbitrary size limits on the shared libraries. The rest of this subsection lists compilers by the operating system that they are bundled with: `aix3*' `aix4*' AIX compilers have no PIC flags, since AIX has been ported only to PowerPC and RS/6000 chips. (1) `hpux10*' Use `+Z' to generate PIC. `osf3*' Digital/UNIX 3.x does not have PIC flags, at least not on the PowerPC platform. `solaris2*' Use `-KPIC' to generate PIC. `sunos4*' Use `-PIC' to generate PIC. ---------- Footnotes ---------- (1) All code compiled for the PowerPC and RS/6000 chips (`powerpc-*-*', `powerpcle-*-*', and `rs6000-*-*') is position-independent, regardless of the operating system or compiler suite. So, "regular objects" can be used to build shared libraries on these systems and no special PIC compiler flags are required.  File: libtool.info, Node: Reloadable objects, Next: Archivers, Prev: Compilers, Up: Platform quirks Reloadable objects ------------------ On all known systems, a reloadable object can be created by running `ld -r -o OUTPUT.o INPUT1.o INPUT2.o'. This reloadable object may be treated as exactly equivalent to other objects.  File: libtool.info, Node: Archivers, Prev: Reloadable objects, Up: Platform quirks Archivers --------- On all known systems, building a static library can be accomplished by running `ar cru libNAME.a OBJ1.o OBJ2.o ...', where the `.a' file is the output library, and each `.o' file is an object file. On all known systems, if there is a program named `ranlib', then it must be used to "bless" the created library before linking against it, with the `ranlib libNAME.a' command.