Filter
Top Products
160 Chapter 5
Creating and Using Libraries
Switching from Archive to Shared Libraries
rearrange data in shared libraries, this is no longer guaranteed. Another
example is a function that assumes variables it declares statically (for
example, C static variables) reside below the reserved symbol _end in
memory (see end(3)). In general, it is a bad idea to depend on the relative
addresses of global variables, because the linker may move them around.
In assembly language, using the address of a label to calculate the size of
the immediately preceding data structure is not affected: the assemblers
still calculate the size correctly.
Stack Usage
To load shared libraries, a program must have a copy of the dynamic
loader (dld.sl) mapped into its address space. This copy of the dynamic
loader shares the stack with the program. The dynamic loader uses the
stack during startup and whenever a program calls a shared library
routine for the first time. If you specify -B immediate, the dynamic
loader uses the stack at startup only.
NOTE For 32-bit mode only:
Although it is not recommended programming practice, some programs
may use stack space “above” the program's current stack. To preserve the
contents “above” the program's logical top of the stack, the dynamic
loader attempts to use stack space far away from program's stack
pointer. If a program is doing its own stack manipulations, such as those
implemented by a “threads” package, the dynamic loader may
inadvertently use stack space that the program had reserved for another
thread. Programs doing such stack manipulations should link with
archive libraries, or at least use immediate binding, if this could
potentially cause problems.
Also be aware that if a program sets its stack pointer to memory
allocated in the heap, the dynamic loader may use the space directly
“above” the top of this stack when deferred binding of symbols is used.
Version Control
You can maintain multiple versions of a shared library using
library-level versioning. This allows you to make incompatible changes
to shared libraries and ensure programs linked with the older versions
continue to run. (See “Library-Level Versioning” for more information.)