HP-UX Linker and Libraries User's Guide

absolute object code: Machine code that contains absolute virtual addresses. Created by the linker when it combines relocatable object files.
archive library: A library, created by the ar command, which contains one or more object modules. By convention, archive library file names end with .a. Compare with shared library.
attaching a shared library: The process the dynamic loader goes through of mapping the shared library code and data into a process's address space, relocating any pointers in the shared library data that depend on actual virtual addresses, allocating the bss segment, and binding routines and data in the shared library to the program.

basic block: A contiguous section of assembly code, produced by compilation, that has no branches in except at the top, and no branches out except at the bottom.
binding: The process the dynamic loader goes through of filling in a process's procedure linkage tables and data linkage tables with the addresses of shared library routines and data. When a symbol is bound, it is accessible to the program.
breadth-first search order: The dependent library search algorithm used when linking and loading 64-bit applications./.
bss segment: A segment of memory in which uninitialized data is stored. Compare with text segment and data segment. For details, refer a.out(4).
buffer: A temporary holding area for data. Buffers are used to perform input and output more efficiently.


child: A process that is spawned by a process (a sub-process).
code generation: A phase of compilation in which object code is created.
compilation phase: A particular step performed during compilation - for example, pre-processing, lexical analysis, parsing, code generation, linking.
complete executable: An executable (a.out) file that does not use shared libraries. It is complete because all of its library code is contained within it. Compare with incomplete executable.
crt0.o file: See startup file.

data export symbol: An initialized global variable that may be referenced outside of the library.
data linkage table: A linkage table that stores the addresses of data items.
data segment: A segment of memory containing a program's initialized data. Compare with bss segment and text segment. For details, refer a.out(4).
deferred binding: The process of waiting to bind a procedure until a program references it. Deferred binding can save program startup time. Compare with immediate binding.
demand-loadable: When a process is "demand-loadable," its pages are brought into physical memory only when they are accessed.
dependency: Occurs when a shared library depends on other libraries - that is, when the shared library was built (with ld -b), other libraries were specified on the command line. See also dependent library.
dependent library: A library that was specified on the command line when building a shared library (with ld -b). See dependency.
depth-first search order: The dependent library search algorithm used when linking and loading in 32-bit mode. Searching a list starting at the end of the list and moving toward the head. Shared library initialization routines are invoked by traversing the list of loaded shared libraries depth-first.
dll: See dynamic loading library.
DLT: See data linkage table.
driver: A program that calls other programs.
dynamic linking: The process of linking an object module with a running program and loading the module into the program's address space.
dynamic loader: Code that attaches a shared library to a program. See dld.sl(5).
dynamic loading library: An SVR4 term for a shared library.
dynamic search path: The process that allows the location of shared libraries to be specified at runtime.

entry point: The location at which a program starts running after HP-UX loads it into memory. The entry point is defined by the symbol $START$ in crt0.o.
explicit loading: The process of using the shl_load(3X) function to load a shared library into a running program.
export stub: A short code segment generated by the linker for a global definition in a shared library. External calls to shared library procedures go through the export stub. See also import stub.
export symbol: A symbol definition that may be referenced outside the library.
exporting a symbol: Making a symbol visible to code outside the module in which the symbol was defined. This is usually done with the +e or -E option.
external reference: A reference to a symbol defined outside an object file.

feedback-directed positioning: An optimization technique wherein procedures are relocated in a program, based on profiling data obtained from running the program. Feedback-directed positioning is one of the optimizations performed during profile-based optimization.
file descriptor: A file descriptor is returned by the open(2), creat(2), and dup(2) system calls. The file descriptor is used by other system calls (for example, read(2), write(2), and close(2)) to refer to a the file.
filters: Programs that accept input data and modify it in some way before passing it on. For example, the pr command is a filter.
flush: The process of emptying a buffer's contents and resetting its internal data structures.

global definition: A definition of a procedure, function, or data item that can be accessed by code in another object file.

header string: A string, !<arch>\n, which identifies a file as an archive created by ar (\n represents the newline character).
hiding a symbol: Making a symbol invisible to code outside the module in which the symbol was defined. Accomplished with the -h linker option.

immediate binding: By default, the dynamic loader attempts to bind all symbols in a shared library when a program starts up - known as immediate binding. Compare with deferred binding.
implicit address dependency: Writing code that relies on the linker to locate a symbol in a particular location or in a particular order in relation to other symbols.
implicit loading: Occurs when the dynamic loader automatically loads any required libraries when a program starts execution. Compare with explicit loading.
import stub: A short code segment generated by the linker for external references to shared library routines. See also export stub.
import symbol: An external reference made from a library.
incomplete executable: An executable (a.out) file that uses shared libraries. It is incomplete because it does not actually contain the shared library code that it uses; instead, the shared library code is attached when the program runs. Compare with complete executable.
indirect addressing: The process of accessing a memory location through a memory address that is stored in memory or a register.
initializer: An initialization routine that is called when a shared library is loaded or unloaded.
intermediate code: A representation of object code that is at a lower level than the source code, but at a higher level than the object code.
I-SOM: Intermediate code-System Object Module. Used during profile-based optimizations and level-4 optimization.

library: A file containing object code for subroutines and data that can be used by programs.
link order: The order in which object files and libraries are specified on the linker command line.
link-edit phase: The compilation phase in which the compiler calls the linker to create an executable (a.out) file from object modules and libraries.
linkage table: A table containing the addresses of shared library routines and data. A process calls shared library routines and accesses shared library data indirectly through the linkage table.
load graph: A list of dependent shared libraries in the order in which the libraries are to be loaded by the dynamic loader. Any executable program or shared library with dependencies has a load graph.
local definition: A definition of a routine or data that is accessible only within the object file in which it is defined.
lock file: A file used to ensure that only one process at a time can access data in a particular file.

magic number: A number that identifies how an executable file should be loaded. Possible values are SHARE_MAGIC, DEMAND_MAGIC, and EXEC_MAGIC. Refer to magic(4) for details.
manpage: A page in the HP-UX Reference. Manpage references take the form title(section), where title is the name of the page and section is the section in which the page can be found. For example, open(2) refers to the open page in section 2 of the HP-UX Reference. Or use the man(1) command to view manpages, for example, man open.
mapfile: The file which describes the mapping of input sections to segments in an output file.
millicode: Special-purpose routines written in assembly language and designed for performance.

nonfatal binding: Like immediate binding, nonfatal immediate binding causes all required symbols to be bound at program startup. The main difference from immediate binding is that program execution continues even if the dynamic loader cannot resolve symbols.

object code: See relocatable object code.
object file: A file containing machine language instructions and data in a form that the linker can use to create an executable program.
object module: A file containing machine language code and data in a form that the linker can use to create an executable program or shared library.

parent process: The process that spawned a particular process. See also process ID.
PBO: See profile-based optimization.
PC-relative: A form of machine-code addressing in which addresses are referenced relative to the program counter register, or PC register.
physical address: A reference to an exact physical memory location (as opposed to virtual memory location).
PIC: See position-independent code.
pipe: An input/output channel intended for use between two processes: One process writes into the pipe, while the other reads.
PLT: See procedure linkage table.
position-independent code: Object code that contains no absolute addresses. All addresses are specified relative to the program counter or indirectly through the linkage table. Position-independent code can be used to create shared libraries.
pragma: A C directive for controlling the compilation of source.
procedure linkage table: A linkage table that stores the addresses of procedures and functions.
process ID: An integer that uniquely identifies a process. Sometimes referred to as PID.
profile-based optimization: A kind of optimization in which the compiler and linker work together to optimize an application based on profile data obtained from running the application on a typical input data set.

relocatable object code: Machine code that is generated by compilers and assemblers. It is relocatable in the sense that it does not contain actual addresses; instead, it contains symbols corresponding to actual addresses. The linker decides where to place these symbols in virtual memory, and changes the symbols to absolute virtual addresses.
relocation: The process of revising code and data addresses in relocatable object code. This occurs when the linker must combine object files to create an executable program. It also occurs when the dynamic loader loads a shared library into a process's address space.
restricted binding: A type of binding in which the dynamic loader restricts its search for symbols to those that were visible when a library was loaded.
RPATH: The variable which contains the search path for dynamic libraries.

section mapping directive: A mapfile directive which specifies how the linker should map the input sections onto the output segments.
segment declaration: A mapfile directive which creates a new section or edits the attributes of an existing segment.
shared executable: An a.out file whose text segment is shareable by multiple processes.
shared library: A library, created by the ld command, which contains one or more PIC object modules. Shared library file names end with .sl. Compare with archive library.
shared library handle: A descriptor of type shl_t (type defined in <dl.h> ), which shared library management routines use to refer to a loaded shared library.
standard error: The default stream for sending error messages - usually connected to the screen.
standard input: The default stream for collecting character input data - usually connected to the keyboard.
standard input/output library: A collection of routines that provide efficient and portable input/output services for most C programs.
standard output: The default stream for sending character output data - usually connected to the screen.
startup file: Also known as crt0.o, this is the first object file that is linked with an executable program. It contains the program's entry point. The startup code does such things as retrieving command line arguments into the program at run time, and activating the dynamic loader (dld.sl(5)) to load any required shared libraries.
storage export symbol: An uninitialized global variable that may be referenced outside of the library.
stream: A data structure of type FILE * used by various input/output routines.
stub: A short code segment inserted into procedure calling sequences by the linker. Stubs are used for very specific purposes, such as inter-space calls (for example, shared-library calls), long branches, and preserving calling interfaces across modules (for example, parameter relocation). Refer PA-RISC Procedure Calling Conventions Reference Manual. See also import stub and export stub.
supporting library: A library that was specified on the command line when building a shared library (with ld -b). Same as dependent library.
symbol name: The name by which a procedure, function, or data item is referred to in an object module.
symbol table: A table, found in object and archive files, which lists the symbols (procedures or data) defined and referenced in the file. For symbols defined in the file, an offset is stored.
system calls: System library routines that provide low-level system services; they are documented in section 2 of the HP-UX Reference.

text segment: A segment of read-only memory in which a program's machine language instructions are typically stored. Compare with bss segment and data segment. For details, refer to a.out(4).

umask: A field of bits (set by the umask(1) command) that turns off certain file permissions for newly created files.

version number: A number that differentiates different versions of routines in a shared library.

wrapper library: A library that contains alternate versions of library functions, each of which performs some bookkeeping and then calls the actual function.