Glossary

Machine code that contains absolute virtual addresses. Created by the linker when it combines relocatable object files.

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."

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.

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.

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.

The dependent library search algorithm used when linking and loading 64-bit applications.

A segment of memory in which uninitialized data is stored. Compare with "text segment" and "data segment." For details, refer to a.out(4).

A temporary holding area for data. Buffers are used to perform input and output more efficiently.

A process that is spawned by a process (a sub-process).

A phase of compilation in which object code is created.

A particular step performed during compilation — for example, pre-processing, lexical analysis, parsing, code generation, linking.

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."

See startup file.

An initialized global variable that may be referenced outside of the library.

A linkage table that stores the addresses of data items.

A segment of memory containing a program's initialized data. Compare with "bss segment" and "text segment." For details, refer to a.out(4).

The process of waiting to bind a procedure until a program references it. Deferred binding can save program startup time. Compare with "immediate binding."

When a process is "demand-loadable," its pages are brought into physical memory only when they are accessed.

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."

A library that was specified on the command line when building a shared library (with ld -b). See "dependency."

The dependent library search alogrithm 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.

See "dynamic loading library."

See "data linkage table."

A program that calls other programs.

The process of linking an object module with a running program and loading the module into the program's address space.

Code that attaches a shared library to a program. See dld.sl(5).

An SVR4 term for a shared library.

The process that allows the location of shared libraries to be specified at runtime.

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.

The process of using the shl_load(3X) function to load a shared library into a running program.

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.

A symbol definition that may be referenced outside the library.

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.

A reference to a symbol defined outside an object file.

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.

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.

Programs that accept input data and modify it in some way before passing it on. For example, the pr command is a filter.

The process of emptying a buffer's contents and resetting its internal data structures.

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

A string, "!<arch>\n", which identifies a file as an archive created by ar (\n represents the newline character).

Making a symbol invisible to code outside the module in which the symbol was defined. Accomplished with the -h linker option.

Intermediate code-System Object Module. Used during profile-based optimizations and level 4 optimization.

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."

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.

Occurs when the dynamic loader automatically loads any required libraries when a program starts execution. Compare with "explicit" loading.

A short code segment generated by the linker for external references to shared library routines. See also export stub.

An external reference made from a library.

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."

The process of accessing a memory location through a memory address that is stored in memory or a register.

An initialization routine that is called when a shared library is loaded or unloaded.

A representation of object code that is at a lower level than the source code, but at a higher level than the object code.

A file containing object code for subroutines and data that can be used by programs.

The order in which object files and libraries are specified on the linker command line.

The compilation phase in which the compiler calls the linker to create an executable (a.out) file from object modules and libraries.

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.

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.

A definition of a routine or data that is accessible only within the object file in which it is defined.

A file used to ensure that only one process at a time can access data in a particular file.

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.

A page in the HP-UX Reference. Man page 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(2) page in section 2 of the HP-UX Reference. Or use the man(1) command to view man pages, for example, man open.

The file which describes the mapping of input sections to segments in an output file.

Special-purpose routines written in assembly language and designed for performance.

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.

See relocatable object code.

A file containing machine language instructions and data in a form that the linker can use to create an executable program.

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

The process that spawned a particular process. See also "process ID."

See "profile-based optimization."

A form of machine-code addressing in which addresses are referenced relative to the program counter register, or PC register.

A reference to an exact physical memory location (as opposed to virtual memory location).

See "position-independent code."

An input/output channel intended for use between two processes: One process writes into the pipe, while the other reads.

See "procedure linkage table."

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.

A C directive for controlling the compilation of source.

A linkage table that stores the addresses of procedures and functions.

An integer that uniquely identifies a process. Sometimes referred to as "PID."

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.

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.

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.

A type of binding in which the dynamic loader restricts its search for symbols to those that were visible when a library was loaded.

The variable which contains the search path for dynamic libraries.

A mapfile directive which specifies how the linker should map the input sections onto the output segments.

A mapfiel directive which creates a new section or edits the attributes of an existing segment.

An a.out file whose text segment is shareable by multiple processes.

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."

A descriptor of type shl_t (type defined in <dl.h>), which shared library management routines use to refer to a loaded shared library.

The default stream for sending error messages — usually connected to the screen.

The default stream for collecting character input data — usually connected to the keyboard.

A collection of routines that provide efficient and portable input/output services for most C programs.

The default stream for sending character output data — usually connected to the screen.

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.

An uninitialized global variable that may be referenced outside of the library.

A data structure of type FILE * used by various input/output routines.

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 to the manual PA-RISC Procedure Calling Conventions Reference Manual. See also import stub and export stub.

A library that was specified on the command line when building a shared library (with ld -b). Same as dependent library.

The name by which a procedure, function, or data item is referred to in an object module.

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 library routines that provide low-level system services; they are documented in section 2 of the HP-UX Reference.

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).

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

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

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