Filter
Top Products
126 Chapter 5
Creating and Using Libraries
What are Shared Libraries?
What are Shared Libraries?
Like an archive library, a shared library contains object code. However,
ld treats shared libraries quite differently from archive libraries. When
linking an object file with a shared library, ld does not copy object code
from the library into the a.out file; instead, the linker simply notes in
the a.out file that the code calls a routine in the shared library. An
a.out file that calls routines in a shared library is known as an
incomplete executable.
The Dynamic Loader dld.sl
When an incomplete executable begins execution, the HP-UX dynamic
loader (see dld.sl(5)) looks at the a.out file to see what libraries the
a.out file needs during execution. In 32-bit mode, the startup code in
crt0.o activates the dynamic loader. In 64-bit mode, the kernel
activates the dynamic loader for a 64-bit a.out.The dynamic loader then
loads and maps any required shared libraries into the process's address
space — known as attaching the libraries. A program calls shared
library routines indirectly through a linkage table that the dynamic
loader fills in with the addresses of the routines. By default, the dynamic
loader places the addresses of shared library routines in the linkage
table as the routines are called — known as deferred binding.
Immediate binding is also possible — that is, binding all required
symbols in the shared library at program startup. In either case, any
routines that are already loaded are shared.
Consequently, linking with shared libraries generally results in smaller
a.out files than linking with archive libraries. Therefore, a clear benefit
of using shared libraries is that it can reduce disk space and virtual
memory requirements.
NOTE In prior releases, data defined by a shared library was copied into the
program file at link time. All references to this data, both in the libraries
and in the program file, referred to the copy in the executable file.
With the HP-UX 10.0 release, however, this data copying is eliminated.
Data is accessed in the shared library itself. The code in the executable
file references the shared library data indirectly through a linkage
pointer, in the same way that a shared library would reference the data.