Inside Macintosh: Mac OS Runtime Architectures /

Glossary

68K application An application that contains code only for a 68K microprocessor. Compare fat application, PowerPC application.

68K-based Macintosh computer Any computer containing a 680x0 central processing unit that runs the Mac OS. Compare PowerPC-based Macintosh computer.

68K microprocessor Any member of the Motorola 68000 family of microprocessors.

accelerated resource An executable resource consisting of a routine descriptor and PowerPC code that specifically models the behavior of a 68K stand-alone code resource.

A5 world In classic 68K and CFM-68K runtime programs, a memory partition that contains the QuickDraw global variables, the application global variables, the application parameters, and the jump table--all of which are accessed through the A5 register. Sometimes called the global variable world.

A-line instruction An instruction used to execute Toolbox and Operating System routines. The first word of an A-line instruction is binary 1010 (hexadecimal A). Also known informally as an A-trap.

application A program of type 'APPL' that is launched from the Finder. Applications typically use event-driven programming and have a user interface. See also program.

application transition vector A 12-byte transition vector used in the CFM-68K runtime environment. The first two fields contain the address of a function and the value to be placed in A5 when the function executes. Because applications can be segmented, the third field contains information to locate the function within a particular segment. See also shared library transition vector, transition vector.

A-trap See A-line instruction.

base register The register that holds a reference address used to access a fragment's data area.

branch island A small assembly-language module used to transmit calls between two independently compiled modules. Branch islands are generated by the ILink linker to allow intrasegment calls to reach beyond 32 KB.

CFM-68K runtime architecture A 68K Mac OS runtime architecture that uses the Code Fragment Manager. Its handling of fragments and the ability to use shared libraries is analogous to that of the PowerPC runtime architecture, but it differs in a number of details because of system limitations. In particular, it uses segmented application code addressed through a jump table. Compare classic 68K runtime architecture, PowerPC runtime architecture.

classic 68K runtime architecture The runtime architecture that has been used historically for 68K-based Macintosh computers. Its defining characteristics are the A5 world, segmented applications addressed through the jump table, and the application heap for dynamic storage allocation. Compare CFM-68K runtime architecture, PowerPC runtime architecture.

closure The set of connections for a root fragment and all the import libraries required for its execution. See also root fragment.

closure ID A unique value assigned by the Code Fragment Manager to each active closure.

code fragment See fragment.

Code Fragment Manager (CFM) The part of the Mac OS that loads fragments into memory and prepares them for execution. There are separate internal components to manage PowerPC code and CFM-68K code, but the APIs to the Code Fragment Manager are identical for each type of code. In general, the context determines which version of the Code Fragment Manager is being referred to.

code fragment resource In CFM-based runtime architectures, a resource of type 'cfrg' with ID 0. The code fragment resource contains information used by the Code Fragment Manager to identify and prepare fragments.

code resource A resource created by the linker that contains the program's code. Code resources can be of many types--most commonly'CODE', 'MPST', or 'DRVR'.

code section A part of a fragment that holds executable code. The code must be position independent and read-only. A fragment may contain multiple code sections.

connection An incarnation of a fragment within a process. A fragment may have several unique connections, each local to a particular process.

connection ID A unique value assigned by the Code Fragment Manager to each active connection.

container The physical storage area for a fragment. Containers can be a file, a section of ROM, or even a resource.

container header A data structure that contains information about a given container, such as the number of code and data sections, the number of imported symbols it requires, and so on.

data fork One of two forks of a Macintosh file. The data fork can contain text, code, or data, or it can be empty. PowerPC runtime fragments and CFM-68K shared library fragments are stored in the data fork. Compare resource fork.

data section The part of a fragment that contains the static data used by the code section. A fragment may contain multiple data sections.

definition stub library The import library used by the linker to resolve imports in the application (or other fragment) being linked. The definition stub library defines the external programming interface and data format of the library. Also called link-time library. Compare implementation library, stub library.

direct data area The area of memory that can be accessed directly through the base register. The direct data area can hold data items or pointers to data items.

drop-in addition See plug-in.

embedding alignment The alignment of a data item within a composite data item (such as a data structure). Compare natural alignment.

entry point A location (offset) within a module.

epilog A sequence of code that cleans up the stack after a procedure call (restoring registers, restoring the stack pointer, and so on).

executable resource Any resource that contains executable code. See also accelerated resource.

export A data item or executable routine within a fragment that is made available for use by other fragments.

Extended Common Object File Format (XCOFF) An executable file format generated by some PowerPC compilers. See also Preferred Executable Format.

external entry point In the CFM-68K runtime architecture, the entry point to a routine when called indirectly or from another fragment. Typically this entry point allows inclusion of instructions to set up an A5 world for the called routine before entering the internal entry point. Compare internal entry point.

external reference A reference to a routine or variable defined in a separate compilation unit or assembly.

far model The model of the classic 68K runtime architecture that specifies 32-bit addressing for code and data. Compare near model.

fat application An application that contains code of two or more runtime architectures. For example, a fat application may contain both CFM-68K and PowerPC runtime code.

fat binary program Any piece of executable code (application, shared library, code resource, trap, or trap patch) that contains code of multiple runtime architectures. See also fat application, fat library, fat resource.

fat library A shared library that contains code of two or more runtime architectures. For example, a fat library may contain both CFM-68K and PowerPC versions of a shared library.

fat resource A resource that contains executable code for two or more runtime architectures. See also safe fat resource.

filename A sequence of up to 31 printing characters (excluding colons) that identifies a file.

file type The type of a file, such as 'APPL', 'shlb', or 'TEXT', which determines how the file is used by the Mac OS or other programs.

fragment An executable unit of code and its associated data. A fragment is produced by the linker and loaded for execution by the Code Fragment Manager.

frame pointer (FP) A pointer to the beginning of a stack frame.

hashing A method of organizing symbol information in tables that allows them to be searched for quickly.

hash word An 4-byte value that contains the length and encoded name of a symbol.

implementation library The import library that is connected at load time to the application (or other fragment) being loaded. The implementation library provides the actual executable code and data exported by the library. Also called runtime library. Compare definition stub library.

import A data item or executable routine referenced by a fragment but not contained in it. An import is identified by name to the linker, but its actual address is bound at load time by the Code Fragment Manager.

import library A shared library that is automatically loaded at runtime by the Code Fragment Manager. The library's name is bound to a client at link time. Import libraries are a subset of shared libraries. Compare plug-in.

initialization function A function contained in a fragment that is executed immediately after the fragment is loaded and prepared. Compare termination routine.

internal entry point In the CFM-68K runtime architecture, the entry point to a routine when accessed through a direct call. The internal entry point skips any A5 switching and simply enters the beginning of the actual routine. Compare external entry point.

intersegment reference In 68K-based runtime architectures, a reference to a routine in another segment.

intrasegment reference In 68K-based runtime architectures, a reference to a routine in the same segment.

jump table In 68K-based runtime architectures, a table that contains one entry for every externally referenced routine in an application or MPW tool and provides the means by which segments are loaded and unloaded.

leaf procedure A routine that calls no other routines.

linkage area The area in the PowerPC stack that holds the calling routine's RTOC value and the saved values of the Condition Register and the Link Register. Compare parameter area.

link-time library See definition stub library.

main segment In 68K-based runtime architectures, the segment that contains the main entry point.

main symbol For applications, the main routine or main entry point. Shared libraries do not require a main symbol.

Mixed Mode Manager The part of the Mac OS that allows code with different calling conventions to call each other. For example, the Mixed Mode Manager makes it possible for PowerPC code to call emulated classic 68K code.

module A contiguous region of memory that contains code or static data; the smallest unit of memory that is included or removed by the linker. See also segment.

natural alignment The alignment of a data type when allocated in memory or assigned a memory address. Compare embedding alignment.

near model The default model of the classic 68K runtime architecture, which specifies 16-bit addressing for code and data. Compare far model.

noncode resource A resource containing the data structures on which the program operates, for example, 'WIND', 'DLOG', 'DITL', or 'SIZE' resources. You use the resource compiler Rez or a resource editor to create noncode resources.

parameter area The area in the PowerPC stack that holds the parameters for any routines called by a given routine. Compare linkage area.

PEF See Preferred Executable Format.

PEF container An addressable entity that contains PEF information.

plug-in A shared library that must be explicitly prepared by the client application before use. Plug-ins typically contain code and data that extend the capabilities of an application. Also called an application extension or a drop-in addition. Compare import library.

PowerPC application An application that contains code only for a PowerPC microprocessor. Compare 68K application, fat application.

PowerPC-based Macintosh computer Any computer containing a PowerPC CPU that runs the Mac OS. Compare 68K-based Macintosh computer.

PowerPC microprocessor Any member of the family of PowerPC microprocessors. Members of the PowerPC family include the MPC601, 603, and 604 CPUs.

PowerPC runtime architecture The runtime architecture for Mac OS-based computers using the PowerPC microprocessor. Its characteristics include storage of code and data in contiguous fragments, the absence of an A5 world, and the ability to use shared libraries. Compare CFM-68K runtime architecture, classic 68K runtime architecture.

Preferred Executable Format (PEF) The format of executable files used for PowerPC applications and shared libraries. It is also used for CFM-68K runtime import libraries that have been flattened. CFM-68K runtime applications are stored in a combination of PEF containers and 'CODE' resources. See also Extended Common Object File Format.

preparation A general term in CFM-based runtime architectures to describe the actions of the Code Fragment Manager prior to executing a fragment. These actions include identifying imports, bringing fragments into memory, and resolving imports.

private connection A connection that cannot be shared between closures. A fragment can have multiple private connections within a process, all serving the same client. Private connections are not visible as import libraries

private resource Any executable resource whose behavior is defined by your application (or other kind of software) alone.

process A prepared application and its associated fragments (including plug-ins). A process holds connections and closures.

program An executable unit that contains executable code (stored in either the data fork or resource fork) and noncode resources (stored in the resource fork). See also code resource, noncode resource.

prolog A sequence of code that prepares the stack for a procedure call (by saving registers, adjusting the stack, and so on).

Red Zone On PowerPC-based computers, the area of memory immediately above the address pointed to by the stack pointer. The Red Zone is reserved for temporary use by a routine's prolog and as an area to store a leaf procedure's nonvolatile registers.

reference The location within one module that contains the address of another module or entry point.

reference count For each prepared fragment, a value indicating the number of closures that contain the fragment.

relocation The process of replacing references to symbols with actual addresses during fragment preparation.

relocation block A 2-byte portion of relocation instruction information. A relocation instruction can span one or more relocation blocks.

resource A data structure used to store a program's data or code. This structure is declared and defined using the Rez language. Resources used to store code are built by the linker; resources used to store data are built by a resource compiler.

resource attributes Values associated with a resource that determine where and when the resource is loaded in memory, whether it can be changed, and whether it can be purged.

resource fork One of two forks of a Macintosh file. It can contain code resources or noncode resources, or it can be empty. 68K-based runtime applications store their code in the resource fork. Compare data fork.

resource specification The information used to identify a resource: the resource name, the resource type, and the values of its attributes.

root fragment The initial fragment in the preparation process when the Code Fragment Manager prepares a fragment and its imports.

routine descriptor A data structure used by the Mixed Mode Manager to execute a routine. A routine descriptor contains information about the routine being called such as its architecture and calling conventions. Defined by the RoutineRecord data type.

runtime architecture A set of basic rules that define how software operates. It dictates how code and data are addressed, the form of generated code, how applications are handled, and how to enable system calls. The runtime architecture defines the core of the runtime environment. Compare runtime environment.

runtime environment The execution environment provided by the Process Manager and other system software services. The runtime environment dictates how executable code is loaded into memory, where data is stored, and how routines call other routines and system software routines. Compare runtime architecture.

runtime library See implementation library.

safe fat resource A fat resource that contains extra classic 68K code at its entry point to check for the presence of the Code Fragment Manager. This guards against calling the Mixed Mode trap when the Mixed Mode Manager is not present. See also fat resource.

section A storage unit in a PEF container that contains object code or data. PEF containers usually contain multiple sections.

section header A data structure in a PEF container that contains information (size, alignment, and so on) about the sections stored within it.

segment A named collection of modules in 68K-based runtime programs.

segment header A collection of fields that provides information about a segment. In the classic 68K near model architecture, it describes the location of the jump table and the number of jump table entries.

segment relocation information Part of a segment header used to store information that allows the relocation of intrasegment references for programs compiled and linked using the -model far option.

shadow library A small stub library that can load a larger import library on demand.

shared library A fragment that exports functions and global variables to other fragments. A shared library is not included with the application code at link time but is linked in dynamically at runtime. A shared library is stored in a file of type 'shlb'. There are two types of shared libraries: import libraries and plug-ins.

shared library transition vector An 8-byte transition vector in the CFM-68K runtime environment. Its two fields contain the address of a function and the value to be placed in A5 when the function executes. A transition vector for a flattened shared library is identical to the PowerPC transition vector. See also application transition vector, transition vector.

stack An area of memory in the application partition that is used for temporary storage of data during the operation of that application or other software.

stack frame The area of the stack used by a routine for its parameters, return address, local variables, and temporary storage.

stack pointer (SP) A pointer to the top of the stack.

stand-alone code A type of program used to supplement the standard features provided by the Mac OS , to execute startup functions, or to control peripherals. This term generally refers to classic 68K programs.

static library A library whose code is included in the application at link time.

stub library A library that contains symbol definitions but no code. See also definition stub library.

switch frame A stack frame, created by the Mixed Mode Manager during a mode switch, that contains information about the routine to be executed, the state of various registers, and the address of the previous frame.

termination routine A function contained in a fragment that is executed just before the fragment is unloaded. Compare initialization function.

transition vector In the PowerPC runtime architecture, an 8-byte data structure that describes the entry point and base register address of a routine. In the CFM-68K runtime environment, a structure that contains the entry point address of a function and the value to be placed in the A5 register when the function executes. A CFM-68K transition vector may be 12 bytes long or 8 bytes long depending on whether it is created for an application or a shared library. See also application transition vector, shared library transition vector.

universal procedure pointer A generalized procedure pointer that can be either a 68K procedure pointer or the address of a routine descriptor.

update library A shared library that contains additions or changes to an existing import library.

weak library A shared library that does not need to be present at runtime for the client application to run. Sometimes called a soft library.

weak symbol A symbol that does not need to be present in any of the client application's import libraries at runtime. Also known as a weak import or soft import.

XCOFF See Extended Common Object File Format.