ldd [-d | -r] [-c] [-e envar] [-f] [-i] [-L] [-l] [-p] [-s] [-U | -u] [-v] [-w] filename...
ldd lists the path names of all shared objects that would be loaded when filename is loaded. ldd expects the shared objects that are being inspected to have execute permission. If a shared object does not have execute permission, ldd issues a warning before attempting to process the file.
ldd processes its input one file at a time. For each file, ldd performs one of the following:
The dynamic objects that are inspected by ldd are not executed. Therefore, ldd does not list any shared objects explicitly attached using dlopen(3C). To display all the objects in use by a process, or a core file, use pldd(1).
Only one of the options -d or -r can be specified during any single invocation of ldd.
immediate references are typically to data items used by the executable or shared object code. immediate references are also pointers to functions, and even calls to functions made from a position dependent shared object. lazy references are typically calls to global functions made from a position independent shared object, or calls to external functions made from an executable. For more information on these types of reference, see When Relocations Are Performed in the Linker and Libraries Guide. Object loading can also be affected by relocation processing. See Lazy Loading under USAGE for more details.
Some unresolved symbol references are not reported by default. These unresolved references can be reported with the following options. These options are only useful when combined with either the -d or the -r options.
A shared object can make reference to symbols that should be supplied by the caller of the shared object. These references can be explicitly classified when the shared object is created, as being available from a parent, or simply as being external. See the -M mapfile option of ld(1), and the PARENT and EXTERN symbol definition keywords. When examining a dynamic executable, a parent or external reference that can not be resolved is flagged as an error. However by default, when examining a shared object, a parent or external reference that can not be resolved is not flagged as an error. The -p option, when used with either the -d or -r options, causes any unresolved parent or external reference to be flagged as a relocation error.
Symbols that are used by relocations may be defined as weak references. By default, if a weak symbol reference can not be resolved, the relocation is ignored and a zero written to the relocation offset. The -w option, when used with either the -d or the -r options, causes any unresolved relocation against a weak symbol reference to be flagged as a relocation error.
ldd can also check dependency use. With each of the following options, ldd prints warnings for any unreferenced, or unused dependencies that are loaded when filename is loaded. Only when a symbol reference is bound to a dependency, is that dependency deemed used. These options are therefore only useful when symbol references are being checked. If the -r option is not in effect, the -d option is enabled.
A dependency that is defined by an object but is not bound to from that object is an unreferenced dependency. A dependency that is not bound to by any other object when filename is loaded is an unused object.
Dependencies can be located in default system locations, or in locations that must be specified by search paths. Search paths may be specified globally, such as the environment variable LD_LIBRARY_PATH. Search paths can also be defined in dynamic objects as runpaths. See the -R option to ld(1). Search paths that are not used to satisfy any dependencies cause unnecessary file system processing.
This option also displays any unused search paths.
Only one of the options -U or -u can be specified during any single invocation of ldd, although -U is a superset of -u. Objects that are found to be unreferenced, or unused when using the -r option, should be removed as dependencies. These objects provide no references, but result in unnecessary overhead when filename is loaded. When using the -d option, any objects that are found to be unreferenced, or unused are not immediately required when filename is loaded. These objects are candidates for lazy loading. See Lazy Loading under USAGE for more details.
The removal of unused dependencies reduces runtime-linking overhead. The removal of unreferenced dependencies reduces runtime-linking overhead to a lesser degree. However, the removal of unreferenced dependencies guards against a dependency being unused when combined with different objects, or as the other object dependencies evolve.
The removal of unused search paths can reduce the work required to locate dependencies. This can be significant when accessing files from a file server over a network. Note, a search path can be encoded within an object to satisfy the requirements of dlopen(3C). This search path might not be required to obtain the dependencies of this object, and hence will look unused to ldd.
The following additional options are supported:
This option is useful for experimenting with environment variables that are recognized by the runtime linker that can adversely affect ldd, for example, LD_PRELOAD.
Untrustworthy objects can be safely examined with dump(1) and with mdb(1), as long as the :r subcommand is not used. In addition, a non-superuser can use either the :r subcommand of mdb, or truss(1) to examine an untrustworthy executable without too much risk of compromise. To minimize risk when using ldd, adb :r, or truss on an untrustworthy executable, use the UID "nobody".
example% ldd main libelf.so.1 => /lib/libelf.so.1 libnsl.so.1 => /lib/libnsl.so.1 libc.so.1 => /lib/libc.so.1
The lazy loading behavior that occurs when this object is used at runtime can be enabled using the -L option. In this mode, lazy dependencies are loaded when reference is made to a symbol that is defined within the lazy object. Therefore, combining the -L option with use of the -d and -r options reveals the dependencies that are needed to satisfy the immediate, and lazy references respectively:
example% ldd -L main example% ldd -d main libc.so.1 => /lib/libc.so.1 example% ldd -r main libc.so.1 => /lib/libc.so.1 libelf.so.1 => /lib/libelf.so.1
Notice that in this example, the order of the dependencies that are listed is not the same as displayed from ldd with no options. Even with the -r option, the lazy reference to dependencies might not occur in the same order as would occur in a running program.
Observing lazy loading can also reveal objects that are not required to satisfy any references. These objects, in this example, libnsl.so.1, are candidates for removal from the link-line used to build the object being inspected.
example% ldd -i main libA.so.1 => ./libA.so.1 libc.so.1 => /lib/libc.so.1 libB.so.1 => ./libB.so.1 init object=./libB.so.1 init object=./libA.so.1 init object=/lib/libc.so.1
whereas, when relocations are applied, the initialization section order is:
example% ldd -ir main ......... init object=/lib/libc.so.1 init object=./libB.so.1 init object=./libA.so.1
In this case, libB.so.1 makes reference to a function in /usr/lib/libc.so.1. However, libB.so.1 has no explicit dependency on this library. Only after a relocation is discovered is a dependency then established. This implicit dependency affects the initialization section order.
Typically, the initialization section order established when an application is executed, is equivalent to ldd with the -d option. The optimum order can be obtained if all objects fully define their dependencies. Use of the ld(1) options -zdefs and -zignore when building dynamic objects is recommended.
Cyclic dependencies can result when one or more dynamic objects reference each other. Cyclic dependencies should be avoided, as a unique initialization sort order for these dependencies can not be established.
Linker and Libraries Guide
ldd uses the same algorithm as the runtime linker to locate shared objects.
|April 9, 2016||OmniOS|