Materialize Program (MATPG)

Instruction Syntax

Op Code (Hex)	Operand 1	Operand 2
0232	Attribute receiver	Program

Operand 1: Space pointer.

Operand 2: System pointer.

Bound Program Access
`Built-in number for MATPG is 31. MATPG ( attribute_receiver : address program : address of system pointer )`

Warning

The following information is subject to change from release to release. Use it with caution and be prepared to adjust for changes with each new release.

Description:

The non-bound program identified by operand 2 is materialized into the template identified by operand 1.

Operand 2 is a system pointer that identifies the program to be materialized. The program identified by operand 2 must be a non-bound program. Otherwise, a program not eligible for operation (hex 220A) exception will be signalled. The values in the materialization relate to the current attributes of the materialized program.

This instruction does not process teraspace addresses used for its operands, nor used in any space pointer contained in a template. Any teraspace address use will cause an unsupported space use (hex 0607) exception to be signaled, whether the issuing program is teraspace capable or not.

The template identified by operand 1 must be 16-byte aligned.

Offset
Dec	Hex	Field Name	Data Type and Length
0	0	Template size specification	Char(8)
0	0	Number of bytes provided	Bin(4)
4	4	Number of bytes available for materialization (used only when the program is materialized)	Bin(4) +
8	8	Program identification	Char(32)
8	8	Type	Char(1) +
9	9	Subtype	Char(1)
10	A	Name	Char(30)
40	28	Program creation options	Char(4)
40	28	Existence attributes 0 = Temporary 1 = Permanent	Bit 0
40	28	Space attribute 0 = Fixed-length 1 = Variable-length	Bit 1
40	28	Initial context 0 = Do not insert addressability into context 1 = Insert addressability into context	Bit 2
40	28	Access group creation 0 = Do not create as a member of an access group 1 = Create as a member of an access group	Bit 3
40	28	Reserved (binary 0)	Bits 4-12
40	28	Initialize space 0 = Initialize 1 = Do not initialize	Bit 13
40	28	Automatically extend space 0 = No 1 = Yes	Bit 14
40	28	Associated space hardware storage protection level 00 = Reference and modify allowed for user state programs 01 = Only reference allowed for user state programs 11 = No reference or modify allowed for user state programs	Bits 15-16
40	28	Reserved (binary 0)	Bits 17-31
44	2C	Reserved (binary 0)	Char(4)
48	30	Size of space	Bin(4)
52	34	Initial value of space	Char(1)
53	35	Performance class	Char(4)
53	35	Obsolete This field is no longer used and will be ignored.	Bit 0 +
53	35	Reserved (binary 0)	Bits 1-4
53	35	Main storage pool selection 0 = Process default main storage pool is used for object. 1 = Machine default main storage pool is used for object.	Bit 5
53	35	Transient storage pool selection 0 = Default main storage pool (process default or machine default as specified for main storage pool selection) is used for object. 1 = Transient storage pool is used for object.	Bit 6
53	35	Block transfer on implicit access state modification 0 = Transfer the minimum storage transfer size for this object. 1 = Transfer the machine default storage transfer size for this object.	Bit 7
53	35	Reserved (binary 0)	Bits 8-31
57	39	Reserved (binary 0)	Char(7)
64	40	Context	System pointer
80	50	Access group	System pointer
96	60	Program attributes	Char(2)
96	60	Adopted user profile 0 = No adoption of user profile. 1 = Adopt program owner's user profile on invocation.	Bit 0
96	60	Array constraint 0 = Arrays are constrained. 1 = Arrays are unconstrained. The predictability of the results of references outside the bounds of arrays are determined by the type of unconstrained arrays field.	Bit 1
96	60	String constraint 0 = Strings are constrained. 1 = Strings are not constrained.	Bit 2
96	60	Obsolete	Bit 3 +
96	60	Adopted user profile propagation 0 = Adopted user profile authorities are not propagated to external invocations. 1 = Adopted user profile authorities are propagated to all subinvocations.	Bit 4
96	60	Static storage 0 = Initialize storage to binary 0. 1 = Do not initialize storage to binary 0.	Bit 5
96	60	Automatic storage 0 = Initialize storage to binary 0. 1 = Do not initialize storage to binary 0.	Bit 6
96	60	Associated journal entry 0 = Program name is recorded in journal entries 1 = Program name is not recorded in journal entries	Bit 7
96	60	Update PASA stack This field is now obsolete. It will be ignored.	Bit 8 +
96	60	Suppress decimal data exception 0 = Exception is not to be suppressed 1 = Exception is to be suppressed	Bit 9
96	60	Template extension existence 0 = Template extension does not exist 1 = Template extension exists	Bit 10
96	60	Suppress previously adopted user profiles 0 = Do not suppress previously adopted user profiles 1 = Suppress previously adopted user profiles	Bit 11
96	60	Template version 0000 = Version 0 0001 = Version 1 0010 through 1111 reserved	Bits 12-15
98	62	Code generation options	Char(1)
98	62	Performance optimization 0 = No optimization 1 = Perform optimization	Bit 0
98	62	Space pointer machine objects 0 = Disallow space pointer machine objects in ODV component 1 = Allow space pointer machine objects in ODV component	Bit 1
98	62	Coincident operand overlap 0 = Do not assume coincident operand overlap 1 = Assume coincident operand overlap	Bit 2
98	62	Reserved (binary 0)	Bits 3-4
98	62	Teraspace capable 0 = Do not generate teraspace capable program 1 = Generate teraspace capable program	Bit 5
98	62	Executable part compression 0 = Do not compress executable part 1 = Compress executable part	Bit 6
98	62	Observation part compression 0 = Do not compress observation part 1 = Compress observation part	Bit 7
99	63	Observation attributes For bits 0 through 5: 1 = The corresponding template component is materializable 0 = The corresponding template component is not materializable	Char(1)
99	63	Instruction stream	Bit 0
99	63	ODT Directory Vector (ODV)	Bit 1
99	63	ODT Entry String (OES)	Bit 2
99	63	Breakpoint Offset Mapping (BOM) table	Bit 3
99	63	Symbol table	Bit 4
99	63	Object Mapping Table (OMT) For bits 6 and 7: 1 = The corresponding performance measurement is prevented 0 = The corresponding performance measurement is allowed	Bit 5
99	63	Prevent performance measurements on entry/exit	Bit 6
99	63	Prevent performance measurements on CALLX	Bit 7
100	64	Size of static storage	UBin(4)
104	68	Size of automatic storage	UBin(4)
108	6C	Number of instructions (1) For version number = hex 0000, this field indicates the number of instructions. For version number = hex 0001, this field is reserved (binary 0).	UBin(2)
110	6E	Number of ODV entries (1) For version number = hex 0000, this field indicates the number of ODV entries. For version number = hex 0001, this field is reserved (binary 0).	Bin(2)
112	70	Offset (in bytes) from beginning of template to the instruction stream component	Bin(4)
116	74	Offset (in bytes) from beginning of template to the ODV component	Bin(4)
120	78	Offset (in bytes) from beginning of template to the OES component	Bin(4)
124	7C	Length of breakpoint offset mapping table entry	Bin(4)
128	80	Length of breakpoint offset mapping table component	Bin(4)
132	84	Offset (in bytes) from beginning of template to the BOM table	Bin(4)
136	88	Length of symbol table entry	Bin(4)
140	8C	Length of symbol table component	Bin(4)
144	90	Offset (in bytes) from beginning of template to the Symbol table	Bin(4)
148	94	Offset (in bytes) from beginning of template to the object mapping table (OMT) component	Bin(4) +
152	98	Number of instructions (2) For version number = hex 0001, this field indicates the number of instructions. For version number = hex 0000, this field is reserved (binary 0).	Bin(4)
156	9C	Number of ODV entries (2) For version number = hex 0001, this field indicates the number of ODV entries. For version number = hex 0000, this field is reserved (binary 0).	Bin(4)
160	A0	Template extension This extension exists only when the template extension existence bit is 1.	Char(64)
160	A0	Extended program attributes	Char(4)
160	A0	Type of unconstrained arrays 0 = Not fully unconstrained. If arrays are unconstrained, unpredictable results may occur when accessing array elements outside the declared bounds of the array. 1 = Fully unconstrained. Predictable results will occur when accessing array elements outside the declared bounds of the array. See the paragraph below describing array constrainment for details.	Bit 0
160	A0	Suppress binary size exception 0 = Exception is not to be suppressed 1 = Exception is to be suppressed	Bit 1
160	A0	Create program for previous mandatory release 0 = Create the program to run on the current release 1 = Create the program to run on the previous mandatory release	Bit 2
160	A0	Collect object usage data for program 0 = Collect the object usage data 1 = Do not collect the object usage data	Bit 3
160	A0	Scope of resources 0 = Resources are scoped to an invocation of this program. 1 = Resources are scoped to a program previous to this one in the invocation stack.	Bit 4
160	A0	Reserved (binary 0)	Bits 5-31
164	A4	Language version, release, and modification level	Char(2)
164	A4	Reserved	Bits 0-3
164	A4	Version	Bits 4-7
164	A4	Release	Bits 8-11
164	A4	Mod level	Bits 12-15
166	A6	Breakpoint offset mapping table data	Char(1)
166	A6	BOM table flags	Char(1)
166	A6	Use new BOM table format	Bit 0
166	A6	User data5A	Bits 1-7
167	A7	User data5B	Char(7)
174	AE	Version, release, and modification level this program is being created for	Char(2)
174	AE	Reserved	Bits 0-3
174	AE	Version	Bits 4-7
174	AE	Release	Bits 8-11
174	AE	Mod level	Bits 12-15
176	B0	Data required for machine retranslation	Char(1)
176	B0	All data required for machine retranslation is present 0 = No 1 = Yes	Bit 0 +
176	B0	Reserved (binary 0)	Bits 1-7
177	B1	Reserved (binary 0)	Char(47)
224	E0	Program data	Char(*)
224	E0	Instruction stream component	Char(*)
*	*	ODV component	Char(*)
*	*	OES component	Char(*)
*	*	BOM table	Char(*)
*	*	Symbol table	Char(*)
*	*	Object mapping table	Char(*) +
*	*	--- End ---

The first 4 bytes of the materialization template identify the total number of bytes provided in the template. This value is supplied as input to the instruction and is not modified. A value of less than 8 causes the materialization length invalid (hex 3803) exception to be signaled.

The second 4 bytes of the materialization template are modified by the instruction to contain a value identifying the template size required to provide for the total number of bytes available to be materialized. The instruction materializes as many bytes as can be contained in the area specified by the receiver. If the byte area identified by the receiver is greater than that required to contain the information requested, then the excess bytes are unchanged. No exceptions (other than the materialization length invalid (hex 3803) exception) are signaled in the event that the receiver contains insufficient area for the materialization.

The existence attribute indicates whether the program is temporary or permanent.

If the program has an associated space, then the space attribute is set to indicate either fixed- or variable-length; the initial value for the space is returned in the initial value of space field, and the size of space field is set to the current size value of the space. If the program has no associated space, the size of space field is set to a zero value, and the space attribute and initial value of space field values are meaningless.

If the program is addressed by a context, then the context addressability attribute is set to indicate this, and a system pointer to the addressing context is returned in the context field. If the program is not addressed by a context, then the context addressability attribute is set to indicate this, and binary 0's are returned in the context field.

If the program is a member of an access group, then the access group attribute is set to indicate this, and a system pointer to the access group is returned in the access group field. If the program is not a member of an access group, then the access group attribute is set to indicate this, and binary 0's are returned in the access group field.

The automatically extend space field controls whether the space is to be extended automatically by the machine or a space addressing violation (hex 0601) exception is to be signaled when a reference is made to an area beyond the allocated portion of the space. A value of binary 1 indicates the space will automatically be extended by an amount determined through internal machine algorithms. A value of binary 0 indicates the exception will result. Note that an attempt to reference an area beyond the maximum size that a space can be allocated, will always result in the signaling of the space addressing violation (hex 0601) exception independently of the setting of this attribute. A value of binary 1 is only valid when the space attribute has been specified as variable length.

Usage of the automatically extend space function is limited. Predictable results will occur only when you ensure that the automatic extension of a space will not happen in conjunction with modification of the space size by another thread. That is, you must ensure that when a thread is using the space in a manner that could cause it to be automatically extended, it is the sole thread which can cause the space size to be modified. Note that in addition to implicit modification through automatic extension, the space size can be explicitly modified through use of the Modify Space Attributes (MODS) instruction.

The associated space hardware storage protection level can be used to restrict access to the contents of the space by user state programs. It is possible to limit the access of the space by user state programs into 1 of three levels:

Reference only (non-modifying storage references are allowed, modifying storing storage references yield an object domain or hardware storage protection violation (hex 4401) exception).
No storage references (all storage references, modifying or non-modifying yield an object domain or hardware storage protection violation (hex 4401) exception).
Full access (both modifying and non-modifying storage references are allowed).

The actual presentation of the object domain or hardware storage protection violation (hex 4401) exception is also dependent on the level of the physical hardware (namely, the CPU).

The performance class field provides information that allows the machine to more effectively manage the program by considering overall performance objectives of operations involving the program.

The primary associated space, if one is created, is always aligned on at least a 512 byte boundary if the target version, release, and modification level is V4R4 or greater. If the target version, release, and modification level is not V4R4 or greater, the primary associated space, if one is created, is always aligned on at least a 16-byte boundary.

If the adopted user profile attribute is yes, any reference to a system object from an invocation of this program uses the user profile of the owner of this program and other sources of authority to determine the authorization to system objects, privileged instructions, ownership rights, and all authorizations. If the adopted user profile propagation attribute is yes, then the authorities available from the adopted user profile are available to any further invocations while this program is invoked. If the adopted user profile propagation attribute is no, then the authorities available to the program's owning user profile are not available to further subinvocations and are available only to this invocation. These attributes do not affect the propagation of authority from higher existing invocations.

The array constraint field determines how array bounds should be checked at execution time. If arrays are constrained, execution time checks are made to verify that the array index is within the bounds of the array. If arrays are unconstrained and the type of unconstrained array is not fully unconstrained, the array references are assumed to be within the bounds of the array. If an array element reference is made outside the bounds of the array, unpredictable results may occur. If the type of unconstrained array is fully unconstrained, array references outside the bounds of the array will be made as if the elements existed. Array references of this type will signal the space addressing violation (hex 0601) exception if the element that is referenced is outside the allocated storage of the space containing the array. It is possible to change the type of constrainment used when referencing array elements by using the Override Program Attributes (OVRPGATR) instruction.

The string constrainment field determines how string limits should be checked at execution time. If string constrainment is strings are not constrained, the references are assumed to be within the defined bounds of the string. No execution time checks are performed to ensure this is the case. However, if the reference is outside the defined bounds, unpredictable results may occur. There may be significant savings in performance if strings are not constrained is specified. It is possible to change the type of constrainment used when substringing by using the Override Program Attributes (OVRPGATR) instruction.

Whenever a new invocation or activation is allocated, the automatic or static storage areas are initialized to bytes of binary 0's, respectively. The static storage and automatic storage program attributes control this default initialization. There is a significant performance advantage when these areas are not initialized by default. However, initial values specified for individual data objects are still set. The automatic storage and static storage will be allocated in single level store.

The associated journal entry field controls which program is associated with a journal entry. As a journal entry is made, a newest-to-oldest interrogation of the invocation stack is performed. The first program encountered that has the associated journal entry field set to program name is recorded in journal entries is associated with the journal entry by a record of the program name in the journal entry. If a program is encountered for which the associated journal entry field is set to program name is not recorded in journal entry, the program is ignored unless the program is on the top of the invocation stack. If the program is on the top of the invocation stack, it is associated with the journal entry by a record of the program name in the journal entry.

The suppress decimal data exception field controls whether or not errors detected in decimal data are to result in the signaling of the decimal data exception. When the decimal data exception is not to be suppressed, decimal values input to numeric operations are verified to contain valid decimal digit and sign codes with the decimal data (hex 0C02) exception being signaled as the result of detection of an invalid code. When the decimal data exception is to be suppressed, decimal values input to numeric operations are still verified to contain valid decimal digit and sign codes. However, detection of an invalid code results in the instruction interpreting an invalid digit as a zero and an invalid sign as positive rather than in signaling of the exception.

The control over suppressing of the decimal data exception applies to only a subset of the numeric operations which may be performed by the machine.

In general, when suppression of the decimal data exception is specified, the Computation and Branching instructions which support numeric source operands will suppress decimal data errors for ZONED source values. Additionally, a few instructions also suppress decimal data errors for packed source values. In all cases, the suppression is only supported when all operands are non-Data Pointer defined (early bound) source values.

Specifically, the following defines the exact list of instructions which support suppression of decimal data errors for certain operand types:

Packed Source Operands supported	Zoned Source Operands supported	Instruction Mnemonic	Note
	yes	ADDN
	yes	CMPNV
yes	yes	CVTCN	Only supported when operand 3, the numeric view to be used for operand 2, is specified as a constant and no DP defined operands are specified.
	yes	CVTDFFP
yes	yes	CVTNC	Only supported when operand 3, the numeric view to be used for operand 1, is specified as a constant and no DP defined operands are specified.
yes	yes	CPYNV	Only supported when no DP defined operands are specified.
	yes	DIV
	yes	DIVREM
	yes	EDIT	Only supported when no DP defined operands are specified.
	yes	EXTRMAG
	yes	MULT
	yes	NEG
	yes	REM
	yes	SCALE
	yes	SUBN

When suppression of the decimal data exception is specified, the decimal data (hex 0C02) exception may still be signaled by the machine. That is, other instructions and instruction combinations not listed above are exposed to signaling the decimal data (hex 0C02) exception when invalid decimal data is encountered and they can't be counted on to fix up invalid decimal data.

Of particular note here is that specification of a Data Pointer as an input operand on any of the instructions in the above list negates the suppression support for the whole instruction. Thus even non-Data Pointer defined operands are then exposed to detection of the decimal data (hex 0C02) exception.

The template extension existence field indicates whether or not there is an extension to the program template.

The suppress previously adopted user profiles field is used to stop the backward search for adopted or propagated authorities. In other words, all programs previous to this program's invocation with adopted or propagated authorities are not considered as sources of authority.

The code generation options provide information that allows the machine to create a program based on the intended use of the program.

If the performance optimization field is binary 1, additional processing is performed which provides for creating a program that requires less processor resource for execution. This optimizes addressability used within the program. If this attribute is set to binary 0, normal optimization processing is performed.

The space pointer machine objects field controls whether space pointer machine objects are allowed in the ODV. If the allow space pointer machine objects in ODV component attribute is set to binary 1, additional processing is performed which allows for space pointer machine objects within the program. If this attribute is set to binary 0, space pointer machine objects are not allowed in the ODV component.

The coincident operand overlap field controls whether or not additional processing is performed during the encapsulation of certain computation and branching instructions which affects the processor resource required to execute these instructions. The effect of the option controls whether or not the encapsulation process for these instructions should assume that coincident operand overlap may occur between the source and receiver operands during execution of the instruction. This assumption applies to cases of nonidentical coincident operand overlap where the Create Program (CRTPG) instruction cannot determine if coincident operand overlap may occur during execution of the instruction. These instructions may produce invalid results if nonidentical coincident overlap occurs during execution, but the instruction was encapsulated with the assumption that it would not occur.

Specifying the do not assume coincident operand overlap attribute indicates that nonidentical coincident overlap will not occur during execution and therefore the receiver on an instruction may be used as a work area during operations performed to produce the final result. Using the receiver as a work area does not require the processor resource that would be required to move the final result from an internal work area to the receiver.

Specifying the assume coincident operand overlap attribute indicates that nonidentical coincident operand overlap may occur during execution and therefore the receiver on an instruction should not be used as a work area during operations that produce the final result. This can require more processor resource for instruction execution but it insures valid results if overlap occurs.

The following is a list of instructions that can be affected by the coincident operand overlap option during the encapsulation process:

Add Logical Character
Add Numeric
And
Compute Math Function Using One Input Value
Concatenate
Convert Character To Numeric
Convert Decimal Form To Floating-Point
Convert External Form To Numeric Value
Convert Floating-Point To Decimal Form
Convert Numeric To Character
Copy Bytes Left Adjusted With Pad
Copy Bytes Right Adjusted With Pad
Divide
Divide With Remainder
Exclusive OR
Multiply
Or
Remainder
Scale
Subtract Logical Character
Subtract Numeric
Trim Length

The teraspace capable option indicates whether or not the program produced should be enabled to use teraspace addresses.

The executable part compression field and observation part compression field indicate whether the executable, observation, or both parts of the program are to be compressed. For materialization, these fields indicate whether parts of the program object are currently compressed.

The observation attributes field specifies options that control the observability and debugability of the program.

The first six bits control the availability of information through the Materialize Program (MATPG) instruction. If a bit is a binary 1 then the corresponding data from the program template is available for materialization. If the program is created without the ability to materialize observability data then less storage may be needed to contain the program object.

The remaining two bits control whether certain performance measurements will be possible when the program is executing. Prevent performance measurements on entry/exit controls whether performance measurements can be made which encompass the duration of the execution of this program. Prevent performance measurements on CALLX controls whether performance measurements can be made which encompass the duration of a CALLX from this program to another program. If either bit is a binary 1 then the corresponding measurement is prevented. If the ability to make performance measurements is prevented then the program may execute more quickly.

The size of static storage field defines the total amount of static storage required for this program's static data. A value of 0 indicates that the amount of static storage required is calculated based upon the amount of static data specified for the program. A value greater than 0 specifies the amount of static storage required.

The size of automatic storage field defines the total amount of automatic storage required for this program's automatic data. A value of 0 indicates that the amount of automatic storage required is calculated based upon the amount of automatic data specified for the program. A value greater than 0 specifies the amount of automatic storage required.

The number of instructions fields (1 and 2) and number of ODV entries fields (1 and 2) is specified in different locations in the template depending on the version of the program template. Template version 0 limits the number of instructions to a maximum of 65,532 and the number of ODV entries to a maximum of 8,191. Programs that exceed one of these maximums cannot be created with template version 0. Template version 1 limits the number of instructions to a maximum of 65,532 and the number of ODV entries to a maximum of 65,526. Programs that exceed one of these maximums cannot be created with template version 1. All other values for the template version are reserved.

The extended program attributes allow for additional attributes of the program to be specified.

To suppress binary size exceptions indicates the size (hex 0C0A) exception will be suppressed when an overflow or underflow occurs on a computation and control instruction with a receiver that is a binary variable scalar. The receiver will contain the left-truncated result.

Create program for previous mandatory release indicates whether or not the program is created to run on the previous mandatory release ¹

The collect object usage data for programs field is used to tell CALLX and XCTL instructions whether or not to collect object usage data for the program being called or transferred to.

The scope of resources field identifies the scope of program resources. The machine will set this field for the affected invocations, but the definition of those resources and the use of this field is determined by the MI user. If the scope of resources field is binary 0, then the resources will be scoped to the invocation of this program. If this scope of resources field is binary 1, then the resources will be scoped to the previous invocation of this program. If the scope of resources is also binary 1 for that invocation, the resources will be scoped to the next previous invocation, and so on.

The language version, release, and modification level is used to limit which version, release, and modification level that this program is allowed to be moved back to. This attribute allows the compilers to specify the earliest release in which the necessary runtime environment exists for the program to execute. The program will not be allowed to be restored to a system running at an earlier release than the one identified. A zero value for this attribute means that no restriction is specified.

The use new BOM table format flag is used to indicate which format of the BOM table is used. Binary 0 indicates old format, binary 1 indicates new format. These formats are documented below in the BOM table component.

The instruction stream component consists of a 4-byte binary value that defines the total length of the instruction stream component and a variable-length array of 2-byte entries that defines the instruction stream. The 2-byte entries define instruction operation codes, instruction operation code extenders, or instruction operands.

The object definition vector (ODV) component consists of a 4-byte binary value that defines the total length of the ODV and a variable-length vector of 4-byte entries. Each entry describes a program object either by a complete description or through an offset into the OES (object entry string) to a location that contains a description. If no program objects are defined, the ODV can be omitted, and its absence is noted with a value of 0 in the offset to ODV component entry. The ODV is required if the OES is present.

The ODV entry string (OES) consists of a 4-byte binary value that defines the total length of the OES and a series of variable-length entries that are used to complete an object description. Entries in the ODV contain offsets into the OES. The OES is optional, and its absence is indicated with a value of 0 in the offset to OES component entry.

The format of the ODT (object definition table) (ODV and OES) is defined in Program Object Specification.

The BOM table component can be used by compilers to relate high-level language statement numbers to instruction numbers.

The BOM table has the 2 formats depending on the BOM table flags. If the flag indicates to use new BOM table format, then the first bit of the MI instruction number is not a flag, so numbers up to 64k-1 can be used.

The BOM table has the following OLD format:

Offset
Dec	Hex	Field Name	Data Type and Length
0	0	MI instruction number	UBin(2)
0	0	Format 0 = High level statement number is in character format 1 = High level statement number is in numeric format	Bit 0
0	0	MI instruction number	Bits 1-15
2	2	High level statement number (character format) If this is in character format, then the length of it is contained in the header in the length of breakpoint offset mapping table entry.	Char(*)
2	2	High level statement number (numeric format)	Bin(2)
*	*	--- End ---

The BOM table has the following NEW format:

Offset
Dec	Hex	Field Name	Data Type and Length
0	0	MI instruction number	UBin(2)
2	2	Flag Byte	Char(1)
2	2	Format 0 = High level statement number is in character format 1 = High level statement number is in numeric format	Bit 0
2	2	Reserved	Bits 1-7
3	3	High level statement number (character format) If this is in character format, then the length of it is contained in the header in the length of breakpoint offset mapping table entry.	Char(*)
3	3	High level statement number (numeric format)	Bin(2)
*	*	--- End ---

The symbol table component can be used by compilers to relate high-level language names to ODT numbers.

The symbol table has the following format:

Offset
Dec	Hex	Field Name	Data Type and Length
0	0	Hashing table structure	Char(*)
0	0	Number of hash buckets	Bin(4)
4	4	Hash bucket Each hash bucket contains an offset to the first symbol table base segment entry of the chain. This offset is from the beginning of the symbol table. The end of the chain has a -1 value. Maximum of 1000 hash buckets.	[*] Bin(4)
*	*	Symbol table base segment	Char(*)
*	*	Offset to next entry from beginning of the table The end of the chain has a -1 value.	UBin(4)
*	*	ODT or MI number	Bin(2)
*	*	Indicators	Char(1)
*	*	Instruction or ODT number 0 = MI instruction number 1 = ODT number	Bit 0
*	*	Symbol origin 0 = Compiler generated 1 = Source program	Bit 1
*	*	Array specification 0 = Row major 1 = Column major	Bit 2
*	*	Format segment present 0 = No 1 = Yes	Bit 3
*	*	Array segment present 0 = No 1 = Yes	Bit 4
*	*	Extension segment present 0 = No 1 = Yes	Bit 5
*	*	Reserved (binary 0)	Bits 6-7
*	*	Length of symbol	Char(1)
*	*	Symbol	Char(*)
*	*	--- End ---

Other segments are only present if the bit in the symbol table base segment is on.

Offset
Dec	Hex	Field Name	Data Type and Length
0	0	Symbol table format segment	Char(20)
0	0	Format program name	Char(10)
10	A	Format code	Char(4)
14	E	Locator variable ODT#	Bin(2)
16	10	Descriptor variable ODT#	Bin(2)
18	12	Reserved (binary 0)	Char(2)
20	14	--- End ---

Offset
Dec	Hex	Field Name	Data Type and Length
0	0	Symbol table array segment	Char(*)
0	0	Number of array dimensions	Bin(2)
2	2	Indexes - 1 per array dimension	[*] Char(8)
2	2	Lower index	Bin(4)
6	6	Upper index	Bin(4)
*	*	--- End ---

Offset
Dec	Hex	Field Name	Data Type and Length
0	0	Symbol table extended segment	Char(26)
0	0	Extended segment length	Bin(2)
2	2	Structure level	Char(2)
4	4	Data representation Hex 00 = See ODT Hex 01 = Binary Hex 02 = Zoned Hex 03 = Bit string	Char(1)
5	5	Number of total digits	Bin(2)
7	7	Number of fractional digits	Bin(2)
9	9	Sign of number Hex 00 = Leading embedded Hex 01 = Leading separated Hex 02 = Trailing separate	Char(1)
10	A	Offset to base segment entry of parent The end of the chain has a -1 value.	Bin(4)
14	E	Offset to base segment entry of synonym The end of the chain has a -1 value.	Bin(4)
18	12	Indicators	Char(1)
18	12	Object is a HLL pointer	Bit 0
18	12	Array segment is in multi-dimensioned array format	Bit 1
18	12	Reserved (binary 0)	Bits 2-7
19	13	Reserved (binary 0)	Char(7)
26	1A	--- End ---

Hashing is done by exclusively Or'ing the first 4 characters of the symbol name with the second 4 characters of the symbol name. The result is then divided by the number of hash buckets. If the result is negative or 0, the number of hash buckets is added to the result. The result is then used as an index to the hash bucket.

Format segment is used by certain compilers to specify a format program name to be used when formatting this variable.

The offset to the OMT component field specifies the location of the OMT component in the materialized program template. The OMT consists of a variable-length vector of 6-byte entries. The number of entries is identical to the number of ODV entries because there is one OMT entry for each ODV entry. The OMT entries correspond one for one with the ODV entries; each OMT entry gives a location mapping for the object defined by its associated ODV entry.

The following describes the formats for an OMT entry:

Offset
Dec	Hex	Field Name	Data Type and Length
0	0	OMT entry	Char(6)
0	0	Addressability type Hex 00 = Base addressability is from the start of the static storage Hex 01 = Base addressability is from the start of the automatic storage area Hex 02 = Base addressability is from the start of the storage area addressed by a space pointer Hex 03 = Base addressability is from the start of the storage area of a parameter Hex 04 = Base addressability is from the start of the storage area addressed by the space pointer found in the process communication object attribute of the process associated with the thread executing the program Hex FF = Base addressability not provided. The object is contained in machine storage areas to which addressability cannot be given, or a parameter has addressability to an object that is in the storage of another program	Char(1)
1	1	Offset from base For types hex 00, hex 01, hex 02, hex 03, and hex 04, this is a 3-byte logical binary value representing the offset to the object from the base addressability. For type hex FF, the value is binary 0.	Char(3)
4	4	Base addressability For types hex 02 and hex 03, this is a 2-byte binary field containing the number of the OMT entry for the space pointer or a parameter that provides base addressability for this object. For types hex 00, hex 01, hex 04 and hex FF, the value is binary 0.	Char(2)
6	6	--- End ---

Authorization Required

Retrieve
- Operand 2
Execute
- Contexts referenced for address resolution

Lock Enforcement

Materialize
- Operand 2
- Contexts referenced for address resolution

Exceptions

06 Addressing
- 0601 Space Addressing Violation
- 0602 Boundary Alignment
- 0603 Range
08 Argument/Parameter
- 0801 Parameter Reference Violation
0A Authorization
- 0A01 Unauthorized for Operation
10 Damage Encountered
- 1004 System Object Damage State
- 1005 Authority Verification Terminated Due to Damaged Object
- 1044 Partial System Object Damage
1A Lock State
- 1A01 Invalid Lock State
1C Machine-Dependent
- 1C03 Machine Storage Limit Exceeded
20 Machine Support
- 2002 Machine Check
- 2003 Function Check
22 Object Access
- 2201 Object Not Found
- 2202 Object Destroyed
- 2203 Object Suspended
- 2207 Authority Verification Terminated Due to Destroyed Object
- 2208 Object Compressed
- 220A Program Not Eligible for Operation
- 220B Object Not Available
24 Pointer Specification
- 2401 Pointer Does Not Exist
- 2402 Pointer Type Invalid
- 2403 Pointer Addressing Invalid Object Type
2E Resource Control Limit
- 2E01 User Profile Storage Limit Exceeded
36 Space Management
- 3601 Space Extension/Truncation
38 Template Specification
- 3803 Materialization Length Invalid
44 Protection Violation
- 4401 Object Domain or Hardware Storage Protection Violation
- 4402 Literal Values Cannot Be Changed

Footnotes: