Glossary

Glossary of Terms for the Microsoft® Shared Source Common Language Infrastructure (SSCLI)

Many commonly used terms and acronyms are also defined in the glossary for the "Standard ECMA-335 Common Language Infrastructure (CLI)" specification (www.ecma.ch/ecma1/STAND/ecma-335.htm).

Term	Definition
assembly	A collection of one or more portable executable (PE) files that are versioned and deployed as a unit. An assembly is the primary building block of a CLI application. All managed types and resources are contained within an assembly and are marked either as accessible only within the assembly or as accessible from code in other assemblies. Assemblies also play a key role in security. The code access security system uses information about the assembly to determine the set of permissions that code in the assembly is granted.
by-ref pointer	A pointer to a location inside a garbage-collectible object, created in order to pass a parameter by reference rather than by value. A by-ref pointer refers to: An address on the stack (when passing the address of a local variable). An address in the static area (when passing the address of a static or class variable). An array (when passing the address of an array element). (See also interior pointer.)
callee-saves	Registers that must be preserved by the called method so the calling method can assume that they are unchanged when control returns. The callee-saves registers are EBP, ESI, EDI, and EBX. The values of ediSaved, esiSaved, ebxSaved, and ebpSaved in the Method Header Information indicate whether each of these registers should be saved in the method prolog.
caller-saves	Registers that are considered to be scratch registers at a call site. If the caller wants the values in these registers to be saved, it has to arrange to save them into the local frame. The caller-saves registers are EAX, ECX and EDX.
checked build	A build of the source tree with optimizations off, debug code enabled, and debugging symbols generated.
CIL	Common intermediate language, the platform-independent persistent, representation of managed executable code used by the CLI runtime engine.
CLI	Common Language Infrastructure. The formal specification for this is Standard ECMA-335. For more information see www.ecma.ch/ecma1/STAND/ecma-335.htm.
CLR	Common language runtime. The Microsoft .NET Framework implementation of the CLI.
code manager or CM	The source language-independent run-time service that supplies access to information about a segment of running code. The code manager is used to support debugging, exception handling, garbage collection, and security management.
COR	An obsolete synonym for CLI or CLR.
delay signed	A synonym for partially signed. See partially signed.
EBP-frame or EBP-based method	Methods that have been compiled to use the EBP pointer to locate the current stack frame. The value of the Method Header Information ebpFrame variable will be set to zero. Since the EBP is a callee-saves register, EBP-frames always contain a slot (pushed immediately after the return address) where the parent's EBP is stored. In EBP-based methods, arguments are referenced as positive offsets from the EBP and local variables or compiler temporaries are typically referenced as negative offsets from the EBP. There is an exception, however, for methods that require that some of their variables be 8-byte-aligned. In this case, the arguments are referenced with respect to the EBP, but the temporaries and locals are referenced using the ESP so that a padding word can be inserted at runtime to provide the required alignment of the locals, temporaries, and ESP without affecting the EBP. NOTE: The Shared Source CLI uses EBP-based methods for most calls.
EBP-less method	Methods that use ESP (the stack pointer) rather than EBP (the frame pointer) to reference arguments, local variables, and compiler temporary values. The value of the Method Header Information ebpFrame variable is set to zero. In these frames, the caller's EBP is saved only if the method's code uses the register for its own purposes. In this case, the old value is saved along with the other callee-saves registers rather than in a special location in the frame. NOTE: The Shared Source CLI uses EBP-less methods only for stubs.
EBP register	One of the seven general-purpose 32-bit registers used in the x86 architecture. It can either be used as a general-purpose register that might contain a garbage collection reference, or as a special-purpose frame pointer register. The value of the Method Header Information variable ebpFrame is equal to 1 when it is used as a special-purpose frame pointer.
ECMA standard	See www.ecma.ch/ecma1/STAND/ecma-334.htm for C# and www.ecma.ch/ecma1/STAND/ecma-335.htm for CLI.
ESP register	The name given to the 32-bit register that is always used as the stack pointer on the x86 architecture.
epilog	Code generated to exit a method. Because the stack pointer and frame pointer are adjusted by this code, the just-in-time (JIT) code manager assumes that a garbage collection is not allowed during this code, and that stack unwinding has detailed knowledge of the precise code sequences present in the epilog.
executable file	A file in PE format that can be loaded into memory and executed by the operating system loader. This includes both .exe and .dll files. (the PE/COFF specification is available on MSDN, but the information needed to implement a CLI is also in the ECMA specification.)
fastchecked build	A build of the source tree with optimizations on, debug code enabled, and debugging symbols generated.
free build	A build of the source tree with optimizations on, debug tracing and assert code disabled, and no debugging symbols generated.
fully interruptible method	A method in which the information for garbage collection is available at all points inside the main body of the method, excluding the prolog and epilog portions of the method. The Method Header Information has interruptible=1. Because of the size of the Method GC Information required to supply this information, the JIT compiler avoids creating fully interruptible methods where possible. However, if a method has a computation-bound loop with no method calls, the method is required to be fully interruptible. Although the Shared Source CLI JIT compiler produces code that could be fully interruptible, the polling garbage collector causes this functionality to remain unexercised. (See also non-fully interruptible method.)
fusion	A portion of the CLI assembly-loading code that finds and loads the correct assembly file based on the versioned assembly references in the calling assembly. This code also manages the global assembly cache.
fx or FX	A major part of the managed source code tree. SSCLI source code is factored into several large source sub-trees: sscli\clr\src for the core engine and base class libraries, sscli\managedlibraries for remoting and soap serialization, and sscli\fx for other fundamental class libraries. The term "FX" is occasionally used in the source code as an abbreviation for "Frameworks."
global assembly cache	A location where assemblies can be installed so they can be shared across applications. For the SSCLI, the global assembly cache is private to a specific installation of the SSCLI code base. The term "GAC" is commonly used in the source code to refer to the global assembly cache.
garbage collection	The process of transitively tracing through all pointers to actively used objects to locate all objects that might be potentially referenced, and then arranging to reuse any heap memory that was not found during this trace. The garbage collector also arranges to compact the memory that is in use to reduce the working space needed for the heap. The term "GC" is commonly used in the source code to refer to garbage collection.
interior pointers	A pointer to a location inside of a garbage-collectible object. An interior pointer or by-ref pointer is typically created by a compiler for temporary use. Three examples of interior pointers are: A pointer to an element within a garbage-collectible array. A pointer to a data member or field of a garbage-collectible object. An argument that has been identified as a by-ref pointer. The garbage collector must update all interior pointers when it compacts the heap. For the garbage collector to operate correctly, there must be a live pointer to the whole object (somewhere visible to the garbage collector) whenever there is an interior pointer to it. (See also by-ref pointer.)
intermediate language	A language designed to be used efficiently both as the output of a number of compilers and as the input to a JIT compiler. The Microsoft implementation of the ECMA common intermediate language (CIL) is Microsoft intermediate language (MSIL).
JIT	Just-in-time compiler which takes intermediate language as input and generates native code, ready to run, in memory. It also produces information used by the built-in code manager.
lifetime	The addresses in the body of a method during which a storage location is actively in use, beginning when the location is initialized and ending with the last reference to the location. For example, an argument location on the stack begins its life immediately after the method's prolog because the caller provides it at the time the method begins execution. Other stack locations might be initialized later in the execution of the method. Some stack locations (or other storage locations) are not referenced after a particular point in the method's body and they are considered "dead" after that point. There is no need for the garbage collector to trace through locations that are not live, and it is critical that the garbage collector not trace through locations that have not been initialized or have out-of-date information. The garbage collector assumes that live locations are safe to trace.
local variable area	Locations allocated on the stack by a method for its own storage purposes. This includes, for example, local variables declared by the user as well as temporary locations for storing intermediate values as well for when the compiler runs out of registers. Typically in the SSCLI the local variables area does not include the linkage area or callee-saves area, nor does it include the variable-sized region of the stack frame that is used to store parameters for methods that are being called.
managed code	Code that executes under the CLI execution environment. Managed code uses the execution environment for memory management, object lifetime, and the basic type-system, among other fundamental services.
metadata	Metadata is binary information that describes and annotates the intermediate language in an assembly. See the ECMA-335 CLI standard for specific details.
metadata root	The root of the section of the PE file that contains metadata.
method	This term has a specialized meaning for higher-level languages like C# and C++. In this document, however, it refers to a sequence of computor instructions that are accessed by a procedure call to a specific code address. The code managers provided by the CLI assume that methods have a single entry point and possibly multiple exit points. Custom code managers need not make these assumptions.
method GC information	A term in the source code that refers to a data structure used to describe a method so that the runtime system can perform garbage collection, handle exceptions, and so forth.
MSIL	The Microsoft implementation of the ECMA standard common intermediate language.
nested call	A method invocation that occurs in the argument list to of another method invocation. For example in: outerMethod(a, b, innerMethod(), c, d) innerMethod is a nested call.
non-fully interruptible method	A method in which the information for garbage collection is provided only at method call sites. The Method Header Information has interruptible=0. The run-time system replaces the actual return address on the stack with an address within the run-time system to accomplish garbage collection. The JIT-compiler preferentially makes methods non-fully-interruptible in order to keep the size of the Method GC data structure size to a minimum.
PAL	The SSCLI Platform Adaptation Layer. This layer allows calls from the SSCLI implementation to be mapped to the underlying operating system.
parameter area	The part of the method's stack frame that is used to store parameters being passed to methods that it calls. This is the part of the stack frame that grows and shrinks as the method executes.
partially signed	An assembly that has the public key field filled in but is not signed with the private key. See also delay signed, strong name, and simple name.
pending arguments	The values already pushed onto the stack at the time of a nested call. For example, in outerMethod(a, b, c, d, e, innerMethod(), f, g, h) when the call to the innnerMethod() is made, the JIT-compiled code for outerMethod() typically would have already pushed three arguments on the stack; the values of c, d and e. The first two arguments are normally passed in registers and are handled specially in the JIT compiler. When innerMethod() returns, outerMethod() continues pushing its remaining arguments, the return value of innerMethod(), and the values of f, g, and h.
pinned pointer	A pointer to a location that must be considered pinned for the purposes of a garbage collection. Only untracked local variables can be marked as pinned pointers. Arguments and class variables cannot be directly marked as pinned. Instead, a copy of the reference that they refer to must be placed in a local variable and that local variable must be marked as pinned. It is also possible to have a pinned by-ref or pinned interior pointer. A pinned pointer is considered to be pinned only during the lifetime of the stack frame associated with the local variable that contains the pinning mark.
platform invoke	The implementation used to call from managed to platform-specific unmanaged code. Sometimes referred to in source by the deprecated term "P/Invoke".
prolog	The part of a method's code that is executed when the method starts and during which the fixed part of the stack frame is not yet completely initialized. The code manager does not permit a garbage collection to occur during a method prolog and it must take extra care during stack unwinding for methods that are executing their prolog. The prolog is responsible for constructing the local stack frame, saving the callee-saved registers, and initializing the untracked local variables.
public key token	A reduced-size numeric token that represents a public key for an assembly. Assembly references in metadata frequently store the public key token rather than the entire public key.
pushed args mask	A bit mask used to indicate which locations in the outgoing parameter area (not the incoming pushed argument area) contain live garbage collection pointers. It sometimes also includes bits to indicate whether particular registers contain live garbage collection pointers.
pushed argument area	The portion of the current stack that holds the incoming arguments passed onto the stack for any given method. The JIT-compiler assumes that this area occupies the portion of the stack frame with the highest memory addresses (that is, that part that is pushed first). It is created by the calling method (in its outgoing parameter area) and, after the call occurs, becomes the base of the current stack frame. Note that the first two arguments are passed in registers, are not pushed onto the stack, and are thus not part of the pushed argument area.
rotor	Code name for the Shared Source CLI implementation (both 1.0 and 2.0 versions).
rotor whidbey	Code name for the Shared Source CLI implementation 2.0.
RVA	Short for "relative virtual address." An offset (in bytes) from the start of the executable file.
security object	Some methods are compiled knowing that they are calling system services that require security checks. These methods allocate a location in their stack frame (currently the last temporary variable) in which the system will store a security token at runtime. The compiler is responsible only for initializing the location when the method begins execution and for making sure that the method GC information indicates that the method has a security object.
SEH facility	The Structured Exception Handling facility supplied by the PAL (or by the Win32 API). The Code Manager is responsible for part of the interface between the runtime system and the Win32 SEH facility. The details of this interface are subject to change.
shim	Used in the SSCLI source code to refer to the .NET Framework startup code used to bootstrap some version of the .NET Framework by means of the system loader on Windows systems. In the Shared Source CLI, the clix application launcher program is used to load PE images rather than the shim technology.
simple name	An assembly that has a blank public key field has only a simple name. See also strong name.
source language processor or SLP	The compiler or JIT compiler that produced the executing code. For a given programming language there might be multiple implementations (for example, from different vendors) and for each implementation there might be multiple source language processors (for example, a compiler, an optimizing compiler, a JIT compiler, and an optimized JIT compiler).
strong name	An assembly that has the cryptographic public key field containing a public key value has a strong name. A strong name implies that the assembly is also signed with the private key. See also simple name and partially signed.
this	A pointer to the object instance on whose behalf the current method is executing. Not all methods have a this pointer. Static methods in C#, for example, do not have a this pointer.
unmanaged code	Code that runs outside the common language runtime. ECMA Section III specifies the assumptions made by the runtime about the behavior of such code.
untracked	An argument, variable, or local variable that contains a garbage collection pointer but whose lifetime information is not available at runtime. Untracked locations are assumed by the garbage collector to be live during the execution of the entire method body, so they must be initialized by the prolog and must be either cleared at the end of their lifetime (if known) or when their contents might become incorrect.
variable-sized stack area	See parameter area.
Windows NDP	The .NET developer platform (.NET Framework) on Windows. "Windows NDP v1" refers to the first released version of the .NET Framework on Windows.
Win32 PCONTEXT	Pointer to a computation context sufficient to resume (or alter and resume) a computation. Part of the Win32 API specification.
zaplogs or zapmonitor	Anything with the "zap" name in the source code refers to native image code generation (also called "ngen"). In native code image generation, JIT-compiled code is stored to the file system for faster loading. The SSCLI implementation does not support generating or using native code images.