B2R2
Opcode Type
Represents a S390 opcode.
Record fields
| Record Field |
Description
|
Add (32)
|
|
Add Normalized (long HFP)
|
|
Add (long BFP)
|
|
Add (long BFP)
|
|
Add Normalized (long HFP)
|
|
Add (long DFP)
|
|
Add (extended DFP)
|
|
Add Normalized (short HFP)
|
|
Add (short BFP)
|
|
Add (short BFP)
|
|
Add Normalized (short HFP)
|
|
Add Immediate (32)
|
|
Add (64)
|
|
Add (64 <- 32)
|
|
Add Immediate to Register (64 <- 32)
|
|
Add Registers (64 <- 32)
|
|
Add Halfword (64 <- 16)
|
|
Add Halfword Immediate to Register (64)
|
|
Add Immediate to Register (64 <- 16)
|
|
Add Registers (64)
|
|
Add (64)
|
|
Add Immediate to Register (64 <- 8)
|
|
Add Halfword (32 <- 16)
|
|
Add High (32)
|
|
Add High (32)
|
|
Add Halfword Immediate to Register (32)
|
|
Add Immediate to Register (32 <- 16)
|
|
Add Halfword (32 <- 16)
|
|
Add Immediate High (32)
|
|
Add Logical (32)
|
|
Add Logical with Carry (32)
|
|
Add Logical with Carry (64)
|
|
Add Logical Registers with Carry (64)
|
|
Add Logical Registers with Carry (32)
|
|
Add Logical Immediate to Register (32)
|
|
Add Logical (64)
|
|
Add Logical (64 <- 32)
|
|
Add Logical Immediate to Register (64 <- 32)
|
|
Add Logical Registers (64 <- 32)
|
|
Add Logical with Signed Immediate (64 <- 16)
|
|
Add Logical Registers (64)
|
|
Add Logical (64)
|
|
Add Logical with Signed Immediate (64 <- 8)
|
|
Add Logical High (32)
|
|
Add Logical High (32)
|
|
Add Logical with Signed Immediate (32 <- 16)
|
|
Add Logical Registers (32)
|
|
Add Logical (32)
|
|
Add Logical with Signed Immediate (32 <- 8)
|
|
Add Logical with Signed Immediate High (32)
|
|
Add Logical with Signed Immediate High (32)
|
|
Add Logical (32)
|
|
Add Decimal
|
|
Add Registers (32)
|
|
Add (32)
|
|
Add Immediate to Register (32 <- 8)
|
|
Add Unnormalized (short HFP)
|
|
Add Unnormalized (short HFP)
|
|
Add Unnormalized (long HFP)
|
|
Add Unnormalized (long HFP)
|
|
Add (extended BFP)
|
|
Add Normalized (extended HFP)
|
|
Add (extended DFP)
|
|
Add (extended DFP)
|
|
Add (32)
|
|
Branch and Stack
|
|
Branch and Link
|
|
Branch and Link
|
|
Branch and Save
|
|
Branch and Save
|
|
Branch and Save and Set Mode
|
|
Branch on Condition
|
|
Branch on Condition
|
|
Branch on Count (32)
|
|
Branch on Count (64)
|
|
Branch on Count Register (64)
|
|
Branch on Count Register (32)
|
|
Branch Indirect on Condition
|
|
Branch Prediction Preload
|
|
Branch Prediction Relative Preload
|
|
Branch Relative and Save
|
|
Branch Relative and Save Long
|
|
Branch Relative on Condition
|
|
Branch Relative on Condition Long
|
|
Branch Relative on Count Register (32)
|
|
Branch Relative on Count Register (64)
|
|
Branch Relative on Count High (32)
|
|
Branch Relative on Index High (32)
|
|
Branch Relative on Index High (64)
|
|
Branch Relative on Index Low or Equal (32)
|
|
Branch Relative on Index Low or Equal (64)
|
|
Branch and Set Authority
|
|
Branch in Subspace Group
|
|
Branch and Set Mode
|
|
Branch on Index High (32)
|
|
Branch on Index High (64)
|
|
Branch on Index Low or Equal (32)
|
|
Branch on Index Low or Equal (64)
|
|
Compare (32)
|
|
Compare (long HFP)
|
|
Compare (long BFP)
|
|
Compare (long BFP)
|
|
Convert from Fixed (long BFP <- 32)
|
|
Convert from Fixed (long BFP <- 64)
|
|
Convert from Fixed (long HFP <- 32)
|
|
Convert from Fixed (long DFP <- 32)
|
|
Convert from Fixed (long BFP <- 64)
|
|
Convert from Fixed (long BFP <- 64)
|
|
Convert from Fixed (long HFP <- 64)
|
|
Convert from Fixed (long DFP <- 64)
|
|
Convert from Fixed (long DFP <- 64)
|
|
Convert from Logical (long BFP <- 32)
|
|
Convert from Logical (long DFP <- 32)
|
|
Convert from Logical (long BFP <- 64)
|
|
Convert from Logical (long DFP <- 64)
|
|
Convert from Packed (to long DFP)
|
|
Compare (long HFP)
|
|
Compare Double and Swap (32)
|
|
Compare Double and Swap (64)
|
|
Convert from Signed Packed (long DFP <- 64)
|
|
Compare Double and Swap (32)
|
|
Compare (long DFP)
|
|
Convert from Unsigned Packed (long DFP <- 64)
|
|
Convert from Zoned (to long DFP)
|
|
Compare (short HFP)
|
|
Compare (short BFP)
|
|
Compare (short BFP)
|
|
Compare Biased Exponent (long DFP)
|
|
Convert from Fixed (short BFP <- 32)
|
|
Convert from Fixed (short BFP <- 32)
|
|
Convert from Fixed (short HFP <- 32)
|
|
Convert from Fixed (short BFP <- 64)
|
|
Convert from Fixed (short BFP <- 32)
|
|
Convert from Fixed (short HFP <- 64)
|
|
Convert from Logical (short BFP <- 32)
|
|
Convert from Logical (short BFP <- 64)
|
|
Compare (short HFP)
|
|
Compare Biased Exponent (extended DFP)
|
|
Compare and Form Codeword
|
|
Convert to Fixed (32 <- long BFP)
|
|
Convert to Fixed (32 <- long BFP)
|
|
Convert to Fixed (32 <- long HFP)
|
|
Convert to Fixed (32 <- long DFP)
|
|
Convert to Fixed (32 <- short BFP)
|
|
Convert to Fixed (32 <- short BFP)
|
|
Convert to Fixed (32 <- short HFP)
|
|
Compare Register with Immediate (32)
|
|
Convert to Fixed (32 <- extended BFP)
|
|
Convert to Fixed (32 <- extended BFP)
|
|
Convert to Fixed (32 <- extended HFP)
|
|
Convert to Fixed (32 <- extended DFP)
|
|
Compare (64)
|
|
Convert to Fixed (64 <- long BFP)
|
|
Convert to Fixed (64 <- long BFP)
|
|
Convert to Fixed (64 <- long HFP)
|
|
Convert to Fixed (64 <- long DFP)
|
|
Convert to Fixed (64 <- long DFP)
|
|
Convert to Fixed (64 <- short BFP)
|
|
Convert to Fixed (64 <- short BFP)
|
|
Convert to Fixed (64 <- short HFP)
|
|
Compare (64 <- 32)
|
|
Compare Register with Immediate (64 <- 32)
|
|
Compare Registers (64 <- 32)
|
|
Compare Relative Long (64 <- 32)
|
|
Compare Halfword (64 <- 16)
|
|
Compare Halfword Immediate (64 <- 16)
|
|
Compare Halfword Relative Long (64 <- 16)
|
|
Compare Halfword Immediate (64 <- 16)
|
|
Compare Immediate And Branch (64 <- 8)
|
|
Compare Immediate and Branch Relative (64 <- 8)
|
|
Compare Immediate and Trap (64 <- 16)
|
|
Compare Registers (64)
|
|
Compare and Branch (64)
|
|
Compare and Branch Relative (64)
|
|
Compare Relative Long (64)
|
|
Compare and Trap (64)
|
|
Convert to Fixed (64 <- extended BFP)
|
|
Convert to Fixed (64 <- extended BFP)
|
|
Convert to Fixed (64 <- extended HFP)
|
|
Convert to Fixed (64 <- extended DFP)
|
|
Convert to Fixed (64 <- extended DFP)
|
|
Compare Halfword (32 <- 16)
|
|
Compare High (32)
|
|
Compare High (32)
|
|
Compare Halfword Immediate (16)
|
|
Compare Halfword Immediate (32 <- 16)
|
|
Compare High (32)
|
|
Compare Halfword Relative Long (32 <- 16)
|
|
Compare Halfword Immediate (32 <- 16)
|
|
Compare Halfword (32 <- 16)
|
|
Compare Immediate and Branch (32 <- 8)
|
|
Compare Immediate High (32)
|
|
Compare Immediate And Branch Relative (32 <- 8)
|
|
Compare Immediate and Trap (32 <- 16)
|
|
Checksun
|
|
Compare Logical (32)
|
|
Compare Logical (Character)
|
|
Compare Logical Long
|
|
Compare Logical Long Extended
|
|
Compare Logical Long Unicode
|
|
Convert to Logical (32 <- long BFP)
|
|
Convert to Logical (32 <- long DFP)
|
|
Convert to Logical (32 <- short BFP)
|
|
Compare Logical Immediate (32 <- 16)
|
|
Compare Logical Immediate (32)
|
|
Compare Logical Immediate and Trap (32 <- 16)
|
|
Convert to Logical (32 <- extended BFP)
|
|
Convert to Logical (32 <- extended DFP)
|
|
Compare Logical (64)
|
|
Convert to Logical (64 <- long BFP)
|
|
Convert to Logical (64 <- long DFP)
|
|
Convert to Logical (64 <- short BFP)
|
|
Compare Logical (64 <- 32)
|
|
Compare Logical Immediate (64 <- 32)
|
|
Compare Logical (64 <- 32)
|
|
Compare Logical Relative Long (64 <- 32)
|
|
Compare Logical Relative Long (64 <- 16)
|
|
Compare Logical Immediate (64 <- 16)
|
|
Compare Logical Immediate and Branch (64 <- 8)
|
|
Compare Logical Immediate and Branch Relative (64 <- 8)
|
|
Compare Logical Immediate and Trap (64 <- 16)
|
|
Compare Logical (64)
|
|
Compare Logical and Branch (64)
|
|
Compare Logical and Branch Relative (64)
|
|
Compare Logical Relative Long (64)
|
|
Compare Logical and Trap (64)
|
|
Compare Logical and Trap (64)
|
|
Convert to Logical (64 <- extended BFP)
|
|
Convert to Logical (64 <- extended DFP)
|
|
Compare Logical High (32)
|
|
Compare Logical High (32)
|
|
Compare Logical Immediate (16)
|
|
Compare Logical High (32)
|
|
Compare Logical Relative Long (32 <- 16)
|
|
Compare Logical Immediate
|
|
Compare Logical Immediate and Branch (32 <- 8)
|
|
Compare Logical Immediate High (32)
|
|
Compare Logical Immediate and Branch Relative (32 <- 8)
|
|
Compare Logical Immediate
|
|
Compare Logical Char under Mask (low)
|
|
Compare Logical Char under Mask (high)
|
|
Compare Logical Char under Mask (low)
|
|
Compare Logical (32)
|
|
Compare Logical and Branch (32)
|
|
Compare Logical and Branch Relative (32)
|
|
Compare Logical Relative Long (32)
|
|
Compare Logical and Trap (32)
|
|
Compare Logical String
|
|
Compare Logical and Trap (32)
|
|
Compare Logical (32)
|
|
Compression Call
|
|
Compare Decimal
|
|
Convert to Packed (from long DFP)
|
|
Copy Sign (long)
|
|
Convert to Packed (from extended DFP)
|
|
Copy Access
|
|
Compare Registers (32)
|
|
Compare and Branch (32)
|
|
Compare and Replace DAT Table Entry
|
|
Compare and Branch Relative (32)
|
|
Compare Relative Long (32)
|
|
Compare and Trap (32)
|
|
Compare and Swap (32)
|
|
Clear Subchannel
|
|
Convert to Signed Packed (64 <- long DFP)
|
|
Compare and Swap (64)
|
|
Compare and Swap and Purge
|
|
Compare and Swap and Purge
|
|
Compare and Swap and Store
|
|
Convert to Signed Packed (128 <- extended DFP)
|
|
Compare and Swap (32)
|
|
Convert UTF-8 to UTF-16
|
|
Convert UTF-8 to UTF-32
|
|
Convert UTF-16 to UTF-8
|
|
Convert UTF-16 to UTF-32
|
|
Convert UTF-32 to UTF-8
|
|
Convert UTF-32 to UTF-16
|
|
Convert to Unsigned Packed (64 <- long DFP)
|
|
Compare Until Substring Equal
|
|
Convert UTF-8 to Unicode
|
|
Convert Unicode to UTF-8
|
|
Convert to Unsigned Packed (64 <- long DFP)
|
|
Convert to Binary (32)
|
|
Convert to Binary (64)
|
|
Convert to Binary (32)
|
|
Convert to Decimal (32)
|
|
Convert to Decimal (64)
|
|
Convert to Decimal (32)
|
|
Compare (extended BFP)
|
|
Convert from Fixed (extended BFP <- 32)
|
|
Convert from Fixed (extended BFP <- 32)
|
|
Convert from Fixed (extended HFP <- 32)
|
|
Convert from Fixed (extended DFP <- 32)
|
|
Convert from Fixed (extended BFP <- 64)
|
|
Convert from Fixed (extended BFP <- 64)
|
|
Convert from Fixed (extended HFP <- 64)
|
|
Convert from Fixed (extended DFP <- 64)
|
|
Convert from Fixed (extended DFP <- 64)
|
|
Convert from Logical (extended BFP <- 32)
|
|
Convert from Logical (extended DFP <- 32)
|
|
Convert from Logical (extended BFP <- 64)
|
|
Convert from Logical (extended DFP <- 64)
|
|
Convert from Packed (to extended DFP)
|
|
Compare (extended HFP)
|
|
Convert from Signed Packed (extended DFP <- 128)
|
|
Compare (extended DFP)
|
|
Convert from Unsigned Packed (extended DFP <- 128)
|
|
Convert from Zoned (to extended DFP)
|
|
Compare (32)
|
|
Convert to Zoned (from long DFP)
|
|
Convert to Zoned (from extended DFP)
|
|
Divide (32 <- 64)
|
|
Divide (long HFP)
|
|
Divide (long BFP)
|
|
Divide (long BFP)
|
|
Divide (long HFP)
|
|
Divide (long DFP)
|
|
Divide (long DFP)
|
|
Divide (short HFP)
|
|
Divide (short BFP)
|
|
Divide (short BFP)
|
|
Divide (short HFP)
|
|
Deflate Conversion Call
|
|
Divide to Integer (long BFP)
|
|
Divide to Integer (short BFP)
|
|
Divide Logical (32 <- 64)
|
|
Divide Logical (64 <- 128)
|
|
Divide Logical (64 <- 128)
|
|
Divide Logical (32 <- 64)
|
|
Divide Decimal
|
|
Divide (32 <- 64)
|
|
Divide Single (64)
|
|
Divide Single (64 <- 32)
|
|
Divide Single (64 <- 32)
|
|
Divide Single (64)
|
|
Divide (extended BFP)
|
|
Divide (extended HFP)
|
|
Divide (extended DFP)
|
|
Divide (extended DFP)
|
|
Diagnose
|
|
Extract Access Register
|
|
Extract Cache Attribute
|
|
Extract CPU Time
|
|
Edit
|
|
Edit and Mark
|
|
Extract Biased Exponent (64 <- long DFP)
|
|
Extract Biased Exponent (64 <- extended DFP)
|
|
Extract FPC
|
|
Extract Primary ASN and Instance
|
|
Extract Primary ASN
|
|
Extract PSW
|
|
Extract Stacked Registers (32)
|
|
Extract Stacked Registers (64)
|
|
Extract Secondary ASN and Instance
|
|
Extract Secondary ASN
|
|
Extract Significance (long DFP)
|
|
Extract and Set Extended Authority
|
|
Extract Stacked State
|
|
Extract Significance (long DFP)
|
|
Extract Transaction Nesting Depth
|
|
Execute
|
|
Execute Relative Long
|
|
Load FP Integer (long BFP)
|
|
Load FP Integer (long BFP)
|
|
Load FP Integer (long HFP)
|
|
Load FP Integer (long DFP)
|
|
Load FP Integer (short BFP)
|
|
Load FP Integer (short BFP)
|
|
Load FP Integer (short HFP)
|
|
Load FP Integer (extended BFP)
|
|
Load FP Integer (extended BFP)
|
|
Load FP Integer (extended HFP)
|
|
Load FP Integer (long DFP)
|
|
Find Leftmost One
|
|
Halve (long HFP)
|
|
Halve (short HFP)
|
|
Halt Subchannel
|
|
Insert Address Space Control
|
|
Insert Character
|
|
Insert Characters under Mask (low)
|
|
Insert Characters under Mask (high)
|
|
Insert Characters under Mask (low)
|
|
Insert Character
|
|
Invalidate DAT Table Entry
|
|
Insert Biased Exponent (long DFP <- 64)
|
|
Insert Biased Exponent (long DFP <- 64)
|
|
Insert Immediate (high)
|
|
Insert Immediate (high high)
|
|
Insert Immediate (high low)
|
|
Insert Immediate (low)
|
|
Insert Immediate (low high)
|
|
Insert Immediate (low low)
|
|
Insert PSW Key
|
|
Insert Program Mask
|
|
Invalidate Page Table Entry
|
|
Insert Reference Bits Multiple
|
|
Insert Storage Key Extended
|
|
Insert Virtual Storage Key
|
|
Invalid Opcode
|
|
Compare and Signal (long BFP)
|
|
Compare and Signal (long BFP)
|
|
Compute Digital Signature Authentication
|
|
Compare and Signal (long DFP)
|
|
Compare and Signal (short BFP)
|
|
Compare and Signal (short BFP)
|
|
Compute Intermediate Message Digest
|
|
Compute Last Message Digest
|
|
Cipher Messasge
|
|
Cipher Message with Authentication
|
|
Compute Message Authentication Code
|
|
Cipher Message with Chaining
|
|
Cipher Message with Counter
|
|
Cipher Message with Cipher Feedback
|
|
Cipher Message with Output Feedback
|
|
Compare and Signal (extended BFP)
|
|
Compare and Signal (extended DFP)
|
|
Load (32)
|
|
Load Address
|
|
Load and Add (32)
|
|
Load and Add (64)
|
|
Load and Add Logical (32)
|
|
Load and Add Logical (64)
|
|
Load Address Extended
|
|
Load Address Extended
|
|
Load Access Multiple
|
|
Load Access Multiple
|
|
Load and AND (32)
|
|
Load and AND (64)
|
|
Load and OR (32)
|
|
Load and OR (64)
|
|
Load Address Relative Long
|
|
Load Address Space Parameters
|
|
Load and Trap (32L <- 32)
|
|
Load and Exclusive OR (32)
|
|
Load and Exclusive OR (64)
|
|
Load Address
|
|
Load Byte (32)
|
|
Load BEAR
|
|
Load Byte High (32 <- 8)
|
|
Load Byte (32)
|
|
Load Count to Block Boundary
|
|
Load Complement (long BFP)
|
|
Load Complement (long)
|
|
Load Complement (long HFP)
|
|
Load Complement (short BFP)
|
|
Load Complement (short HFP)
|
|
Load Complement (64 <- 32)
|
|
Load Complement (64)
|
|
Load Complement (32)
|
|
Load Control (32)
|
|
Load Control (64)
|
|
Load Complement (extended BFP)
|
|
Load Complement (extended HFP)
|
|
Load (long)
|
|
Load Lengthened (long HFP <- short)
|
|
Load Lengthened (long BFP <- short)
|
|
Load Lengthened (long BFP <- short)
|
|
Load Lengthened (long HFP <- short)
|
|
Load Lengthened (long DFP <- short)
|
|
Load FPR from GR (long <- 64)
|
|
Load (long)
|
|
Load Rounded (long BFP <- extended)
|
|
Load Rounded (long BFP <- extended)
|
|
Load Rounded (long HFP <- extended)
|
|
Load Rounded (long DFP <- extended)
|
|
Load (long)
|
|
Load (short)
|
|
Load Rounded (short BFP <- long)
|
|
Load Rounded (short BFP <- long)
|
|
Load Rounded (short HFP <- long)
|
|
Load Rounded (short DFP <- long)
|
|
Load (short)
|
|
Load Rounded (short BFP <- extended)
|
|
Load Rounded (short BFP <- extended)
|
|
Load Rounded (short HFP <- extended)
|
|
Load (short)
|
|
Load FPC and Signal
|
|
Load High (32)
|
|
Load High and Trap (32)
|
|
Load FPC
|
|
Load (64)
|
|
Load and Trap (64)
|
|
Load Byte (64)
|
|
Load Byte (64)
|
|
Load GR from FPR (64 <- long)
|
|
Load (64 <- 32)
|
|
Load Immediate (64 <- 32)
|
|
Load (64 <- 32)
|
|
Load Relative Long (64 <- 32)
|
|
Load Guarded (64)
|
|
Load Halfword (64)
|
|
Load Halfword Immediate (64)
|
|
Load Halfword (64)
|
|
Load Halfword Relative Long (64 <- 16)
|
|
Load (64)
|
|
Load Relative Long (64)
|
|
Load Guarded Storage Controls
|
|
Load Halfword (32)
|
|
Load Halfword High (32 <- 16)
|
|
Load Halfword Immediate (32)
|
|
Load Halfword (32)
|
|
Load Halfword Relative Long (32 <- 16)
|
|
Load Halfword (32)
|
|
Load Logical Character (32)
|
|
Load Logical Character High (32 <- 8)
|
|
Load Logical Character (32)
|
|
Load Logical Character (64)
|
|
Load Logical Character (64)
|
|
Load Logical (64 <- 32)
|
|
Load Logical and Trap (64 <- 32)
|
|
Load Logical (64 <- 32)
|
|
Load Logical Relative Long (64 <- 32)
|
|
Load Logical and Shift Guarded (64 <- 32)
|
|
Load Logical Halfword (64)
|
|
Load Logical Halfword (64)
|
|
Load Logical Halfword Relative Long (64 <- 16)
|
|
Load Logical Thirty One Bits
|
|
Load Logical Thirty One Bits and Trap (64 <- 31)
|
|
Load Logical Thirty One Bits
|
|
Load Logical Halfword (32)
|
|
Load Logical Halfword High (32 <- 16)
|
|
Load Logical Halfword (32)
|
|
Load Logical Halfword Relative Long (32 <- 16)
|
|
Load Logical Immediate (high)
|
|
Load Logical Immediate (high high)
|
|
Load Logical Immediate (high low)
|
|
Load Logical Immediate (low)
|
|
Load Logical Immediate (low high)
|
|
Load Logical Immediate (low low)
|
|
Load Logical and Zero Rightmost Byte (64 <- 32)
|
|
Load Multiple (32)
|
|
Load Multiple Disjoint
|
|
Load Multiple (64)
|
|
Load Multiple High
|
|
Load Multiple (32)
|
|
Load Negative (long BFP)
|
|
Load Negative (long)
|
|
Load Negative (long HFP)
|
|
Load Negative (short BFP)
|
|
Load Negative (short HFP)
|
|
Load Negative (64 <- 32)
|
|
Load Negative (64)
|
|
Load Negative (32)
|
|
Load Negative (extended BFP)
|
|
Load Negative (extended HFP)
|
|
Load on Condition (32)
|
|
Load High on Condition (32)
|
|
Load High on Condition (32)
|
|
Load on Condition (64)
|
|
Load Halfword Immediate on Condition (64 <- 16)
|
|
Load on Condition (64)
|
|
Load Halfword High Immediate on Condition (32 <- 16)
|
|
Load Halfword Immediate on Condition (32 <- 16)
|
|
Load on Condition (32)
|
|
Load Pair Disjoint (32)
|
|
Load Positive (long BFP)
|
|
Load Positive (long)
|
|
Load Pair Disjoint (64)
|
|
Load Positive (long HFP)
|
|
Load Positive (short BFP)
|
|
Load Positive (short HFP)
|
|
Load Positive (64 <- 32)
|
|
Load Positive (64)
|
|
Load Pair from Quadword
|
|
Load Positive (32)
|
|
Load PSW
|
|
Load PSW Extended
|
|
Load PSW Extended
|
|
Load Page Table Entry Address
|
|
Load Positive (extended BFP)
|
|
Load Positive (extended HFP)
|
|
Load (32)
|
|
Load Real Address (32)
|
|
Load Real Address (64)
|
|
Load Real Address (32)
|
|
Load Relative Long (32)
|
|
Load Reserved (32)
|
|
Load Reserved (64)
|
|
Load Reserved (64)
|
|
Load Reserved (16)
|
|
Load Reserved (32)
|
|
Load and Test (32)
|
|
Load and Test (long BFP)
|
|
Load and Test (long HFP)
|
|
Load and Test (long DFP)
|
|
Load and Test (short BFP)
|
|
Load and Test (short HFP)
|
|
Load and Test (64)
|
|
Load and Test (64 <- 32)
|
|
Load and Test (64 <- 32)
|
|
Load and Test (64)
|
|
Load and Test (32)
|
|
Load and Test (extended BFP)
|
|
Load and Test (extended HFP)
|
|
Load and Test (extended DFP)
|
|
Load Using Real Address (32)
|
|
Load Using Real Address (64)
|
|
Load Lengthened (extended HFP <- long)
|
|
Load Lengthened (extended BFP <- long)
|
|
Load Lengthened (extended BFP <- long)
|
|
Load Lengthened (extended HFP <- long)
|
|
Load Lengthened (extended DFP <- long)
|
|
Load Lengthened (extended HFP <- short)
|
|
Load Lengthened (extended BFP <- short)
|
|
Load Lengthened (extended BFP <- short)
|
|
Load Lengthened (extended HFP <- short)
|
|
Load (extended)
|
|
Load (32)
|
|
Load Zero (long)
|
|
Load Zero (short)
|
|
Load and Zero Rightmost Byte (32)
|
|
Load and Zero Rightmost Byte (64)
|
|
Load Zero (extended)
|
|
Multiply (64 <- 32)
|
|
Multiply and Add (long HFP)
|
|
Multiply and Add (long BFP)
|
|
Multiply and Add (long BFP)
|
|
Multiply and Add (long HFP)
|
|
Multiply and Add (short HFP)
|
|
Multiply and Add (short BFP)
|
|
Multiply and Add (short BFP)
|
|
Multiply and Add (short HFP)
|
|
Multiply and Add Unnormalized (long to ext. HFP)
|
|
Multiply and Add Unnormalized (long to ext. high HFP)
|
|
Multiply and Add Unnormalized (long to ext. high HFP)
|
|
Multiply and Add Unnormalized (long to ext. low HFP)
|
|
Multiply and Add Unnormalized (long to ext. low HFP)
|
|
Multiply and Add Unnormalized (long to ext. HFP)
|
|
Monitor Call
|
|
Multiply (long HFP)
|
|
Multiply (long BFP)
|
|
Multiply (long BFP)
|
|
Multiply (long HFP <- short)
|
|
Multiply (long BFP <- short)
|
|
Multiply (long BFP <- short)
|
|
Multiply (long HFP <- short)
|
|
Multiply (long HFP)
|
|
Multiply (long DFP)
|
|
Multiply (long DFP)
|
|
Multiply (short HFP)
|
|
Multiply (short BFP)
|
|
Multiply (short BFP)
|
|
Multiply (short HFP)
|
|
Multiply (64 <- 32)
|
|
Multiply (128 <- 64)
|
|
Multiply Halfword (64 <- 16)
|
|
Multiply Halfword Immediate (64)
|
|
Multiply (128 <- 64)
|
|
Multiply Halfword (32)
|
|
Multiply Halfword Immediate (32)
|
|
Multiply Halfword (32)
|
|
Multiply Logical (64 <- 32)
|
|
Multiply Logical (128 <- 64)
|
|
Multiply Logical (128 <- 64)
|
|
Multiply Logical (64 <- 32)
|
|
Multiply Decimal
|
|
Multiply (64 <- 32)
|
|
Multiply Single (32)
|
|
Multiply Single (32)
|
|
Modify Subchannel
|
|
Multiply and Subtract (long HFP)
|
|
Multiply and Subtract (long BFP)
|
|
Multiply and Subtract (long BFP)
|
|
Multiply and Subtract (long HFP)
|
|
Multiply and Subtract (short HFP)
|
|
Multiply and Subtract (short BFP)
|
|
Multiply and Subtract (short BFP)
|
|
Multiply and Subtract (short HFP)
|
|
Multiply Single Immediate (32)
|
|
Multiply Single (64)
|
|
Multiply Single (64)
|
|
Multiply Single (64 <- 32)
|
|
Multiply Single Immediate (64 <- 32)
|
|
Multiply Single (64 <- 32)
|
|
Multiply Single (64)
|
|
Multiply Single (64)
|
|
Multiply Single (32)
|
|
Multiply Single (32)
|
|
Modify Stacked State
|
|
Multiply Single (32)
|
|
Move (Character)
|
|
Move with Destination Key
|
|
Move Inverse
|
|
Move with Key
|
|
Move Long
|
|
Move Long Extended
|
|
Move Long Unicode
|
|
Move with Optional Specifications
|
|
Move to Primary
|
|
Move Right to Left
|
|
Move to Secondary
|
|
Move with Source Key
|
|
Move (64 <- 16)
|
|
Move (16 <- 16)
|
|
Move (32 <- 16)
|
|
Move (Immediate)
|
|
Move (Immediate)
|
|
Move Numerics
|
|
Move with Offset
|
|
Move Page
|
|
Move String
|
|
Move Zones
|
|
Mulltiply (extended BFP)
|
|
Multiply (extended HFP <- long)
|
|
Multiply (extended BFP <- long)
|
|
Multiply (extended BFP <- long)
|
|
Multiply (extended HFP <- long)
|
|
Multiply (extended HFP)
|
|
Multiply (extended DFP)
|
|
Multiply (extended DFP)
|
|
Multiply Unnormalized (long to ext. HFP)
|
|
Multiply Unnormalized (long to ext. high HFP)
|
|
Multiply Unnormalized (long to ext. high HFP)
|
|
Multiply Unnormalized (long to ext. low HFP)
|
|
Multiply Unnormalized (long to ext. low HFP)
|
|
Multiply Unnormalized (long to ext. HFP)
|
|
AND (32)
|
|
AND (Character)
|
|
AND (64)
|
|
AND Registers (64)
|
|
And Registers (64)
|
|
AND Immediate
|
|
Next Instruction Access Intent
|
|
AND Register with Immediate (high, bit 0-31)
|
|
AND Register with Immediate (high high, bit 0-15)
|
|
AND Register with Immediate (high low, bit 16-31)
|
|
AND Register with Immediate (low, bit 32-63)
|
|
AND Register with Immediate (low high, bit 32-47)
|
|
AND Register with Immediate (low low, bit 48-63)
|
|
AND Immediate
|
|
Neural Networking Processing Assist
|
|
AND Registers (32)
|
|
And Registers (32)
|
|
Nontransactional Store (64)
|
|
AND (32)
|
|
OR (32)
|
|
OR (Character)
|
|
OR (64)
|
|
OR (64)
|
|
OR (64)
|
|
OR (Immediate)
|
|
OR Immediate (high)
|
|
OR Immediate (high high)
|
|
OR Immediate (high low)
|
|
OR Immediate (low)
|
|
OR Immediate (low high)
|
|
OR Immediate (low low)
|
|
OR (Immediate)
|
|
OR (32)
|
|
OR (32)
|
|
OR (32)
|
|
Pack
|
|
Purge ALB
|
|
Program Call
|
|
Perform Cryptographic Computation
|
|
Perform Cryptography Key Management Operation
|
|
Prefetch Data
|
|
Prefetch Data Relative Long
|
|
Perform Frame Management Function
|
|
Perform Floating-Point Operation
|
|
Page In
|
|
Page Out
|
|
Pack ASCII
|
|
Pack Unicode
|
|
Perform Locked Operation
|
|
Population Count
|
|
Perform Processor Assist
|
|
Program Return
|
|
Perform Random Number Operation
|
|
Program Transfer
|
|
Perform Topology Function
|
|
Perform Timing Facility Function
|
|
Program Transfer with Instance
|
|
Purge TLB
|
|
Quantize (long DFP)
|
|
Quantize (extended DFP)
|
|
Query Processor Activity Counter Information
|
|
Reset Channel Path
|
|
Rotate then Insert Selected Bits
|
|
Rotate then Insert Selected Bits (64)
|
|
Rotate then Insert Selected Bits High (32)
|
|
Rotate then Insert Selected Bits Low (32)
|
|
Rotate Left Single Logical (32)
|
|
Rotate Left Single Logical (64)
|
|
Rotate then AND Selected Bits
|
|
Rotate then OR Selected Bits
|
|
Resume Program
|
|
Reset Reference Bit Extended
|
|
Reset Reference Bit Multiple
|
|
Reround (long DFP)
|
|
Reround (extended DFP)
|
|
Resume Subchannel
|
|
Rotate then Exclusive OR Selected Bits
|
|
Subtract (32)
|
|
Set Address Space Control
|
|
Set Address Space Control Fast
|
|
Set Address Limit
|
|
Set Addressing Mode (24)
|
|
Set Addressing Mode (31)
|
|
Set Addressing Mode (64)
|
|
Set Access Register
|
|
Set Channel Monitor
|
|
Set Clock
|
|
Set Clock Comparator
|
|
Set Clock Programmable Field
|
|
Subtract Normalized (long HFP)
|
|
Subtract (long BFP)
|
|
Subtract (long BFP)
|
|
Subtract Normalized (long HFP)
|
|
Subtract (long DFP)
|
|
Subtract (long DFP)
|
|
Subtract Normalized (short HFP)
|
|
Subtract (short BFP)
|
|
Subtract (short BFP)
|
|
Subtract Normalized (short HFP)
|
|
Set FPC and Signal
|
|
Set FPC
|
|
Subtract (64)
|
|
Subtract (64 <- 32)
|
|
Subtract (64 <- 32)
|
|
Subtract Halfword (64 <- 16)
|
|
Subtract (64)
|
|
Subtract (64)
|
|
Subtract Halfword
|
|
Subtract High (32)
|
|
Subtract High (32)
|
|
Subtract Halfword
|
|
Signal Processor
|
|
Subtract Logical (32)
|
|
Shift Left Single (32)
|
|
Shift Left Single (64)
|
|
Shift Left Single (32)
|
|
Subtract Logical with Borrow (32)
|
|
Subtract Logical with Borrow (64)
|
|
Subtract Logical with Borrow (64)
|
|
Subtract Logical with Borrow (32)
|
|
Shift Left Double
|
|
Shift Left Double Logical
|
|
Shift Significand Left (long DFP)
|
|
Subtract Logical Immediate (32)
|
|
Subtract Logical (64)
|
|
Subtract Logical (64 <- 32)
|
|
Subtract Logical Immediate (64 <- 32)
|
|
Subtract Logical (64 <- 32)
|
|
Subtract Logical (64)
|
|
Subtract Logical (64)
|
|
Subtract Logical High (32)
|
|
Subtract Logical High (32)
|
|
Shift Left Single Logical (32)
|
|
Shift Left Single Logical (64)
|
|
Shift Left Single Logical (32)
|
|
Subtract Logical (32)
|
|
Subtract Logical (32)
|
|
Shift Significand Left (extended DFP)
|
|
Subtract Logical (32)
|
|
Sort Lists
|
|
Subtract Decimal
|
|
Set PSW Key from Address
|
|
Set Program Mask
|
|
Set CPU Timer
|
|
Set Prefix
|
|
Square Root (long HFP)
|
|
Square Root (long BFP)
|
|
Square Root (long BFP)
|
|
Square Root (long HFP)
|
|
Square Root (short HFP)
|
|
Square Root (short BFP)
|
|
Square Root (short BFP)
|
|
Square Root (short HFP)
|
|
Square Root (extended BFP)
|
|
Square Root (extended HFP)
|
|
Subtract (32)
|
|
Shift Right Single (32)
|
|
Shift Right Single (64)
|
|
Shift Right Single (32)
|
|
Shift Right Double
|
|
Shift Right Double Logical
|
|
Shift Significand Right (long DFP)
|
|
Subtract (32)
|
|
Shift Right Single Logical (32)
|
|
Shift Right Single Logical (64)
|
|
Shift Right Single Logical (32)
|
|
Set BFP Rounding Mode (2 bit)
|
|
Set BFP Rounding Mode (3 bit)
|
|
Set DPF Rounding Mode
|
|
Shift and Round Decimal
|
|
Search String
|
|
Search String Unicode
|
|
Shift Significand Right (extended DFP)
|
|
Set Secondary ASN with Instance
|
|
Set Secondary ASN
|
|
Start Subchannel
|
|
Set Storage Key Extended
|
|
Set System Mask
|
|
Store (32)
|
|
Store Access Multiple
|
|
Store Access Multiple
|
|
Store CPU Address
|
|
Store BEAR
|
|
Store Character
|
|
Store Character High (8)
|
|
Store Clock
|
|
Store Clock Comparator
|
|
Store Clock Extended
|
|
Store Clock Fast
|
|
Store Characters under Mask (low)
|
|
Store Characters under Mask (high)
|
|
Store Characters under Mask (low)
|
|
Store Channel Path Status
|
|
Store Channel Report Word
|
|
Store Control (64)
|
|
Store Control (32)
|
|
Store Character
|
|
Store (long)
|
|
Store (long)
|
|
Store (short)
|
|
Store (short)
|
|
Store High (32)
|
|
Store Facility List
|
|
Store Facility List Extended
|
|
Store FPC
|
|
Store (64)
|
|
Store Relative Long (64)
|
|
Store Guarded Storage Controls
|
|
Store Halfword
|
|
Store Halfword High (16)
|
|
Store Halfword Relative Long
|
|
Store Halfword
|
|
Store CPU ID
|
|
Store Multiple (32)
|
|
Store Multiple (64)
|
|
Store Multiple High
|
|
Store Multiple (32)
|
|
Store then AND System Mask
|
|
Store on Condition (32)
|
|
Store High on Condition
|
|
Store on Condition (64)
|
|
Store then OR System Mask
|
|
Store Pair to Quadword
|
|
Store CPU Timer
|
|
Store Prefix
|
|
Store Real Address
|
|
Store Relative Long (32)
|
|
Store Reversed (32)
|
|
Store Reversed (46)
|
|
Store Reversed (16)
|
|
Store Subchannel
|
|
Store System Information
|
|
Store Using Real Address (32)
|
|
Store Using Real Address (64)
|
|
Store (32)
|
|
Subtract Unnormalized (short HFP)
|
|
Subtract Unnormalized (short HFP)
|
|
Supervisor Call
|
|
Subtract Unnormalized (long HFP)
|
|
Subtract Unnormalized (long HFP)
|
|
Subtract (extended BFP)
|
|
Subtract Normalized (extended HFP)
|
|
Subtract (extended DFP)
|
|
Subtract (extended DFP)
|
|
Subtract (32)
|
|
Transaction Abort
|
|
Test Addressing Mode
|
|
Test Access
|
|
Test Block
|
|
Convert HFP to BFP (long)
|
|
Convert HFP to BFP (short to long)
|
|
Transaction Begin (nonconstrained)
|
|
Transaction Begin (constrained)
|
|
Test Data Class (long BFP)
|
|
Test Data Class (short BFP)
|
|
Test Data Class (extended BFP)
|
|
Test Data Class (long DFP)
|
|
Test Data Class (short DFP)
|
|
Test Data Class (extended DFP)
|
|
Test Data Group (long DFP)
|
|
Test Data Group (short DFP)
|
|
Test Data Group (extended DFP)
|
|
Transaction End
|
|
Convert BFP to HFP (short to long)
|
|
Convert BFP to HFP (long)
|
|
Test under Mask
|
|
Test under Mask (high high)
|
|
Test under Mask (high low)
|
|
Test under Mask (low high)
|
|
Test under Mask (low low)
|
|
Test under Mask
|
|
Test Decimal
|
|
Test Pending External Interruption
|
|
Test Pending Interruption
|
|
Test Protection
|
|
Translate
|
|
Trace (32)
|
|
Trace (64)
|
|
Trap
|
|
TRAP
|
|
Translate Extended
|
|
Translate One to One
|
|
Translate One to Two
|
|
Translate and Test
|
|
Translate and Test Extended
|
|
Translate Two to One
|
|
Translate and Test Reverse
|
|
Translate and Test Reverse Extended
|
|
Translate Two to Two
|
|
Test and Set
|
|
Test Subchannel
|
|
Unpack
|
|
Unpack ASCII
|
|
Unpack Unicode
|
|
Update Tree
|
|
Vector Add
|
|
Vector Add with Carry
|
|
Vector Add Compute Carry
|
|
Vector Add with Carry Compute Carry
|
|
Vector Add Decimal
|
|
Vector Average
|
|
Vector Average Logical
|
|
Vector Bit Permute
|
|
Vector Compare Equal
|
|
Vector FP Convert from NNP
|
|
Vector FP Convert from Logical
|
|
Vector FP Convert from Fixed
|
|
Vector Compare High
|
|
Vector Compare High Logical
|
|
Vector Checksum
|
|
Vector FP Convert and Lengthen from NNP High
|
|
Vector FP Convert and Lengthen from NNP Low
|
|
Vector FP Convert to Logical
|
|
Vector Count Leading Zeros
|
|
Vector Count Leading Zero Digits
|
|
Vector FP Convert to NNP
|
|
Vector Compare Decimal
|
|
Vector FP Convert and Round to NNP
|
|
Vector FP Convert to Fixed
|
|
Vector Convert HFP to Scaled Decimal
|
|
Vector Count Trailing Zeros
|
|
Vector Convert to Binary
|
|
Vector Convert to Binary
|
|
Vector Convert to Decimal
|
|
Vector Convert to Decimal
|
|
Vector Divide Decimal
|
|
Vector Element Compare
|
|
Vector Element Compare Logical
|
|
Vector Element Rotate and Insert Under Mask
|
|
Vector Element Rotate Left Logical
|
|
Vector Element Rotate Left Logical
|
|
Vector Element Shift Left
|
|
Vector Element Shift Left
|
|
Vector Element Shift Right Arithmetic
|
|
Vector Element Shift Right Arithmentic
|
|
Vector Element Shift Right Logical
|
|
Vector Element Shift Right Logical
|
|
Vector FP Add
|
|
Vector Find Any Element Equal
|
|
Vector FP Compare Equal
|
|
Vector fP Compare High
|
|
VEctor FP Compare High or Equal
|
|
Vector FP Divide
|
|
Vector Find Element Equal
|
|
Vector Find Element Not Equal
|
|
Vector Load FP Integer
|
|
Vector FP Load Lengthened
|
|
Vector FP Load Rounded
|
|
Vector FP Multiply
|
|
Vector FP Multiply and Add
|
|
Vector FP Maximum
|
|
Vector FP Minimum
|
|
Vector FP Multiply and Subtract
|
|
Vector FP Negative Multiply and Add
|
|
Vector FP Negative Multiply and Subtract
|
|
Vector FP Perform Sign Operation
|
|
Vector FP Subtract
|
|
Vector FP Square Root
|
|
Vector FP Test Data Class Immediate
|
|
Vector Generate Byte Mask
|
|
Vector Gather Element (32)
|
|
Vector Gather Element (64)
|
|
Vector Galois Field Multiply Sum
|
|
Vector Galois Field Multiply Sum and Accumulate
|
|
Vector Generate Mask
|
|
Vector Isolate String
|
|
Vector Load
|
|
Vector Load to Block Boundary
|
|
Vector Load Byte Reversed Elements
|
|
Vector Load Byte Reversed Element and Replicate
|
|
Vector Load Complement
|
|
Vector Load Element (8)
|
|
Vector Load Byte Reversed Element
|
|
Vector Load Byte Reversed Element
|
|
Vectir Load Byte Reversed Element
|
|
Vector Load Element (32)
|
|
Vector Load Element (64)
|
|
Vector Load Element (16)
|
|
Vector Load Element Immediate (8)
|
|
Vector Load Element Immediate (32)
|
|
Vector Load Element Immediate (64)
|
|
Vector Load Element Immediate (16)
|
|
Vector Load Elements Reversed
|
|
Vector Load GR from VR Element
|
|
Vector Load Immediate Decimal
|
|
Vector Load with Length
|
|
Vector Load Byte Reversed Element and Zero
|
|
Vector Load Logical Element and Zero
|
|
Vector Load Multiple
|
|
Vector Load Positive
|
|
Vector Load
|
|
Vector Load and Replicate
|
|
Vector Load Rightmost with Length
|
|
VEctor Load Rightmost with Length
|
|
Vector Load VR Element from GR
|
|
Vector Load VR from GRS Disjoint
|
|
Vector Multiply and Add Even
|
|
Vector Multiply and Add High
|
|
Vector Multiply and Add Low
|
|
Vector Multiply and Add Logical Even
|
|
Vector Multiply and Add Logical High
|
|
Vector Multiply and Add Logical Odd
|
|
Vector Multiply and Add Odd
|
|
Vector Multiply Even
|
|
Vector Multiply High
|
|
Vector Multiply Low
|
|
Vector Multiply Logical Even
|
|
Vector Multiply Logical High
|
|
Vector Multiply Logial Odd
|
|
Vector Minimum
|
|
Vector Minimum Logical
|
|
Vector Multiply Odd
|
|
Vector Multiply Decimal
|
|
Vector Merge High
|
|
Vector Merge Low
|
|
Vector Multiply Sum Logical
|
|
Vector Multiply and Shift Decimal
|
|
Vector Maximum
|
|
Vector Maximum Logical
|
|
Vector AND
|
|
Vector AND with Complement
|
|
Vector NAND
|
|
Vector NOR
|
|
Vector NOT Exclusive OR
|
|
Vector OR
|
|
Vector OR with Complement
|
|
Vector Permute Doubleword Immediate
|
|
Vector Permute
|
|
Vector Pack
|
|
Vector Pack Logical Saturate
|
|
Vector Pack Saturate
|
|
Vector Pack Zoned
|
|
Vector Pack Zoned Register
|
|
Vector Population Count
|
|
Vector Perform Sign Operation Decimal
|
|
Vector Replicate
|
|
Vector Replicate Immediate
|
|
Vector Remainder Decimal
|
|
Vector Subtract
|
|
Vector Subtract with Borrow Compute Borrow Indication
|
|
Vector Subtract with Borrow Indication
|
|
Vector Subtract Compute Borrow Indication
|
|
Vector Scatter Element (32)
|
|
Vector Scatter Element (64)
|
|
Decimal Scale and Convert to HFP
|
|
Decimal Scale and Convert and Split to HFP
|
|
Vector Shift and Divide Decimal
|
|
Vector Sign Extend to Doubleword
|
|
Vector Select
|
|
Vector Shift Left
|
|
Vector Shift Left by Byte
|
|
Vector Shift Left Double by Bit
|
|
Vector Shift Left Double by Byte
|
|
Vector Subtract Decimal
|
|
Vector Shift Right Arithmetic
|
|
Vector Shift Right Arithmetic by Byte
|
|
Vector Shift Right Double by Bit
|
|
Vector Shift Right Logical
|
|
Vector Shift Right Logical by Byte
|
|
Vector Shift and Round Decimal
|
|
Vector Shift and Round Decimal Register
|
|
Vector Store
|
|
Vector Store Byte Reversed Elements
|
|
Vector Store Element (8)
|
|
Vector Store Byte Reversed Elements
|
|
Vector Store Byte Reversed Elements
|
|
Vector Store Byte Reversed Elements
|
|
Vector Store Element (32)
|
|
Vector Store Element (64)
|
|
Vector Store Element (16)
|
|
Vector Store Elements Reversed
|
|
Vectore Store with Length
|
|
Vector Store Multiple
|
|
Vector String Range Compare
|
|
Vector Store Rightmost with Length
|
|
Vector Store Rightmost with Length
|
|
Vector String Search
|
|
Vector Sum Across Word
|
|
Vector Sum Across Doubleword
|
|
Vector Sum Across Quadword
|
|
Vector Test under Mask
|
|
Vector Test Decimal
|
|
Vector Unpack High
|
|
Vector Unpack Zoned
|
|
Vector Unpack Zoned High
|
|
Vector Unpack Zoned Low
|
|
Vector Unpack Low
|
|
Vector Unpack Logical High
|
|
Vector Unpack Logical Low
|
|
Vector Exclusive OR
|
|
Vector FP Compare Scalar
|
|
Vector FP Compare and Signal Scalar
|
|
Exclusive OR (32)
|
|
Exclusive OR (Character)
|
|
Exclusive OR (64)
|
|
Exclusive OR (64)
|
|
Exclusive OR (64)
|
|
Exclusive OR (Immediate)
|
|
Exclusive OR Immediate (high)
|
|
Exclusive OR Immediate (low)
|
|
Exclusive OR (Immediate)
|
|
Exclusive OR (32)
|
|
Exclusive OR (32)
|
|
Cancel Subchannel
|
|
Exclusive OR (32)
|
|
Zero and Add
|