dld.so.5 (2012 03)

ManualsBrandsHP ManualsSoftwareHP-UX Manpages

dld.so(5)

Itanium(R)-based Systems Only

dld.so(5)

NAME

dld.so - dynamic loader

MULTITHREAD USAGE

The dynamic loader is thread-safe.

DESCRIPTION

The

/usr/lib/hpux64/dld.so

shared library is the 64-bit dynamic loader. The

/usr/lib/hpux32/dld.so

shared library is the 32-bit dynamic loader. In programs that use shared

libraries,

dld.so is invoked automatically at startup time.

/usr/ccs/lib/hpux64/crt0.o

is the

64-bit run-time startup ﬁle.

/usr/ccs/lib/hpux32/crt0.o

is the 32-bit run-time startup ﬁle. The

/usr/lib/hpux32/uld.so

and /usr/lib/hpux64/uld.so

shared libraries are the 32-bit and

64-bit microloaders. In programs that use shared libraries, the microloader is invoked automatically at

startup time by exec(2). The microloader’s sole responsibility is to load the dynamic loader,

dld.so

, into

memory for program execution. The microloaders (

uld.so

) and the dynamic loaders (dld.so) are,

themselves, shared libraries, although they deﬁne no symbols for use by user programs.

Shared Libraries

Shared libraries are executable ﬁles created with the

-b option to ld (see ld(1)). They must contain

position-independent code (PIC) that can be mapped anywhere in the address space of a process and exe-

cuted with minimal relocation. PIC can use PC-relative addressing modes and/or linkage tables. The HP

compilers generate PIC by default.

Incomplete Executables

An executable program linked with one or more shared libraries is called an incomplete executable.

When creating an executable (

a.out) ﬁle from object ﬁles and libraries, the linker does not copy text

(code) or data from the shared library into the output ﬁle. Instead, the dynamic loader maps the library

into the address space of the process at run time. The linker binds all program references to shared

library routines and data to entries in a linkage table, and relies on the dynamic loader to ﬁll in the link-

age table entries once the libraries have been mapped. This linkage table serves as a jump table for func-

tion calls.

Thread local storage

Two thread local storage models are supported: static and dynamic, which is controlled by a compiler

option

+tls=static/dynamic

. The default is +tls=dynamic. Shared libraries built with the

dynamic model can be loaded using dlopen (3C) and shl_load (3X) APIs. An attempt to load a shared

library built with the static model using dlopen (3C) or shl_load (3X) APIs will result in the following

error:

/usr/lib/hpux[32|64]/dld.so: Can’t shl_load() a library containing

Thread Local Storage: /usr/lib/hpux[32|64]/libcps.so.1

The dynamic loader tallies each shared library’s thread local storage size as well as the program’s thread

local storage size. When all libraries are loaded, the dynamic loader invokes an initializer in the system

library libc, which does the thread initialization, allocation of the initial thread, and sets the thread

pointer.

An incomplete executable contains a list of path names of the shared libraries searched at link time. At

run time, the dynamic loader attaches to the process all shared libraries that were linked with the pro-

gram. The dynamic loader attempts to load each library from the same directory in which it was found at

link time. It is possible to change the shared library run time search path by specifying a dynamic path

list. (For PA-RISC 32-bit compatibility mode information, see Dynamic Path List .)

The text segment of a library is shared among all processes that use it. The data and bss (uninitialized

data) segments are loaded on a page-by-page basis. When a process ﬁrst accesses (reads or writes) a data

or bss page, a copy of that page is made for the process.

Dynamic Path List

For default mode libraries, the dynamic loader uses dynamic path searching to ﬁnd shared libraries

whose names appear in a library list of the program or loaded shared libraries with no embedded

/ char-

acter. Dynamic path searching is enabled by default for these libraries or executables. If ld

+noenvvar is speciﬁed, the dynamic loader does not look at any dynamic path environment variables to

ﬁnd dependent shared libraries. This limits the dynamic path searching to the value of rpath (run time

HP-UX 11i Version 3: March 2012 − 1 − Hewlett-Packard Company 1

Summary of content (8 pages)

PAGE 1
dld.so(5) Itanium(R)-based Systems Only dld.so(5) NAME dld.so - dynamic loader MULTITHREAD USAGE The dynamic loader is thread-safe. DESCRIPTION The /usr/lib/hpux64/dld.so shared library is the 64-bit dynamic loader. The /usr/lib/hpux32/dld.so shared library is the 32-bit dynamic loader. In programs that use shared libraries, dld.so is invoked automatically at startup time. /usr/ccs/lib/hpux64/crt0.o is the 64-bit run-time startup file. /usr/ccs/lib/hpux32/crt0.o is the 32-bit run-time startup file.
PAGE 2
dld.so(5) dld.so(5) Itanium(R)-based Systems Only path or embedded path set by the ld +b command) and the default directory /usr/lib/hpux64 for 64-bit libraries or the default directory /usr/lib/hpux32 for 32-bit libraries.
PAGE 3
dld.so(5) Itanium(R)-based Systems Only dld.so(5) function call that could potentially reference the object. If the -B immediate option to ld is used, the loader binds all necessary references at startup time. This increases the startup cost of a program, but ensures that no more binding operations are required later. Thus, better real-time response may result, and the risk of a later abort due to unresolved externals is eliminated.
PAGE 4
dld.so(5) dld.so(5) Itanium(R)-based Systems Only With the global symbol table, the dynamic loader may need to perform a large number of hashing operations to locate symbols. Performing this hash function may cost considerable time, especially when symbol names are very long (C++ programs). To speed up dld, computing hash values can be off-loaded to the linker. Use the +gst options, +gst, +gstsize, and +nodynhash, to control the behavior of the global symbol table hash mechanism.
PAGE 5
dld.so(5) -nofastbind dld.so(5) Itanium(R)-based Systems Only See fastbind (1). The LD_PRELOAD Environment Variable NOTE: The LD_PRELOAD feature is disabled for seteuid/setegid programs, such as passwd. See ld(1) for more details. This feature is not available to fully-bound static executables. The LD_PRELOAD environment variable allows you to load additional shared libraries at program startup.
PAGE 6
dld.so(5) dld.so(5) Itanium(R)-based Systems Only certain libraries preloaded while the child application is adversely affected if these are preloaded (for example, ksh terminates abnormally if LD_PRELOAD contains /usr/lib/hpux[32|64]/libpthread.1). The libraries specified by LD_PRELOAD_ONCE are loaded before the ones specified by LD_PRELOAD. The effect on symbol resolution is that the symbols from libraries specified by LD_PRELOAD_ONCE take precedence over symbols from libraries specified by LD_PRELOAD.
PAGE 7
dld.so(5) dld.so(5) Itanium(R)-based Systems Only When using the explicit load facilities of the dynamic loader, these types of errors are not considered fatal. Consult shl_load (3X), dlclose (3C), dlget (3C), dlgetname (3C), dlmodinfo (3C), dlopen (3C), and dlsym (3C) for more information. To see error messages, use the dlerror() routine. This routine prints the last error message recorded by the dynamic loader.
PAGE 8
(Notes) A (Notes) dA 8 Hewlett-Packard Company −1− HP-UX 11i Version 3: March 2012