diff options
Diffstat (limited to 'deps/v8/src/s390/constants-s390.h')
-rw-r--r-- | deps/v8/src/s390/constants-s390.h | 1561 |
1 files changed, 1561 insertions, 0 deletions
diff --git a/deps/v8/src/s390/constants-s390.h b/deps/v8/src/s390/constants-s390.h new file mode 100644 index 0000000000..c313c929e6 --- /dev/null +++ b/deps/v8/src/s390/constants-s390.h @@ -0,0 +1,1561 @@ +// Copyright 2014 the V8 project authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef V8_S390_CONSTANTS_S390_H_ +#define V8_S390_CONSTANTS_S390_H_ + +// Get the standard printf format macros for C99 stdint types. +#ifndef __STDC_FORMAT_MACROS +#define __STDC_FORMAT_MACROS +#endif +#include <inttypes.h> + +#include <stdint.h> + +#include "src/base/logging.h" +#include "src/base/macros.h" +#include "src/globals.h" + +namespace v8 { +namespace internal { + +// Number of registers +const int kNumRegisters = 16; + +// FP support. +const int kNumDoubleRegisters = 16; + +const int kNoRegister = -1; + +// sign-extend the least significant 16-bits of value <imm> +#define SIGN_EXT_IMM16(imm) ((static_cast<int>(imm) << 16) >> 16) + +// sign-extend the least significant 26-bits of value <imm> +#define SIGN_EXT_IMM26(imm) ((static_cast<int>(imm) << 6) >> 6) + +// ----------------------------------------------------------------------------- +// Conditions. + +// Defines constants and accessor classes to assemble, disassemble and +// simulate z/Architecture instructions. +// +// Section references in the code refer to the "z/Architecture Principles +// Of Operation" http://publibfi.boulder.ibm.com/epubs/pdf/dz9zr009.pdf +// + +// Constants for specific fields are defined in their respective named enums. +// General constants are in an anonymous enum in class Instr. +enum Condition { + kNoCondition = -1, + eq = 0x8, // Equal. + ne = 0x7, // Not equal. + ge = 0xa, // Greater or equal. + lt = 0x4, // Less than. + gt = 0x2, // Greater than. + le = 0xc, // Less then or equal + al = 0xf, // Always. + + CC_NOP = 0x0, // S390 NOP + CC_EQ = 0x08, // S390 condition code 0b1000 + CC_LT = 0x04, // S390 condition code 0b0100 + CC_LE = CC_EQ | CC_LT, // S390 condition code 0b1100 + CC_GT = 0x02, // S390 condition code 0b0010 + CC_GE = CC_EQ | CC_GT, // S390 condition code 0b1010 + CC_OF = 0x01, // S390 condition code 0b0001 + CC_NOF = 0x0E, // S390 condition code 0b1110 + CC_ALWAYS = 0x0F, // S390 always taken branch + unordered = CC_OF, // Floating-point unordered + ordered = CC_NOF, // floating-point ordered + overflow = CC_OF, // Summary overflow + nooverflow = CC_NOF, + + mask0x0 = 0, // no jumps + mask0x1 = 1, + mask0x2 = 2, + mask0x3 = 3, + mask0x4 = 4, + mask0x5 = 5, + mask0x6 = 6, + mask0x7 = 7, + mask0x8 = 8, + mask0x9 = 9, + mask0xA = 10, + mask0xB = 11, + mask0xC = 12, + mask0xD = 13, + mask0xE = 14, + mask0xF = 15, + + // Rounding modes for floating poing facility + CURRENT_ROUNDING_MODE = 0, + ROUND_TO_NEAREST_WITH_TIES_AWAY_FROM_0 = 1, + ROUND_TO_PREPARE_FOR_SHORTER_PRECISION = 3, + ROUND_TO_NEAREST_WITH_TIES_TO_EVEN = 4, + ROUND_TOWARD_0 = 5, + ROUND_TOWARD_PLUS_INFINITE = 6, + ROUND_TOWARD_MINUS_INFINITE = 7 +}; + +inline Condition NegateCondition(Condition cond) { + DCHECK(cond != al); + switch (cond) { + case eq: + return ne; + case ne: + return eq; + case ge: + return lt; + case gt: + return le; + case le: + return gt; + case lt: + return ge; + case lt | gt: + return eq; + case le | ge: + return CC_OF; + case CC_OF: + return CC_NOF; + default: + DCHECK(false); + } + return al; +} + +// Commute a condition such that {a cond b == b cond' a}. +inline Condition CommuteCondition(Condition cond) { + switch (cond) { + case lt: + return gt; + case gt: + return lt; + case ge: + return le; + case le: + return ge; + case eq: + return eq; + case ne: + return ne; + default: + DCHECK(false); + return cond; + } +} + +// ----------------------------------------------------------------------------- +// Instructions encoding. + +// Instr is merely used by the Assembler to distinguish 32bit integers +// representing instructions from usual 32 bit values. +// Instruction objects are pointers to 32bit values, and provide methods to +// access the various ISA fields. +typedef int32_t Instr; +typedef uint16_t TwoByteInstr; +typedef uint32_t FourByteInstr; +typedef uint64_t SixByteInstr; + +// Opcodes as defined in Appendix B-2 table +enum Opcode { + A = 0x5A, // Add (32) + ADB = 0xED1A, // Add (long BFP) + ADBR = 0xB31A, // Add (long BFP) + ADTR = 0xB3D2, // Add (long DFP) + ADTRA = 0xB3D2, // Add (long DFP) + AEB = 0xED0A, // Add (short BFP) + AEBR = 0xB30A, // Add (short BFP) + AFI = 0xC29, // Add Immediate (32) + AG = 0xE308, // Add (64) + AGF = 0xE318, // Add (64<-32) + AGFI = 0xC28, // Add Immediate (64<-32) + AGFR = 0xB918, // Add (64<-32) + AGHI = 0xA7B, // Add Halfword Immediate (64) + AGHIK = 0xECD9, // Add Immediate (64<-16) + AGR = 0xB908, // Add (64) + AGRK = 0xB9E8, // Add (64) + AGSI = 0xEB7A, // Add Immediate (64<-8) + AH = 0x4A, // Add Halfword + AHHHR = 0xB9C8, // Add High (32) + AHHLR = 0xB9D8, // Add High (32) + AHI = 0xA7A, // Add Halfword Immediate (32) + AHIK = 0xECD8, // Add Immediate (32<-16) + AHY = 0xE37A, // Add Halfword + AIH = 0xCC8, // Add Immediate High (32) + AL = 0x5E, // Add Logical (32) + ALC = 0xE398, // Add Logical With Carry (32) + ALCG = 0xE388, // Add Logical With Carry (64) + ALCGR = 0xB988, // Add Logical With Carry (64) + ALCR = 0xB998, // Add Logical With Carry (32) + ALFI = 0xC2B, // Add Logical Immediate (32) + ALG = 0xE30A, // Add Logical (64) + ALGF = 0xE31A, // Add Logical (64<-32) + ALGFI = 0xC2A, // Add Logical Immediate (64<-32) + ALGFR = 0xB91A, // Add Logical (64<-32) + ALGHSIK = 0xECDB, // Add Logical With Signed Immediate (64<-16) + ALGR = 0xB90A, // Add Logical (64) + ALGRK = 0xB9EA, // Add Logical (64) + ALGSI = 0xEB7E, // Add Logical With Signed Immediate (64<-8) + ALHHHR = 0xB9CA, // Add Logical High (32) + ALHHLR = 0xB9DA, // Add Logical High (32) + ALHSIK = 0xECDA, // Add Logical With Signed Immediate (32<-16) + ALR = 0x1E, // Add Logical (32) + ALRK = 0xB9FA, // Add Logical (32) + ALSI = 0xEB6E, // Add Logical With Signed Immediate (32<-8) + ALSIH = 0xCCA, // Add Logical With Signed Immediate High (32) + ALSIHN = 0xCCB, // Add Logical With Signed Immediate High (32) + ALY = 0xE35E, // Add Logical (32) + AP = 0xFA, // Add Decimal + AR = 0x1A, // Add (32) + ARK = 0xB9F8, // Add (32) + ASI = 0xEB6A, // Add Immediate (32<-8) + AXBR = 0xB34A, // Add (extended BFP) + AXTR = 0xB3DA, // Add (extended DFP) + AXTRA = 0xB3DA, // Add (extended DFP) + AY = 0xE35A, // Add (32) + BAL = 0x45, // Branch And Link + BALR = 0x05, // Branch And Link + BAS = 0x4D, // Branch And Save + BASR = 0x0D, // Branch And Save + BASSM = 0x0C, // Branch And Save And Set Mode + BC = 0x47, // Branch On Condition + BCR = 0x07, // Branch On Condition + BCT = 0x46, // Branch On Count (32) + BCTG = 0xE346, // Branch On Count (64) + BCTGR = 0xB946, // Branch On Count (64) + BCTR = 0x06, // Branch On Count (32) + BPP = 0xC7, // Branch Prediction Preload + BPRP = 0xC5, // Branch Prediction Relative Preload + BRAS = 0xA75, // Branch Relative And Save + BRASL = 0xC05, // Branch Relative And Save Long + BRC = 0xA74, // Branch Relative On Condition + BRCL = 0xC04, // Branch Relative On Condition Long + BRCT = 0xA76, // Branch Relative On Count (32) + BRCTG = 0xA77, // Branch Relative On Count (64) + BRCTH = 0xCC6, // Branch Relative On Count High (32) + BRXH = 0x84, // Branch Relative On Index High (32) + BRXHG = 0xEC44, // Branch Relative On Index High (64) + BRXLE = 0x85, // Branch Relative On Index Low Or Eq. (32) + BRXLG = 0xEC45, // Branch Relative On Index Low Or Eq. (64) + BSM = 0x0B, // Branch And Set Mode + BXH = 0x86, // Branch On Index High (32) + BXHG = 0xEB44, // Branch On Index High (64) + BXLE = 0x87, // Branch On Index Low Or Equal (32) + BXLEG = 0xEB45, // Branch On Index Low Or Equal (64) + C = 0x59, // Compare (32) + CDB = 0xED19, // Compare (long BFP) + CDBR = 0xB319, // Compare (long BFP) + CDFBR = 0xB395, // Convert From Fixed (32 to long BFP) + CDFBRA = 0xB395, // Convert From Fixed (32 to long BFP) + CDFTR = 0xB951, // Convert From Fixed (32 to long DFP) + CDGBR = 0xB3A5, // Convert From Fixed (64 to long BFP) + CDGBRA = 0xB3A5, // Convert From Fixed (64 to long BFP) + CDGTR = 0xB3F1, // Convert From Fixed (64 to long DFP) + CDGTRA = 0xB3F1, // Convert From Fixed (64 to long DFP) + CDLFBR = 0xB391, // Convert From Logical (32 to long BFP) + CDLFTR = 0xB953, // Convert From Logical (32 to long DFP) + CDLGBR = 0xB3A1, // Convert From Logical (64 to long BFP) + CDLGTR = 0xB952, // Convert From Logical (64 to long DFP) + CDS = 0xBB, // Compare Double And Swap (32) + CDSG = 0xEB3E, // Compare Double And Swap (64) + CDSTR = 0xB3F3, // Convert From Signed Packed (64 to long DFP) + CDSY = 0xEB31, // Compare Double And Swap (32) + CDTR = 0xB3E4, // Compare (long DFP) + CDUTR = 0xB3F2, // Convert From Unsigned Packed (64 to long DFP) + CDZT = 0xEDAA, // Convert From Zoned (to long DFP) + CEB = 0xED09, // Compare (short BFP) + CEBR = 0xB309, // Compare (short BFP) + CEDTR = 0xB3F4, // Compare Biased Exponent (long DFP) + CEFBR = 0xB394, // Convert From Fixed (32 to short BFP) + CEFBRA = 0xB394, // Convert From Fixed (32 to short BFP) + CEGBR = 0xB3A4, // Convert From Fixed (64 to short BFP) + CEGBRA = 0xB3A4, // Convert From Fixed (64 to short BFP) + CELFBR = 0xB390, // Convert From Logical (32 to short BFP) + CELGBR = 0xB3A0, // Convert From Logical (64 to short BFP) + CEXTR = 0xB3FC, // Compare Biased Exponent (extended DFP) + CFC = 0xB21A, // Compare And Form Codeword + CFDBR = 0xB399, // Convert To Fixed (long BFP to 32) + CFDBRA = 0xB399, // Convert To Fixed (long BFP to 32) + CFDR = 0xB3B9, // Convert To Fixed (long HFP to 32) + CFDTR = 0xB941, // Convert To Fixed (long DFP to 32) + CFEBR = 0xB398, // Convert To Fixed (short BFP to 32) + CFEBRA = 0xB398, // Convert To Fixed (short BFP to 32) + CFER = 0xB3B8, // Convert To Fixed (short HFP to 32) + CFI = 0xC2D, // Compare Immediate (32) + CFXBR = 0xB39A, // Convert To Fixed (extended BFP to 32) + CFXBRA = 0xB39A, // Convert To Fixed (extended BFP to 32) + CFXR = 0xB3BA, // Convert To Fixed (extended HFP to 32) + CFXTR = 0xB949, // Convert To Fixed (extended DFP to 32) + CG = 0xE320, // Compare (64) + CGDBR = 0xB3A9, // Convert To Fixed (long BFP to 64) + CGDBRA = 0xB3A9, // Convert To Fixed (long BFP to 64) + CGDR = 0xB3C9, // Convert To Fixed (long HFP to 64) + CGDTR = 0xB3E1, // Convert To Fixed (long DFP to 64) + CGDTRA = 0xB3E1, // Convert To Fixed (long DFP to 64) + CGEBR = 0xB3A8, // Convert To Fixed (short BFP to 64) + CGEBRA = 0xB3A8, // Convert To Fixed (short BFP to 64) + CGER = 0xB3C8, // Convert To Fixed (short HFP to 64) + CGF = 0xE330, // Compare (64<-32) + CGFI = 0xC2C, // Compare Immediate (64<-32) + CGFR = 0xB930, // Compare (64<-32) + CGFRL = 0xC6C, // Compare Relative Long (64<-32) + CGH = 0xE334, // Compare Halfword (64<-16) + CGHI = 0xA7F, // Compare Halfword Immediate (64<-16) + CGHRL = 0xC64, // Compare Halfword Relative Long (64<-16) + CGHSI = 0xE558, // Compare Halfword Immediate (64<-16) + CGIB = 0xECFC, // Compare Immediate And Branch (64<-8) + CGIJ = 0xEC7C, // Compare Immediate And Branch Relative (64<-8) + CGIT = 0xEC70, // Compare Immediate And Trap (64<-16) + CGR = 0xB920, // Compare (64) + CGRB = 0xECE4, // Compare And Branch (64) + CGRJ = 0xEC64, // Compare And Branch Relative (64) + CGRL = 0xC68, // Compare Relative Long (64) + CGRT = 0xB960, // Compare And Trap (64) + CGXBR = 0xB3AA, // Convert To Fixed (extended BFP to 64) + CGXBRA = 0xB3AA, // Convert To Fixed (extended BFP to 64) + CGXR = 0xB3CA, // Convert To Fixed (extended HFP to 64) + CGXTR = 0xB3E9, // Convert To Fixed (extended DFP to 64) + CGXTRA = 0xB3E9, // Convert To Fixed (extended DFP to 64) + CH = 0x49, // Compare Halfword (32<-16) + CHF = 0xE3CD, // Compare High (32) + CHHR = 0xB9CD, // Compare High (32) + CHHSI = 0xE554, // Compare Halfword Immediate (16) + CHI = 0xA7E, // Compare Halfword Immediate (32<-16) + CHLR = 0xB9DD, // Compare High (32) + CHRL = 0xC65, // Compare Halfword Relative Long (32<-16) + CHSI = 0xE55C, // Compare Halfword Immediate (32<-16) + CHY = 0xE379, // Compare Halfword (32<-16) + CIB = 0xECFE, // Compare Immediate And Branch (32<-8) + CIH = 0xCCD, // Compare Immediate High (32) + CIJ = 0xEC7E, // Compare Immediate And Branch Relative (32<-8) + CIT = 0xEC72, // Compare Immediate And Trap (32<-16) + CKSM = 0xB241, // Checksum + CL = 0x55, // Compare Logical (32) + CLC = 0xD5, // Compare Logical (character) + CLCL = 0x0F, // Compare Logical Long + CLCLE = 0xA9, // Compare Logical Long Extended + CLCLU = 0xEB8F, // Compare Logical Long Unicode + CLFDBR = 0xB39D, // Convert To Logical (long BFP to 32) + CLFDTR = 0xB943, // Convert To Logical (long DFP to 32) + CLFEBR = 0xB39C, // Convert To Logical (short BFP to 32) + CLFHSI = 0xE55D, // Compare Logical Immediate (32<-16) + CLFI = 0xC2F, // Compare Logical Immediate (32) + CLFIT = 0xEC73, // Compare Logical Immediate And Trap (32<-16) + CLFXBR = 0xB39E, // Convert To Logical (extended BFP to 32) + CLFXTR = 0xB94B, // Convert To Logical (extended DFP to 32) + CLG = 0xE321, // Compare Logical (64) + CLGDBR = 0xB3AD, // Convert To Logical (long BFP to 64) + CLGDTR = 0xB942, // Convert To Logical (long DFP to 64) + CLGEBR = 0xB3AC, // Convert To Logical (short BFP to 64) + CLGF = 0xE331, // Compare Logical (64<-32) + CLGFI = 0xC2E, // Compare Logical Immediate (64<-32) + CLGR = 0xB921, // Compare Logical (64) + CLI = 0x95, // Compare Logical Immediate (8) + CLIY = 0xEB55, // Compare Logical Immediate (8) + CLR = 0x15, // Compare Logical (32) + CLY = 0xE355, // Compare Logical (32) + CD = 0x69, // Compare (LH) + CDR = 0x29, // Compare (LH) + CR = 0x19, // Compare (32) + CSST = 0xC82, // Compare And Swap And Store + CSXTR = 0xB3EB, // Convert To Signed Packed (extended DFP to 128) + CSY = 0xEB14, // Compare And Swap (32) + CU12 = 0xB2A7, // Convert Utf-8 To Utf-16 + CU14 = 0xB9B0, // Convert Utf-8 To Utf-32 + CU21 = 0xB2A6, // Convert Utf-16 To Utf-8 + CU24 = 0xB9B1, // Convert Utf-16 To Utf-32 + CU41 = 0xB9B2, // Convert Utf-32 To Utf-8 + CU42 = 0xB9B3, // Convert Utf-32 To Utf-16 + CUDTR = 0xB3E2, // Convert To Unsigned Packed (long DFP to 64) + CUSE = 0xB257, // Compare Until Substring Equal + CUTFU = 0xB2A7, // Convert Utf-8 To Unicode + CUUTF = 0xB2A6, // Convert Unicode To Utf-8 + CUXTR = 0xB3EA, // Convert To Unsigned Packed (extended DFP to 128) + CVB = 0x4F, // Convert To Binary (32) + CVBG = 0xE30E, // Convert To Binary (64) + CVBY = 0xE306, // Convert To Binary (32) + CVD = 0x4E, // Convert To Decimal (32) + CVDG = 0xE32E, // Convert To Decimal (64) + CVDY = 0xE326, // Convert To Decimal (32) + CXBR = 0xB349, // Compare (extended BFP) + CXFBR = 0xB396, // Convert From Fixed (32 to extended BFP) + CXFBRA = 0xB396, // Convert From Fixed (32 to extended BFP) + CXFTR = 0xB959, // Convert From Fixed (32 to extended DFP) + CXGBR = 0xB3A6, // Convert From Fixed (64 to extended BFP) + CXGBRA = 0xB3A6, // Convert From Fixed (64 to extended BFP) + CXGTR = 0xB3F9, // Convert From Fixed (64 to extended DFP) + CXGTRA = 0xB3F9, // Convert From Fixed (64 to extended DFP) + CXLFBR = 0xB392, // Convert From Logical (32 to extended BFP) + CXLFTR = 0xB95B, // Convert From Logical (32 to extended DFP) + CXLGBR = 0xB3A2, // Convert From Logical (64 to extended BFP) + CXLGTR = 0xB95A, // Convert From Logical (64 to extended DFP) + CXSTR = 0xB3FB, // Convert From Signed Packed (128 to extended DFP) + CXTR = 0xB3EC, // Compare (extended DFP) + CXUTR = 0xB3FA, // Convert From Unsigned Packed (128 to ext. DFP) + CXZT = 0xEDAB, // Convert From Zoned (to extended DFP) + CY = 0xE359, // Compare (32) + CZDT = 0xEDA8, // Convert To Zoned (from long DFP) + CZXT = 0xEDA9, // Convert To Zoned (from extended DFP) + D = 0x5D, // Divide (32<-64) + DDB = 0xED1D, // Divide (long BFP) + DDBR = 0xB31D, // Divide (long BFP) + DDTR = 0xB3D1, // Divide (long DFP) + DDTRA = 0xB3D1, // Divide (long DFP) + DEB = 0xED0D, // Divide (short BFP) + DEBR = 0xB30D, // Divide (short BFP) + DIDBR = 0xB35B, // Divide To Integer (long BFP) + DIEBR = 0xB353, // Divide To Integer (short BFP) + DL = 0xE397, // Divide Logical (32<-64) + DLG = 0xE387, // Divide Logical (64<-128) + DLGR = 0xB987, // Divide Logical (64<-128) + DLR = 0xB997, // Divide Logical (32<-64) + DP = 0xFD, // Divide Decimal + DR = 0x1D, // Divide (32<-64) + DSG = 0xE30D, // Divide Single (64) + DSGF = 0xE31D, // Divide Single (64<-32) + DSGFR = 0xB91D, // Divide Single (64<-32) + DSGR = 0xB90D, // Divide Single (64) + DXBR = 0xB34D, // Divide (extended BFP) + DXTR = 0xB3D9, // Divide (extended DFP) + DXTRA = 0xB3D9, // Divide (extended DFP) + EAR = 0xB24F, // Extract Access + ECAG = 0xEB4C, // Extract Cache Attribute + ECTG = 0xC81, // Extract Cpu Time + ED = 0xDE, // Edit + EDMK = 0xDF, // Edit And Mark + EEDTR = 0xB3E5, // Extract Biased Exponent (long DFP to 64) + EEXTR = 0xB3ED, // Extract Biased Exponent (extended DFP to 64) + EFPC = 0xB38C, // Extract Fpc + EPSW = 0xB98D, // Extract Psw + ESDTR = 0xB3E7, // Extract Significance (long DFP) + ESXTR = 0xB3EF, // Extract Significance (extended DFP) + ETND = 0xB2EC, // Extract Transaction Nesting Depth + EX = 0x44, // Execute + EXRL = 0xC60, // Execute Relative Long + FIDBR = 0xB35F, // Load Fp Integer (long BFP) + FIDBRA = 0xB35F, // Load Fp Integer (long BFP) + FIDTR = 0xB3D7, // Load Fp Integer (long DFP) + FIEBR = 0xB357, // Load Fp Integer (short BFP) + FIEBRA = 0xB357, // Load Fp Integer (short BFP) + FIXBR = 0xB347, // Load Fp Integer (extended BFP) + FIXBRA = 0xB347, // Load Fp Integer (extended BFP) + FIXTR = 0xB3DF, // Load Fp Integer (extended DFP) + FLOGR = 0xB983, // Find Leftmost One + HSCH = 0xB231, // Halt Subchannel + IC_z = 0x43, // Insert Character + ICM = 0xBF, // Insert Characters Under Mask (low) + ICMH = 0xEB80, // Insert Characters Under Mask (high) + ICMY = 0xEB81, // Insert Characters Under Mask (low) + ICY = 0xE373, // Insert Character + IEDTR = 0xB3F6, // Insert Biased Exponent (64 to long DFP) + IEXTR = 0xB3FE, // Insert Biased Exponent (64 to extended DFP) + IIHF = 0xC08, // Insert Immediate (high) + IIHH = 0xA50, // Insert Immediate (high high) + IIHL = 0xA51, // Insert Immediate (high low) + IILF = 0xC09, // Insert Immediate (low) + IILH = 0xA52, // Insert Immediate (low high) + IILL = 0xA53, // Insert Immediate (low low) + IPM = 0xB222, // Insert Program Mask + KDB = 0xED18, // Compare And Signal (long BFP) + KDBR = 0xB318, // Compare And Signal (long BFP) + KDTR = 0xB3E0, // Compare And Signal (long DFP) + KEB = 0xED08, // Compare And Signal (short BFP) + KEBR = 0xB308, // Compare And Signal (short BFP) + KIMD = 0xB93E, // Compute Intermediate Message Digest + KLMD = 0xB93F, // Compute Last Message Digest + KM = 0xB92E, // Cipher Message + KMAC = 0xB91E, // Compute Message Authentication Code + KMC = 0xB92F, // Cipher Message With Chaining + KMCTR = 0xB92D, // Cipher Message With Counter + KMF = 0xB92A, // Cipher Message With Cfb + KMO = 0xB92B, // Cipher Message With Ofb + KXBR = 0xB348, // Compare And Signal (extended BFP) + KXTR = 0xB3E8, // Compare And Signal (extended DFP) + L = 0x58, // Load (32) + LA = 0x41, // Load Address + LAA = 0xEBF8, // Load And Add (32) + LAAG = 0xEBE8, // Load And Add (64) + LAAL = 0xEBFA, // Load And Add Logical (32) + LAALG = 0xEBEA, // Load And Add Logical (64) + LAE = 0x51, // Load Address Extended + LAEY = 0xE375, // Load Address Extended + LAN = 0xEBF4, // Load And And (32) + LANG = 0xEBE4, // Load And And (64) + LAO = 0xEBF6, // Load And Or (32) + LAOG = 0xEBE6, // Load And Or (64) + LARL = 0xC00, // Load Address Relative Long + LAT = 0xE39F, // Load And Trap (32L<-32) + LAX = 0xEBF7, // Load And Exclusive Or (32) + LAXG = 0xEBE7, // Load And Exclusive Or (64) + LAY = 0xE371, // Load Address + LB = 0xE376, // Load Byte (32) + LBH = 0xE3C0, // Load Byte High (32<-8) + LBR = 0xB926, // Load Byte (32) + LCDBR = 0xB313, // Load Complement (long BFP) + LCDFR = 0xB373, // Load Complement (long) + LCEBR = 0xB303, // Load Complement (short BFP) + LCGFR = 0xB913, // Load Complement (64<-32) + LCGR = 0xB903, // Load Complement (64) + LCR = 0x13, // Load Complement (32) + LCXBR = 0xB343, // Load Complement (extended BFP) + LD = 0x68, // Load (long) + LDEB = 0xED04, // Load Lengthened (short to long BFP) + LDEBR = 0xB304, // Load Lengthened (short to long BFP) + LDETR = 0xB3D4, // Load Lengthened (short to long DFP) + LDGR = 0xB3C1, // Load Fpr From Gr (64 to long) + LDR = 0x28, // Load (long) + LDXBR = 0xB345, // Load Rounded (extended to long BFP) + LDXBRA = 0xB345, // Load Rounded (extended to long BFP) + LDXTR = 0xB3DD, // Load Rounded (extended to long DFP) + LDY = 0xED65, // Load (long) + LE = 0x78, // Load (short) + LEDBR = 0xB344, // Load Rounded (long to short BFP) + LEDBRA = 0xB344, // Load Rounded (long to short BFP) + LEDTR = 0xB3D5, // Load Rounded (long to short DFP) + LER = 0x38, // Load (short) + LEXBR = 0xB346, // Load Rounded (extended to short BFP) + LEXBRA = 0xB346, // Load Rounded (extended to short BFP) + LEY = 0xED64, // Load (short) + LFAS = 0xB2BD, // Load Fpc And Signal + LFH = 0xE3CA, // Load High (32) + LFHAT = 0xE3C8, // Load High And Trap (32H<-32) + LFPC = 0xB29D, // Load Fpc + LG = 0xE304, // Load (64) + LGAT = 0xE385, // Load And Trap (64) + LGB = 0xE377, // Load Byte (64) + LGBR = 0xB906, // Load Byte (64) + LGDR = 0xB3CD, // Load Gr From Fpr (long to 64) + LGF = 0xE314, // Load (64<-32) + LGFI = 0xC01, // Load Immediate (64<-32) + LGFR = 0xB914, // Load (64<-32) + LGFRL = 0xC4C, // Load Relative Long (64<-32) + LGH = 0xE315, // Load Halfword (64) + LGHI = 0xA79, // Load Halfword Immediate (64) + LGHR = 0xB907, // Load Halfword (64) + LGHRL = 0xC44, // Load Halfword Relative Long (64<-16) + LGR = 0xB904, // Load (64) + LGRL = 0xC48, // Load Relative Long (64) + LH = 0x48, // Load Halfword (32) + LHH = 0xE3C4, // Load Halfword High (32<-16) + LHI = 0xA78, // Load Halfword Immediate (32) + LHR = 0xB927, // Load Halfword (32) + LHRL = 0xC45, // Load Halfword Relative Long (32<-16) + LHY = 0xE378, // Load Halfword (32) + LLC = 0xE394, // Load Logical Character (32) + LLCH = 0xE3C2, // Load Logical Character High (32<-8) + LLCR = 0xB994, // Load Logical Character (32) + LLGC = 0xE390, // Load Logical Character (64) + LLGCR = 0xB984, // Load Logical Character (64) + LLGF = 0xE316, // Load Logical (64<-32) + LLGFAT = 0xE39D, // Load Logical And Trap (64<-32) + LLGFR = 0xB916, // Load Logical (64<-32) + LLGFRL = 0xC4E, // Load Logical Relative Long (64<-32) + LLGH = 0xE391, // Load Logical Halfword (64) + LLGHR = 0xB985, // Load Logical Halfword (64) + LLGHRL = 0xC46, // Load Logical Halfword Relative Long (64<-16) + LLGT = 0xE317, // Load Logical Thirty One Bits + LLGTAT = 0xE39C, // Load Logical Thirty One Bits And Trap (64<-31) + LLGTR = 0xB917, // Load Logical Thirty One Bits + LLH = 0xE395, // Load Logical Halfword (32) + LLHH = 0xE3C6, // Load Logical Halfword High (32<-16) + LLHR = 0xB995, // Load Logical Halfword (32) + LLHRL = 0xC42, // Load Logical Halfword Relative Long (32<-16) + LLIHF = 0xC0E, // Load Logical Immediate (high) + LLIHH = 0xA5C, // Load Logical Immediate (high high) + LLIHL = 0xA5D, // Load Logical Immediate (high low) + LLILF = 0xC0F, // Load Logical Immediate (low) + LLILH = 0xA5E, // Load Logical Immediate (low high) + LLILL = 0xA5F, // Load Logical Immediate (low low) + LM = 0x98, // Load Multiple (32) + LMD = 0xEF, // Load Multiple Disjoint + LMG = 0xEB04, // Load Multiple (64) + LMH = 0xEB96, // Load Multiple High + LMY = 0xEB98, // Load Multiple (32) + LNDBR = 0xB311, // Load Negative (long BFP) + LNDFR = 0xB371, // Load Negative (long) + LNEBR = 0xB301, // Load Negative (short BFP) + LNGFR = 0xB911, // Load Negative (64<-32) + LNGR = 0xB901, // Load Negative (64) + LNR = 0x11, // Load Negative (32) + LNXBR = 0xB341, // Load Negative (extended BFP) + LOC = 0xEBF2, // Load On Condition (32) + LOCG = 0xEBE2, // Load On Condition (64) + LOCGR = 0xB9E2, // Load On Condition (64) + LOCR = 0xB9F2, // Load On Condition (32) + LPD = 0xC84, // Load Pair Disjoint (32) + LPDBR = 0xB310, // Load Positive (long BFP) + LPDFR = 0xB370, // Load Positive (long) + LPDG = 0xC85, // Load Pair Disjoint (64) + LPEBR = 0xB300, // Load Positive (short BFP) + LPGFR = 0xB910, // Load Positive (64<-32) + LPGR = 0xB900, // Load Positive (64) + LPQ = 0xE38F, // Load Pair From Quadword + LPR = 0x10, // Load Positive (32) + LPXBR = 0xB340, // Load Positive (extended BFP) + LR = 0x18, // Load (32) + LRL = 0xC4D, // Load Relative Long (32) + LRV = 0xE31E, // Load Reversed (32) + LRVG = 0xE30F, // Load Reversed (64) + LRVGR = 0xB90F, // Load Reversed (64) + LRVH = 0xE31F, // Load Reversed (16) + LRVR = 0xB91F, // Load Reversed (32) + LT = 0xE312, // Load And Test (32) + LTDBR = 0xB312, // Load And Test (long BFP) + LTDTR = 0xB3D6, // Load And Test (long DFP) + LTEBR = 0xB302, // Load And Test (short BFP) + LTG = 0xE302, // Load And Test (64) + LTGF = 0xE332, // Load And Test (64<-32) + LTGFR = 0xB912, // Load And Test (64<-32) + LTGR = 0xB902, // Load And Test (64) + LTR = 0x12, // Load And Test (32) + LTXBR = 0xB342, // Load And Test (extended BFP) + LTXTR = 0xB3DE, // Load And Test (extended DFP) + LXDB = 0xED05, // Load Lengthened (long to extended BFP) + LXDBR = 0xB305, // Load Lengthened (long to extended BFP) + LXDTR = 0xB3DC, // Load Lengthened (long to extended DFP) + LXEB = 0xED06, // Load Lengthened (short to extended BFP) + LXEBR = 0xB306, // Load Lengthened (short to extended BFP) + LXR = 0xB365, // Load (extended) + LY = 0xE358, // Load (32) + LZDR = 0xB375, // Load Zero (long) + LZER = 0xB374, // Load Zero (short) + LZXR = 0xB376, // Load Zero (extended) + M = 0x5C, // Multiply (64<-32) + MADB = 0xED1E, // Multiply And Add (long BFP) + MADBR = 0xB31E, // Multiply And Add (long BFP) + MAEB = 0xED0E, // Multiply And Add (short BFP) + MAEBR = 0xB30E, // Multiply And Add (short BFP) + MC = 0xAF, // Monitor Call + MDB = 0xED1C, // Multiply (long BFP) + MDBR = 0xB31C, // Multiply (long BFP) + MDEB = 0xED0C, // Multiply (short to long BFP) + MDEBR = 0xB30C, // Multiply (short to long BFP) + MDTR = 0xB3D0, // Multiply (long DFP) + MDTRA = 0xB3D0, // Multiply (long DFP) + MEEB = 0xED17, // Multiply (short BFP) + MEEBR = 0xB317, // Multiply (short BFP) + MFY = 0xE35C, // Multiply (64<-32) + MGHI = 0xA7D, // Multiply Halfword Immediate (64) + MH = 0x4C, // Multiply Halfword (32) + MHI = 0xA7C, // Multiply Halfword Immediate (32) + MHY = 0xE37C, // Multiply Halfword (32) + ML = 0xE396, // Multiply Logical (64<-32) + MLG = 0xE386, // Multiply Logical (128<-64) + MLGR = 0xB986, // Multiply Logical (128<-64) + MLR = 0xB996, // Multiply Logical (64<-32) + MP = 0xFC, // Multiply Decimal + MR = 0x1C, // Multiply (64<-32) + MS = 0x71, // Multiply Single (32) + MSCH = 0xB232, // Modify Subchannel + MSDB = 0xED1F, // Multiply And Subtract (long BFP) + MSDBR = 0xB31F, // Multiply And Subtract (long BFP) + MSEB = 0xED0F, // Multiply And Subtract (short BFP) + MSEBR = 0xB30F, // Multiply And Subtract (short BFP) + MSFI = 0xC21, // Multiply Single Immediate (32) + MSG = 0xE30C, // Multiply Single (64) + MSGF = 0xE31C, // Multiply Single (64<-32) + MSGFI = 0xC20, // Multiply Single Immediate (64<-32) + MSGFR = 0xB91C, // Multiply Single (64<-32) + MSGR = 0xB90C, // Multiply Single (64) + MSR = 0xB252, // Multiply Single (32) + MSY = 0xE351, // Multiply Single (32) + MVC = 0xD2, // Move (character) + MVCP = 0xDA, // Move To Primary + MVCDK = 0xE50F, // Move To Primary + MVCIN = 0xE8, // Move Inverse + MVCL = 0x0E, // Move Long + MVCLE = 0xA8, // Move Long Extended + MVCLU = 0xEB8E, // Move Long Unicode + MVGHI = 0xE548, // Move (64<-16) + MVHHI = 0xE544, // Move (16<-16) + MVHI = 0xE54C, // Move (32<-16) + MVI = 0x92, // Move (immediate) + MVIY = 0xEB52, // Move (immediate) + MVN = 0xD1, // Move Numerics + MVO = 0xF1, // Move With Offset + MVST = 0xB255, // Move String + MVZ = 0xD3, // Move Zones + MXBR = 0xB34C, // Multiply (extended BFP) + MXDB = 0xED07, // Multiply (long to extended BFP) + MXDBR = 0xB307, // Multiply (long to extended BFP) + MXTR = 0xB3D8, // Multiply (extended DFP) + MXTRA = 0xB3D8, // Multiply (extended DFP) + N = 0x54, // And (32) + NC = 0xD4, // And (character) + NG = 0xE380, // And (64) + NGR = 0xB980, // And (64) + NGRK = 0xB9E4, // And (64) + NI = 0x94, // And (immediate) + NIAI = 0xB2FA, // Next Instruction Access Intent Ie Eh + NIHF = 0xC0A, // And Immediate (high) + NIHH = 0xA54, // And Immediate (high high) + NIHL = 0xA55, // And Immediate (high low) + NILF = 0xC0B, // And Immediate (low) + NILH = 0xA56, // And Immediate (low high) + NILL = 0xA57, // And Immediate (low low) + NIY = 0xEB54, // And (immediate) + NR = 0x14, // And (32) + NRK = 0xB9F4, // And (32) + NTSTG = 0xE325, // Nontransactional Store Rxy Tx ยค9 A Sp St B2 + NY = 0xE354, // And (32) + O = 0x56, // Or (32) + OC = 0xD6, // Or (character) + OG = 0xE381, // Or (64) + OGR = 0xB981, // Or (64) + OGRK = 0xB9E6, // Or (64) + OI = 0x96, // Or (immediate) + OIHF = 0xC0C, // Or Immediate (high) + OIHH = 0xA58, // Or Immediate (high high) + OIHL = 0xA59, // Or Immediate (high low) + OILF = 0xC0D, // Or Immediate (low) + OILH = 0xA5A, // Or Immediate (low high) + OILL = 0xA5B, // Or Immediate (low low) + OIY = 0xEB56, // Or (immediate) + OR = 0x16, // Or (32) + ORK = 0xB9F6, // Or (32) + OY = 0xE356, // Or (32) + PACK = 0xF2, // Pack + PCC = 0xB92C, // Perform Cryptographic Computation + PFD = 0xE336, // Prefetch Data + PFDRL = 0xC62, // Prefetch Data Relative Long + PFPO = 0x010A, // Perform Floating-POINT Operation + PKA = 0xE9, // Pack Ascii + PKU = 0xE1, // Pack Unicode + PLO = 0xEE, // Perform Locked Operation + POPCNT_Z = 0xB9E1, // Population Count + PPA = 0xB2E8, // Perform Processor Assist + QADTR = 0xB3F5, // Quantize (long DFP) + QAXTR = 0xB3FD, // Quantize (extended DFP) + RCHP = 0xB23B, // Reset Channel Path + RISBG = 0xEC55, // Rotate Then Insert Selected Bits + RISBGN = 0xEC59, // Rotate Then Insert Selected Bits + RISBHG = 0xEC5D, // Rotate Then Insert Selected Bits High + RISBLG = 0xEC51, // Rotate Then Insert Selected Bits Low + RLL = 0xEB1D, // Rotate Left Single Logical (32) + RLLG = 0xEB1C, // Rotate Left Single Logical (64) + RNSBG = 0xEC54, // Rotate Then And Selected Bits + ROSBG = 0xEC56, // Rotate Then Or Selected Bits + RRDTR = 0xB3F7, // Reround (long DFP) + RRXTR = 0xB3FF, // Reround (extended DFP) + RSCH = 0xB238, // Resume Subchannel + RXSBG = 0xEC57, // Rotate Then Exclusive Or Selected Bits + S = 0x5B, // Subtract (32) + SAL = 0xB237, // Set Address Limit + SAR = 0xB24E, // Set Access + SCHM = 0xB23C, // Set Channel Monitor + SDB = 0xED1B, // Subtract (long BFP) + SDBR = 0xB31B, // Subtract (long BFP) + SDTR = 0xB3D3, // Subtract (long DFP) + SDTRA = 0xB3D3, // Subtract (long DFP) + SEB = 0xED0B, // Subtract (short BFP) + SEBR = 0xB30B, // Subtract (short BFP) + SFASR = 0xB385, // Set Fpc And Signal + SFPC = 0xB384, // Set Fpc + SG = 0xE309, // Subtract (64) + SGF = 0xE319, // Subtract (64<-32) + SGFR = 0xB919, // Subtract (64<-32) + SGR = 0xB909, // Subtract (64) + SGRK = 0xB9E9, // Subtract (64) + SH = 0x4B, // Subtract Halfword + SHHHR = 0xB9C9, // Subtract High (32) + SHHLR = 0xB9D9, // Subtract High (32) + SHY = 0xE37B, // Subtract Halfword + SL = 0x5F, // Subtract Logical (32) + SLA = 0x8B, // Shift Left Single (32) + SLAG = 0xEB0B, // Shift Left Single (64) + SLAK = 0xEBDD, // Shift Left Single (32) + SLB = 0xE399, // Subtract Logical With Borrow (32) + SLBG = 0xE389, // Subtract Logical With Borrow (64) + SLBGR = 0xB989, // Subtract Logical With Borrow (64) + SLBR = 0xB999, // Subtract Logical With Borrow (32) + SLDA = 0x8F, // Shift Left Double + SLDL = 0x8D, // Shift Left Double Logical + SLDT = 0xED40, // Shift Significand Left (long DFP) + SLFI = 0xC25, // Subtract Logical Immediate (32) + SLG = 0xE30B, // Subtract Logical (64) + SLGF = 0xE31B, // Subtract Logical (64<-32) + SLGFI = 0xC24, // Subtract Logical Immediate (64<-32) + SLGFR = 0xB91B, // Subtract Logical (64<-32) + SLGR = 0xB90B, // Subtract Logical (64) + SLGRK = 0xB9EB, // Subtract Logical (64) + SLHHHR = 0xB9CB, // Subtract Logical High (32) + SLHHLR = 0xB9DB, // Subtract Logical High (32) + SLL = 0x89, // Shift Left Single Logical (32) + SLLG = 0xEB0D, // Shift Left Single Logical (64) + SLLK = 0xEBDF, // Shift Left Single Logical (32) + SLR = 0x1F, // Subtract Logical (32) + SLRK = 0xB9FB, // Subtract Logical (32) + SLXT = 0xED48, // Shift Significand Left (extended DFP) + SLY = 0xE35F, // Subtract Logical (32) + SP = 0xFB, // Subtract Decimal + SPM = 0x04, // Set Program Mask + SQDB = 0xED15, // Square Root (long BFP) + SQDBR = 0xB315, // Square Root (long BFP) + SQEB = 0xED14, // Square Root (short BFP) + SQEBR = 0xB314, // Square Root (short BFP) + SQXBR = 0xB316, // Square Root (extended BFP) + SR = 0x1B, // Subtract (32) + SRA = 0x8A, // Shift Right Single (32) + SRAG = 0xEB0A, // Shift Right Single (64) + SRAK = 0xEBDC, // Shift Right Single (32) + SRDA = 0x8E, // Shift Right Double + SRDL = 0x8C, // Shift Right Double Logical + SRDT = 0xED41, // Shift Significand Right (long DFP) + SRK = 0xB9F9, // Subtract (32) + SRL = 0x88, // Shift Right Single Logical (32) + SRLG = 0xEB0C, // Shift Right Single Logical (64) + SRLK = 0xEBDE, // Shift Right Single Logical (32) + SRNM = 0xB299, // Set BFP Rounding Mode (2 bit) + SRNMB = 0xB2B8, // Set BFP Rounding Mode (3 bit) + SRNMT = 0xB2B9, // Set DFP Rounding Mode + SRP = 0xF0, // Shift And Round Decimal + SRST = 0xB25E, // Search String + SRSTU = 0xB9BE, // Search String Unicode + SRXT = 0xED49, // Shift Significand Right (extended DFP) + SSCH = 0xB233, // Start Subchannel + ST = 0x50, // Store (32) + STC = 0x42, // Store Character + STCH = 0xE3C3, // Store Character High (8) + STCK = 0xB205, // Store Clock + STCKE = 0xB278, // Store Clock Extended + STCKF = 0xB27C, // Store Clock Fast + STCM = 0xBE, // Store Characters Under Mask (low) + STCMH = 0xEB2C, // Store Characters Under Mask (high) + STCMY = 0xEB2D, // Store Characters Under Mask (low) + STCPS = 0xB23A, // Store Channel Path Status + STCRW = 0xB239, // Store Channel Report Word + STCY = 0xE372, // Store Character + STD = 0x60, // Store (long) + STDY = 0xED67, // Store (long) + STE = 0x70, // Store (short) + STEY = 0xED66, // Store (short) + STFH = 0xE3CB, // Store High (32) + STFLE = 0xB2B0, // Store Facility List Extended + STFPC = 0xB29C, // Store Fpc + STG = 0xE324, // Store (64) + STGRL = 0xC4B, // Store Relative Long (64) + STH = 0x40, // Store Halfword + STHH = 0xE3C7, // Store Halfword High (16) + STHRL = 0xC47, // Store Halfword Relative Long + STHY = 0xE370, // Store Halfword + STM = 0x90, // Store Multiple (32) + STMG = 0xEB24, // Store Multiple (64) + STMH = 0xEB26, // Store Multiple High + STMY = 0xEB90, // Store Multiple (32) + STOC = 0xEBF3, // Store On Condition (32) + STOCG = 0xEBE3, // Store On Condition (64) + STPQ = 0xE38E, // Store Pair To Quadword + STRL = 0xC4F, // Store Relative Long (32) + STRV = 0xE33E, // Store Reversed (32) + STRVG = 0xE32F, // Store Reversed (64) + STRVH = 0xE33F, // Store Reversed (16) + STSCH = 0xB234, // Store Subchannel + STY = 0xE350, // Store (32) + SVC = 0x0A, // Supervisor Call + SXBR = 0xB34B, // Subtract (extended BFP) + SXTR = 0xB3DB, // Subtract (extended DFP) + SXTRA = 0xB3DB, // Subtract (extended DFP) + SY = 0xE35B, // Subtract (32) + TABORT = 0xB2FC, // Transaction Abort + TBDR = 0xB351, // Convert HFP To BFP (long) + TBEDR = 0xB350, // Convert HFP To BFP (long to short) + TBEGIN = 0xE560, // Transaction Begin + TBEGINC = 0xE561, // Transaction Begin + TCDB = 0xED11, // Test Data Class (long BFP) + TCEB = 0xED10, // Test Data Class (short BFP) + TCXB = 0xED12, // Test Data Class (extended BFP) + TDCDT = 0xED54, // Test Data Class (long DFP) + TDCET = 0xED50, // Test Data Class (short DFP) + TDCXT = 0xED58, // Test Data Class (extended DFP) + TDGDT = 0xED55, // Test Data Group (long DFP) + TDGET = 0xED51, // Test Data Group (short DFP) + TDGXT = 0xED59, // Test Data Group (extended DFP) + TEND = 0xB2F8, // Transaction End + THDER = 0xB358, // Convert BFP To HFP (short to long) + THDR = 0xB359, // Convert BFP To HFP (long) + TM = 0x91, // Test Under Mask Si C A B1 + TMH = 0xA70, // Test Under Mask High + TMHH = 0xA72, // Test Under Mask (high high) + TMHL = 0xA73, // Test Under Mask (high low) + TML = 0xA71, // Test Under Mask Low + TMLH = 0xA70, // Test Under Mask (low high) + TMLL = 0xA71, // Test Under Mask (low low) + TMY = 0xEB51, // Test Under Mask + TP = 0xEBC0, // Test Decimal + TPI = 0xB236, // Test Pending Interruption + TR = 0xDC, // Translate + TRAP4 = 0xB2FF, // Trap (4) + TRE = 0xB2A5, // Translate Extended + TROO = 0xB993, // Translate One To One + TROT = 0xB992, // Translate One To Two + TRT = 0xDD, // Translate And Test + TRTE = 0xB9BF, // Translate And Test Extended + TRTO = 0xB991, // Translate Two To One + TRTR = 0xD0, // Translate And Test Reverse + TRTRE = 0xB9BD, // Translate And Test Reverse Extended + TRTT = 0xB990, // Translate Two To Two + TS = 0x93, // Test And Set + TSCH = 0xB235, // Test Subchannel + UNPK = 0xF3, // Unpack + UNPKA = 0xEA, // Unpack Ascii + UNPKU = 0xE2, // Unpack Unicode + UPT = 0x0102, // Update Tree + X = 0x57, // Exclusive Or (32) + XC = 0xD7, // Exclusive Or (character) + XG = 0xE382, // Exclusive Or (64) + XGR = 0xB982, // Exclusive Or (64) + XGRK = 0xB9E7, // Exclusive Or (64) + XI = 0x97, // Exclusive Or (immediate) + XIHF = 0xC06, // Exclusive Or Immediate (high) + XILF = 0xC07, // Exclusive Or Immediate (low) + XIY = 0xEB57, // Exclusive Or (immediate) + XR = 0x17, // Exclusive Or (32) + XRK = 0xB9F7, // Exclusive Or (32) + XSCH = 0xB276, // Cancel Subchannel + XY = 0xE357, // Exclusive Or (32) + ZAP = 0xF8, // Zero And Add + BKPT = 0x0001 // GDB Software Breakpoint +}; + +// Instruction encoding bits and masks. +enum { + // Instruction encoding bit + B1 = 1 << 1, + B4 = 1 << 4, + B5 = 1 << 5, + B7 = 1 << 7, + B8 = 1 << 8, + B9 = 1 << 9, + B12 = 1 << 12, + B18 = 1 << 18, + B19 = 1 << 19, + B20 = 1 << 20, + B22 = 1 << 22, + B23 = 1 << 23, + B24 = 1 << 24, + B25 = 1 << 25, + B26 = 1 << 26, + B27 = 1 << 27, + B28 = 1 << 28, + + B6 = 1 << 6, + B10 = 1 << 10, + B11 = 1 << 11, + B16 = 1 << 16, + B17 = 1 << 17, + B21 = 1 << 21, + + // Instruction bit masks + kCondMask = 0x1F << 21, + kOff12Mask = (1 << 12) - 1, + kImm24Mask = (1 << 24) - 1, + kOff16Mask = (1 << 16) - 1, + kImm16Mask = (1 << 16) - 1, + kImm26Mask = (1 << 26) - 1, + kBOfieldMask = 0x1f << 21, + kOpcodeMask = 0x3f << 26, + kExt2OpcodeMask = 0x1f << 1, + kExt5OpcodeMask = 0x3 << 2, + kBIMask = 0x1F << 16, + kBDMask = 0x14 << 2, + kAAMask = 0x01 << 1, + kLKMask = 0x01, + kRCMask = 0x01, + kTOMask = 0x1f << 21 +}; + +// S390 instructions requires bigger shifts, +// make them macros instead of enum because of the typing issue +#define B32 ((uint64_t)1 << 32) +#define B36 ((uint64_t)1 << 36) +#define B40 ((uint64_t)1 << 40) +const FourByteInstr kFourByteBrCondMask = 0xF << 20; +const SixByteInstr kSixByteBrCondMask = static_cast<SixByteInstr>(0xF) << 36; + +// ----------------------------------------------------------------------------- +// Addressing modes and instruction variants. + +// Overflow Exception +enum OEBit { + SetOE = 1 << 10, // Set overflow exception + LeaveOE = 0 << 10 // No overflow exception +}; + +// Record bit +enum RCBit { // Bit 0 + SetRC = 1, // LT,GT,EQ,SO + LeaveRC = 0 // None +}; + +// Link bit +enum LKBit { // Bit 0 + SetLK = 1, // Load effective address of next instruction + LeaveLK = 0 // No action +}; + +enum BOfield { // Bits 25-21 + DCBNZF = 0 << 21, // Decrement CTR; branch if CTR != 0 and condition false + DCBEZF = 2 << 21, // Decrement CTR; branch if CTR == 0 and condition false + BF = 4 << 21, // Branch if condition false + DCBNZT = 8 << 21, // Decrement CTR; branch if CTR != 0 and condition true + DCBEZT = 10 << 21, // Decrement CTR; branch if CTR == 0 and condition true + BT = 12 << 21, // Branch if condition true + DCBNZ = 16 << 21, // Decrement CTR; branch if CTR != 0 + DCBEZ = 18 << 21, // Decrement CTR; branch if CTR == 0 + BA = 20 << 21 // Branch always +}; + +#ifdef _AIX +#undef CR_LT +#undef CR_GT +#undef CR_EQ +#undef CR_SO +#endif + +enum CRBit { CR_LT = 0, CR_GT = 1, CR_EQ = 2, CR_SO = 3, CR_FU = 3 }; + +#define CRWIDTH 4 + +// ----------------------------------------------------------------------------- +// Supervisor Call (svc) specific support. + +// Special Software Interrupt codes when used in the presence of the S390 +// simulator. +// SVC provides a 24bit immediate value. Use bits 22:0 for standard +// SoftwareInterrupCode. Bit 23 is reserved for the stop feature. +enum SoftwareInterruptCodes { + // Transition to C code + kCallRtRedirected = 0x0010, + // Breakpoint + kBreakpoint = 0x0000, + // Stop + kStopCode = 1 << 23 +}; +const uint32_t kStopCodeMask = kStopCode - 1; +const uint32_t kMaxStopCode = kStopCode - 1; +const int32_t kDefaultStopCode = -1; + +// FP rounding modes. +enum FPRoundingMode { + RN = 0, // Round to Nearest. + RZ = 1, // Round towards zero. + RP = 2, // Round towards Plus Infinity. + RM = 3, // Round towards Minus Infinity. + + // Aliases. + kRoundToNearest = RN, + kRoundToZero = RZ, + kRoundToPlusInf = RP, + kRoundToMinusInf = RM +}; + +const uint32_t kFPRoundingModeMask = 3; + +enum CheckForInexactConversion { + kCheckForInexactConversion, + kDontCheckForInexactConversion +}; + +// ----------------------------------------------------------------------------- +// Specific instructions, constants, and masks. + +// use TRAP4 to indicate redirection call for simulation mode +const Instr rtCallRedirInstr = TRAP4; + +// ----------------------------------------------------------------------------- +// Instruction abstraction. + +// The class Instruction enables access to individual fields defined in the +// z/Architecture instruction set encoding. +class Instruction { + public: + // S390 Opcode Format Types + // Based on the first byte of the opcode, we can determine how to extract + // the entire opcode of the instruction. The various favours include: + enum OpcodeFormatType { + ONE_BYTE_OPCODE, // One Byte - Bits 0 to 7 + TWO_BYTE_OPCODE, // Two Bytes - Bits 0 to 15 + TWO_BYTE_DISJOINT_OPCODE, // Two Bytes - Bits 0 to 7, 40 to 47 + THREE_NIBBLE_OPCODE // Three Nibbles - Bits 0 to 7, 12 to 15 + }; + +// Helper macro to define static accessors. +// We use the cast to char* trick to bypass the strict anti-aliasing rules. +#define DECLARE_STATIC_TYPED_ACCESSOR(return_type, Name) \ + static inline return_type Name(Instr instr) { \ + char* temp = reinterpret_cast<char*>(&instr); \ + return reinterpret_cast<Instruction*>(temp)->Name(); \ + } + +#define DECLARE_STATIC_ACCESSOR(Name) DECLARE_STATIC_TYPED_ACCESSOR(int, Name) + + // Get the raw instruction bits. + template <typename T> + inline T InstructionBits() const { + return Instruction::InstructionBits<T>(reinterpret_cast<const byte*>(this)); + } + inline Instr InstructionBits() const { + return *reinterpret_cast<const Instr*>(this); + } + + // Set the raw instruction bits to value. + template <typename T> + inline void SetInstructionBits(T value) const { + Instruction::SetInstructionBits<T>(reinterpret_cast<const byte*>(this), + value); + } + inline void SetInstructionBits(Instr value) { + *reinterpret_cast<Instr*>(this) = value; + } + + // Read one particular bit out of the instruction bits. + inline int Bit(int nr) const { return (InstructionBits() >> nr) & 1; } + + // Read a bit field's value out of the instruction bits. + inline int Bits(int hi, int lo) const { + return (InstructionBits() >> lo) & ((2 << (hi - lo)) - 1); + } + + // Read bits according to instruction type + template <typename T, typename U> + inline U Bits(int hi, int lo) const { + return (InstructionBits<T>() >> lo) & ((2 << (hi - lo)) - 1); + } + + // Read a bit field out of the instruction bits. + inline int BitField(int hi, int lo) const { + return InstructionBits() & (((2 << (hi - lo)) - 1) << lo); + } + + // Determine the instruction length + inline int InstructionLength() { + return Instruction::InstructionLength(reinterpret_cast<const byte*>(this)); + } + // Extract the Instruction Opcode + inline Opcode S390OpcodeValue() { + return Instruction::S390OpcodeValue(reinterpret_cast<const byte*>(this)); + } + + // Static support. + + // Read one particular bit out of the instruction bits. + static inline int Bit(Instr instr, int nr) { return (instr >> nr) & 1; } + + // Read the value of a bit field out of the instruction bits. + static inline int Bits(Instr instr, int hi, int lo) { + return (instr >> lo) & ((2 << (hi - lo)) - 1); + } + + // Read a bit field out of the instruction bits. + static inline int BitField(Instr instr, int hi, int lo) { + return instr & (((2 << (hi - lo)) - 1) << lo); + } + + // Determine the instruction length of the given instruction + static inline int InstructionLength(const byte* instr) { + // Length can be determined by the first nibble. + // 0x0 to 0x3 => 2-bytes + // 0x4 to 0xB => 4-bytes + // 0xC to 0xF => 6-bytes + byte topNibble = (*instr >> 4) & 0xF; + if (topNibble <= 3) + return 2; + else if (topNibble <= 0xB) + return 4; + return 6; + } + + // Returns the instruction bits of the given instruction + static inline uint64_t InstructionBits(const byte* instr) { + int length = InstructionLength(instr); + if (2 == length) + return static_cast<uint64_t>(InstructionBits<TwoByteInstr>(instr)); + else if (4 == length) + return static_cast<uint64_t>(InstructionBits<FourByteInstr>(instr)); + else + return InstructionBits<SixByteInstr>(instr); + } + + // Extract the raw instruction bits + template <typename T> + static inline T InstructionBits(const byte* instr) { +#if !V8_TARGET_LITTLE_ENDIAN + if (sizeof(T) <= 4) { + return *reinterpret_cast<const T*>(instr); + } else { + // We cannot read 8-byte instructon address directly, because for a + // six-byte instruction, the extra 2-byte address might not be + // allocated. + uint64_t fourBytes = *reinterpret_cast<const uint32_t*>(instr); + uint16_t twoBytes = *reinterpret_cast<const uint16_t*>(instr + 4); + return (fourBytes << 16 | twoBytes); + } +#else + // Even on little endian hosts (simulation), the instructions + // are stored as big-endian in order to decode the opcode and + // instruction length. + T instr_bits = 0; + + // 6-byte instrs are represented by uint64_t + uint32_t size = (sizeof(T) == 8) ? 6 : sizeof(T); + + for (T i = 0; i < size; i++) { + instr_bits <<= 8; + instr_bits |= *(instr + i); + } + return instr_bits; +#endif + } + + // Set the Instruction Bits to value + template <typename T> + static inline void SetInstructionBits(byte* instr, T value) { +#if V8_TARGET_LITTLE_ENDIAN + // The instruction bits are stored in big endian format even on little + // endian hosts, in order to decode instruction length and opcode. + // The following code will reverse the bytes so that the stores later + // (which are in native endianess) will effectively save the instruction + // in big endian. + if (sizeof(T) == 2) { + // Two Byte Instruction + value = ((value & 0x00FF) << 8) | ((value & 0xFF00) >> 8); + } else if (sizeof(T) == 4) { + // Four Byte Instruction + value = ((value & 0x000000FF) << 24) | ((value & 0x0000FF00) << 8) | + ((value & 0x00FF0000) >> 8) | ((value & 0xFF000000) >> 24); + } else if (sizeof(T) == 8) { + // Six Byte Instruction + uint64_t orig_value = static_cast<uint64_t>(value); + value = (static_cast<uint64_t>(orig_value & 0xFF) << 40) | + (static_cast<uint64_t>((orig_value >> 8) & 0xFF) << 32) | + (static_cast<uint64_t>((orig_value >> 16) & 0xFF) << 24) | + (static_cast<uint64_t>((orig_value >> 24) & 0xFF) << 16) | + (static_cast<uint64_t>((orig_value >> 32) & 0xFF) << 8) | + (static_cast<uint64_t>((orig_value >> 40) & 0xFF)); + } +#endif + if (sizeof(T) <= 4) { + *reinterpret_cast<T*>(instr) = value; + } else { +#if V8_TARGET_LITTLE_ENDIAN + uint64_t orig_value = static_cast<uint64_t>(value); + *reinterpret_cast<uint32_t*>(instr) = static_cast<uint32_t>(value); + *reinterpret_cast<uint16_t*>(instr + 4) = + static_cast<uint16_t>((orig_value >> 32) & 0xFFFF); +#else + *reinterpret_cast<uint32_t*>(instr) = static_cast<uint32_t>(value >> 16); + *reinterpret_cast<uint16_t*>(instr + 4) = + static_cast<uint16_t>(value & 0xFFFF); +#endif + } + } + + // Get Instruction Format Type + static OpcodeFormatType getOpcodeFormatType(const byte* instr) { + const byte firstByte = *instr; + // Based on Figure B-3 in z/Architecture Principles of + // Operation. + + // 1-byte opcodes + // I, RR, RS, RSI, RX, SS Formats + if ((0x04 <= firstByte && 0x9B >= firstByte) || + (0xA8 <= firstByte && 0xB1 >= firstByte) || + (0xBA <= firstByte && 0xBF >= firstByte) || (0xC5 == firstByte) || + (0xC7 == firstByte) || (0xD0 <= firstByte && 0xE2 >= firstByte) || + (0xE8 <= firstByte && 0xEA >= firstByte) || + (0xEE <= firstByte && 0xFD >= firstByte)) { + return ONE_BYTE_OPCODE; + } + + // 2-byte opcodes + // E, IE, RRD, RRE, RRF, SIL, S, SSE Formats + if ((0x00 == firstByte) || // Software breakpoint 0x0001 + (0x01 == firstByte) || (0xB2 == firstByte) || (0xB3 == firstByte) || + (0xB9 == firstByte) || (0xE5 == firstByte)) { + return TWO_BYTE_OPCODE; + } + + // 3-nibble opcodes + // RI, RIL, SSF Formats + if ((0xA5 == firstByte) || (0xA7 == firstByte) || + (0xC0 <= firstByte && 0xCC >= firstByte)) { // C5,C7 handled above + return THREE_NIBBLE_OPCODE; + } + // Remaining ones are all TWO_BYTE_DISJOINT OPCODES. + DCHECK(InstructionLength(instr) == 6); + return TWO_BYTE_DISJOINT_OPCODE; + } + + // Extract the full opcode from the instruction. + static inline Opcode S390OpcodeValue(const byte* instr) { + OpcodeFormatType opcodeType = getOpcodeFormatType(instr); + + // The native instructions are encoded in big-endian format + // even if running on little-endian host. Hence, we need + // to ensure we use byte* based bit-wise logic. + switch (opcodeType) { + case ONE_BYTE_OPCODE: + // One Byte - Bits 0 to 7 + return static_cast<Opcode>(*instr); + case TWO_BYTE_OPCODE: + // Two Bytes - Bits 0 to 15 + return static_cast<Opcode>((*instr << 8) | (*(instr + 1))); + case TWO_BYTE_DISJOINT_OPCODE: + // Two Bytes - Bits 0 to 7, 40 to 47 + return static_cast<Opcode>((*instr << 8) | (*(instr + 5) & 0xFF)); + case THREE_NIBBLE_OPCODE: + // Three Nibbles - Bits 0 to 7, 12 to 15 + return static_cast<Opcode>((*instr << 4) | (*(instr + 1) & 0xF)); + default: + break; + } + + UNREACHABLE(); + return static_cast<Opcode>(-1); + } + + // Fields used in Software interrupt instructions + inline SoftwareInterruptCodes SvcValue() const { + return static_cast<SoftwareInterruptCodes>(Bits<FourByteInstr, int>(15, 0)); + } + + // Instructions are read of out a code stream. The only way to get a + // reference to an instruction is to convert a pointer. There is no way + // to allocate or create instances of class Instruction. + // Use the At(pc) function to create references to Instruction. + static Instruction* At(byte* pc) { + return reinterpret_cast<Instruction*>(pc); + } + + private: + // We need to prevent the creation of instances of class Instruction. + DISALLOW_IMPLICIT_CONSTRUCTORS(Instruction); +}; + +// I Instruction -- suspect this will not be used, +// but implement for completeness +class IInstruction : Instruction { + public: + inline int IValue() const { return Bits<TwoByteInstr, int>(7, 0); } + + inline int size() const { return 2; } +}; + +// RR Instruction +class RRInstruction : Instruction { + public: + inline int R1Value() const { + // the high and low parameters of Bits is the number of bits from + // rightmost place + return Bits<TwoByteInstr, int>(7, 4); + } + inline int R2Value() const { return Bits<TwoByteInstr, int>(3, 0); } + inline Condition M1Value() const { + return static_cast<Condition>(Bits<TwoByteInstr, int>(7, 4)); + } + + inline int size() const { return 2; } +}; + +// RRE Instruction +class RREInstruction : Instruction { + public: + inline int R1Value() const { return Bits<FourByteInstr, int>(7, 4); } + inline int R2Value() const { return Bits<FourByteInstr, int>(3, 0); } + inline int M3Value() const { return Bits<FourByteInstr, int>(15, 12); } + inline int M4Value() const { return Bits<FourByteInstr, int>(19, 16); } + inline int size() const { return 4; } +}; + +// RRF Instruction +class RRFInstruction : Instruction { + public: + inline int R1Value() const { return Bits<FourByteInstr, int>(7, 4); } + inline int R2Value() const { return Bits<FourByteInstr, int>(3, 0); } + inline int R3Value() const { return Bits<FourByteInstr, int>(15, 12); } + inline int M3Value() const { return Bits<FourByteInstr, int>(15, 12); } + inline int M4Value() const { return Bits<FourByteInstr, int>(11, 8); } + inline int size() const { return 4; } +}; + +// RRD Isntruction +class RRDInstruction : Instruction { + public: + inline int R1Value() const { return Bits<FourByteInstr, int>(15, 12); } + inline int R2Value() const { return Bits<FourByteInstr, int>(3, 0); } + inline int R3Value() const { return Bits<FourByteInstr, int>(7, 4); } + inline int size() const { return 4; } +}; + +// RI Instruction +class RIInstruction : Instruction { + public: + inline int R1Value() const { return Bits<FourByteInstr, int>(23, 20); } + inline int16_t I2Value() const { return Bits<FourByteInstr, int16_t>(15, 0); } + inline uint16_t I2UnsignedValue() const { + return Bits<FourByteInstr, uint16_t>(15, 0); + } + inline Condition M1Value() const { + return static_cast<Condition>(Bits<FourByteInstr, int>(23, 20)); + } + inline int size() const { return 4; } +}; + +// RS Instruction +class RSInstruction : Instruction { + public: + inline int R1Value() const { return Bits<FourByteInstr, int>(23, 20); } + inline int R3Value() const { return Bits<FourByteInstr, int>(19, 16); } + inline int B2Value() const { return Bits<FourByteInstr, int>(15, 12); } + inline unsigned int D2Value() const { + return Bits<FourByteInstr, unsigned int>(11, 0); + } + inline int size() const { return 4; } +}; + +// RSY Instruction +class RSYInstruction : Instruction { + public: + inline int R1Value() const { return Bits<SixByteInstr, int>(39, 36); } + inline int R3Value() const { return Bits<SixByteInstr, int>(35, 32); } + inline int B2Value() const { return Bits<SixByteInstr, int>(31, 28); } + inline int32_t D2Value() const { + int32_t value = Bits<SixByteInstr, int32_t>(27, 16); + value += Bits<SixByteInstr, int8_t>(15, 8) << 12; + return value; + } + inline int size() const { return 6; } +}; + +// RX Instruction +class RXInstruction : Instruction { + public: + inline int R1Value() const { return Bits<FourByteInstr, int>(23, 20); } + inline int X2Value() const { return Bits<FourByteInstr, int>(19, 16); } + inline int B2Value() const { return Bits<FourByteInstr, int>(15, 12); } + inline uint32_t D2Value() const { + return Bits<FourByteInstr, uint32_t>(11, 0); + } + inline int size() const { return 4; } +}; + +// RXY Instruction +class RXYInstruction : Instruction { + public: + inline int R1Value() const { return Bits<SixByteInstr, int>(39, 36); } + inline int X2Value() const { return Bits<SixByteInstr, int>(35, 32); } + inline int B2Value() const { return Bits<SixByteInstr, int>(31, 28); } + inline int32_t D2Value() const { + int32_t value = Bits<SixByteInstr, uint32_t>(27, 16); + value += Bits<SixByteInstr, int8_t>(15, 8) << 12; + return value; + } + inline int size() const { return 6; } +}; + +// RIL Instruction +class RILInstruction : Instruction { + public: + inline int R1Value() const { return Bits<SixByteInstr, int>(39, 36); } + inline int32_t I2Value() const { return Bits<SixByteInstr, int32_t>(31, 0); } + inline uint32_t I2UnsignedValue() const { + return Bits<SixByteInstr, uint32_t>(31, 0); + } + inline int size() const { return 6; } +}; + +// SI Instruction +class SIInstruction : Instruction { + public: + inline int B1Value() const { return Bits<FourByteInstr, int>(15, 12); } + inline uint32_t D1Value() const { + return Bits<FourByteInstr, uint32_t>(11, 0); + } + inline uint8_t I2Value() const { + return Bits<FourByteInstr, uint8_t>(23, 16); + } + inline int size() const { return 4; } +}; + +// SIY Instruction +class SIYInstruction : Instruction { + public: + inline int B1Value() const { return Bits<SixByteInstr, int>(31, 28); } + inline int32_t D1Value() const { + int32_t value = Bits<SixByteInstr, uint32_t>(27, 16); + value += Bits<SixByteInstr, int8_t>(15, 8) << 12; + return value; + } + inline uint8_t I2Value() const { return Bits<SixByteInstr, uint8_t>(39, 32); } + inline int size() const { return 6; } +}; + +// SIL Instruction +class SILInstruction : Instruction { + public: + inline int B1Value() const { return Bits<SixByteInstr, int>(31, 28); } + inline int D1Value() const { return Bits<SixByteInstr, int>(27, 16); } + inline int I2Value() const { return Bits<SixByteInstr, int>(15, 0); } + inline int size() const { return 6; } +}; + +// SS Instruction +class SSInstruction : Instruction { + public: + inline int B1Value() const { return Bits<SixByteInstr, int>(31, 28); } + inline int B2Value() const { return Bits<SixByteInstr, int>(15, 12); } + inline int D1Value() const { return Bits<SixByteInstr, int>(27, 16); } + inline int D2Value() const { return Bits<SixByteInstr, int>(11, 0); } + inline int Length() const { return Bits<SixByteInstr, int>(39, 32); } + inline int size() const { return 6; } +}; + +// RXE Instruction +class RXEInstruction : Instruction { + public: + inline int R1Value() const { return Bits<SixByteInstr, int>(39, 36); } + inline int X2Value() const { return Bits<SixByteInstr, int>(35, 32); } + inline int B2Value() const { return Bits<SixByteInstr, int>(31, 28); } + inline int D2Value() const { return Bits<SixByteInstr, int>(27, 16); } + inline int size() const { return 6; } +}; + +// RIE Instruction +class RIEInstruction : Instruction { + public: + inline int R1Value() const { return Bits<SixByteInstr, int>(39, 36); } + inline int R2Value() const { return Bits<SixByteInstr, int>(35, 32); } + inline int I3Value() const { return Bits<SixByteInstr, uint32_t>(31, 24); } + inline int I4Value() const { return Bits<SixByteInstr, uint32_t>(23, 16); } + inline int I5Value() const { return Bits<SixByteInstr, uint32_t>(15, 8); } + inline int I6Value() const { + return static_cast<int32_t>(Bits<SixByteInstr, int16_t>(31, 16)); + } + inline int size() const { return 6; } +}; + +// Helper functions for converting between register numbers and names. +class Registers { + public: + // Lookup the register number for the name provided. + static int Number(const char* name); + + private: + static const char* names_[kNumRegisters]; +}; + +// Helper functions for converting between FP register numbers and names. +class DoubleRegisters { + public: + // Lookup the register number for the name provided. + static int Number(const char* name); + + private: + static const char* names_[kNumDoubleRegisters]; +}; + +} // namespace internal +} // namespace v8 + +#endif // V8_S390_CONSTANTS_S390_H_ |