int __clcle(char *OP1, unsigned long op1_len, unsigned char OP2,
char *OP3, unsigned long op3_len)Operands: - OP1 represents the first operand in the hardware instruction.
- op1_len specifies the zero-based length of OP1,
which is the number of additional bytes to the right of OP1. A length of 1 is
represented by 0, a length of 2 is represented by 1, and so forth.
- OP2 specifies the number of bytes to pad the shorter operand on the right.
- OP3 represents the third operand in the hardware instruction.
- op3_len specifies the zero-based length of OP3,
which is the number of additional bytes to the right of OP3. A length of 1 is
represented by 0, a length of 2 is represented by 1, and so forth.
Note: If the LP64 compiler option is in effect, the op1_len and
op3_len operands are 64-bit unsigned integers. Otherwise, op1_len
and op3_len are 32-bit unsigned integers.
The return value is the condition
code set by the CLCLE instruction. Note: When the condition code is 3, the condition is handled
by the compiler-generated code.
|
L R2, OP1
L R3, op1_len
L R4, OP3
L R5, op3_len
CLCLE R2, R4, OP2D(OP2B)
|
ARCH(2) |
int __clclu(unsigned short *OP1, unsigned long op1_len, unsigned
short OP2, unsigned short *OP3, unsigned long op3_len)Operands: - OP1 represents the first operand in the hardware instruction.
- op1_len specifies the zero-based length of OP1,
which is the number of additional bytes to the right of OP1. A length of 1 is
represented by 0, a length of 2 is represented by 1, and so forth.
- OP2 specifies the number of bytes to pad the first operand on the right, in the
event that it is shorter than the third operand.
- OP3 represents the third operand in the hardware instruction.
- op3_len specifies the zero-based length of OP3,
which is the number of additional bytes to the right of OP3. A length of 1 is
represented by 0, a length of 2 is represented by 1, and so forth.
Notes: - If the LP64 compiler option is in effect, the op1_len and
op3_len operands are 64-bit unsigned integers. Otherwise they are 32-bit unsigned
integers.
- If the operand values are odd numbers, a specification exception will be triggered by the
hardware.
The return value is the condition code set by the CLCLU instruction. Note: When the condition code is 3, the condition is handled
by the compiler-generated code.
|
L R2, OP1
L R3, op1_len
L R4, OP3
L R5, op3_len
CLCLU R2, R4, OP2D(OP2B)
|
ARCH(6) |
int __cu12(unsigned short *OP1, unsigned long op1_len, char *OP2,
unsigned long op2_len, char **invalid_utf8, unsigned char mask)
The return
value is the condition code set by the CU12 instruction. Note: When the condition code is 3, the condition is handled
by the compiler-generated code.
|
L R2, OP1
L R3, op1_len
L R4, OP2
L R5, op2_len
CU12 R2, R4, Mask
|
ARCH(7) |
int __cu14 (unsigned int *OP1, unsigned long op1_len, char *OP2,
unsigned long op2_len, unsigned char **invalid_utf8, unsigned char mask)
The return
value is the condition code set by the CU14 instruction. Note: When the condition code is 3, the condition is handled
by the compiler-generated code.
|
L R2, OP1
L R3, op1_len
L R4, OP2
L R5, op2_len
CU14 R2, R4, Mask
ST *invalid_utf8,R4
|
ARCH(7) |
int __cu21(char *OP1, unsigned long op1_len, unsigned short *OP2,
unsigned long op2_len, unsigned char mask)
The return
value is the condition code set by the CU21 instruction. Note: When the condition code is 3, the condition is handled
by the compiler-generated code.
|
L R2, OP1
L R3, op1_len
L R4, OP2
L R5, op2_len
CU21 R2, R4, Mask
|
ARCH(7) |
int __cu24(unsigned int *OP1, unsigned long op1_len,
unsigned short *OP2, unsigned long op2_len, usigned char mask)
The return
value is the condition code set by the CU24 instruction. Note: When the condition code is 3, the condition is handled
by the compiler-generated code.
|
L R2, OP1
L R3, op1_len
L R4, OP2
L R5, op2_len
CU21 R2, R4, Mask
|
ARCH(7) |
int __cu41(char *OP1, unsigned long op1_len, unsigned int *OP2,
unsigned long op2_len, unsigned int **invalid_utf32)
Operands: - OP1 represents the first operand in the hardware instruction.
OP1 points to the storage location for receiving the converted UTF-8
characters.
- op1_len specifies the zero-based length of OP1,
which is the number of additional bytes to the right of OP1. A length of 1 is
represented by 0, a length of 2 is represented by 1, and so forth.
- OP2 represents the second operand in the hardware instruction.
OP2 points to the source UTF-32 characters.
- op2_len specifies the zero-based length of OP2,
which is the number of additional bytes to the right of OP2. A length of 1 is
represented by 0, a length of 2 is represented by 1, and so forth.
- invalid_utf32 points to a pointer field for receiving the address of the
invalid UTF-32 character in the source when the condition code is "2".
Note: If option LP64 is specified, both op1_len and op2_len
are 64-bit unsigned integers. Otherwise they are 32-bit unsigned integers.
The return value is
the condition code set by the CU41 instruction. Note: When the condition code is 3, the condition is handled
by the compiler-generated code.
|
L R2, OP1
L R3, op1_len
L R4, OP2
L R5, op2_len
CU41 R2, R4
ST *invalid_utf32,R4
|
ARCH(7) |
int __cu42(unsigned short *OP1, unsigned long op1_len, unsigned
int *OP2, unsigned long op2_len, unsigned int **invalid_utf32)
The return
value is the condition code set by the CU42 instruction. Note: When the condition code is 3, the condition is handled
by the compiler-generated code.
|
L R2, OP1
L R3, op1_len
L R4, OP2
L R5, op2_len
CU42 R2, R4
ST *invalid_utf32, R4
|
ARCH(7) |
int __cvb(char *OP2)
OP2 points to an 8-byte storage area that contains a valid packed-decimal value.
The return value is the converted 32-bit signed binary integer.
|
CVB R1, OP2D(OP2X, OP2B) |
ARCH(0) |
long long __cvbg(char *OP2)
Operands: OP2 points to a 16-byte storage area that contains a valid
packed-decimal value.
The return value is the converted 64-bit signed binary integer.
|
CVBG R1, OP2D(OP2X, OP2B) |
ARCH(5) |
void __cvd(int OP1, char *OP2)
- OP1 is a 32-bit signed binary integer value that gets converted into a
packed-decimal value.
- OP2 points to an 8-byte storage area that receives the converted packed-decimal
value.
|
CVD OP1, OP2D(OP2X, OP2B) |
ARCH(0) |
void __cvdg(long long OP1, char *OP2)
Operands: - OP1 is a 64-bit signed binary integer value that gets converted into a
packed-decimal value.
- OP2 points to a 16-byte storage area that receives the converted packed-decimal
value.
|
CVDG OP1, OP2D(OP2X, OP2B) |
ARCH(5) |
int __lad(int* OP1, int OP3, int* OP2)
Notes: - Return value corresponds to the condition code set by LAA.
- The location pointed to by OP2 must be word aligned for __lad.
Otherwise, a specification exception is recognized.
|
L R3, OP3
LAA R1, R3, OP2D(OP2B)
ST R1, *OP1
|
ARCH(9) |
int __ladg(long* OP1, long OP3, long* OP2)
Notes: - Return value corresponds to the condition code set by LAAG.
- The location pointed to by OP2 must be double-word aligned for
__ladg. Otherwise, a specification exception is recognized.
|
LG R3, OP3
LAAG R1, R3, OP2D(OP2B)
STG R1, *OP1
|
ARCH(9) with LP64 |
int __ladl(unsigned int* OP1, unsigned int OP3, unsigned int*
OP2)
Notes: - Return value corresponds to the condition code set by LAAL.
- The location pointed to by OP2 must be word aligned for
__ladl. Otherwise, a specification exception is recognized.
|
L R3, OP3
LAAL R1, R3, OP2D(OP2B)
ST R1, *OP1
|
ARCH(9) |
int __ladlg(unsigned long* OP1, unsigned long OP3, unsigned long*
OP2)
Notes: - Return value corresponds to the condition code set by LAALG.
- The location pointed to by OP2 must be double-word aligned for
__ladlg. Otherwise, a specification exception is recognized.
|
LG R3, OP3
LAALG R1, R3, Op2D(OP2B)
STG R1, *OP1
|
ARCH(9) with LP64 |
int __lan(unsigned int* OP1, unsigned int OP3, unsigned int*
OP2)
Notes: - Return value corresponds to the condition code set by LAN.
- The location pointed to by OP2 must be word aligned for __lan.
Otherwise, a specification exception is recognized.
|
L R3, OP3
LAN R1, R3, OP2D(OP2B)
ST R1, *OP1
|
ARCH(9) |
int __lang(unsigned long* OP1, unsigned long OP3, unsigned long*
OP2)
Notes: - Return value corresponds to the condition code set by LANG.
- The location pointed to by OP2 must be double-word aligned for
__lang. Otherwise, a specification exception is recognized.
|
LG R3, OP3
LANG R1, R3, OP2D(OP2B)
STG R1, *OP1
|
ARCH(9) with LP64 |
int __lao(unsigned int* OP1, unsigned int OP3, unsigned int*
OP2)
Notes: - Return value corresponds to the condition code set by LAO.
- The location pointed to by OP2 must be word aligned for __lao.
Otherwise, a specification exception is recognized.
|
L R3, OP3
LAO R1, R3, OP2D(OP2B)
ST R1, *OP1
|
ARCH(9) |
int __laog(unsigned long* OP1, unsigned long OP3, unsigned long*
OP2)
Notes: - Return value corresponds to the condition code set by LAOG.
- The location pointed to by OP2 must be double-word aligned for
__laog. Otherwise, a specification exception is recognized.
|
LG R3, OP3
LAOG R1, R3, OP2D(OP2B)
STG R1, *OP1
|
ARCH(9) with LP64 |
int __lax(unsigned int* OP1, unsigned int OP3, unsigned int*
OP2)
Notes: - Return value corresponds to the condition code set by LAX.
- The location pointed to by OP2 must be word aligned for __lax.
Otherwise, a specification exception is recognized.
|
L R3, OP3
LAX R1, R3, OP2D(OP2B)
ST R1, *OP1
|
ARCH(9) |
int __laxg(unsigned long* OP1, unsigned long OP3, unsigned long*
OP2)
Notes: - Return value corresponds to the condition code set by LAXG.
- The location pointed to by OP2 must be double-word aligned for
__laxg. Otherwise, a specification exception is recognized.
|
LG R3, OP3
LAXG R1, R3, OP2D(OP2B)
STG R1, *OP1
|
ARCH(9) with LP64 |
unsigned int __lcbb(const void*
OP2, unsigned short boundary)Operands: - OP2 represents the second operand in the hardware
instruction.
- boundary represents the boundary to encode in
the hardware instruction. It must be a literal value of either 64,
128, 256, 512, 1024, 2048, or 4096.
The return value is the first operand set by the LCBB
instruction. The first operand contains the number of bytes to load
from the second operand location without crossing the specified block
boundary. If the number of bytes is greater than 16, sixteen is placed
in the first operand.
|
LCBB R1, OP2D(OP2X, OP2B),
BoundaryM
|
ARCH(11) |
int __lpd(unsigned int* OP3, unsigned int* OP4, unsigned int* OP1,
unsigned int* OP2)
Notes: - Return value corresponds to the condition code set by LPD.
- The locations pointed to by OP1 and OP2 must be word aligned
for __lpd. Otherwise, a specification exception is recognized.
|
LPD R3, OP1D(OP1B),
OP2D(OP2B)
ST R3, *OP3
ST R4, *OP4
|
ARCH(9) |
int __lpdg(unsigned long* OP3, unsigned long* OP4, unsigned long*
OP1, unsigned long* OP2)
Notes: - Return value corresponds to the condition code set by LPDG.
- The locations pointed to by OP1 and OP2 must be double-word
aligned for __lpdg. Otherwise, a specification exception is recognized.
|
LPDG R3, OP1D(OP1B),
OP2D(OP2B)
STG R3, *OP3
STG R4, *OP4
|
ARCH(9) with LP64 |
unsigned int __lrv(unsigned int
*OP) The return value is the result.
|
LRV R1, OPD(OPX,OPR) |
ARCH(4) |
unsigned long __lrvg(unsigned long
*OP) The return value is the result.
|
LRVG R1, OPD(OPX,OPR) |
ARCH(5) with LP64 |
unsigned short __lrvh(unsigned short
*OP) The return value is the result.
|
LRVH R1, OPD(OPX,OPR) |
ARCH(4) |
int __mvcle(char *OP1, unsigned long op1_len, unsigned char OP2,
char *OP3, unsigned long op3_len)
Operands: - OP1 represents the first operand in the hardware instruction.
- op1_len specifies the zero-based length of OP1,
which is the number of additional bytes to the right of OP1. A length of 1 is
represented by 0, a length of 2 is represented by 1, and so forth.
- OP2 specifies the byte for padding the first operand on the right, in the event
that it is shorter than the third operand.
- OP3 represents the third operand in the hardware instruction.
- op3_len specifies the zero-based length of OP3,
which is the number of additional bytes to the right of OP3. A length of 1 is
represented by 0, a length of 2 is represented by 1, and so forth.
Note: If the LP64 compiler option is in effect, the op1_len and
op3_len operands are 64-bit unsigned integers. Otherwise, op1_len
and op3_len are 32-bit unsigned integers.
The return value is the condition
code set by the MVCLE instruction. Note: When the condition code is 3, the condition is handled
by the compiler-generated code.
|
L R2, OP1
L R3, op1_len
L R4, OP3
L R5, op3_len
MVCLE R2, R4, OP2D(OP2B)
|
ARCH(2) |
int __mvclu(unsigned short *OP1, unsigned long op1_len, unsigned
short OP2, unsigned short *OP3, unsigned long op3_len)Operands: - OP1 represents the first operand in the hardware instruction.
- op1_len specifies the zero-based length of OP1,
which is the number of additional bytes to the right of OP1. A length of 1 is
represented by 0, a length of 2 is represented by 1, and so forth.
- OP2 specifies padding the first operand with 2 bytes if it is shorter than the
third operand.
- OP3 represents the third operand in the hardware instruction.
- op3_len specifies the zero-based length of OP3,
which is the number of additional bytes to the right of OP3. A length of 1 is
represented by 0, a length of 2 is represented by 1, and so forth.
Notes: - If the operand values are odd numbers, a specification exception will be triggered by the
hardware.
- If the LP64 compiler option is in effect, the op1_len and
op3_len operands are 64-bit unsigned integers. Otherwise they are 32-bit unsigned
integers.
The return value is the condition code set by the MVCLU instruction. Note: When the condition code is 3, the condition is handled
by the compiler-generated code.
|
L R2, OP1
L R3, op1_len
L R4, OP3
L R5, op3_len
MVCLU R2, R4, OP2D(OP2B)
|
ARCH(6) |
int __nc (unsigned char *OP1, unsigned char *OP2, unsigned char
len)
The return value is the condition code.
|
NC OP1D(len,OP1B),
OP2D(OP2B)
|
ARCH(0) |
int __oc (unsigned char *OP1, unsigned char *OP2, unsigned char
len)
The return value is the condition code.
|
OC OP1D(len,OP1B),
OP2D(OP2B)
|
ARCH(0) |
void __pack (unsigned char *OP1, unsigned char op1_len, unsigned char *OP2, unsigned char op2_len)
Operands: - The format of OP2 is changed from zoned to signed-packed-decimal, and the
result is placed at OP1 location.
- OP2 is treated as having the zoned format. The numeric bits of each byte are
treated as a digit. The zone bits are ignored, except the zone bits in the rightmost byte, which are
treated as a sign.
- The sign and digits are moved unchanged to OP1 and are not checked for valid
codes. The sign is placed in the rightmost four bit positions of the rightmost byte of the result
field, and the digits are placed adjacent to the sign and to each other in the remainder of the
result field.
- The result is obtained as if the operands were processed right to left. When necessary,
OP2 is considered to be extended on the left with zeros. If OP1
field is too short to contain all digits of OP2, the remaining leftmost portion of
OP2 is ignored. Access exceptions for the unused portion of OP2
may or may not be indicated.
- op1_len specifies the zero-based length of
OP1, which is the number of additional bytes to the right of
OP1. A length of 1 is represented by 0, a length of 2 is represented
by 1, and so forth. op1_len must be in the range of 0 to 15
inclusive.
- op2_len specifies the zero-based length of
OP2, which is the number of additional bytes to the right of
OP2. A length of 1 is represented by 0, a length of 2 is represented
by 1, and so forth. op2_len must be in the range of 0 to 15
inclusive.
|
PACK OP1D(op1_len,OP1B),
OP2D(op2_len,OP2B)
|
ARCH(0) |
void __pka(char *OP1, char *OP2, unsigned char
op2_len)
- OP1 points to a 16-byte storage area. The packed string is stored in the
storage addressed by OP1.
- OP2 points to an ASCII string to be packed by the operation.
- op2_len specifies the zero-based length of OP2,
which is the number of additional bytes to the right of OP2. A length of 1 is
represented by 0, a length of 2 is represented by 1, and so forth.
Notes: - If op2_len is not between 0 and 31, a specification exception will be triggered
by the hardware.
- If op2_len is not a literal, the compiler will issue an EX instruction that
executes a target PKA instruction with op2_len encoded in the register used by the
EX instruction.
|
PKA OP1D(OP1B),
OP2D(op2_len, OP2B)
|
ARCH(6) |
void __pku(char *OP1, unsigned short *OP2, unsigned
char op2_len)
- OP1 points to a 16-byte storage area. The packed string is stored in the
storage addressed by OP1.
- OP2 points to Unicode Basic Latin character string to be packed by the
operation.
- op2_len specifies the zero-based length of OP2,
which is the number of additional bytes to the right of OP2. A length of 1 is
represented by 0, a length of 2 is represented by 1, and so forth.
Notes: - If op2_len is not an odd number between 0 and 63, a specification exception
will be triggered by the hardware.
- If op2_len is not a literal, the compiler will issue an EX instruction that
executes a target PKU instruction with op2_len encoded in the register used by the
EX instruction.
|
PKU OP1D(OP1B),
OP2D(op2_len, OP2B)
|
ARCH(6) |
unsigned long __popcnt(unsigned long OP)
The population count instruction counts the number of bits set in each byte of a register. It
then sets the corresponding byte of the result register to reflect the count.
The instruction
operates on all 64-bits of a register and thus clobbers the upper half of a register in 32-bit mode.
Volatile registers R0, R1, or R15 are used for the instruction in 32-bit mode with
NOHGPR.
|
POPCNT R1, OP |
ARCH(9) |
int __srstu (unsigned short *OP1, unsigned short *OP2, unsigned
short pattern, unsigned short **found_char)Operands: - OP1 represents the first operand in the hardware instruction, it points at the
first 2-byte character after the end of the second operand.
- OP2 represents the second operand in the hardware instruction, it points at the
start of a 2-byte character string.
- pattern is the 2-byte character to be searched for.
- found_char points to a pointer field for receiving the address of the 2-byte
character that was found in the second operand.
The return value is the condition code set by the SRSTU instruction. Note: When the condition code is 3, the condition is handled
by the compiler-generated code.
|
L GR0, pattern
L R1, OP1
SRSTU R1, OP2
ST *found_char, R1
|
ARCH(7) |
int __stck(unsigned long long *OP1) The
return value is the condition code.
|
STCK Op1D(OP1B) |
ARCH(0) |
int __stcke(void *OP1) The
return value is the condition code.
|
STCKE Op1D(OP1B) |
ARCH(4) |
int __stckf(unsigned long long *OP1) The
return value is the condition code.
|
STCKF Op1D(OP1B) |
ARCH(7) |
void __strv(unsigned int OP1, unsigned
int *OP2) |
STRV R1, OP2D(OP2X,OP2R) |
ARCH(4) |
void __strvg(unsigned long OP1,
unsigned long *OP2)
|
STRVG R1, OP2D(OP2X,OP2R) |
ARCH(5) with LP64 |
void __strvh(unsigned short OP1,unsigned
short *OP2) |
STRVH R1, OP2D(OP2X,OP2R) |
ARCH(4) |
void __tr (unsigned char *OP1, const
unsigned char *OP2, unsigned char len)
|
TR OP1D(len,OP1B),
OP2D(OP2B)
|
ARCH(0) |
int __tre(char *OP1, unsigned long op1_len, char *OP2, unsigned
char test_char)Operands:
The return value is the condition code set by the TRE instruction. Note: When the condition code is 3, the condition is handled
by the compiler-generated code.
|
TRE R1, OP2 |
ARCH(5) |
int __troo (char *OP1, char *OP2, unsigned long op2_len, char
*tr_table, unsigned char test_char, unsigned char mask)Operands: - OP1 represents the first operand in the hardware instruction.
- OP2 represents the second operand in the hardware instruction.
- op2_len specifies the zero-based length of OP2,
which is the number of additional bytes to the right of OP2. A length of 1 is
represented by 0, a length of 2 is represented by 1, and so forth.
Note: If option LP64 is
specified, op2_len is a 64-bit unsigned integer and the length of the first operand
is considered the same as that of the second operand. If option LP64 is not specified, both operands
are 32-bit unsigned integers.
- tr_table points to a 256-byte translation table on a double-word boundary.
Note: It is the user's responsibility to provide a double-word aligned translation
table.
- test_char specifies a 1-byte function character that can be coded in the
translation table for stopping the operation.
- mask specifies the mask encoded in the machine instruction; it must be a
literal value of either 0 or 1.
The return value is the condition code set by the TROO instruction. Note: When the condition code is 3, the condition is handled
by the compiler-generated code.
|
L GR0, test_char
L GR1, tr_table
L R2, OP1
L R3, op2_len
TROO R2, OP2, Mask
|
ARCH(7) |
int __trot(unsigned short *OP1, char *OP2, unsigned long op2_len,
char *tr_table, unsigned short test_char, unsigned char mask) Operands: - OP1 represents the first operand in the hardware instruction.
- OP2 represents the second operand in the hardware instruction.
- op2_len specifies the zero-based length of OP2,
which is the number of additional bytes to the right of OP2. A length of 1 is
represented by 0, a length of 2 is represented by 1, and so forth.
Note: If option LP64 is
specified, op2_len is a 64-bit unsigned integer and the length of the first operand
is considered the same as that of the second operand. Otherwise, both operands are 32-bit unsigned
integers.
- tr_table points to a 512-byte translation table on a double-word boundary.
Note: It is the user's responsibility to provide a double-word aligned translation
table.
- test_char specifies a 2-byte function character that can be coded in the
translation table for stopping the operation.
- mask specifies the mask encoded in the machine instruction; it must be a
literal value of either 0 or 1.
The return value is the condition code set by the TRTO instruction. Note: When the condition code is 3, the condition is handled
by the compiler-generated code.
|
L GR0, test_char
L GR1, tr_table
L R2, OP1
L R3, op2_len
TROT R2, OP2, Mask
|
ARCH(7) |
int __trto(char *OP1, unsigned short *OP2, unsigned long op2_len,
char *tr_table, char test_char, unsigned char mask)
The return value is the condition code set by the TROT instruction. Note: When the condition code is 3, the condition is handled
by the compiler-generated code.
|
L GR0, test_char
L GR1, tr_table
L R2, OP1
L R3, op2_len
TRTO R2, OP2, Mask
|
ARCH(7) |
int __trt (unsigned char *OP1, const
unsigned char *OP2, unsigned char len, unsigned char *R2, unsigned
char **R1)
The return value is the condition code.
|
TRT OP1D(len,OP1B),
OP2D(OP2B)
|
ARCH(0) |
int __trtr (unsigned char *OP1, const unsigned char *OP2, unsigned
char len, unsigned char *R2, unsigned char **R1)Operands:
The return value is the condition code set by the TRTR instruction.
|
TRTR OP1D(len, OP1B),
OP2D(OP2B)
ST *R2, GR2
ST *R1, GR1
|
ARCH(7) |
int __trtt(unsigned short *OP1, unsigned short *OP2, unsigned
long op2_len, char*tr_table, unsigned short test_char, unsigned char mask)Operands: - OP1 represents the first operand in the hardware instruction.
- OP2 represents the second operand in the hardware instruction.
- op2_len specifies the zero-based length of OP2,
which is the number of additional bytes to the right of OP2. A length of 1 is
represented by 0, a length of 2 is represented by 1, and so forth.
Note: If option LP64 is
specified, op2_len is a 64-bit unsigned integer and the length of the first operand
is considered the same as that of the second operand. Otherwise, both operands are 32-bit unsigned
integers.
- tr_table points to a 128-KB translation table on a double-word boundary.
Note: It is the user's responsibility to provide a double-word aligned translation
table.
- test_char specifies a 2-byte function character that can be coded in the
translation table for stopping the operation.
- mask specifies the mask encoded in the machine instruction; it must be a
literal value of either 0 or 1.
The return value is the condition code set by the TRTT instruction. Note: When the condition code is 3, the condition is handled
by the compiler-generated code.
|
L GR0, test_char
L GR1, tr_table
L R2, OP1
L R3, op2_len
TRTT R2, OP2, Mask
|
ARCH(7) |
void __unpk (unsigned char *OP1, unsigned char op1_len, unsigned char *OP2, unsigned char op2_len)
Operands: - The format of OP2 is changed from signed-packed-decimal to zoned, and the
result is placed at OP1 location.
- OP2 is treated as having the signed-packed-decimal format. Its digits and sign
are placed unchanged in OP1 location, using the zoned format. Zone bits with coding
of 1111 are supplied for all bytes except the rightmost byte, the zone of which receives the sign of
OP2. The sign and digits are not checked for valid codes.
- The result is obtained as if the operands were processed right to left. When necessary,
OP2 is considered to be extended on the left with zeros. If OP1
field is too short to contain all digits of OP2, the remaining leftmost portion of
OP2 is ignored. Access exceptions for the unused portion of OP2
may or may not be indicated.
- op1_len specifies the zero-based length of
OP1, which is the number of additional bytes to the right of
OP1. A length of 1 is represented by 0, a length of 2 is represented
by 1, and so forth. op1_len must be in the range of 0 to 15
inclusive.
- op2_len specifies the zero-based length of
OP2, which is the number of additional bytes to the right of
OP2. A length of 1 is represented by 0, a length of 2 is represented
by 1, and so forth. op2_len must be in the range of 0 to 15
inclusive.
|
UNPK OP1D(op1_len,OP1B),
OP2D(op2_len,OP2B)
|
ARCH(0) |
int __unpka(char *OP1,
unsigned char op1_len, char *OP2); Operands:
The return value is the condition code set by the UNPKA instruction.
|
UNPKA OP1D(op1_len, OP1B),
OP2D(OP2B)
|
ARCH(6) |
int __unpku(unsigned
short *OP1, unsigned char op1_len, char *OP2); Operands: - OP1 points to a maximum 64-byte storage area
to receive the unpacked data from the second operand.
- op1_len specifies the zero-based length of OP1,
which is the number of additional bytes to the right of OP1. A length of 1 is
represented by 0, a length of 2 is represented by 1, and so forth.
Notes: - If op1_len is not a literal, the compiler will issue an EX instruction that
executes a target UNPKU instruction with op1_len encoded in the register used by
the EX instruction.
- If op1_len is not an odd number between 0 and 63, a specification exception
will be triggered by the hardware.
- OP2 points to a 16-byte data string that represents
31 digits and a sign.
The return value is the condition code set by the UNPKU
instruction.
|
UNPKU OP1D(op1_len, OP1B),
OP2D(OP2B)
|
ARCH(6) |
int __xc (unsigned char *OP1, unsigned char *OP2, unsigned char
len)
The return value is the condition code.
|
XC OP1D(len,OP1B),
OP2D(OP2B)
|
ARCH(0) |