1// Copyright 2014 the V8 project authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#ifndef V8_CODEGEN_S390_CONSTANTS_S390_H_ 6#define V8_CODEGEN_S390_CONSTANTS_S390_H_ 7 8// Get the standard printf format macros for C99 stdint types. 9#ifndef __STDC_FORMAT_MACROS 10#define __STDC_FORMAT_MACROS 11#endif 12#include <inttypes.h> 13 14#include <stdint.h> 15 16#include "src/base/logging.h" 17#include "src/base/macros.h" 18#include "src/common/globals.h" 19 20// UNIMPLEMENTED_ macro for S390. 21#ifdef DEBUG 22#define UNIMPLEMENTED_S390() \ 23 v8::internal::PrintF("%s, \tline %d: \tfunction %s not implemented. \n", \ 24 __FILE__, __LINE__, __func__) 25#else 26#define UNIMPLEMENTED_S390() 27#endif 28 29namespace v8 { 30namespace internal { 31 32constexpr size_t kMaxPCRelativeCodeRangeInMB = 4096; 33 34// Number of registers 35const int kNumRegisters = 16; 36 37// FP support. 38const int kNumDoubleRegisters = 16; 39 40const int kNoRegister = -1; 41 42// Actual value of root register is offset from the root array's start 43// to take advantage of negative displacement values. 44// TODO(sigurds): Choose best value. 45constexpr int kRootRegisterBias = 128; 46 47// sign-extend the least significant 16-bits of value <imm> 48#define SIGN_EXT_IMM16(imm) ((static_cast<int>(imm) << 16) >> 16) 49 50// sign-extend the least significant 26-bits of value <imm> 51#define SIGN_EXT_IMM26(imm) ((static_cast<int>(imm) << 6) >> 6) 52 53// ----------------------------------------------------------------------------- 54// Conditions. 55 56// Defines constants and accessor classes to assemble, disassemble and 57// simulate z/Architecture instructions. 58// 59// Section references in the code refer to the "z/Architecture Principles 60// Of Operation" http://publibfi.boulder.ibm.com/epubs/pdf/dz9zr009.pdf 61// 62 63// Constants for specific fields are defined in their respective named enums. 64// General constants are in an anonymous enum in class Instr. 65enum Condition { 66 kNoCondition = -1, 67 eq = 0x8, // Equal. 68 ne = 0x7, // Not equal. 69 ge = 0xa, // Greater or equal. 70 lt = 0x4, // Less than. 71 gt = 0x2, // Greater than. 72 le = 0xc, // Less then or equal 73 al = 0xf, // Always. 74 75 CC_NOP = 0x0, // S390 NOP 76 CC_EQ = 0x08, // S390 condition code 0b1000 77 CC_LT = 0x04, // S390 condition code 0b0100 78 CC_LE = CC_EQ | CC_LT, // S390 condition code 0b1100 79 CC_GT = 0x02, // S390 condition code 0b0010 80 CC_GE = CC_EQ | CC_GT, // S390 condition code 0b1010 81 CC_OF = 0x01, // S390 condition code 0b0001 82 CC_NOF = 0x0E, // S390 condition code 0b1110 83 CC_ALWAYS = 0x0F, // S390 always taken branch 84 unordered = CC_OF, // Floating-point unordered 85 ordered = CC_NOF, // floating-point ordered 86 overflow = CC_OF, // Summary overflow 87 nooverflow = CC_NOF, 88 89 mask0x0 = 0, // no jumps 90 mask0x1 = 1, 91 mask0x2 = 2, 92 mask0x3 = 3, 93 mask0x4 = 4, 94 mask0x5 = 5, 95 mask0x6 = 6, 96 mask0x7 = 7, 97 mask0x8 = 8, 98 mask0x9 = 9, 99 mask0xA = 10, 100 mask0xB = 11, 101 mask0xC = 12, 102 mask0xD = 13, 103 mask0xE = 14, 104 mask0xF = 15 105}; 106 107inline Condition NegateCondition(Condition cond) { 108 DCHECK(cond != al); 109 switch (cond) { 110 case eq: 111 return ne; 112 case ne: 113 return eq; 114 case ge: 115 return lt; 116 case gt: 117 return le; 118 case le: 119 return gt; 120 case lt: 121 return ge; 122 case lt | gt: 123 return eq; 124 case le | ge: 125 return CC_OF; 126 case CC_OF: 127 return CC_NOF; 128 default: 129 DCHECK(false); 130 } 131 return al; 132} 133 134// ----------------------------------------------------------------------------- 135// Instructions encoding. 136 137// Instr is merely used by the Assembler to distinguish 32bit integers 138// representing instructions from usual 32 bit values. 139// Instruction objects are pointers to 32bit values, and provide methods to 140// access the various ISA fields. 141using Instr = int32_t; 142using TwoByteInstr = uint16_t; 143using FourByteInstr = uint32_t; 144using SixByteInstr = uint64_t; 145 146#define S390_RSY_A_OPCODE_LIST(V) \ 147 V(lmg, LMG, 0xEB04) /* type = RSY_A LOAD MULTIPLE (64) */ \ 148 V(srag, SRAG, 0xEB0A) /* type = RSY_A SHIFT RIGHT SINGLE (64) */ \ 149 V(slag, SLAG, 0xEB0B) /* type = RSY_A SHIFT LEFT SINGLE (64) */ \ 150 V(srlg, SRLG, 0xEB0C) /* type = RSY_A SHIFT RIGHT SINGLE LOGICAL (64) */ \ 151 V(sllg, SLLG, 0xEB0D) /* type = RSY_A SHIFT LEFT SINGLE LOGICAL (64) */ \ 152 V(tracg, TRACG, 0xEB0F) /* type = RSY_A TRACE (64) */ \ 153 V(csy, CSY, 0xEB14) /* type = RSY_A COMPARE AND SWAP (32) */ \ 154 V(rllg, RLLG, 0xEB1C) /* type = RSY_A ROTATE LEFT SINGLE LOGICAL (64) */ \ 155 V(rll, RLL, 0xEB1D) /* type = RSY_A ROTATE LEFT SINGLE LOGICAL (32) */ \ 156 V(stmg, STMG, 0xEB24) /* type = RSY_A STORE MULTIPLE (64) */ \ 157 V(stctg, STCTG, 0xEB25) /* type = RSY_A STORE CONTROL (64) */ \ 158 V(stmh, STMH, 0xEB26) /* type = RSY_A STORE MULTIPLE HIGH (32) */ \ 159 V(lctlg, LCTLG, 0xEB2F) /* type = RSY_A LOAD CONTROL (64) */ \ 160 V(csg, CSG, 0xEB30) /* type = RSY_A COMPARE AND SWAP (64) */ \ 161 V(cdsy, CDSY, 0xEB31) /* type = RSY_A COMPARE DOUBLE AND SWAP (32) */ \ 162 V(cdsg, CDSG, 0xEB3E) /* type = RSY_A COMPARE DOUBLE AND SWAP (64) */ \ 163 V(bxhg, BXHG, 0xEB44) /* type = RSY_A BRANCH ON INDEX HIGH (64) */ \ 164 V(bxleg, BXLEG, 0xEB45) /* type = RSY_A BRANCH ON INDEX LOW OR EQUAL (64) */ \ 165 V(ecag, ECAG, 0xEB4C) /* type = RSY_A EXTRACT CPU ATTRIBUTE */ \ 166 V(mvclu, MVCLU, 0xEB8E) /* type = RSY_A MOVE LONG UNICODE */ \ 167 V(clclu, CLCLU, 0xEB8F) /* type = RSY_A COMPARE LOGICAL LONG UNICODE */ \ 168 V(stmy, STMY, 0xEB90) /* type = RSY_A STORE MULTIPLE (32) */ \ 169 V(lmh, LMH, 0xEB96) /* type = RSY_A LOAD MULTIPLE HIGH (32) */ \ 170 V(lmy, LMY, 0xEB98) /* type = RSY_A LOAD MULTIPLE (32) */ \ 171 V(lamy, LAMY, 0xEB9A) /* type = RSY_A LOAD ACCESS MULTIPLE */ \ 172 V(stamy, STAMY, 0xEB9B) /* type = RSY_A STORE ACCESS MULTIPLE */ \ 173 V(srak, SRAK, 0xEBDC) /* type = RSY_A SHIFT RIGHT SINGLE (32) */ \ 174 V(slak, SLAK, 0xEBDD) /* type = RSY_A SHIFT LEFT SINGLE (32) */ \ 175 V(srlk, SRLK, 0xEBDE) /* type = RSY_A SHIFT RIGHT SINGLE LOGICAL (32) */ \ 176 V(sllk, SLLK, 0xEBDF) /* type = RSY_A SHIFT LEFT SINGLE LOGICAL (32) */ \ 177 V(lang, LANG, 0xEBE4) /* type = RSY_A LOAD AND AND (64) */ \ 178 V(laog, LAOG, 0xEBE6) /* type = RSY_A LOAD AND OR (64) */ \ 179 V(laxg, LAXG, 0xEBE7) /* type = RSY_A LOAD AND EXCLUSIVE OR (64) */ \ 180 V(laag, LAAG, 0xEBE8) /* type = RSY_A LOAD AND ADD (64) */ \ 181 V(laalg, LAALG, 0xEBEA) /* type = RSY_A LOAD AND ADD LOGICAL (64) */ \ 182 V(lan, LAN, 0xEBF4) /* type = RSY_A LOAD AND AND (32) */ \ 183 V(lao, LAO, 0xEBF6) /* type = RSY_A LOAD AND OR (32) */ \ 184 V(lax, LAX, 0xEBF7) /* type = RSY_A LOAD AND EXCLUSIVE OR (32) */ \ 185 V(laa, LAA, 0xEBF8) /* type = RSY_A LOAD AND ADD (32) */ \ 186 V(laal, LAAL, 0xEBFA) /* type = RSY_A LOAD AND ADD LOGICAL (32) */ 187 188#define S390_RSY_B_OPCODE_LIST(V) \ 189 V(clmh, CLMH, \ 190 0xEB20) /* type = RSY_B COMPARE LOGICAL CHAR. UNDER MASK (high) */ \ 191 V(clmy, CLMY, \ 192 0xEB21) /* type = RSY_B COMPARE LOGICAL CHAR. UNDER MASK (low) */ \ 193 V(clt, CLT, 0xEB23) /* type = RSY_B COMPARE LOGICAL AND TRAP (32) */ \ 194 V(clgt, CLGT, 0xEB2B) /* type = RSY_B COMPARE LOGICAL AND TRAP (64) */ \ 195 V(stcmh, STCMH, \ 196 0xEB2C) /* type = RSY_B STORE CHARACTERS UNDER MASK (high) */ \ 197 V(stcmy, STCMY, 0xEB2D) /* type = RSY_B STORE CHARACTERS UNDER MASK (low) */ \ 198 V(icmh, ICMH, 0xEB80) /* type = RSY_B INSERT CHARACTERS UNDER MASK (high) */ \ 199 V(icmy, ICMY, 0xEB81) /* type = RSY_B INSERT CHARACTERS UNDER MASK (low) */ \ 200 V(locfh, LOCFH, 0xEBE0) /* type = RSY_B LOAD HIGH ON CONDITION (32) */ \ 201 V(stocfh, STOCFH, 0xEBE1) /* type = RSY_B STORE HIGH ON CONDITION */ \ 202 V(locg, LOCG, 0xEBE2) /* type = RSY_B LOAD ON CONDITION (64) */ \ 203 V(stocg, STOCG, 0xEBE3) /* type = RSY_B STORE ON CONDITION (64) */ \ 204 V(loc, LOC, 0xEBF2) /* type = RSY_B LOAD ON CONDITION (32) */ \ 205 V(stoc, STOC, 0xEBF3) /* type = RSY_B STORE ON CONDITION (32) */ 206 207#define S390_RXE_OPCODE_LIST(V) \ 208 V(lcbb, LCBB, 0xE727) /* type = RXE LOAD COUNT TO BLOCK BOUNDARY */ \ 209 V(ldeb, LDEB, 0xED04) /* type = RXE LOAD LENGTHENED (short to long BFP) */ \ 210 V(lxdb, LXDB, \ 211 0xED05) /* type = RXE LOAD LENGTHENED (long to extended BFP) */ \ 212 V(lxeb, LXEB, \ 213 0xED06) /* type = RXE LOAD LENGTHENED (short to extended BFP) */ \ 214 V(mxdb, MXDB, 0xED07) /* type = RXE MULTIPLY (long to extended BFP) */ \ 215 V(keb, KEB, 0xED08) /* type = RXE COMPARE AND SIGNAL (short BFP) */ \ 216 V(ceb, CEB, 0xED09) /* type = RXE COMPARE (short BFP) */ \ 217 V(aeb, AEB, 0xED0A) /* type = RXE ADD (short BFP) */ \ 218 V(seb, SEB, 0xED0B) /* type = RXE SUBTRACT (short BFP) */ \ 219 V(mdeb, MDEB, 0xED0C) /* type = RXE MULTIPLY (short to long BFP) */ \ 220 V(deb, DEB, 0xED0D) /* type = RXE DIVIDE (short BFP) */ \ 221 V(tceb, TCEB, 0xED10) /* type = RXE TEST DATA CLASS (short BFP) */ \ 222 V(tcdb, TCDB, 0xED11) /* type = RXE TEST DATA CLASS (long BFP) */ \ 223 V(tcxb, TCXB, 0xED12) /* type = RXE TEST DATA CLASS (extended BFP) */ \ 224 V(sqeb, SQEB, 0xED14) /* type = RXE SQUARE ROOT (short BFP) */ \ 225 V(sqdb, SQDB, 0xED15) /* type = RXE SQUARE ROOT (long BFP) */ \ 226 V(meeb, MEEB, 0xED17) /* type = RXE MULTIPLY (short BFP) */ \ 227 V(kdb, KDB, 0xED18) /* type = RXE COMPARE AND SIGNAL (long BFP) */ \ 228 V(cdb, CDB, 0xED19) /* type = RXE COMPARE (long BFP) */ \ 229 V(adb, ADB, 0xED1A) /* type = RXE ADD (long BFP) */ \ 230 V(sdb, SDB, 0xED1B) /* type = RXE SUBTRACT (long BFP) */ \ 231 V(mdb, MDB, 0xED1C) /* type = RXE MULTIPLY (long BFP) */ \ 232 V(ddb, DDB, 0xED1D) /* type = RXE DIVIDE (long BFP) */ \ 233 V(lde, LDE, 0xED24) /* type = RXE LOAD LENGTHENED (short to long HFP) */ \ 234 V(lxd, LXD, \ 235 0xED25) /* type = RXE LOAD LENGTHENED (long to extended HFP) */ \ 236 V(lxe, LXE, \ 237 0xED26) /* type = RXE LOAD LENGTHENED (short to extended HFP) */ \ 238 V(sqe, SQE, 0xED34) /* type = RXE SQUARE ROOT (short HFP) */ \ 239 V(sqd, SQD, 0xED35) /* type = RXE SQUARE ROOT (long HFP) */ \ 240 V(mee, MEE, 0xED37) /* type = RXE MULTIPLY (short HFP) */ \ 241 V(tdcet, TDCET, 0xED50) /* type = RXE TEST DATA CLASS (short DFP) */ \ 242 V(tdget, TDGET, 0xED51) /* type = RXE TEST DATA GROUP (short DFP) */ \ 243 V(tdcdt, TDCDT, 0xED54) /* type = RXE TEST DATA CLASS (long DFP) */ \ 244 V(tdgdt, TDGDT, 0xED55) /* type = RXE TEST DATA GROUP (long DFP) */ \ 245 V(tdcxt, TDCXT, 0xED58) /* type = RXE TEST DATA CLASS (extended DFP) */ \ 246 V(tdgxt, TDGXT, 0xED59) /* type = RXE TEST DATA GROUP (extended DFP) */ 247 248#define S390_RRF_A_OPCODE_LIST(V) \ 249 V(ipte, IPTE, 0xB221) /* type = RRF_A INVALIDATE PAGE TABLE ENTRY */ \ 250 V(mdtra, MDTRA, 0xB3D0) /* type = RRF_A MULTIPLY (long DFP) */ \ 251 V(ddtra, DDTRA, 0xB3D1) /* type = RRF_A DIVIDE (long DFP) */ \ 252 V(adtra, ADTRA, 0xB3D2) /* type = RRF_A ADD (long DFP) */ \ 253 V(sdtra, SDTRA, 0xB3D3) /* type = RRF_A SUBTRACT (long DFP) */ \ 254 V(mxtra, MXTRA, 0xB3D8) /* type = RRF_A MULTIPLY (extended DFP) */ \ 255 V(msrkc, MSRKC, 0xB9FD) /* type = RRF_A MULTIPLY (32)*/ \ 256 V(msgrkc, MSGRKC, 0xB9ED) /* type = RRF_A MULTIPLY (64)*/ \ 257 V(dxtra, DXTRA, 0xB3D9) /* type = RRF_A DIVIDE (extended DFP) */ \ 258 V(axtra, AXTRA, 0xB3DA) /* type = RRF_A ADD (extended DFP) */ \ 259 V(sxtra, SXTRA, 0xB3DB) /* type = RRF_A SUBTRACT (extended DFP) */ \ 260 V(ahhhr, AHHHR, 0xB9C8) /* type = RRF_A ADD HIGH (32) */ \ 261 V(shhhr, SHHHR, 0xB9C9) /* type = RRF_A SUBTRACT HIGH (32) */ \ 262 V(alhhhr, ALHHHR, 0xB9CA) /* type = RRF_A ADD LOGICAL HIGH (32) */ \ 263 V(slhhhr, SLHHHR, 0xB9CB) /* type = RRF_A SUBTRACT LOGICAL HIGH (32) */ \ 264 V(ahhlr, AHHLR, 0xB9D8) /* type = RRF_A ADD HIGH (32) */ \ 265 V(shhlr, SHHLR, 0xB9D9) /* type = RRF_A SUBTRACT HIGH (32) */ \ 266 V(alhhlr, ALHHLR, 0xB9DA) /* type = RRF_A ADD LOGICAL HIGH (32) */ \ 267 V(slhhlr, SLHHLR, 0xB9DB) /* type = RRF_A SUBTRACT LOGICAL HIGH (32) */ \ 268 V(ngrk, NGRK, 0xB9E4) /* type = RRF_A AND (64) */ \ 269 V(ogrk, OGRK, 0xB9E6) /* type = RRF_A OR (64) */ \ 270 V(xgrk, XGRK, 0xB9E7) /* type = RRF_A EXCLUSIVE OR (64) */ \ 271 V(agrk, AGRK, 0xB9E8) /* type = RRF_A ADD (64) */ \ 272 V(sgrk, SGRK, 0xB9E9) /* type = RRF_A SUBTRACT (64) */ \ 273 V(algrk, ALGRK, 0xB9EA) /* type = RRF_A ADD LOGICAL (64) */ \ 274 V(slgrk, SLGRK, 0xB9EB) /* type = RRF_A SUBTRACT LOGICAL (64) */ \ 275 V(nrk, NRK, 0xB9F4) /* type = RRF_A AND (32) */ \ 276 V(ork, ORK, 0xB9F6) /* type = RRF_A OR (32) */ \ 277 V(xrk, XRK, 0xB9F7) /* type = RRF_A EXCLUSIVE OR (32) */ \ 278 V(ark, ARK, 0xB9F8) /* type = RRF_A ADD (32) */ \ 279 V(srk, SRK, 0xB9F9) /* type = RRF_A SUBTRACT (32) */ \ 280 V(alrk, ALRK, 0xB9FA) /* type = RRF_A ADD LOGICAL (32) */ \ 281 V(slrk, SLRK, 0xB9FB) /* type = RRF_A SUBTRACT LOGICAL (32) */ 282 283#define S390_RXF_OPCODE_LIST(V) \ 284 V(maeb, MAEB, 0xED0E) /* type = RXF MULTIPLY AND ADD (short BFP) */ \ 285 V(mseb, MSEB, 0xED0F) /* type = RXF MULTIPLY AND SUBTRACT (short BFP) */ \ 286 V(madb, MADB, 0xED1E) /* type = RXF MULTIPLY AND ADD (long BFP) */ \ 287 V(msdb, MSDB, 0xED1F) /* type = RXF MULTIPLY AND SUBTRACT (long BFP) */ \ 288 V(mae, MAE, 0xED2E) /* type = RXF MULTIPLY AND ADD (short HFP) */ \ 289 V(mse, MSE, 0xED2F) /* type = RXF MULTIPLY AND SUBTRACT (short HFP) */ \ 290 V(mayl, MAYL, \ 291 0xED38) /* type = RXF MULTIPLY AND ADD UNNRM. (long to ext. low HFP) */ \ 292 V(myl, MYL, \ 293 0xED39) /* type = RXF MULTIPLY UNNORM. (long to ext. low HFP) */ \ 294 V(may, MAY, \ 295 0xED3A) /* type = RXF MULTIPLY & ADD UNNORMALIZED (long to ext. HFP) */ \ 296 V(my, MY, \ 297 0xED3B) /* type = RXF MULTIPLY UNNORMALIZED (long to ext. HFP) */ \ 298 V(mayh, MAYH, \ 299 0xED3C) /* type = RXF MULTIPLY AND ADD UNNRM. (long to ext. high HFP) */ \ 300 V(myh, MYH, \ 301 0xED3D) /* type = RXF MULTIPLY UNNORM. (long to ext. high HFP) */ \ 302 V(mad, MAD, 0xED3E) /* type = RXF MULTIPLY AND ADD (long HFP) */ \ 303 V(msd, MSD, 0xED3F) /* type = RXF MULTIPLY AND SUBTRACT (long HFP) */ \ 304 V(sldt, SLDT, 0xED40) /* type = RXF SHIFT SIGNIFICAND LEFT (long DFP) */ \ 305 V(srdt, SRDT, 0xED41) /* type = RXF SHIFT SIGNIFICAND RIGHT (long DFP) */ \ 306 V(slxt, SLXT, \ 307 0xED48) /* type = RXF SHIFT SIGNIFICAND LEFT (extended DFP) */ \ 308 V(srxt, SRXT, \ 309 0xED49) /* type = RXF SHIFT SIGNIFICAND RIGHT (extended DFP) */ 310 311#define S390_IE_OPCODE_LIST(V) \ 312 V(niai, NIAI, 0xB2FA) /* type = IE NEXT INSTRUCTION ACCESS INTENT */ 313 314#define S390_RRF_B_OPCODE_LIST(V) \ 315 V(diebr, DIEBR, 0xB353) /* type = RRF_B DIVIDE TO INTEGER (short BFP) */ \ 316 V(didbr, DIDBR, 0xB35B) /* type = RRF_B DIVIDE TO INTEGER (long BFP) */ \ 317 V(cpsdr, CPSDR, 0xB372) /* type = RRF_B COPY SIGN (long) */ \ 318 V(qadtr, QADTR, 0xB3F5) /* type = RRF_B QUANTIZE (long DFP) */ \ 319 V(iedtr, IEDTR, \ 320 0xB3F6) /* type = RRF_B INSERT BIASED EXPONENT (64 to long DFP) */ \ 321 V(rrdtr, RRDTR, 0xB3F7) /* type = RRF_B REROUND (long DFP) */ \ 322 V(qaxtr, QAXTR, 0xB3FD) /* type = RRF_B QUANTIZE (extended DFP) */ \ 323 V(iextr, IEXTR, \ 324 0xB3FE) /* type = RRF_B INSERT BIASED EXPONENT (64 to extended DFP) */ \ 325 V(rrxtr, RRXTR, 0xB3FF) /* type = RRF_B REROUND (extended DFP) */ \ 326 V(kmctr, KMCTR, 0xB92D) /* type = RRF_B CIPHER MESSAGE WITH COUNTER */ \ 327 V(idte, IDTE, 0xB98E) /* type = RRF_B INVALIDATE DAT TABLE ENTRY */ \ 328 V(crdte, CRDTE, \ 329 0xB98F) /* type = RRF_B COMPARE AND REPLACE DAT TABLE ENTRY */ \ 330 V(lptea, LPTEA, 0xB9AA) /* type = RRF_B LOAD PAGE TABLE ENTRY ADDRESS */ 331 332#define S390_RRF_C_OPCODE_LIST(V) \ 333 V(sske, SSKE, 0xB22B) /* type = RRF_C SET STORAGE KEY EXTENDED */ \ 334 V(cu21, CU21, 0xB2A6) /* type = RRF_C CONVERT UTF-16 TO UTF-8 */ \ 335 V(cu12, CU12, 0xB2A7) /* type = RRF_C CONVERT UTF-8 TO UTF-16 */ \ 336 V(ppa, PPA, 0xB2E8) /* type = RRF_C PERFORM PROCESSOR ASSIST */ \ 337 V(cgrt, CGRT, 0xB960) /* type = RRF_C COMPARE AND TRAP (64) */ \ 338 V(clgrt, CLGRT, 0xB961) /* type = RRF_C COMPARE LOGICAL AND TRAP (64) */ \ 339 V(crt, CRT, 0xB972) /* type = RRF_C COMPARE AND TRAP (32) */ \ 340 V(clrt, CLRT, 0xB973) /* type = RRF_C COMPARE LOGICAL AND TRAP (32) */ \ 341 V(trtt, TRTT, 0xB990) /* type = RRF_C TRANSLATE TWO TO TWO */ \ 342 V(trto, TRTO, 0xB991) /* type = RRF_C TRANSLATE TWO TO ONE */ \ 343 V(trot, TROT, 0xB992) /* type = RRF_C TRANSLATE ONE TO TWO */ \ 344 V(troo, TROO, 0xB993) /* type = RRF_C TRANSLATE ONE TO ONE */ \ 345 V(cu14, CU14, 0xB9B0) /* type = RRF_C CONVERT UTF-8 TO UTF-32 */ \ 346 V(cu24, CU24, 0xB9B1) /* type = RRF_C CONVERT UTF-16 TO UTF-32 */ \ 347 V(trtre, TRTRE, \ 348 0xB9BD) /* type = RRF_C TRANSLATE AND TEST REVERSE EXTENDED */ \ 349 V(trte, TRTE, 0xB9BF) /* type = RRF_C TRANSLATE AND TEST EXTENDED */ \ 350 V(locfhr, LOCFHR, 0xB9E0) /* type = RRF_C LOAD HIGH ON CONDITION (32) */ \ 351 V(locgr, LOCGR, 0xB9E2) /* type = RRF_C LOAD ON CONDITION (64) */ \ 352 V(locr, LOCR, 0xB9F2) /* type = RRF_C LOAD ON CONDITION (32) */ 353 354#define S390_MII_OPCODE_LIST(V) \ 355 V(bprp, BPRP, 0xC5) /* type = MII BRANCH PREDICTION RELATIVE PRELOAD */ 356 357#define S390_RRF_D_OPCODE_LIST(V) \ 358 V(ldetr, LDETR, \ 359 0xB3D4) /* type = RRF_D LOAD LENGTHENED (short to long DFP) */ \ 360 V(lxdtr, LXDTR, \ 361 0xB3DC) /* type = RRF_D LOAD LENGTHENED (long to extended DFP) */ \ 362 V(csdtr, CSDTR, \ 363 0xB3E3) /* type = RRF_D CONVERT TO SIGNED PACKED (long DFP to 64) */ \ 364 V(csxtr, CSXTR, \ 365 0xB3EB) /* type = RRF_D CONVERT TO SIGNED PACKED (extended DFP to 128) */ 366 367#define S390_RRF_E_OPCODE_LIST(V) \ 368 V(ledbra, LEDBRA, \ 369 0xB344) /* type = RRF_E LOAD ROUNDED (long to short BFP) */ \ 370 V(ldxbra, LDXBRA, \ 371 0xB345) /* type = RRF_E LOAD ROUNDED (extended to long BFP) */ \ 372 V(lexbra, LEXBRA, \ 373 0xB346) /* type = RRF_E LOAD ROUNDED (extended to short BFP) */ \ 374 V(fixbra, FIXBRA, 0xB347) /* type = RRF_E LOAD FP INTEGER (extended BFP) */ \ 375 V(tbedr, TBEDR, \ 376 0xB350) /* type = RRF_E CONVERT HFP TO BFP (long to short) */ \ 377 V(tbdr, TBDR, 0xB351) /* type = RRF_E CONVERT HFP TO BFP (long) */ \ 378 V(fiebra, FIEBRA, 0xB357) /* type = RRF_E LOAD FP INTEGER (short BFP) */ \ 379 V(fidbra, FIDBRA, 0xB35F) /* type = RRF_E LOAD FP INTEGER (long BFP) */ \ 380 V(celfbr, CELFBR, \ 381 0xB390) /* type = RRF_E CONVERT FROM LOGICAL (32 to short BFP) */ \ 382 V(cdlfbr, CDLFBR, \ 383 0xB391) /* type = RRF_E CONVERT FROM LOGICAL (32 to long BFP) */ \ 384 V(cxlfbr, CXLFBR, \ 385 0xB392) /* type = RRF_E CONVERT FROM LOGICAL (32 to extended BFP) */ \ 386 V(cefbra, CEFBRA, \ 387 0xB394) /* type = RRF_E CONVERT FROM FIXED (32 to short BFP) */ \ 388 V(cdfbra, CDFBRA, \ 389 0xB395) /* type = RRF_E CONVERT FROM FIXED (32 to long BFP) */ \ 390 V(cxfbra, CXFBRA, \ 391 0xB396) /* type = RRF_E CONVERT FROM FIXED (32 to extended BFP) */ \ 392 V(cfebra, CFEBRA, \ 393 0xB398) /* type = RRF_E CONVERT TO FIXED (short BFP to 32) */ \ 394 V(cfdbra, CFDBRA, \ 395 0xB399) /* type = RRF_E CONVERT TO FIXED (long BFP to 32) */ \ 396 V(cfxbra, CFXBRA, \ 397 0xB39A) /* type = RRF_E CONVERT TO FIXED (extended BFP to 32) */ \ 398 V(clfebr, CLFEBR, \ 399 0xB39C) /* type = RRF_E CONVERT TO LOGICAL (short BFP to 32) */ \ 400 V(clfdbr, CLFDBR, \ 401 0xB39D) /* type = RRF_E CONVERT TO LOGICAL (long BFP to 32) */ \ 402 V(clfxbr, CLFXBR, \ 403 0xB39E) /* type = RRF_E CONVERT TO LOGICAL (extended BFP to 32) */ \ 404 V(celgbr, CELGBR, \ 405 0xB3A0) /* type = RRF_E CONVERT FROM LOGICAL (64 to short BFP) */ \ 406 V(cdlgbr, CDLGBR, \ 407 0xB3A1) /* type = RRF_E CONVERT FROM LOGICAL (64 to long BFP) */ \ 408 V(cxlgbr, CXLGBR, \ 409 0xB3A2) /* type = RRF_E CONVERT FROM LOGICAL (64 to extended BFP) */ \ 410 V(cegbra, CEGBRA, \ 411 0xB3A4) /* type = RRF_E CONVERT FROM FIXED (64 to short BFP) */ \ 412 V(cdgbra, CDGBRA, \ 413 0xB3A5) /* type = RRF_E CONVERT FROM FIXED (64 to long BFP) */ \ 414 V(cxgbra, CXGBRA, \ 415 0xB3A6) /* type = RRF_E CONVERT FROM FIXED (64 to extended BFP) */ \ 416 V(cgebra, CGEBRA, \ 417 0xB3A8) /* type = RRF_E CONVERT TO FIXED (short BFP to 64) */ \ 418 V(cgdbra, CGDBRA, \ 419 0xB3A9) /* type = RRF_E CONVERT TO FIXED (long BFP to 64) */ \ 420 V(cgxbra, CGXBRA, \ 421 0xB3AA) /* type = RRF_E CONVERT TO FIXED (extended BFP to 64) */ \ 422 V(clgebr, CLGEBR, \ 423 0xB3AC) /* type = RRF_E CONVERT TO LOGICAL (short BFP to 64) */ \ 424 V(clgdbr, CLGDBR, \ 425 0xB3AD) /* type = RRF_E CONVERT TO LOGICAL (long BFP to 64) */ \ 426 V(clgxbr, CLGXBR, \ 427 0xB3AE) /* type = RRF_E CONVERT TO LOGICAL (extended BFP to 64) */ \ 428 V(cfer, CFER, 0xB3B8) /* type = RRF_E CONVERT TO FIXED (short HFP to 32) */ \ 429 V(cfdr, CFDR, 0xB3B9) /* type = RRF_E CONVERT TO FIXED (long HFP to 32) */ \ 430 V(cfxr, CFXR, \ 431 0xB3BA) /* type = RRF_E CONVERT TO FIXED (extended HFP to 32) */ \ 432 V(cger, CGER, 0xB3C8) /* type = RRF_E CONVERT TO FIXED (short HFP to 64) */ \ 433 V(cgdr, CGDR, 0xB3C9) /* type = RRF_E CONVERT TO FIXED (long HFP to 64) */ \ 434 V(cgxr, CGXR, \ 435 0xB3CA) /* type = RRF_E CONVERT TO FIXED (extended HFP to 64) */ \ 436 V(ledtr, LEDTR, 0xB3D5) /* type = RRF_E LOAD ROUNDED (long to short DFP) */ \ 437 V(fidtr, FIDTR, 0xB3D7) /* type = RRF_E LOAD FP INTEGER (long DFP) */ \ 438 V(ldxtr, LDXTR, \ 439 0xB3DD) /* type = RRF_E LOAD ROUNDED (extended to long DFP) */ \ 440 V(fixtr, FIXTR, 0xB3DF) /* type = RRF_E LOAD FP INTEGER (extended DFP) */ \ 441 V(cgdtra, CGDTRA, \ 442 0xB3E1) /* type = RRF_E CONVERT TO FIXED (long DFP to 64) */ \ 443 V(cgxtra, CGXTRA, \ 444 0xB3E9) /* type = RRF_E CONVERT TO FIXED (extended DFP to 64) */ \ 445 V(cdgtra, CDGTRA, \ 446 0xB3F1) /* type = RRF_E CONVERT FROM FIXED (64 to long DFP) */ \ 447 V(cxgtra, CXGTRA, \ 448 0xB3F9) /* type = RRF_E CONVERT FROM FIXED (64 to extended DFP) */ \ 449 V(cfdtr, CFDTR, 0xB941) /* type = RRF_E CONVERT TO FIXED (long DFP to 32) */ \ 450 V(clgdtr, CLGDTR, \ 451 0xB942) /* type = RRF_E CONVERT TO LOGICAL (long DFP to 64) */ \ 452 V(clfdtr, CLFDTR, \ 453 0xB943) /* type = RRF_E CONVERT TO LOGICAL (long DFP to 32) */ \ 454 V(cfxtr, CFXTR, \ 455 0xB949) /* type = RRF_E CONVERT TO FIXED (extended DFP to 32) */ \ 456 V(clgxtr, CLGXTR, \ 457 0xB94A) /* type = RRF_E CONVERT TO LOGICAL (extended DFP to 64) */ \ 458 V(clfxtr, CLFXTR, \ 459 0xB94B) /* type = RRF_E CONVERT TO LOGICAL (extended DFP to 32) */ \ 460 V(cdlgtr, CDLGTR, \ 461 0xB952) /* type = RRF_E CONVERT FROM LOGICAL (64 to long DFP) */ \ 462 V(cdlftr, CDLFTR, \ 463 0xB953) /* type = RRF_E CONVERT FROM LOGICAL (32 to long DFP) */ \ 464 V(cxlgtr, CXLGTR, \ 465 0xB95A) /* type = RRF_E CONVERT FROM LOGICAL (64 to extended DFP) */ \ 466 V(cxlftr, CXLFTR, \ 467 0xB95B) /* type = RRF_E CONVERT FROM LOGICAL (32 to extended DFP) */ 468 469#define S390_VRR_A_OPCODE_LIST(V) \ 470 V(vpopct, VPOPCT, 0xE750) /* type = VRR_A VECTOR POPULATION COUNT */ \ 471 V(vctz, VCTZ, 0xE752) /* type = VRR_A VECTOR COUNT TRAILING ZEROS */ \ 472 V(vclz, VCLZ, 0xE753) /* type = VRR_A VECTOR COUNT LEADING ZEROS */ \ 473 V(vlr, VLR, 0xE756) /* type = VRR_A VECTOR LOAD */ \ 474 V(vistr, VISTR, 0xE75C) /* type = VRR_A VECTOR ISOLATE STRING */ \ 475 V(vseg, VSEG, 0xE75F) /* type = VRR_A VECTOR SIGN EXTEND TO DOUBLEWORD */ \ 476 V(vclgd, VCLGD, \ 477 0xE7C0) /* type = VRR_A VECTOR FP CONVERT TO LOGICAL 64-BIT */ \ 478 V(vcdlg, VCDLG, \ 479 0xE7C1) /* type = VRR_A VECTOR FP CONVERT FROM LOGICAL 64-BIT */ \ 480 V(vcgd, VCGD, 0xE7C2) /* type = VRR_A VECTOR FP CONVERT TO FIXED 64-BIT */ \ 481 V(vcdg, VCDG, 0xE7C3) /* type = VRR_A VECTOR FP CONVERT FROM FIXED 64-BIT */ \ 482 V(vlde, VLDE, 0xE7C4) /* type = VRR_A VECTOR FP LOAD LENGTHENED */ \ 483 V(vled, VLED, 0xE7C5) /* type = VRR_A VECTOR FP LOAD ROUNDED */ \ 484 V(vfi, VFI, 0xE7C7) /* type = VRR_A VECTOR LOAD FP INTEGER */ \ 485 V(wfk, WFK, 0xE7CA) /* type = VRR_A VECTOR FP COMPARE AND SIGNAL SCALAR */ \ 486 V(wfc, WFC, 0xE7CB) /* type = VRR_A VECTOR FP COMPARE SCALAR */ \ 487 V(vfpso, VFPSO, 0xE7CC) /* type = VRR_A VECTOR FP PERFORM SIGN OPERATION */ \ 488 V(vfsq, VFSQ, 0xE7CE) /* type = VRR_A VECTOR FP SQUARE ROOT */ \ 489 V(vupll, VUPLL, 0xE7D4) /* type = VRR_A VECTOR UNPACK LOGICAL LOW */ \ 490 V(vuplh, VUPLH, 0xE7D5) /* type = VRR_A VECTOR UNPACK LOGICAL HIGH */ \ 491 V(vupl, VUPL, 0xE7D6) /* type = VRR_A VECTOR UNPACK LOW */ \ 492 V(vuph, VUPH, 0xE7D7) /* type = VRR_A VECTOR UNPACK HIGH */ \ 493 V(vtm, VTM, 0xE7D8) /* type = VRR_A VECTOR TEST UNDER MASK */ \ 494 V(vecl, VECL, 0xE7D9) /* type = VRR_A VECTOR ELEMENT COMPARE LOGICAL */ \ 495 V(vec, VEC, 0xE7DB) /* type = VRR_A VECTOR ELEMENT COMPARE */ \ 496 V(vlc, VLC, 0xE7DE) /* type = VRR_A VECTOR LOAD COMPLEMENT */ \ 497 V(vlp, VLP, 0xE7DF) /* type = VRR_A VECTOR LOAD POSITIVE */ 498 499#define S390_VRR_B_OPCODE_LIST(V) \ 500 V(vfee, VFEE, 0xE780) /* type = VRR_B VECTOR FIND ELEMENT EQUAL */ \ 501 V(vfene, VFENE, 0xE781) /* type = VRR_B VECTOR FIND ELEMENT NOT EQUAL */ \ 502 V(vfae, VFAE, 0xE782) /* type = VRR_B VECTOR FIND ANY ELEMENT EQUAL */ \ 503 V(vpkls, VPKLS, 0xE795) /* type = VRR_B VECTOR PACK LOGICAL SATURATE */ \ 504 V(vpks, VPKS, 0xE797) /* type = VRR_B VECTOR PACK SATURATE */ \ 505 V(vceq, VCEQ, 0xE7F8) /* type = VRR_B VECTOR COMPARE EQUAL */ \ 506 V(vchl, VCHL, 0xE7F9) /* type = VRR_B VECTOR COMPARE HIGH LOGICAL */ \ 507 V(vch, VCH, 0xE7FB) /* type = VRR_B VECTOR COMPARE HIGH */ 508 509#define S390_VRR_C_OPCODE_LIST(V) \ 510 V(vmrl, VMRL, 0xE760) /* type = VRR_C VECTOR MERGE LOW */ \ 511 V(vmrh, VMRH, 0xE761) /* type = VRR_C VECTOR MERGE HIGH */ \ 512 V(vsum, VSUM, 0xE764) /* type = VRR_C VECTOR SUM ACROSS WORD */ \ 513 V(vsumg, VSUMG, 0xE765) /* type = VRR_C VECTOR SUM ACROSS DOUBLEWORD */ \ 514 V(vcksm, VCKSM, 0xE766) /* type = VRR_C VECTOR CHECKSUM */ \ 515 V(vsumq, VSUMQ, 0xE767) /* type = VRR_C VECTOR SUM ACROSS QUADWORD */ \ 516 V(vn, VN, 0xE768) /* type = VRR_C VECTOR AND */ \ 517 V(vnc, VNC, 0xE769) /* type = VRR_C VECTOR AND WITH COMPLEMENT */ \ 518 V(vo, VO, 0xE76A) /* type = VRR_C VECTOR OR */ \ 519 V(vno, VNO, 0xE76B) /* type = VRR_C VECTOR NOR */ \ 520 V(vx, VX, 0xE76D) /* type = VRR_C VECTOR EXCLUSIVE OR */ \ 521 V(veslv, VESLV, 0xE770) /* type = VRR_C VECTOR ELEMENT SHIFT LEFT */ \ 522 V(verllv, VERLLV, \ 523 0xE773) /* type = VRR_C VECTOR ELEMENT ROTATE LEFT LOGICAL */ \ 524 V(vsl, VSL, 0xE774) /* type = VRR_C VECTOR SHIFT LEFT */ \ 525 V(vslb, VSLB, 0xE775) /* type = VRR_C VECTOR SHIFT LEFT BY BYTE */ \ 526 V(vesrlv, VESRLV, \ 527 0xE778) /* type = VRR_C VECTOR ELEMENT SHIFT RIGHT LOGICAL */ \ 528 V(vesrav, VESRAV, \ 529 0xE77A) /* type = VRR_C VECTOR ELEMENT SHIFT RIGHT ARITHMETIC */ \ 530 V(vsrl, VSRL, 0xE77C) /* type = VRR_C VECTOR SHIFT RIGHT LOGICAL */ \ 531 V(vsrlb, VSRLB, \ 532 0xE77D) /* type = VRR_C VECTOR SHIFT RIGHT LOGICAL BY BYTE */ \ 533 V(vsra, VSRA, 0xE77E) /* type = VRR_C VECTOR SHIFT RIGHT ARITHMETIC */ \ 534 V(vsrab, VSRAB, \ 535 0xE77F) /* type = VRR_C VECTOR SHIFT RIGHT ARITHMETIC BY BYTE */ \ 536 V(vpdi, VPDI, 0xE784) /* type = VRR_C VECTOR PERMUTE DOUBLEWORD IMMEDIATE */ \ 537 V(vpk, VPK, 0xE794) /* type = VRR_C VECTOR PACK */ \ 538 V(vmlh, VMLH, 0xE7A1) /* type = VRR_C VECTOR MULTIPLY LOGICAL HIGH */ \ 539 V(vml, VML, 0xE7A2) /* type = VRR_C VECTOR MULTIPLY LOW */ \ 540 V(vmh, VMH, 0xE7A3) /* type = VRR_C VECTOR MULTIPLY HIGH */ \ 541 V(vmle, VMLE, 0xE7A4) /* type = VRR_C VECTOR MULTIPLY LOGICAL EVEN */ \ 542 V(vmlo, VMLO, 0xE7A5) /* type = VRR_C VECTOR MULTIPLY LOGICAL ODD */ \ 543 V(vme, VME, 0xE7A6) /* type = VRR_C VECTOR MULTIPLY EVEN */ \ 544 V(vmo, VMO, 0xE7A7) /* type = VRR_C VECTOR MULTIPLY ODD */ \ 545 V(vgfm, VGFM, 0xE7B4) /* type = VRR_C VECTOR GALOIS FIELD MULTIPLY SUM */ \ 546 V(vfs, VFS, 0xE7E2) /* type = VRR_C VECTOR FP SUBTRACT */ \ 547 V(vfa, VFA, 0xE7E3) /* type = VRR_C VECTOR FP ADD */ \ 548 V(vfd, VFD, 0xE7E5) /* type = VRR_C VECTOR FP DIVIDE */ \ 549 V(vfm, VFM, 0xE7E7) /* type = VRR_C VECTOR FP MULTIPLY */ \ 550 V(vfce, VFCE, 0xE7E8) /* type = VRR_C VECTOR FP COMPARE EQUAL */ \ 551 V(vfche, VFCHE, 0xE7EA) /* type = VRR_C VECTOR FP COMPARE HIGH OR EQUAL */ \ 552 V(vfch, VFCH, 0xE7EB) /* type = VRR_C VECTOR FP COMPARE HIGH */ \ 553 V(vfmax, VFMAX, 0xE7EF) /* type = VRR_C VECTOR FP MAXIMUM */ \ 554 V(vfmin, VFMIN, 0xE7EE) /* type = VRR_C VECTOR FP MINIMUM */ \ 555 V(vavgl, VAVGL, 0xE7F0) /* type = VRR_C VECTOR AVERAGE LOGICAL */ \ 556 V(vacc, VACC, 0xE7F1) /* type = VRR_C VECTOR ADD COMPUTE CARRY */ \ 557 V(vavg, VAVG, 0xE7F2) /* type = VRR_C VECTOR AVERAGE */ \ 558 V(va, VA, 0xE7F3) /* type = VRR_C VECTOR ADD */ \ 559 V(vscbi, VSCBI, \ 560 0xE7F5) /* type = VRR_C VECTOR SUBTRACT COMPUTE BORROW INDICATION */ \ 561 V(vs, VS, 0xE7F7) /* type = VRR_C VECTOR SUBTRACT */ \ 562 V(vmnl, VMNL, 0xE7FC) /* type = VRR_C VECTOR MINIMUM LOGICAL */ \ 563 V(vmxl, VMXL, 0xE7FD) /* type = VRR_C VECTOR MAXIMUM LOGICAL */ \ 564 V(vmn, VMN, 0xE7FE) /* type = VRR_C VECTOR MINIMUM */ \ 565 V(vmx, VMX, 0xE7FF) /* type = VRR_C VECTOR MAXIMUM */ \ 566 V(vbperm, VBPERM, 0xE785) /* type = VRR_C VECTOR BIT PERMUTE */ 567 568#define S390_VRI_A_OPCODE_LIST(V) \ 569 V(vleib, VLEIB, 0xE740) /* type = VRI_A VECTOR LOAD ELEMENT IMMEDIATE (8) */ \ 570 V(vleih, VLEIH, \ 571 0xE741) /* type = VRI_A VECTOR LOAD ELEMENT IMMEDIATE (16) */ \ 572 V(vleig, VLEIG, \ 573 0xE742) /* type = VRI_A VECTOR LOAD ELEMENT IMMEDIATE (64) */ \ 574 V(vleif, VLEIF, \ 575 0xE743) /* type = VRI_A VECTOR LOAD ELEMENT IMMEDIATE (32) */ \ 576 V(vgbm, VGBM, 0xE744) /* type = VRI_A VECTOR GENERATE BYTE MASK */ \ 577 V(vrepi, VREPI, 0xE745) /* type = VRI_A VECTOR REPLICATE IMMEDIATE */ 578 579#define S390_VRR_D_OPCODE_LIST(V) \ 580 V(vstrc, VSTRC, 0xE78A) /* type = VRR_D VECTOR STRING RANGE COMPARE */ \ 581 V(vmalh, VMALH, \ 582 0xE7A9) /* type = VRR_D VECTOR MULTIPLY AND ADD LOGICAL HIGH */ \ 583 V(vmal, VMAL, 0xE7AA) /* type = VRR_D VECTOR MULTIPLY AND ADD LOW */ \ 584 V(vmah, VMAH, 0xE7AB) /* type = VRR_D VECTOR MULTIPLY AND ADD HIGH */ \ 585 V(vmale, VMALE, \ 586 0xE7AC) /* type = VRR_D VECTOR MULTIPLY AND ADD LOGICAL EVEN */ \ 587 V(vmalo, VMALO, \ 588 0xE7AD) /* type = VRR_D VECTOR MULTIPLY AND ADD LOGICAL ODD */ \ 589 V(vmae, VMAE, 0xE7AE) /* type = VRR_D VECTOR MULTIPLY AND ADD EVEN */ \ 590 V(vmao, VMAO, 0xE7AF) /* type = VRR_D VECTOR MULTIPLY AND ADD ODD */ \ 591 V(vaccc, VACCC, \ 592 0xE7B9) /* type = VRR_D VECTOR ADD WITH CARRY COMPUTE CARRY */ \ 593 V(vac, VAC, 0xE7BB) /* type = VRR_D VECTOR ADD WITH CARRY */ \ 594 V(vgfma, VGFMA, \ 595 0xE7BC) /* type = VRR_D VECTOR GALOIS FIELD MULTIPLY SUM AND ACCUMULATE */ \ 596 V(vsbcbi, VSBCBI, 0xE7BD) /* type = VRR_D VECTOR SUBTRACT WITH BORROW */ \ 597 /* COMPUTE BORROW INDICATION */ \ 598 V(vsbi, VSBI, \ 599 0xE7BF) /* type = VRR_D VECTOR SUBTRACT WITH BORROW INDICATION */ 600 601#define S390_VRI_B_OPCODE_LIST(V) \ 602 V(vgm, VGM, 0xE746) /* type = VRI_B VECTOR GENERATE MASK */ 603 604#define S390_VRR_E_OPCODE_LIST(V) \ 605 V(vperm, VPERM, 0xE78C) /* type = VRR_E VECTOR PERMUTE */ \ 606 V(vsel, VSEL, 0xE78D) /* type = VRR_E VECTOR SELECT */ \ 607 V(vfms, VFMS, 0xE78E) /* type = VRR_E VECTOR FP MULTIPLY AND SUBTRACT */ \ 608 V(vfnms, VFNMS, \ 609 0xE79E) /* type = VRR_E VECTOR FP NEGATIVE MULTIPLY AND SUBTRACT */ \ 610 V(vfma, VFMA, 0xE78F) /* type = VRR_E VECTOR FP MULTIPLY AND ADD */ 611 612#define S390_VRI_C_OPCODE_LIST(V) \ 613 V(vrep, VREP, 0xE74D) /* type = VRI_C VECTOR REPLICATE */ 614 615#define S390_VRI_D_OPCODE_LIST(V) \ 616 V(verim, VERIM, \ 617 0xE772) /* type = VRI_D VECTOR ELEMENT ROTATE AND INSERT UNDER MASK */ \ 618 V(vsldb, VSLDB, 0xE777) /* type = VRI_D VECTOR SHIFT LEFT DOUBLE BY BYTE */ 619 620#define S390_VRR_F_OPCODE_LIST(V) \ 621 V(vlvgp, VLVGP, 0xE762) /* type = VRR_F VECTOR LOAD VR FROM GRS DISJOINT */ 622 623#define S390_RIS_OPCODE_LIST(V) \ 624 V(cgib, CGIB, \ 625 0xECFC) /* type = RIS COMPARE IMMEDIATE AND BRANCH (64<-8) */ \ 626 V(clgib, CLGIB, \ 627 0xECFD) /* type = RIS COMPARE LOGICAL IMMEDIATE AND BRANCH (64<-8) */ \ 628 V(cib, CIB, 0xECFE) /* type = RIS COMPARE IMMEDIATE AND BRANCH (32<-8) */ \ 629 V(clib, CLIB, \ 630 0xECFF) /* type = RIS COMPARE LOGICAL IMMEDIATE AND BRANCH (32<-8) */ 631 632#define S390_VRI_E_OPCODE_LIST(V) \ 633 V(vftci, VFTCI, \ 634 0xE74A) /* type = VRI_E VECTOR FP TEST DATA CLASS IMMEDIATE */ 635 636#define S390_RSL_A_OPCODE_LIST(V) \ 637 V(tp, TP, 0xEBC0) /* type = RSL_A TEST DECIMAL */ 638 639#define S390_RSL_B_OPCODE_LIST(V) \ 640 V(cpdt, CPDT, 0xEDAC) /* type = RSL_B CONVERT TO PACKED (from long DFP) */ \ 641 V(cpxt, CPXT, \ 642 0xEDAD) /* type = RSL_B CONVERT TO PACKED (from extended DFP) */ \ 643 V(cdpt, CDPT, 0xEDAE) /* type = RSL_B CONVERT FROM PACKED (to long DFP) */ \ 644 V(cxpt, CXPT, \ 645 0xEDAF) /* type = RSL_B CONVERT FROM PACKED (to extended DFP) */ \ 646 V(czdt, CZDT, 0xEDA8) /* type = RSL CONVERT TO ZONED (from long DFP) */ \ 647 V(czxt, CZXT, 0xEDA9) /* type = RSL CONVERT TO ZONED (from extended DFP) */ \ 648 V(cdzt, CDZT, 0xEDAA) /* type = RSL CONVERT FROM ZONED (to long DFP) */ \ 649 V(cxzt, CXZT, 0xEDAB) /* type = RSL CONVERT FROM ZONED (to extended DFP) */ 650 651#define S390_SI_OPCODE_LIST(V) \ 652 V(tm, TM, 0x91) /* type = SI TEST UNDER MASK */ \ 653 V(mvi, MVI, 0x92) /* type = SI MOVE (immediate) */ \ 654 V(ni, NI, 0x94) /* type = SI AND (immediate) */ \ 655 V(cli, CLI, 0x95) /* type = SI COMPARE LOGICAL (immediate) */ \ 656 V(oi, OI, 0x96) /* type = SI OR (immediate) */ \ 657 V(xi, XI, 0x97) /* type = SI EXCLUSIVE OR (immediate) */ \ 658 V(stnsm, STNSM, 0xAC) /* type = SI STORE THEN AND SYSTEM MASK */ \ 659 V(stosm, STOSM, 0xAD) /* type = SI STORE THEN OR SYSTEM MASK */ \ 660 V(mc, MC, 0xAF) /* type = SI MONITOR CALL */ 661 662#define S390_SIL_OPCODE_LIST(V) \ 663 V(mvhhi, MVHHI, 0xE544) /* type = SIL MOVE (16<-16) */ \ 664 V(mvghi, MVGHI, 0xE548) /* type = SIL MOVE (64<-16) */ \ 665 V(mvhi, MVHI, 0xE54C) /* type = SIL MOVE (32<-16) */ \ 666 V(chhsi, CHHSI, \ 667 0xE554) /* type = SIL COMPARE HALFWORD IMMEDIATE (16<-16) */ \ 668 V(clhhsi, CLHHSI, \ 669 0xE555) /* type = SIL COMPARE LOGICAL IMMEDIATE (16<-16) */ \ 670 V(cghsi, CGHSI, \ 671 0xE558) /* type = SIL COMPARE HALFWORD IMMEDIATE (64<-16) */ \ 672 V(clghsi, CLGHSI, \ 673 0xE559) /* type = SIL COMPARE LOGICAL IMMEDIATE (64<-16) */ \ 674 V(chsi, CHSI, 0xE55C) /* type = SIL COMPARE HALFWORD IMMEDIATE (32<-16) */ \ 675 V(clfhsi, CLFHSI, \ 676 0xE55D) /* type = SIL COMPARE LOGICAL IMMEDIATE (32<-16) */ \ 677 V(tbegin, TBEGIN, \ 678 0xE560) /* type = SIL TRANSACTION BEGIN (nonconstrained) */ \ 679 V(tbeginc, TBEGINC, \ 680 0xE561) /* type = SIL TRANSACTION BEGIN (constrained) */ 681 682#define S390_VRS_A_OPCODE_LIST(V) \ 683 V(vesl, VESL, 0xE730) /* type = VRS_A VECTOR ELEMENT SHIFT LEFT */ \ 684 V(verll, VERLL, \ 685 0xE733) /* type = VRS_A VECTOR ELEMENT ROTATE LEFT LOGICAL */ \ 686 V(vlm, VLM, 0xE736) /* type = VRS_A VECTOR LOAD MULTIPLE */ \ 687 V(vesrl, VESRL, \ 688 0xE738) /* type = VRS_A VECTOR ELEMENT SHIFT RIGHT LOGICAL */ \ 689 V(vesra, VESRA, \ 690 0xE73A) /* type = VRS_A VECTOR ELEMENT SHIFT RIGHT ARITHMETIC */ \ 691 V(vstm, VSTM, 0xE73E) /* type = VRS_A VECTOR STORE MULTIPLE */ 692 693#define S390_RIL_A_OPCODE_LIST(V) \ 694 V(lgfi, LGFI, 0xC01) /* type = RIL_A LOAD IMMEDIATE (64<-32) */ \ 695 V(xihf, XIHF, 0xC06) /* type = RIL_A EXCLUSIVE OR IMMEDIATE (high) */ \ 696 V(xilf, XILF, 0xC07) /* type = RIL_A EXCLUSIVE OR IMMEDIATE (low) */ \ 697 V(iihf, IIHF, 0xC08) /* type = RIL_A INSERT IMMEDIATE (high) */ \ 698 V(iilf, IILF, 0xC09) /* type = RIL_A INSERT IMMEDIATE (low) */ \ 699 V(nihf, NIHF, 0xC0A) /* type = RIL_A AND IMMEDIATE (high) */ \ 700 V(nilf, NILF, 0xC0B) /* type = RIL_A AND IMMEDIATE (low) */ \ 701 V(oihf, OIHF, 0xC0C) /* type = RIL_A OR IMMEDIATE (high) */ \ 702 V(oilf, OILF, 0xC0D) /* type = RIL_A OR IMMEDIATE (low) */ \ 703 V(llihf, LLIHF, 0xC0E) /* type = RIL_A LOAD LOGICAL IMMEDIATE (high) */ \ 704 V(llilf, LLILF, 0xC0F) /* type = RIL_A LOAD LOGICAL IMMEDIATE (low) */ \ 705 V(msgfi, MSGFI, 0xC20) /* type = RIL_A MULTIPLY SINGLE IMMEDIATE (64<-32) */ \ 706 V(msfi, MSFI, 0xC21) /* type = RIL_A MULTIPLY SINGLE IMMEDIATE (32) */ \ 707 V(slgfi, SLGFI, \ 708 0xC24) /* type = RIL_A SUBTRACT LOGICAL IMMEDIATE (64<-32) */ \ 709 V(slfi, SLFI, 0xC25) /* type = RIL_A SUBTRACT LOGICAL IMMEDIATE (32) */ \ 710 V(agfi, AGFI, 0xC28) /* type = RIL_A ADD IMMEDIATE (64<-32) */ \ 711 V(afi, AFI, 0xC29) /* type = RIL_A ADD IMMEDIATE (32) */ \ 712 V(algfi, ALGFI, 0xC2A) /* type = RIL_A ADD LOGICAL IMMEDIATE (64<-32) */ \ 713 V(alfi, ALFI, 0xC2B) /* type = RIL_A ADD LOGICAL IMMEDIATE (32) */ \ 714 V(cgfi, CGFI, 0xC2C) /* type = RIL_A COMPARE IMMEDIATE (64<-32) */ \ 715 V(cfi, CFI, 0xC2D) /* type = RIL_A COMPARE IMMEDIATE (32) */ \ 716 V(clgfi, CLGFI, 0xC2E) /* type = RIL_A COMPARE LOGICAL IMMEDIATE (64<-32) */ \ 717 V(clfi, CLFI, 0xC2F) /* type = RIL_A COMPARE LOGICAL IMMEDIATE (32) */ \ 718 V(aih, AIH, 0xCC8) /* type = RIL_A ADD IMMEDIATE HIGH (32) */ \ 719 V(alsih, ALSIH, \ 720 0xCCA) /* type = RIL_A ADD LOGICAL WITH SIGNED IMMEDIATE HIGH (32) */ \ 721 V(alsihn, ALSIHN, \ 722 0xCCB) /* type = RIL_A ADD LOGICAL WITH SIGNED IMMEDIATE HIGH (32) */ \ 723 V(cih, CIH, 0xCCD) /* type = RIL_A COMPARE IMMEDIATE HIGH (32) */ \ 724 V(clih, CLIH, 0xCCF) /* type = RIL_A COMPARE LOGICAL IMMEDIATE HIGH (32) */ 725 726#define S390_RIL_B_OPCODE_LIST(V) \ 727 V(larl, LARL, 0xC00) /* type = RIL_B LOAD ADDRESS RELATIVE LONG */ \ 728 V(brasl, BRASL, 0xC05) /* type = RIL_B BRANCH RELATIVE AND SAVE LONG */ \ 729 V(llhrl, LLHRL, \ 730 0xC42) /* type = RIL_B LOAD LOGICAL HALFWORD RELATIVE LONG (32<-16) */ \ 731 V(lghrl, LGHRL, \ 732 0xC44) /* type = RIL_B LOAD HALFWORD RELATIVE LONG (64<-16) */ \ 733 V(lhrl, LHRL, 0xC45) /* type = RIL_B LOAD HALFWORD RELATIVE LONG (32<-16) */ \ 734 V(llghrl, LLGHRL, \ 735 0xC46) /* type = RIL_B LOAD LOGICAL HALFWORD RELATIVE LONG (64<-16) */ \ 736 V(sthrl, STHRL, 0xC47) /* type = RIL_B STORE HALFWORD RELATIVE LONG (16) */ \ 737 V(lgrl, LGRL, 0xC48) /* type = RIL_B LOAD RELATIVE LONG (64) */ \ 738 V(stgrl, STGRL, 0xC4B) /* type = RIL_B STORE RELATIVE LONG (64) */ \ 739 V(lgfrl, LGFRL, 0xC4C) /* type = RIL_B LOAD RELATIVE LONG (64<-32) */ \ 740 V(lrl, LRL, 0xC4D) /* type = RIL_B LOAD RELATIVE LONG (32) */ \ 741 V(llgfrl, LLGFRL, \ 742 0xC4E) /* type = RIL_B LOAD LOGICAL RELATIVE LONG (64<-32) */ \ 743 V(strl, STRL, 0xC4F) /* type = RIL_B STORE RELATIVE LONG (32) */ \ 744 V(exrl, EXRL, 0xC60) /* type = RIL_B EXECUTE RELATIVE LONG */ \ 745 V(cghrl, CGHRL, \ 746 0xC64) /* type = RIL_B COMPARE HALFWORD RELATIVE LONG (64<-16) */ \ 747 V(chrl, CHRL, \ 748 0xC65) /* type = RIL_B COMPARE HALFWORD RELATIVE LONG (32<-16) */ \ 749 V(clghrl, CLGHRL, \ 750 0xC66) /* type = RIL_B COMPARE LOGICAL RELATIVE LONG (64<-16) */ \ 751 V(clhrl, CLHRL, \ 752 0xC67) /* type = RIL_B COMPARE LOGICAL RELATIVE LONG (32<-16) */ \ 753 V(cgrl, CGRL, 0xC68) /* type = RIL_B COMPARE RELATIVE LONG (64) */ \ 754 V(clgrl, CLGRL, 0xC6A) /* type = RIL_B COMPARE LOGICAL RELATIVE LONG (64) */ \ 755 V(cgfrl, CGFRL, 0xC6C) /* type = RIL_B COMPARE RELATIVE LONG (64<-32) */ \ 756 V(crl, CRL, 0xC6D) /* type = RIL_B COMPARE RELATIVE LONG (32) */ \ 757 V(clgfrl, CLGFRL, \ 758 0xC6E) /* type = RIL_B COMPARE LOGICAL RELATIVE LONG (64<-32) */ \ 759 V(clrl, CLRL, 0xC6F) /* type = RIL_B COMPARE LOGICAL RELATIVE LONG (32) */ \ 760 V(brcth, BRCTH, 0xCC6) /* type = RIL_B BRANCH RELATIVE ON COUNT HIGH (32) */ 761 762#define S390_VRS_B_OPCODE_LIST(V) \ 763 V(vlvg, VLVG, 0xE722) /* type = VRS_B VECTOR LOAD VR ELEMENT FROM GR */ \ 764 V(vll, VLL, 0xE737) /* type = VRS_B VECTOR LOAD WITH LENGTH */ \ 765 V(vstl, VSTL, 0xE73F) /* type = VRS_B VECTOR STORE WITH LENGTH */ 766 767#define S390_RIL_C_OPCODE_LIST(V) \ 768 V(brcl, BRCL, 0xC04) /* type = RIL_C BRANCH RELATIVE ON CONDITION LONG */ \ 769 V(pfdrl, PFDRL, 0xC62) /* type = RIL_C PREFETCH DATA RELATIVE LONG */ 770 771#define S390_VRS_C_OPCODE_LIST(V) \ 772 V(vlgv, VLGV, 0xE721) /* type = VRS_C VECTOR LOAD GR FROM VR ELEMENT */ 773 774#define S390_RI_A_OPCODE_LIST(V) \ 775 V(iihh, IIHH, 0xA50) /* type = RI_A INSERT IMMEDIATE (high high) */ \ 776 V(iihl, IIHL, 0xA51) /* type = RI_A INSERT IMMEDIATE (high low) */ \ 777 V(iilh, IILH, 0xA52) /* type = RI_A INSERT IMMEDIATE (low high) */ \ 778 V(iill, IILL, 0xA53) /* type = RI_A INSERT IMMEDIATE (low low) */ \ 779 V(nihh, NIHH, 0xA54) /* type = RI_A AND IMMEDIATE (high high) */ \ 780 V(nihl, NIHL, 0xA55) /* type = RI_A AND IMMEDIATE (high low) */ \ 781 V(nilh, NILH, 0xA56) /* type = RI_A AND IMMEDIATE (low high) */ \ 782 V(nill, NILL, 0xA57) /* type = RI_A AND IMMEDIATE (low low) */ \ 783 V(oihh, OIHH, 0xA58) /* type = RI_A OR IMMEDIATE (high high) */ \ 784 V(oihl, OIHL, 0xA59) /* type = RI_A OR IMMEDIATE (high low) */ \ 785 V(oilh, OILH, 0xA5A) /* type = RI_A OR IMMEDIATE (low high) */ \ 786 V(oill, OILL, 0xA5B) /* type = RI_A OR IMMEDIATE (low low) */ \ 787 V(llihh, LLIHH, 0xA5C) /* type = RI_A LOAD LOGICAL IMMEDIATE (high high) */ \ 788 V(llihl, LLIHL, 0xA5D) /* type = RI_A LOAD LOGICAL IMMEDIATE (high low) */ \ 789 V(llilh, LLILH, 0xA5E) /* type = RI_A LOAD LOGICAL IMMEDIATE (low high) */ \ 790 V(llill, LLILL, 0xA5F) /* type = RI_A LOAD LOGICAL IMMEDIATE (low low) */ \ 791 V(tmlh, TMLH, 0xA70) /* type = RI_A TEST UNDER MASK (low high) */ \ 792 V(tmll, TMLL, 0xA71) /* type = RI_A TEST UNDER MASK (low low) */ \ 793 V(tmhh, TMHH, 0xA72) /* type = RI_A TEST UNDER MASK (high high) */ \ 794 V(tmhl, TMHL, 0xA73) /* type = RI_A TEST UNDER MASK (high low) */ \ 795 V(lhi, LHI, 0xA78) /* type = RI_A LOAD HALFWORD IMMEDIATE (32)<-16 */ \ 796 V(lghi, LGHI, 0xA79) /* type = RI_A LOAD HALFWORD IMMEDIATE (64<-16) */ \ 797 V(ahi, AHI, 0xA7A) /* type = RI_A ADD HALFWORD IMMEDIATE (32<-16) */ \ 798 V(aghi, AGHI, 0xA7B) /* type = RI_A ADD HALFWORD IMMEDIATE (64<-16) */ \ 799 V(mhi, MHI, 0xA7C) /* type = RI_A MULTIPLY HALFWORD IMMEDIATE (32<-16) */ \ 800 V(mghi, MGHI, 0xA7D) /* type = RI_A MULTIPLY HALFWORD IMMEDIATE (64<-16) */ \ 801 V(chi, CHI, 0xA7E) /* type = RI_A COMPARE HALFWORD IMMEDIATE (32<-16) */ \ 802 V(cghi, CGHI, 0xA7F) /* type = RI_A COMPARE HALFWORD IMMEDIATE (64<-16) */ 803 804#define S390_RSI_OPCODE_LIST(V) \ 805 V(brxh, BRXH, 0x84) /* type = RSI BRANCH RELATIVE ON INDEX HIGH (32) */ \ 806 V(brxle, BRXLE, \ 807 0x85) /* type = RSI BRANCH RELATIVE ON INDEX LOW OR EQ. (32) */ 808 809#define S390_RI_B_OPCODE_LIST(V) \ 810 V(bras, BRAS, 0xA75) /* type = RI_B BRANCH RELATIVE AND SAVE */ \ 811 V(brct, BRCT, 0xA76) /* type = RI_B BRANCH RELATIVE ON COUNT (32) */ \ 812 V(brctg, BRCTG, 0xA77) /* type = RI_B BRANCH RELATIVE ON COUNT (64) */ 813 814#define S390_RI_C_OPCODE_LIST(V) \ 815 V(brc, BRC, 0xA74) /* type = RI_C BRANCH RELATIVE ON CONDITION */ 816 817#define S390_SMI_OPCODE_LIST(V) \ 818 V(bpp, BPP, 0xC7) /* type = SMI BRANCH PREDICTION PRELOAD */ 819 820#define S390_RXY_A_OPCODE_LIST(V) \ 821 V(ltg, LTG, 0xE302) /* type = RXY_A LOAD AND TEST (64) */ \ 822 V(lrag, LRAG, 0xE303) /* type = RXY_A LOAD REAL ADDRESS (64) */ \ 823 V(lg, LG, 0xE304) /* type = RXY_A LOAD (64) */ \ 824 V(cvby, CVBY, 0xE306) /* type = RXY_A CONVERT TO BINARY (32) */ \ 825 V(ag, AG, 0xE308) /* type = RXY_A ADD (64) */ \ 826 V(sg, SG, 0xE309) /* type = RXY_A SUBTRACT (64) */ \ 827 V(alg, ALG, 0xE30A) /* type = RXY_A ADD LOGICAL (64) */ \ 828 V(slg, SLG, 0xE30B) /* type = RXY_A SUBTRACT LOGICAL (64) */ \ 829 V(msg, MSG, 0xE30C) /* type = RXY_A MULTIPLY SINGLE (64) */ \ 830 V(dsg, DSG, 0xE30D) /* type = RXY_A DIVIDE SINGLE (64) */ \ 831 V(cvbg, CVBG, 0xE30E) /* type = RXY_A CONVERT TO BINARY (64) */ \ 832 V(lrvg, LRVG, 0xE30F) /* type = RXY_A LOAD REVERSED (64) */ \ 833 V(lt_z, LT, 0xE312) /* type = RXY_A LOAD AND TEST (32) */ \ 834 V(lray, LRAY, 0xE313) /* type = RXY_A LOAD REAL ADDRESS (32) */ \ 835 V(lgf, LGF, 0xE314) /* type = RXY_A LOAD (64<-32) */ \ 836 V(lgh, LGH, 0xE315) /* type = RXY_A LOAD HALFWORD (64<-16) */ \ 837 V(llgf, LLGF, 0xE316) /* type = RXY_A LOAD LOGICAL (64<-32) */ \ 838 V(llgt, LLGT, \ 839 0xE317) /* type = RXY_A LOAD LOGICAL THIRTY ONE BITS (64<-31) */ \ 840 V(agf, AGF, 0xE318) /* type = RXY_A ADD (64<-32) */ \ 841 V(sgf, SGF, 0xE319) /* type = RXY_A SUBTRACT (64<-32) */ \ 842 V(algf, ALGF, 0xE31A) /* type = RXY_A ADD LOGICAL (64<-32) */ \ 843 V(slgf, SLGF, 0xE31B) /* type = RXY_A SUBTRACT LOGICAL (64<-32) */ \ 844 V(msgf, MSGF, 0xE31C) /* type = RXY_A MULTIPLY SINGLE (64<-32) */ \ 845 V(dsgf, DSGF, 0xE31D) /* type = RXY_A DIVIDE SINGLE (64<-32) */ \ 846 V(lrv, LRV, 0xE31E) /* type = RXY_A LOAD REVERSED (32) */ \ 847 V(lrvh, LRVH, 0xE31F) /* type = RXY_A LOAD REVERSED (16) */ \ 848 V(cg, CG, 0xE320) /* type = RXY_A COMPARE (64) */ \ 849 V(clg, CLG, 0xE321) /* type = RXY_A COMPARE LOGICAL (64) */ \ 850 V(stg, STG, 0xE324) /* type = RXY_A STORE (64) */ \ 851 V(ntstg, NTSTG, 0xE325) /* type = RXY_A NONTRANSACTIONAL STORE (64) */ \ 852 V(cvdy, CVDY, 0xE326) /* type = RXY_A CONVERT TO DECIMAL (32) */ \ 853 V(lzrg, LZRG, 0xE32A) /* type = RXY_A LOAD AND ZERO RIGHTMOST BYTE (64) */ \ 854 V(cvdg, CVDG, 0xE32E) /* type = RXY_A CONVERT TO DECIMAL (64) */ \ 855 V(strvg, STRVG, 0xE32F) /* type = RXY_A STORE REVERSED (64) */ \ 856 V(cgf, CGF, 0xE330) /* type = RXY_A COMPARE (64<-32) */ \ 857 V(clgf, CLGF, 0xE331) /* type = RXY_A COMPARE LOGICAL (64<-32) */ \ 858 V(ltgf, LTGF, 0xE332) /* type = RXY_A LOAD AND TEST (64<-32) */ \ 859 V(cgh, CGH, 0xE334) /* type = RXY_A COMPARE HALFWORD (64<-16) */ \ 860 V(llzrgf, LLZRGF, \ 861 0xE33A) /* type = RXY_A LOAD LOGICAL AND ZERO RIGHTMOST BYTE (64<-32) */ \ 862 V(lzrf, LZRF, 0xE33B) /* type = RXY_A LOAD AND ZERO RIGHTMOST BYTE (32) */ \ 863 V(strv, STRV, 0xE33E) /* type = RXY_A STORE REVERSED (32) */ \ 864 V(strvh, STRVH, 0xE33F) /* type = RXY_A STORE REVERSED (16) */ \ 865 V(bctg, BCTG, 0xE346) /* type = RXY_A BRANCH ON COUNT (64) */ \ 866 V(sty, STY, 0xE350) /* type = RXY_A STORE (32) */ \ 867 V(msy, MSY, 0xE351) /* type = RXY_A MULTIPLY SINGLE (32) */ \ 868 V(ny, NY, 0xE354) /* type = RXY_A AND (32) */ \ 869 V(cly, CLY, 0xE355) /* type = RXY_A COMPARE LOGICAL (32) */ \ 870 V(oy, OY, 0xE356) /* type = RXY_A OR (32) */ \ 871 V(xy, XY, 0xE357) /* type = RXY_A EXCLUSIVE OR (32) */ \ 872 V(ly, LY, 0xE358) /* type = RXY_A LOAD (32) */ \ 873 V(cy, CY, 0xE359) /* type = RXY_A COMPARE (32) */ \ 874 V(ay, AY, 0xE35A) /* type = RXY_A ADD (32) */ \ 875 V(sy, SY, 0xE35B) /* type = RXY_A SUBTRACT (32) */ \ 876 V(mfy, MFY, 0xE35C) /* type = RXY_A MULTIPLY (64<-32) */ \ 877 V(aly, ALY, 0xE35E) /* type = RXY_A ADD LOGICAL (32) */ \ 878 V(sly, SLY, 0xE35F) /* type = RXY_A SUBTRACT LOGICAL (32) */ \ 879 V(sthy, STHY, 0xE370) /* type = RXY_A STORE HALFWORD (16) */ \ 880 V(lay, LAY, 0xE371) /* type = RXY_A LOAD ADDRESS */ \ 881 V(stcy, STCY, 0xE372) /* type = RXY_A STORE CHARACTER */ \ 882 V(icy, ICY, 0xE373) /* type = RXY_A INSERT CHARACTER */ \ 883 V(laey, LAEY, 0xE375) /* type = RXY_A LOAD ADDRESS EXTENDED */ \ 884 V(lb, LB, 0xE376) /* type = RXY_A LOAD BYTE (32<-8) */ \ 885 V(lgb, LGB, 0xE377) /* type = RXY_A LOAD BYTE (64<-8) */ \ 886 V(lhy, LHY, 0xE378) /* type = RXY_A LOAD HALFWORD (32)<-16 */ \ 887 V(chy, CHY, 0xE379) /* type = RXY_A COMPARE HALFWORD (32<-16) */ \ 888 V(ahy, AHY, 0xE37A) /* type = RXY_A ADD HALFWORD (32<-16) */ \ 889 V(shy, SHY, 0xE37B) /* type = RXY_A SUBTRACT HALFWORD (32<-16) */ \ 890 V(mhy, MHY, 0xE37C) /* type = RXY_A MULTIPLY HALFWORD (32<-16) */ \ 891 V(ng, NG, 0xE380) /* type = RXY_A AND (64) */ \ 892 V(og, OG, 0xE381) /* type = RXY_A OR (64) */ \ 893 V(xg, XG, 0xE382) /* type = RXY_A EXCLUSIVE OR (64) */ \ 894 V(lgat, LGAT, 0xE385) /* type = RXY_A LOAD AND TRAP (64) */ \ 895 V(mlg, MLG, 0xE386) /* type = RXY_A MULTIPLY LOGICAL (128<-64) */ \ 896 V(dlg, DLG, 0xE387) /* type = RXY_A DIVIDE LOGICAL (64<-128) */ \ 897 V(alcg, ALCG, 0xE388) /* type = RXY_A ADD LOGICAL WITH CARRY (64) */ \ 898 V(slbg, SLBG, 0xE389) /* type = RXY_A SUBTRACT LOGICAL WITH BORROW (64) */ \ 899 V(stpq, STPQ, 0xE38E) /* type = RXY_A STORE PAIR TO QUADWORD */ \ 900 V(lpq, LPQ, 0xE38F) /* type = RXY_A LOAD PAIR FROM QUADWORD (64&64<-128) */ \ 901 V(llgc, LLGC, 0xE390) /* type = RXY_A LOAD LOGICAL CHARACTER (64<-8) */ \ 902 V(llgh, LLGH, 0xE391) /* type = RXY_A LOAD LOGICAL HALFWORD (64<-16) */ \ 903 V(llc, LLC, 0xE394) /* type = RXY_A LOAD LOGICAL CHARACTER (32<-8) */ \ 904 V(llh, LLH, 0xE395) /* type = RXY_A LOAD LOGICAL HALFWORD (32<-16) */ \ 905 V(ml, ML, 0xE396) /* type = RXY_A MULTIPLY LOGICAL (64<-32) */ \ 906 V(dl, DL, 0xE397) /* type = RXY_A DIVIDE LOGICAL (32<-64) */ \ 907 V(alc, ALC, 0xE398) /* type = RXY_A ADD LOGICAL WITH CARRY (32) */ \ 908 V(slb, SLB, 0xE399) /* type = RXY_A SUBTRACT LOGICAL WITH BORROW (32) */ \ 909 V(llgtat, LLGTAT, \ 910 0xE39C) /* type = RXY_A LOAD LOGICAL THIRTY ONE BITS AND TRAP (64<-31) */ \ 911 V(llgfat, LLGFAT, 0xE39D) /* type = RXY_A LOAD LOGICAL AND TRAP (64<-32) */ \ 912 V(lat, LAT, 0xE39F) /* type = RXY_A LOAD AND TRAP (32L<-32) */ \ 913 V(lbh, LBH, 0xE3C0) /* type = RXY_A LOAD BYTE HIGH (32<-8) */ \ 914 V(llch, LLCH, 0xE3C2) /* type = RXY_A LOAD LOGICAL CHARACTER HIGH (32<-8) */ \ 915 V(stch, STCH, 0xE3C3) /* type = RXY_A STORE CHARACTER HIGH (8) */ \ 916 V(lhh, LHH, 0xE3C4) /* type = RXY_A LOAD HALFWORD HIGH (32<-16) */ \ 917 V(llhh, LLHH, 0xE3C6) /* type = RXY_A LOAD LOGICAL HALFWORD HIGH (32<-16) */ \ 918 V(sthh, STHH, 0xE3C7) /* type = RXY_A STORE HALFWORD HIGH (16) */ \ 919 V(lfhat, LFHAT, 0xE3C8) /* type = RXY_A LOAD HIGH AND TRAP (32H<-32) */ \ 920 V(lfh, LFH, 0xE3CA) /* type = RXY_A LOAD HIGH (32) */ \ 921 V(stfh, STFH, 0xE3CB) /* type = RXY_A STORE HIGH (32) */ \ 922 V(chf, CHF, 0xE3CD) /* type = RXY_A COMPARE HIGH (32) */ \ 923 V(clhf, CLHF, 0xE3CF) /* type = RXY_A COMPARE LOGICAL HIGH (32) */ \ 924 V(ley, LEY, 0xED64) /* type = RXY_A LOAD (short) */ \ 925 V(ldy, LDY, 0xED65) /* type = RXY_A LOAD (long) */ \ 926 V(stey, STEY, 0xED66) /* type = RXY_A STORE (short) */ \ 927 V(stdy, STDY, 0xED67) /* type = RXY_A STORE (long) */ \ 928 V(msc, MSC, 0xE353) /* type = RSY_A MULTIPLY SINGLE (32) */ \ 929 V(msgc, MSGC, 0xE383) /* type = RSY_A MULTIPLY SINGLE (64) */ 930 931#define S390_RXY_B_OPCODE_LIST(V) \ 932 V(pfd, PFD, 0xE336) /* type = RXY_B PREFETCH DATA */ 933 934#define S390_SIY_OPCODE_LIST(V) \ 935 V(tmy, TMY, 0xEB51) /* type = SIY TEST UNDER MASK */ \ 936 V(mviy, MVIY, 0xEB52) /* type = SIY MOVE (immediate) */ \ 937 V(niy, NIY, 0xEB54) /* type = SIY AND (immediate) */ \ 938 V(cliy, CLIY, 0xEB55) /* type = SIY COMPARE LOGICAL (immediate) */ \ 939 V(oiy, OIY, 0xEB56) /* type = SIY OR (immediate) */ \ 940 V(xiy, XIY, 0xEB57) /* type = SIY EXCLUSIVE OR (immediate) */ \ 941 V(asi, ASI, 0xEB6A) /* type = SIY ADD IMMEDIATE (32<-8) */ \ 942 V(alsi, ALSI, \ 943 0xEB6E) /* type = SIY ADD LOGICAL WITH SIGNED IMMEDIATE (32<-8) */ \ 944 V(agsi, AGSI, 0xEB7A) /* type = SIY ADD IMMEDIATE (64<-8) */ \ 945 V(algsi, ALGSI, \ 946 0xEB7E) /* type = SIY ADD LOGICAL WITH SIGNED IMMEDIATE (64<-8) */ 947 948#define S390_SS_A_OPCODE_LIST(V) \ 949 V(trtr, TRTR, 0xD0) /* type = SS_A TRANSLATE AND TEST REVERSE */ \ 950 V(mvn, MVN, 0xD1) /* type = SS_A MOVE NUMERICS */ \ 951 V(mvc, MVC, 0xD2) /* type = SS_A MOVE (character) */ \ 952 V(mvz, MVZ, 0xD3) /* type = SS_A MOVE ZONES */ \ 953 V(nc, NC, 0xD4) /* type = SS_A AND (character) */ \ 954 V(clc, CLC, 0xD5) /* type = SS_A COMPARE LOGICAL (character) */ \ 955 V(oc, OC, 0xD6) /* type = SS_A OR (character) */ \ 956 V(xc, XC, 0xD7) /* type = SS_A EXCLUSIVE OR (character) */ \ 957 V(tr, TR, 0xDC) /* type = SS_A TRANSLATE */ \ 958 V(trt, TRT, 0xDD) /* type = SS_A TRANSLATE AND TEST */ \ 959 V(ed, ED, 0xDE) /* type = SS_A EDIT */ \ 960 V(edmk, EDMK, 0xDF) /* type = SS_A EDIT AND MARK */ \ 961 V(unpku, UNPKU, 0xE2) /* type = SS_A UNPACK UNICODE */ \ 962 V(mvcin, MVCIN, 0xE8) /* type = SS_A MOVE INVERSE */ \ 963 V(unpka, UNPKA, 0xEA) /* type = SS_A UNPACK ASCII */ 964 965#define S390_E_OPCODE_LIST(V) \ 966 V(pr, PR, 0x0101) /* type = E PROGRAM RETURN */ \ 967 V(upt, UPT, 0x0102) /* type = E UPDATE TREE */ \ 968 V(ptff, PTFF, 0x0104) /* type = E PERFORM TIMING FACILITY FUNCTION */ \ 969 V(sckpf, SCKPF, 0x0107) /* type = E SET CLOCK PROGRAMMABLE FIELD */ \ 970 V(pfpo, PFPO, 0x010A) /* type = E PERFORM FLOATING-POINT OPERATION */ \ 971 V(tam, TAM, 0x010B) /* type = E TEST ADDRESSING MODE */ \ 972 V(sam24, SAM24, 0x010C) /* type = E SET ADDRESSING MODE (24) */ \ 973 V(sam31, SAM31, 0x010D) /* type = E SET ADDRESSING MODE (31) */ \ 974 V(sam64, SAM64, 0x010E) /* type = E SET ADDRESSING MODE (64) */ \ 975 V(trap2, TRAP2, 0x01FF) /* type = E TRAP */ 976 977#define S390_SS_B_OPCODE_LIST(V) \ 978 V(mvo, MVO, 0xF1) /* type = SS_B MOVE WITH OFFSET */ \ 979 V(pack, PACK, 0xF2) /* type = SS_B PACK */ \ 980 V(unpk, UNPK, 0xF3) /* type = SS_B UNPACK */ \ 981 V(zap, ZAP, 0xF8) /* type = SS_B ZERO AND ADD */ \ 982 V(cp, CP, 0xF9) /* type = SS_B COMPARE DECIMAL */ \ 983 V(ap, AP, 0xFA) /* type = SS_B ADD DECIMAL */ \ 984 V(sp, SP, 0xFB) /* type = SS_B SUBTRACT DECIMAL */ \ 985 V(mp, MP, 0xFC) /* type = SS_B MULTIPLY DECIMAL */ \ 986 V(dp, DP, 0xFD) /* type = SS_B DIVIDE DECIMAL */ 987 988#define S390_SS_C_OPCODE_LIST(V) \ 989 V(srp, SRP, 0xF0) /* type = SS_C SHIFT AND ROUND DECIMAL */ 990 991#define S390_SS_D_OPCODE_LIST(V) \ 992 V(mvck, MVCK, 0xD9) /* type = SS_D MOVE WITH KEY */ \ 993 V(mvcp, MVCP, 0xDA) /* type = SS_D MOVE TO PRIMARY */ \ 994 V(mvcs, MVCS, 0xDB) /* type = SS_D MOVE TO SECONDARY */ 995 996#define S390_SS_E_OPCODE_LIST(V) \ 997 V(plo, PLO, 0xEE) /* type = SS_E PERFORM LOCKED OPERATION */ \ 998 V(lmd, LMD, 0xEF) /* type = SS_E LOAD MULTIPLE DISJOINT (64<-32&32) */ 999 1000#define S390_I_OPCODE_LIST(V) \ 1001 V(svc, SVC, 0x0A) /* type = I SUPERVISOR CALL */ 1002 1003#define S390_SS_F_OPCODE_LIST(V) \ 1004 V(pku, PKU, 0xE1) /* type = SS_F PACK UNICODE */ \ 1005 V(pka, PKA, 0xE9) /* type = SS_F PACK ASCII */ 1006 1007#define S390_SSE_OPCODE_LIST(V) \ 1008 V(lasp, LASP, 0xE500) /* type = SSE LOAD ADDRESS SPACE PARAMETERS */ \ 1009 V(tprot, TPROT, 0xE501) /* type = SSE TEST PROTECTION */ \ 1010 V(strag, STRAG, 0xE502) /* type = SSE STORE REAL ADDRESS */ \ 1011 V(mvcsk, MVCSK, 0xE50E) /* type = SSE MOVE WITH SOURCE KEY */ \ 1012 V(mvcdk, MVCDK, 0xE50F) /* type = SSE MOVE WITH DESTINATION KEY */ 1013 1014#define S390_SSF_OPCODE_LIST(V) \ 1015 V(mvcos, MVCOS, 0xC80) /* type = SSF MOVE WITH OPTIONAL SPECIFICATIONS */ \ 1016 V(ectg, ECTG, 0xC81) /* type = SSF EXTRACT CPU TIME */ \ 1017 V(csst, CSST, 0xC82) /* type = SSF COMPARE AND SWAP AND STORE */ \ 1018 V(lpd, LPD, 0xC84) /* type = SSF LOAD PAIR DISJOINT (32) */ \ 1019 V(lpdg, LPDG, 0xC85) /* type = SSF LOAD PAIR DISJOINT (64) */ 1020 1021#define S390_RS_A_OPCODE_LIST(V) \ 1022 V(bxh, BXH, 0x86) /* type = RS_A BRANCH ON INDEX HIGH (32) */ \ 1023 V(bxle, BXLE, 0x87) /* type = RS_A BRANCH ON INDEX LOW OR EQUAL (32) */ \ 1024 V(srl, SRL, 0x88) /* type = RS_A SHIFT RIGHT SINGLE LOGICAL (32) */ \ 1025 V(sll, SLL, 0x89) /* type = RS_A SHIFT LEFT SINGLE LOGICAL (32) */ \ 1026 V(sra, SRA, 0x8A) /* type = RS_A SHIFT RIGHT SINGLE (32) */ \ 1027 V(sla, SLA, 0x8B) /* type = RS_A SHIFT LEFT SINGLE (32) */ \ 1028 V(srdl, SRDL, 0x8C) /* type = RS_A SHIFT RIGHT DOUBLE LOGICAL (64) */ \ 1029 V(sldl, SLDL, 0x8D) /* type = RS_A SHIFT LEFT DOUBLE LOGICAL (64) */ \ 1030 V(srda, SRDA, 0x8E) /* type = RS_A SHIFT RIGHT DOUBLE (64) */ \ 1031 V(slda, SLDA, 0x8F) /* type = RS_A SHIFT LEFT DOUBLE (64) */ \ 1032 V(stm, STM, 0x90) /* type = RS_A STORE MULTIPLE (32) */ \ 1033 V(lm, LM, 0x98) /* type = RS_A LOAD MULTIPLE (32) */ \ 1034 V(trace, TRACE, 0x99) /* type = RS_A TRACE (32) */ \ 1035 V(lam, LAM, 0x9A) /* type = RS_A LOAD ACCESS MULTIPLE */ \ 1036 V(stam, STAM, 0x9B) /* type = RS_A STORE ACCESS MULTIPLE */ \ 1037 V(mvcle, MVCLE, 0xA8) /* type = RS_A MOVE LONG EXTENDED */ \ 1038 V(clcle, CLCLE, 0xA9) /* type = RS_A COMPARE LOGICAL LONG EXTENDED */ \ 1039 V(sigp, SIGP, 0xAE) /* type = RS_A SIGNAL PROCESSOR */ \ 1040 V(stctl, STCTL, 0xB6) /* type = RS_A STORE CONTROL (32) */ \ 1041 V(lctl, LCTL, 0xB7) /* type = RS_A LOAD CONTROL (32) */ \ 1042 V(cs, CS, 0xBA) /* type = RS_A COMPARE AND SWAP (32) */ \ 1043 V(cds, CDS, 0xBB) /* type = RS_A COMPARE DOUBLE AND SWAP (32) */ 1044 1045#define S390_RS_B_OPCODE_LIST(V) \ 1046 V(clm, CLM, 0xBD) /* type = RS_B COMPARE LOGICAL CHAR. UNDER MASK (low) */ \ 1047 V(stcm, STCM, 0xBE) /* type = RS_B STORE CHARACTERS UNDER MASK (low) */ \ 1048 V(icm, ICM, 0xBF) /* type = RS_B INSERT CHARACTERS UNDER MASK (low) */ 1049 1050#define S390_S_OPCODE_LIST(V) \ 1051 V(lpsw, LPSW, 0x82) /* type = S LOAD PSW */ \ 1052 V(diagnose, DIAGNOSE, 0x83) /* type = S DIAGNOSE */ \ 1053 V(ts, TS, 0x93) /* type = S TEST AND SET */ \ 1054 V(stidp, STIDP, 0xB202) /* type = S STORE CPU ID */ \ 1055 V(sck, SCK, 0xB204) /* type = S SET CLOCK */ \ 1056 V(stck, STCK, 0xB205) /* type = S STORE CLOCK */ \ 1057 V(sckc, SCKC, 0xB206) /* type = S SET CLOCK COMPARATOR */ \ 1058 V(stckc, STCKC, 0xB207) /* type = S STORE CLOCK COMPARATOR */ \ 1059 V(spt, SPT, 0xB208) /* type = S SET CPU TIMER */ \ 1060 V(stpt, STPT, 0xB209) /* type = S STORE CPU TIMER */ \ 1061 V(spka, SPKA, 0xB20A) /* type = S SET PSW KEY FROM ADDRESS */ \ 1062 V(ipk, IPK, 0xB20B) /* type = S INSERT PSW KEY */ \ 1063 V(ptlb, PTLB, 0xB20D) /* type = S PURGE TLB */ \ 1064 V(spx, SPX, 0xB210) /* type = S SET PREFIX */ \ 1065 V(stpx, STPX, 0xB211) /* type = S STORE PREFIX */ \ 1066 V(stap, STAP, 0xB212) /* type = S STORE CPU ADDRESS */ \ 1067 V(pc, PC, 0xB218) /* type = S PROGRAM CALL */ \ 1068 V(sac, SAC, 0xB219) /* type = S SET ADDRESS SPACE CONTROL */ \ 1069 V(cfc, CFC, 0xB21A) /* type = S COMPARE AND FORM CODEWORD */ \ 1070 V(csch, CSCH, 0xB230) /* type = S CLEAR SUBCHANNEL */ \ 1071 V(hsch, HSCH, 0xB231) /* type = S HALT SUBCHANNEL */ \ 1072 V(msch, MSCH, 0xB232) /* type = S MODIFY SUBCHANNEL */ \ 1073 V(ssch, SSCH, 0xB233) /* type = S START SUBCHANNEL */ \ 1074 V(stsch, STSCH, 0xB234) /* type = S STORE SUBCHANNEL */ \ 1075 V(tsch, TSCH, 0xB235) /* type = S TEST SUBCHANNEL */ \ 1076 V(tpi, TPI, 0xB236) /* type = S TEST PENDING INTERRUPTION */ \ 1077 V(sal, SAL, 0xB237) /* type = S SET ADDRESS LIMIT */ \ 1078 V(rsch, RSCH, 0xB238) /* type = S RESUME SUBCHANNEL */ \ 1079 V(stcrw, STCRW, 0xB239) /* type = S STORE CHANNEL REPORT WORD */ \ 1080 V(stcps, STCPS, 0xB23A) /* type = S STORE CHANNEL PATH STATUS */ \ 1081 V(rchp, RCHP, 0xB23B) /* type = S RESET CHANNEL PATH */ \ 1082 V(schm, SCHM, 0xB23C) /* type = S SET CHANNEL MONITOR */ \ 1083 V(xsch, XSCH, 0xB276) /* type = S CANCEL SUBCHANNEL */ \ 1084 V(rp, RP_Z, 0xB277) /* type = S RESUME PROGRAM */ \ 1085 V(stcke, STCKE, 0xB278) /* type = S STORE CLOCK EXTENDED */ \ 1086 V(sacf, SACF, 0xB279) /* type = S SET ADDRESS SPACE CONTROL FAST */ \ 1087 V(stckf, STCKF, 0xB27C) /* type = S STORE CLOCK FAST */ \ 1088 V(stsi, STSI, 0xB27D) /* type = S STORE SYSTEM INFORMATION */ \ 1089 V(srnm, SRNM, 0xB299) /* type = S SET BFP ROUNDING MODE (2 bit) */ \ 1090 V(stfpc, STFPC, 0xB29C) /* type = S STORE FPC */ \ 1091 V(lfpc, LFPC, 0xB29D) /* type = S LOAD FPC */ \ 1092 V(stfle, STFLE, 0xB2B0) /* type = S STORE FACILITY LIST EXTENDED */ \ 1093 V(stfl, STFL, 0xB2B1) /* type = S STORE FACILITY LIST */ \ 1094 V(lpswe, LPSWE, 0xB2B2) /* type = S LOAD PSW EXTENDED */ \ 1095 V(srnmb, SRNMB, 0xB2B8) /* type = S SET BFP ROUNDING MODE (3 bit) */ \ 1096 V(srnmt, SRNMT, 0xB2B9) /* type = S SET DFP ROUNDING MODE */ \ 1097 V(lfas, LFAS, 0xB2BD) /* type = S LOAD FPC AND SIGNAL */ \ 1098 V(tend, TEND, 0xB2F8) /* type = S TRANSACTION END */ \ 1099 V(tabort, TABORT, 0xB2FC) /* type = S TRANSACTION ABORT */ \ 1100 V(trap4, TRAP4, 0xB2FF) /* type = S TRAP */ 1101 1102#define S390_RX_A_OPCODE_LIST(V) \ 1103 V(la, LA, 0x41) /* type = RX_A LOAD ADDRESS */ \ 1104 V(stc, STC, 0x42) /* type = RX_A STORE CHARACTER */ \ 1105 V(ic_z, IC_z, 0x43) /* type = RX_A INSERT CHARACTER */ \ 1106 V(ex, EX, 0x44) /* type = RX_A EXECUTE */ \ 1107 V(bal, BAL, 0x45) /* type = RX_A BRANCH AND LINK */ \ 1108 V(bct, BCT, 0x46) /* type = RX_A BRANCH ON COUNT (32) */ \ 1109 V(lh, LH, 0x48) /* type = RX_A LOAD HALFWORD (32<-16) */ \ 1110 V(ch, CH, 0x49) /* type = RX_A COMPARE HALFWORD (32<-16) */ \ 1111 V(ah, AH, 0x4A) /* type = RX_A ADD HALFWORD (32<-16) */ \ 1112 V(sh, SH, 0x4B) /* type = RX_A SUBTRACT HALFWORD (32<-16) */ \ 1113 V(mh, MH, 0x4C) /* type = RX_A MULTIPLY HALFWORD (32<-16) */ \ 1114 V(bas, BAS, 0x4D) /* type = RX_A BRANCH AND SAVE */ \ 1115 V(cvd, CVD, 0x4E) /* type = RX_A CONVERT TO DECIMAL (32) */ \ 1116 V(cvb, CVB, 0x4F) /* type = RX_A CONVERT TO BINARY (32) */ \ 1117 V(st, ST, 0x50) /* type = RX_A STORE (32) */ \ 1118 V(lae, LAE, 0x51) /* type = RX_A LOAD ADDRESS EXTENDED */ \ 1119 V(n, N, 0x54) /* type = RX_A AND (32) */ \ 1120 V(cl, CL, 0x55) /* type = RX_A COMPARE LOGICAL (32) */ \ 1121 V(o, O, 0x56) /* type = RX_A OR (32) */ \ 1122 V(x, X, 0x57) /* type = RX_A EXCLUSIVE OR (32) */ \ 1123 V(l, L, 0x58) /* type = RX_A LOAD (32) */ \ 1124 V(c, C, 0x59) /* type = RX_A COMPARE (32) */ \ 1125 V(a, A, 0x5A) /* type = RX_A ADD (32) */ \ 1126 V(s, S, 0x5B) /* type = RX_A SUBTRACT (32) */ \ 1127 V(m, M, 0x5C) /* type = RX_A MULTIPLY (64<-32) */ \ 1128 V(d, D, 0x5D) /* type = RX_A DIVIDE (32<-64) */ \ 1129 V(al_z, AL, 0x5E) /* type = RX_A ADD LOGICAL (32) */ \ 1130 V(sl, SL, 0x5F) /* type = RX_A SUBTRACT LOGICAL (32) */ \ 1131 V(std, STD, 0x60) /* type = RX_A STORE (long) */ \ 1132 V(mxd, MXD, 0x67) /* type = RX_A MULTIPLY (long to extended HFP) */ \ 1133 V(ld, LD, 0x68) /* type = RX_A LOAD (long) */ \ 1134 V(cd, CD, 0x69) /* type = RX_A COMPARE (long HFP) */ \ 1135 V(ad, AD, 0x6A) /* type = RX_A ADD NORMALIZED (long HFP) */ \ 1136 V(sd, SD, 0x6B) /* type = RX_A SUBTRACT NORMALIZED (long HFP) */ \ 1137 V(md, MD, 0x6C) /* type = RX_A MULTIPLY (long HFP) */ \ 1138 V(dd, DD, 0x6D) /* type = RX_A DIVIDE (long HFP) */ \ 1139 V(aw, AW, 0x6E) /* type = RX_A ADD UNNORMALIZED (long HFP) */ \ 1140 V(sw, SW, 0x6F) /* type = RX_A SUBTRACT UNNORMALIZED (long HFP) */ \ 1141 V(ste, STE, 0x70) /* type = RX_A STORE (short) */ \ 1142 V(ms, MS, 0x71) /* type = RX_A MULTIPLY SINGLE (32) */ \ 1143 V(le_z, LE, 0x78) /* type = RX_A LOAD (short) */ \ 1144 V(ce, CE, 0x79) /* type = RX_A COMPARE (short HFP) */ \ 1145 V(ae, AE, 0x7A) /* type = RX_A ADD NORMALIZED (short HFP) */ \ 1146 V(se, SE, 0x7B) /* type = RX_A SUBTRACT NORMALIZED (short HFP) */ \ 1147 V(mde, MDE, 0x7C) /* type = RX_A MULTIPLY (short to long HFP) */ \ 1148 V(de, DE, 0x7D) /* type = RX_A DIVIDE (short HFP) */ \ 1149 V(au, AU, 0x7E) /* type = RX_A ADD UNNORMALIZED (short HFP) */ \ 1150 V(su, SU, 0x7F) /* type = RX_A SUBTRACT UNNORMALIZED (short HFP) */ \ 1151 V(ssm, SSM, 0x80) /* type = RX_A SET SYSTEM MASK */ \ 1152 V(lra, LRA, 0xB1) /* type = RX_A LOAD REAL ADDRESS (32) */ \ 1153 V(sth, STH, 0x40) /* type = RX_A STORE HALFWORD (16) */ 1154 1155#define S390_RX_B_OPCODE_LIST(V) \ 1156 V(bc, BC, 0x47) /* type = RX_B BRANCH ON CONDITION */ 1157 1158#define S390_RIE_A_OPCODE_LIST(V) \ 1159 V(cgit, CGIT, 0xEC70) /* type = RIE_A COMPARE IMMEDIATE AND TRAP (64<-16) */ \ 1160 V(clgit, CLGIT, \ 1161 0xEC71) /* type = RIE_A COMPARE LOGICAL IMMEDIATE AND TRAP (64<-16) */ \ 1162 V(cit, CIT, 0xEC72) /* type = RIE_A COMPARE IMMEDIATE AND TRAP (32<-16) */ \ 1163 V(clfit, CLFIT, \ 1164 0xEC73) /* type = RIE_A COMPARE LOGICAL IMMEDIATE AND TRAP (32<-16) */ 1165 1166#define S390_RRD_OPCODE_LIST(V) \ 1167 V(maebr, MAEBR, 0xB30E) /* type = RRD MULTIPLY AND ADD (short BFP) */ \ 1168 V(msebr, MSEBR, 0xB30F) /* type = RRD MULTIPLY AND SUBTRACT (short BFP) */ \ 1169 V(madbr, MADBR, 0xB31E) /* type = RRD MULTIPLY AND ADD (long BFP) */ \ 1170 V(msdbr, MSDBR, 0xB31F) /* type = RRD MULTIPLY AND SUBTRACT (long BFP) */ \ 1171 V(maer, MAER, 0xB32E) /* type = RRD MULTIPLY AND ADD (short HFP) */ \ 1172 V(mser, MSER, 0xB32F) /* type = RRD MULTIPLY AND SUBTRACT (short HFP) */ \ 1173 V(maylr, MAYLR, \ 1174 0xB338) /* type = RRD MULTIPLY AND ADD UNNRM. (long to ext. low HFP) */ \ 1175 V(mylr, MYLR, \ 1176 0xB339) /* type = RRD MULTIPLY UNNORM. (long to ext. low HFP) */ \ 1177 V(mayr, MAYR, \ 1178 0xB33A) /* type = RRD MULTIPLY & ADD UNNORMALIZED (long to ext. HFP) */ \ 1179 V(myr, MYR, \ 1180 0xB33B) /* type = RRD MULTIPLY UNNORMALIZED (long to ext. HFP) */ \ 1181 V(mayhr, MAYHR, \ 1182 0xB33C) /* type = RRD MULTIPLY AND ADD UNNRM. (long to ext. high HFP) */ \ 1183 V(myhr, MYHR, \ 1184 0xB33D) /* type = RRD MULTIPLY UNNORM. (long to ext. high HFP) */ \ 1185 V(madr, MADR, 0xB33E) /* type = RRD MULTIPLY AND ADD (long HFP) */ \ 1186 V(msdr, MSDR, 0xB33F) /* type = RRD MULTIPLY AND SUBTRACT (long HFP) */ 1187 1188#define S390_RIE_B_OPCODE_LIST(V) \ 1189 V(cgrj, CGRJ, 0xEC64) /* type = RIE_B COMPARE AND BRANCH RELATIVE (64) */ \ 1190 V(clgrj, CLGRJ, \ 1191 0xEC65) /* type = RIE_B COMPARE LOGICAL AND BRANCH RELATIVE (64) */ \ 1192 V(crj, CRJ, 0xEC76) /* type = RIE_B COMPARE AND BRANCH RELATIVE (32) */ \ 1193 V(clrj, CLRJ, \ 1194 0xEC77) /* type = RIE_B COMPARE LOGICAL AND BRANCH RELATIVE (32) */ 1195 1196#define S390_RRE_OPCODE_LIST(V) \ 1197 V(ipm, IPM, 0xB222) /* type = RRE INSERT PROGRAM MASK */ \ 1198 V(ivsk, IVSK, 0xB223) /* type = RRE INSERT VIRTUAL STORAGE KEY */ \ 1199 V(iac, IAC, 0xB224) /* type = RRE INSERT ADDRESS SPACE CONTROL */ \ 1200 V(ssar, SSAR, 0xB225) /* type = RRE SET SECONDARY ASN */ \ 1201 V(epar, EPAR, 0xB226) /* type = RRE EXTRACT PRIMARY ASN */ \ 1202 V(esar, ESAR, 0xB227) /* type = RRE EXTRACT SECONDARY ASN */ \ 1203 V(pt, PT, 0xB228) /* type = RRE PROGRAM TRANSFER */ \ 1204 V(iske, ISKE, 0xB229) /* type = RRE INSERT STORAGE KEY EXTENDED */ \ 1205 V(rrbe, RRBE, 0xB22A) /* type = RRE RESET REFERENCE BIT EXTENDED */ \ 1206 V(tb, TB_, 0xB22C) /* type = RRE TEST BLOCK */ \ 1207 V(dxr, DXR, 0xB22D) /* type = RRE DIVIDE (extended HFP) */ \ 1208 V(pgin, PGIN, 0xB22E) /* type = RRE PAGE IN */ \ 1209 V(pgout, PGOUT, 0xB22F) /* type = RRE PAGE OUT */ \ 1210 V(bakr, BAKR, 0xB240) /* type = RRE BRANCH AND STACK */ \ 1211 V(cksm, CKSM, 0xB241) /* type = RRE CHECKSUM */ \ 1212 V(sqdr, SQDR, 0xB244) /* type = RRE SQUARE ROOT (long HFP) */ \ 1213 V(sqer, SQER, 0xB245) /* type = RRE SQUARE ROOT (short HFP) */ \ 1214 V(stura, STURA, 0xB246) /* type = RRE STORE USING REAL ADDRESS (32) */ \ 1215 V(msta, MSTA, 0xB247) /* type = RRE MODIFY STACKED STATE */ \ 1216 V(palb, PALB, 0xB248) /* type = RRE PURGE ALB */ \ 1217 V(ereg, EREG, 0xB249) /* type = RRE EXTRACT STACKED REGISTERS (32) */ \ 1218 V(esta, ESTA, 0xB24A) /* type = RRE EXTRACT STACKED STATE */ \ 1219 V(lura, LURA, 0xB24B) /* type = RRE LOAD USING REAL ADDRESS (32) */ \ 1220 V(tar, TAR, 0xB24C) /* type = RRE TEST ACCESS */ \ 1221 V(cpya, CPYA, 0xB24D) /* type = RRE COPY ACCESS */ \ 1222 V(sar, SAR, 0xB24E) /* type = RRE SET ACCESS */ \ 1223 V(ear, EAR, 0xB24F) /* type = RRE EXTRACT ACCESS */ \ 1224 V(csp, CSP, 0xB250) /* type = RRE COMPARE AND SWAP AND PURGE (32) */ \ 1225 V(msr, MSR, 0xB252) /* type = RRE MULTIPLY SINGLE (32) */ \ 1226 V(mvpg, MVPG, 0xB254) /* type = RRE MOVE PAGE */ \ 1227 V(mvst, MVST, 0xB255) /* type = RRE MOVE STRING */ \ 1228 V(cuse, CUSE, 0xB257) /* type = RRE COMPARE UNTIL SUBSTRING EQUAL */ \ 1229 V(bsg, BSG, 0xB258) /* type = RRE BRANCH IN SUBSPACE GROUP */ \ 1230 V(bsa, BSA, 0xB25A) /* type = RRE BRANCH AND SET AUTHORITY */ \ 1231 V(clst, CLST, 0xB25D) /* type = RRE COMPARE LOGICAL STRING */ \ 1232 V(srst, SRST, 0xB25E) /* type = RRE SEARCH STRING */ \ 1233 V(cmpsc, CMPSC, 0xB263) /* type = RRE COMPRESSION CALL */ \ 1234 V(tre, TRE, 0xB2A5) /* type = RRE TRANSLATE EXTENDED */ \ 1235 V(etnd, ETND, 0xB2EC) /* type = RRE EXTRACT TRANSACTION NESTING DEPTH */ \ 1236 V(lpebr, LPEBR, 0xB300) /* type = RRE LOAD POSITIVE (short BFP) */ \ 1237 V(lnebr, LNEBR, 0xB301) /* type = RRE LOAD NEGATIVE (short BFP) */ \ 1238 V(ltebr, LTEBR, 0xB302) /* type = RRE LOAD AND TEST (short BFP) */ \ 1239 V(lcebr, LCEBR, 0xB303) /* type = RRE LOAD COMPLEMENT (short BFP) */ \ 1240 V(ldebr, LDEBR, \ 1241 0xB304) /* type = RRE LOAD LENGTHENED (short to long BFP) */ \ 1242 V(lxdbr, LXDBR, \ 1243 0xB305) /* type = RRE LOAD LENGTHENED (long to extended BFP) */ \ 1244 V(lxebr, LXEBR, \ 1245 0xB306) /* type = RRE LOAD LENGTHENED (short to extended BFP) */ \ 1246 V(mxdbr, MXDBR, 0xB307) /* type = RRE MULTIPLY (long to extended BFP) */ \ 1247 V(kebr, KEBR, 0xB308) /* type = RRE COMPARE AND SIGNAL (short BFP) */ \ 1248 V(cebr, CEBR, 0xB309) /* type = RRE COMPARE (short BFP) */ \ 1249 V(aebr, AEBR, 0xB30A) /* type = RRE ADD (short BFP) */ \ 1250 V(sebr, SEBR, 0xB30B) /* type = RRE SUBTRACT (short BFP) */ \ 1251 V(mdebr, MDEBR, 0xB30C) /* type = RRE MULTIPLY (short to long BFP) */ \ 1252 V(debr, DEBR, 0xB30D) /* type = RRE DIVIDE (short BFP) */ \ 1253 V(lpdbr, LPDBR, 0xB310) /* type = RRE LOAD POSITIVE (long BFP) */ \ 1254 V(lndbr, LNDBR, 0xB311) /* type = RRE LOAD NEGATIVE (long BFP) */ \ 1255 V(ltdbr, LTDBR, 0xB312) /* type = RRE LOAD AND TEST (long BFP) */ \ 1256 V(lcdbr, LCDBR, 0xB313) /* type = RRE LOAD COMPLEMENT (long BFP) */ \ 1257 V(sqebr, SQEBR, 0xB314) /* type = RRE SQUARE ROOT (short BFP) */ \ 1258 V(sqdbr, SQDBR, 0xB315) /* type = RRE SQUARE ROOT (long BFP) */ \ 1259 V(sqxbr, SQXBR, 0xB316) /* type = RRE SQUARE ROOT (extended BFP) */ \ 1260 V(meebr, MEEBR, 0xB317) /* type = RRE MULTIPLY (short BFP) */ \ 1261 V(kdbr, KDBR, 0xB318) /* type = RRE COMPARE AND SIGNAL (long BFP) */ \ 1262 V(cdbr, CDBR, 0xB319) /* type = RRE COMPARE (long BFP) */ \ 1263 V(adbr, ADBR, 0xB31A) /* type = RRE ADD (long BFP) */ \ 1264 V(sdbr, SDBR, 0xB31B) /* type = RRE SUBTRACT (long BFP) */ \ 1265 V(mdbr, MDBR, 0xB31C) /* type = RRE MULTIPLY (long BFP) */ \ 1266 V(ddbr, DDBR, 0xB31D) /* type = RRE DIVIDE (long BFP) */ \ 1267 V(lder, LDER, 0xB324) /* type = RRE LOAD LENGTHENED (short to long HFP) */ \ 1268 V(lxdr, LXDR, \ 1269 0xB325) /* type = RRE LOAD LENGTHENED (long to extended HFP) */ \ 1270 V(lxer, LXER, \ 1271 0xB326) /* type = RRE LOAD LENGTHENED (short to extended HFP) */ \ 1272 V(sqxr, SQXR, 0xB336) /* type = RRE SQUARE ROOT (extended HFP) */ \ 1273 V(meer, MEER, 0xB337) /* type = RRE MULTIPLY (short HFP) */ \ 1274 V(lpxbr, LPXBR, 0xB340) /* type = RRE LOAD POSITIVE (extended BFP) */ \ 1275 V(lnxbr, LNXBR, 0xB341) /* type = RRE LOAD NEGATIVE (extended BFP) */ \ 1276 V(ltxbr, LTXBR, 0xB342) /* type = RRE LOAD AND TEST (extended BFP) */ \ 1277 V(lcxbr, LCXBR, 0xB343) /* type = RRE LOAD COMPLEMENT (extended BFP) */ \ 1278 V(kxbr, KXBR, 0xB348) /* type = RRE COMPARE AND SIGNAL (extended BFP) */ \ 1279 V(cxbr, CXBR, 0xB349) /* type = RRE COMPARE (extended BFP) */ \ 1280 V(axbr, AXBR, 0xB34A) /* type = RRE ADD (extended BFP) */ \ 1281 V(sxbr, SXBR, 0xB34B) /* type = RRE SUBTRACT (extended BFP) */ \ 1282 V(mxbr, MXBR, 0xB34C) /* type = RRE MULTIPLY (extended BFP) */ \ 1283 V(dxbr, DXBR, 0xB34D) /* type = RRE DIVIDE (extended BFP) */ \ 1284 V(thder, THDER, \ 1285 0xB358) /* type = RRE CONVERT BFP TO HFP (short to long) */ \ 1286 V(thdr, THDR, 0xB359) /* type = RRE CONVERT BFP TO HFP (long) */ \ 1287 V(lpxr, LPXR, 0xB360) /* type = RRE LOAD POSITIVE (extended HFP) */ \ 1288 V(lnxr, LNXR, 0xB361) /* type = RRE LOAD NEGATIVE (extended HFP) */ \ 1289 V(ltxr, LTXR, 0xB362) /* type = RRE LOAD AND TEST (extended HFP) */ \ 1290 V(lcxr, LCXR, 0xB363) /* type = RRE LOAD COMPLEMENT (extended HFP) */ \ 1291 V(lxr, LXR, 0xB365) /* type = RRE LOAD (extended) */ \ 1292 V(lexr, LEXR, \ 1293 0xB366) /* type = RRE LOAD ROUNDED (extended to short HFP) */ \ 1294 V(fixr, FIXR, 0xB367) /* type = RRE LOAD FP INTEGER (extended HFP) */ \ 1295 V(cxr, CXR, 0xB369) /* type = RRE COMPARE (extended HFP) */ \ 1296 V(lpdfr, LPDFR, 0xB370) /* type = RRE LOAD POSITIVE (long) */ \ 1297 V(lndfr, LNDFR, 0xB371) /* type = RRE LOAD NEGATIVE (long) */ \ 1298 V(lcdfr, LCDFR, 0xB373) /* type = RRE LOAD COMPLEMENT (long) */ \ 1299 V(lzer, LZER, 0xB374) /* type = RRE LOAD ZERO (short) */ \ 1300 V(lzdr, LZDR, 0xB375) /* type = RRE LOAD ZERO (long) */ \ 1301 V(lzxr, LZXR, 0xB376) /* type = RRE LOAD ZERO (extended) */ \ 1302 V(fier, FIER, 0xB377) /* type = RRE LOAD FP INTEGER (short HFP) */ \ 1303 V(fidr, FIDR, 0xB37F) /* type = RRE LOAD FP INTEGER (long HFP) */ \ 1304 V(sfpc, SFPC, 0xB384) /* type = RRE SET FPC */ \ 1305 V(sfasr, SFASR, 0xB385) /* type = RRE SET FPC AND SIGNAL */ \ 1306 V(efpc, EFPC, 0xB38C) /* type = RRE EXTRACT FPC */ \ 1307 V(cefr, CEFR, \ 1308 0xB3B4) /* type = RRE CONVERT FROM FIXED (32 to short HFP) */ \ 1309 V(cdfr, CDFR, 0xB3B5) /* type = RRE CONVERT FROM FIXED (32 to long HFP) */ \ 1310 V(cxfr, CXFR, \ 1311 0xB3B6) /* type = RRE CONVERT FROM FIXED (32 to extended HFP) */ \ 1312 V(ldgr, LDGR, 0xB3C1) /* type = RRE LOAD FPR FROM GR (64 to long) */ \ 1313 V(cegr, CEGR, \ 1314 0xB3C4) /* type = RRE CONVERT FROM FIXED (64 to short HFP) */ \ 1315 V(cdgr, CDGR, 0xB3C5) /* type = RRE CONVERT FROM FIXED (64 to long HFP) */ \ 1316 V(cxgr, CXGR, \ 1317 0xB3C6) /* type = RRE CONVERT FROM FIXED (64 to extended HFP) */ \ 1318 V(lgdr, LGDR, 0xB3CD) /* type = RRE LOAD GR FROM FPR (long to 64) */ \ 1319 V(ltdtr, LTDTR, 0xB3D6) /* type = RRE LOAD AND TEST (long DFP) */ \ 1320 V(ltxtr, LTXTR, 0xB3DE) /* type = RRE LOAD AND TEST (extended DFP) */ \ 1321 V(kdtr, KDTR, 0xB3E0) /* type = RRE COMPARE AND SIGNAL (long DFP) */ \ 1322 V(cudtr, CUDTR, 0xB3E2) /* type = RRE CONVERT TO UNSIGNED PACKED (long */ \ 1323 /* DFP to 64) CUDTR */ \ 1324 V(cdtr, CDTR, 0xB3E4) /* type = RRE COMPARE (long DFP) */ \ 1325 V(eedtr, EEDTR, \ 1326 0xB3E5) /* type = RRE EXTRACT BIASED EXPONENT (long DFP to 64) */ \ 1327 V(esdtr, ESDTR, \ 1328 0xB3E7) /* type = RRE EXTRACT SIGNIFICANCE (long DFP to 64) */ \ 1329 V(kxtr, KXTR, 0xB3E8) /* type = RRE COMPARE AND SIGNAL (extended DFP) */ \ 1330 V(cuxtr, CUXTR, \ 1331 0xB3EA) /* type = RRE CONVERT TO UNSIGNED PACKED (extended DFP */ \ 1332 /* CUXTR to 128) */ \ 1333 V(cxtr, CXTR, 0xB3EC) /* type = RRE COMPARE (extended DFP) */ \ 1334 V(eextr, EEXTR, \ 1335 0xB3ED) /* type = RRE EXTRACT BIASED EXPONENT (extended DFP to 64) */ \ 1336 V(esxtr, ESXTR, \ 1337 0xB3EF) /* type = RRE EXTRACT SIGNIFICANCE (extended DFP to 64) */ \ 1338 V(cdutr, CDUTR, \ 1339 0xB3F2) /* type = RRE CONVERT FROM UNSIGNED PACKED (64 to long DFP) */ \ 1340 V(cdstr, CDSTR, \ 1341 0xB3F3) /* type = RRE CONVERT FROM SIGNED PACKED (64 to long DFP) */ \ 1342 V(cedtr, CEDTR, \ 1343 0xB3F4) /* type = RRE COMPARE BIASED EXPONENT (long DFP) */ \ 1344 V(cxutr, CXUTR, \ 1345 0xB3FA) /* type = RRE CONVERT FROM UNSIGNED PACKED (128 to ext. DFP) */ \ 1346 V(cxstr, CXSTR, 0xB3FB) /* type = RRE CONVERT FROM SIGNED PACKED (128 to*/ \ 1347 /* extended DFP) */ \ 1348 V(cextr, CEXTR, \ 1349 0xB3FC) /* type = RRE COMPARE BIASED EXPONENT (extended DFP) */ \ 1350 V(lpgr, LPGR, 0xB900) /* type = RRE LOAD POSITIVE (64) */ \ 1351 V(lngr, LNGR, 0xB901) /* type = RRE LOAD NEGATIVE (64) */ \ 1352 V(ltgr, LTGR, 0xB902) /* type = RRE LOAD AND TEST (64) */ \ 1353 V(lcgr, LCGR, 0xB903) /* type = RRE LOAD COMPLEMENT (64) */ \ 1354 V(lgr, LGR, 0xB904) /* type = RRE LOAD (64) */ \ 1355 V(lurag, LURAG, 0xB905) /* type = RRE LOAD USING REAL ADDRESS (64) */ \ 1356 V(lgbr, LGBR, 0xB906) /* type = RRE LOAD BYTE (64<-8) */ \ 1357 V(lghr, LGHR, 0xB907) /* type = RRE LOAD HALFWORD (64<-16) */ \ 1358 V(agr, AGR, 0xB908) /* type = RRE ADD (64) */ \ 1359 V(sgr, SGR, 0xB909) /* type = RRE SUBTRACT (64) */ \ 1360 V(algr, ALGR, 0xB90A) /* type = RRE ADD LOGICAL (64) */ \ 1361 V(slgr, SLGR, 0xB90B) /* type = RRE SUBTRACT LOGICAL (64) */ \ 1362 V(msgr, MSGR, 0xB90C) /* type = RRE MULTIPLY SINGLE (64) */ \ 1363 V(dsgr, DSGR, 0xB90D) /* type = RRE DIVIDE SINGLE (64) */ \ 1364 V(eregg, EREGG, 0xB90E) /* type = RRE EXTRACT STACKED REGISTERS (64) */ \ 1365 V(lrvgr, LRVGR, 0xB90F) /* type = RRE LOAD REVERSED (64) */ \ 1366 V(lpgfr, LPGFR, 0xB910) /* type = RRE LOAD POSITIVE (64<-32) */ \ 1367 V(lngfr, LNGFR, 0xB911) /* type = RRE LOAD NEGATIVE (64<-32) */ \ 1368 V(ltgfr, LTGFR, 0xB912) /* type = RRE LOAD AND TEST (64<-32) */ \ 1369 V(lcgfr, LCGFR, 0xB913) /* type = RRE LOAD COMPLEMENT (64<-32) */ \ 1370 V(lgfr, LGFR, 0xB914) /* type = RRE LOAD (64<-32) */ \ 1371 V(llgfr, LLGFR, 0xB916) /* type = RRE LOAD LOGICAL (64<-32) */ \ 1372 V(llgtr, LLGTR, \ 1373 0xB917) /* type = RRE LOAD LOGICAL THIRTY ONE BITS (64<-31) */ \ 1374 V(agfr, AGFR, 0xB918) /* type = RRE ADD (64<-32) */ \ 1375 V(sgfr, SGFR, 0xB919) /* type = RRE SUBTRACT (64<-32) */ \ 1376 V(algfr, ALGFR, 0xB91A) /* type = RRE ADD LOGICAL (64<-32) */ \ 1377 V(slgfr, SLGFR, 0xB91B) /* type = RRE SUBTRACT LOGICAL (64<-32) */ \ 1378 V(msgfr, MSGFR, 0xB91C) /* type = RRE MULTIPLY SINGLE (64<-32) */ \ 1379 V(dsgfr, DSGFR, 0xB91D) /* type = RRE DIVIDE SINGLE (64<-32) */ \ 1380 V(kmac, KMAC, 0xB91E) /* type = RRE COMPUTE MESSAGE AUTHENTICATION CODE */ \ 1381 V(lrvr, LRVR, 0xB91F) /* type = RRE LOAD REVERSED (32) */ \ 1382 V(cgr, CGR, 0xB920) /* type = RRE COMPARE (64) */ \ 1383 V(clgr, CLGR, 0xB921) /* type = RRE COMPARE LOGICAL (64) */ \ 1384 V(sturg, STURG, 0xB925) /* type = RRE STORE USING REAL ADDRESS (64) */ \ 1385 V(lbr, LBR, 0xB926) /* type = RRE LOAD BYTE (32<-8) */ \ 1386 V(lhr, LHR, 0xB927) /* type = RRE LOAD HALFWORD (32<-16) */ \ 1387 V(pckmo, PCKMO, \ 1388 0xB928) /* type = RRE PERFORM CRYPTOGRAPHIC KEY MGMT. OPERATIONS */ \ 1389 V(kmf, KMF, 0xB92A) /* type = RRE CIPHER MESSAGE WITH CIPHER FEEDBACK */ \ 1390 V(kmo, KMO, 0xB92B) /* type = RRE CIPHER MESSAGE WITH OUTPUT FEEDBACK */ \ 1391 V(pcc, PCC, 0xB92C) /* type = RRE PERFORM CRYPTOGRAPHIC COMPUTATION */ \ 1392 V(km, KM, 0xB92E) /* type = RRE CIPHER MESSAGE */ \ 1393 V(kmc, KMC, 0xB92F) /* type = RRE CIPHER MESSAGE WITH CHAINING */ \ 1394 V(cgfr, CGFR, 0xB930) /* type = RRE COMPARE (64<-32) */ \ 1395 V(clgfr, CLGFR, 0xB931) /* type = RRE COMPARE LOGICAL (64<-32) */ \ 1396 V(ppno, PPNO, \ 1397 0xB93C) /* type = RRE PERFORM PSEUDORANDOM NUMBER OPERATION */ \ 1398 V(kimd, KIMD, 0xB93E) /* type = RRE COMPUTE INTERMEDIATE MESSAGE DIGEST */ \ 1399 V(klmd, KLMD, 0xB93F) /* type = RRE COMPUTE LAST MESSAGE DIGEST */ \ 1400 V(bctgr, BCTGR, 0xB946) /* type = RRE BRANCH ON COUNT (64) */ \ 1401 V(cdftr, CDFTR, \ 1402 0xB951) /* type = RRE CONVERT FROM FIXED (32 to long DFP) */ \ 1403 V(cxftr, CXFTR, \ 1404 0xB959) /* type = RRE CONVERT FROM FIXED (32 to extended DFP) */ \ 1405 V(ngr, NGR, 0xB980) /* type = RRE AND (64) */ \ 1406 V(ogr, OGR, 0xB981) /* type = RRE OR (64) */ \ 1407 V(xgr, XGR, 0xB982) /* type = RRE EXCLUSIVE OR (64) */ \ 1408 V(flogr, FLOGR, 0xB983) /* type = RRE FIND LEFTMOST ONE */ \ 1409 V(llgcr, LLGCR, 0xB984) /* type = RRE LOAD LOGICAL CHARACTER (64<-8) */ \ 1410 V(llghr, LLGHR, 0xB985) /* type = RRE LOAD LOGICAL HALFWORD (64<-16) */ \ 1411 V(mlgr, MLGR, 0xB986) /* type = RRE MULTIPLY LOGICAL (128<-64) */ \ 1412 V(dlgr, DLGR, 0xB987) /* type = RRE DIVIDE LOGICAL (64<-128) */ \ 1413 V(alcgr, ALCGR, 0xB988) /* type = RRE ADD LOGICAL WITH CARRY (64) */ \ 1414 V(slbgr, SLBGR, 0xB989) /* type = RRE SUBTRACT LOGICAL WITH BORROW (64) */ \ 1415 V(cspg, CSPG, 0xB98A) /* type = RRE COMPARE AND SWAP AND PURGE (64) */ \ 1416 V(epsw, EPSW, 0xB98D) /* type = RRE EXTRACT PSW */ \ 1417 V(llcr, LLCR, 0xB994) /* type = RRE LOAD LOGICAL CHARACTER (32<-8) */ \ 1418 V(llhr, LLHR, 0xB995) /* type = RRE LOAD LOGICAL HALFWORD (32<-16) */ \ 1419 V(mlr, MLR, 0xB996) /* type = RRE MULTIPLY LOGICAL (64<-32) */ \ 1420 V(dlr, DLR, 0xB997) /* type = RRE DIVIDE LOGICAL (32<-64) */ \ 1421 V(alcr, ALCR, 0xB998) /* type = RRE ADD LOGICAL WITH CARRY (32) */ \ 1422 V(slbr, SLBR, 0xB999) /* type = RRE SUBTRACT LOGICAL WITH BORROW (32) */ \ 1423 V(epair, EPAIR, 0xB99A) /* type = RRE EXTRACT PRIMARY ASN AND INSTANCE */ \ 1424 V(esair, ESAIR, \ 1425 0xB99B) /* type = RRE EXTRACT SECONDARY ASN AND INSTANCE */ \ 1426 V(esea, ESEA, 0xB99D) /* type = RRE EXTRACT AND SET EXTENDED AUTHORITY */ \ 1427 V(pti, PTI, 0xB99E) /* type = RRE PROGRAM TRANSFER WITH INSTANCE */ \ 1428 V(ssair, SSAIR, 0xB99F) /* type = RRE SET SECONDARY ASN WITH INSTANCE */ \ 1429 V(ptf, PTF, 0xB9A2) /* type = RRE PERFORM TOPOLOGY FUNCTION */ \ 1430 V(rrbm, RRBM, 0xB9AE) /* type = RRE RESET REFERENCE BITS MULTIPLE */ \ 1431 V(pfmf, PFMF, 0xB9AF) /* type = RRE PERFORM FRAME MANAGEMENT FUNCTION */ \ 1432 V(cu41, CU41, 0xB9B2) /* type = RRE CONVERT UTF-32 TO UTF-8 */ \ 1433 V(cu42, CU42, 0xB9B3) /* type = RRE CONVERT UTF-32 TO UTF-16 */ \ 1434 V(srstu, SRSTU, 0xB9BE) /* type = RRE SEARCH STRING UNICODE */ \ 1435 V(chhr, CHHR, 0xB9CD) /* type = RRE COMPARE HIGH (32) */ \ 1436 V(clhhr, CLHHR, 0xB9CF) /* type = RRE COMPARE LOGICAL HIGH (32) */ \ 1437 V(chlr, CHLR, 0xB9DD) /* type = RRE COMPARE HIGH (32) */ \ 1438 V(clhlr, CLHLR, 0xB9DF) /* type = RRE COMPARE LOGICAL HIGH (32) */ \ 1439 V(popcnt, POPCNT_Z, 0xB9E1) /* type = RRE POPULATION COUNT */ 1440 1441#define S390_RIE_C_OPCODE_LIST(V) \ 1442 V(cgij, CGIJ, \ 1443 0xEC7C) /* type = RIE_C COMPARE IMMEDIATE AND BRANCH RELATIVE (64<-8) */ \ 1444 V(clgij, CLGIJ, \ 1445 0xEC7D) /* type = RIE_C COMPARE LOGICAL IMMEDIATE AND BRANCH RELATIVE */ \ 1446 /* (64<-8) */ \ 1447 V(cij, CIJ, \ 1448 0xEC7E) /* type = RIE_C COMPARE IMMEDIATE AND BRANCH RELATIVE (32<-8) */ \ 1449 V(clij, CLIJ, 0xEC7F) /* type = RIE_C COMPARE LOGICAL IMMEDIATE AND */ \ 1450 /* BRANCH RELATIVE (32<-8) */ 1451 1452#define S390_RIE_D_OPCODE_LIST(V) \ 1453 V(ahik, AHIK, 0xECD8) /* type = RIE_D ADD IMMEDIATE (32<-16) */ \ 1454 V(aghik, AGHIK, 0xECD9) /* type = RIE_D ADD IMMEDIATE (64<-16) */ \ 1455 V(alhsik, ALHSIK, \ 1456 0xECDA) /* type = RIE_D ADD LOGICAL WITH SIGNED IMMEDIATE (32<-16) */ \ 1457 V(alghsik, ALGHSIK, \ 1458 0xECDB) /* type = RIE_D ADD LOGICAL WITH SIGNED IMMEDIATE (64<-16) */ 1459 1460#define S390_VRV_OPCODE_LIST(V) \ 1461 V(vgeg, VGEG, 0xE712) /* type = VRV VECTOR GATHER ELEMENT (64) */ \ 1462 V(vgef, VGEF, 0xE713) /* type = VRV VECTOR GATHER ELEMENT (32) */ \ 1463 V(vsceg, VSCEG, 0xE71A) /* type = VRV VECTOR SCATTER ELEMENT (64) */ \ 1464 V(vscef, VSCEF, 0xE71B) /* type = VRV VECTOR SCATTER ELEMENT (32) */ 1465 1466#define S390_RIE_E_OPCODE_LIST(V) \ 1467 V(brxhg, BRXHG, \ 1468 0xEC44) /* type = RIE_E BRANCH RELATIVE ON INDEX HIGH (64) */ \ 1469 V(brxlg, BRXLG, \ 1470 0xEC45) /* type = RIE_E BRANCH RELATIVE ON INDEX LOW OR EQ. (64) */ 1471 1472#define S390_RR_OPCODE_LIST(V) \ 1473 V(awr, AWR, 0x2E) /* type = RR ADD UNNORMALIZED (long HFP) */ \ 1474 V(spm, SPM, 0x04) /* type = RR SET PROGRAM MASK */ \ 1475 V(balr, BALR, 0x05) /* type = RR BRANCH AND LINK */ \ 1476 V(bctr, BCTR, 0x06) /* type = RR BRANCH ON COUNT (32) */ \ 1477 V(bcr, BCR, 0x07) /* type = RR BRANCH ON CONDITION */ \ 1478 V(bsm, BSM, 0x0B) /* type = RR BRANCH AND SET MODE */ \ 1479 V(bassm, BASSM, 0x0C) /* type = RR BRANCH AND SAVE AND SET MODE */ \ 1480 V(basr, BASR, 0x0D) /* type = RR BRANCH AND SAVE */ \ 1481 V(mvcl, MVCL, 0x0E) /* type = RR MOVE LONG */ \ 1482 V(clcl, CLCL, 0x0F) /* type = RR COMPARE LOGICAL LONG */ \ 1483 V(lpr, LPR, 0x10) /* type = RR LOAD POSITIVE (32) */ \ 1484 V(lnr, LNR, 0x11) /* type = RR LOAD NEGATIVE (32) */ \ 1485 V(ltr, LTR, 0x12) /* type = RR LOAD AND TEST (32) */ \ 1486 V(lcr, LCR, 0x13) /* type = RR LOAD COMPLEMENT (32) */ \ 1487 V(nr, NR, 0x14) /* type = RR AND (32) */ \ 1488 V(clr, CLR, 0x15) /* type = RR COMPARE LOGICAL (32) */ \ 1489 V(or_z, OR, 0x16) /* type = RR OR (32) */ \ 1490 V(xr, XR, 0x17) /* type = RR EXCLUSIVE OR (32) */ \ 1491 V(lr, LR, 0x18) /* type = RR LOAD (32) */ \ 1492 V(cr_z, CR, 0x19) /* type = RR COMPARE (32) */ \ 1493 V(ar, AR, 0x1A) /* type = RR ADD (32) */ \ 1494 V(sr, SR, 0x1B) /* type = RR SUBTRACT (32) */ \ 1495 V(mr_z, MR, 0x1C) /* type = RR MULTIPLY (64<-32) */ \ 1496 V(dr, DR, 0x1D) /* type = RR DIVIDE (32<-64) */ \ 1497 V(alr, ALR, 0x1E) /* type = RR ADD LOGICAL (32) */ \ 1498 V(slr, SLR, 0x1F) /* type = RR SUBTRACT LOGICAL (32) */ \ 1499 V(lpdr, LPDR, 0x20) /* type = RR LOAD POSITIVE (long HFP) */ \ 1500 V(lndr, LNDR, 0x21) /* type = RR LOAD NEGATIVE (long HFP) */ \ 1501 V(ltdr, LTDR, 0x22) /* type = RR LOAD AND TEST (long HFP) */ \ 1502 V(lcdr, LCDR, 0x23) /* type = RR LOAD COMPLEMENT (long HFP) */ \ 1503 V(hdr, HDR, 0x24) /* type = RR HALVE (long HFP) */ \ 1504 V(ldxr, LDXR, 0x25) /* type = RR LOAD ROUNDED (extended to long HFP) */ \ 1505 V(mxr, MXR, 0x26) /* type = RR MULTIPLY (extended HFP) */ \ 1506 V(mxdr, MXDR, 0x27) /* type = RR MULTIPLY (long to extended HFP) */ \ 1507 V(ldr, LDR, 0x28) /* type = RR LOAD (long) */ \ 1508 V(cdr, CDR, 0x29) /* type = RR COMPARE (long HFP) */ \ 1509 V(adr, ADR, 0x2A) /* type = RR ADD NORMALIZED (long HFP) */ \ 1510 V(sdr, SDR, 0x2B) /* type = RR SUBTRACT NORMALIZED (long HFP) */ \ 1511 V(mdr, MDR, 0x2C) /* type = RR MULTIPLY (long HFP) */ \ 1512 V(ddr, DDR, 0x2D) /* type = RR DIVIDE (long HFP) */ \ 1513 V(swr, SWR, 0x2F) /* type = RR SUBTRACT UNNORMALIZED (long HFP) */ \ 1514 V(lper, LPER, 0x30) /* type = RR LOAD POSITIVE (short HFP) */ \ 1515 V(lner, LNER, 0x31) /* type = RR LOAD NEGATIVE (short HFP) */ \ 1516 V(lter, LTER, 0x32) /* type = RR LOAD AND TEST (short HFP) */ \ 1517 V(lcer, LCER, 0x33) /* type = RR LOAD COMPLEMENT (short HFP) */ \ 1518 V(her_z, HER_Z, 0x34) /* type = RR HALVE (short HFP) */ \ 1519 V(ledr, LEDR, 0x35) /* type = RR LOAD ROUNDED (long to short HFP) */ \ 1520 V(axr, AXR, 0x36) /* type = RR ADD NORMALIZED (extended HFP) */ \ 1521 V(sxr, SXR, 0x37) /* type = RR SUBTRACT NORMALIZED (extended HFP) */ \ 1522 V(ler, LER, 0x38) /* type = RR LOAD (short) */ \ 1523 V(cer, CER, 0x39) /* type = RR COMPARE (short HFP) */ \ 1524 V(aer, AER, 0x3A) /* type = RR ADD NORMALIZED (short HFP) */ \ 1525 V(ser, SER, 0x3B) /* type = RR SUBTRACT NORMALIZED (short HFP) */ \ 1526 V(mder, MDER, 0x3C) /* type = RR MULTIPLY (short to long HFP) */ \ 1527 V(der, DER, 0x3D) /* type = RR DIVIDE (short HFP) */ \ 1528 V(aur, AUR, 0x3E) /* type = RR ADD UNNORMALIZED (short HFP) */ \ 1529 V(sur, SUR, 0x3F) /* type = RR SUBTRACT UNNORMALIZED (short HFP) */ 1530 1531#define S390_RIE_F_OPCODE_LIST(V) \ 1532 V(risblg, RISBLG, \ 1533 0xEC51) /* type = RIE_F ROTATE THEN INSERT SELECTED BITS LOW (64) */ \ 1534 V(rnsbg, RNSBG, \ 1535 0xEC54) /* type = RIE_F ROTATE THEN AND SELECTED BITS (64) */ \ 1536 V(risbg, RISBG, \ 1537 0xEC55) /* type = RIE_F ROTATE THEN INSERT SELECTED BITS (64) */ \ 1538 V(rosbg, ROSBG, 0xEC56) /* type = RIE_F ROTATE THEN OR SELECTED BITS (64) */ \ 1539 V(rxsbg, RXSBG, \ 1540 0xEC57) /* type = RIE_F ROTATE THEN EXCLUSIVE OR SELECT. BITS (64) */ \ 1541 V(risbgn, RISBGN, \ 1542 0xEC59) /* type = RIE_F ROTATE THEN INSERT SELECTED BITS (64) */ \ 1543 V(risbhg, RISBHG, \ 1544 0xEC5D) /* type = RIE_F ROTATE THEN INSERT SELECTED BITS HIGH (64) */ 1545 1546#define S390_VRX_OPCODE_LIST(V) \ 1547 V(vleb, VLEB, 0xE700) /* type = VRX VECTOR LOAD ELEMENT (8) */ \ 1548 V(vleh, VLEH, 0xE701) /* type = VRX VECTOR LOAD ELEMENT (16) */ \ 1549 V(vleg, VLEG, 0xE702) /* type = VRX VECTOR LOAD ELEMENT (64) */ \ 1550 V(vlef, VLEF, 0xE703) /* type = VRX VECTOR LOAD ELEMENT (32) */ \ 1551 V(vllez, VLLEZ, \ 1552 0xE704) /* type = VRX VECTOR LOAD LOGICAL ELEMENT AND ZERO */ \ 1553 V(vlrep, VLREP, 0xE705) /* type = VRX VECTOR LOAD AND REPLICATE */ \ 1554 V(vl, VL, 0xE706) /* type = VRX VECTOR LOAD */ \ 1555 V(vlbb, VLBB, 0xE707) /* type = VRX VECTOR LOAD TO BLOCK BOUNDARY */ \ 1556 V(vlbr, VLBR, 0xE606) /* type = VRX VECTOR LOAD BYTE REVERSED ELEMENTS */ \ 1557 V(vlbrrep, VLBRREP, \ 1558 0xE605) /* type = VRX VECTOR LOAD BYTE REVERSED ELEMENT AND REPLICATE */ \ 1559 V(vlebrh, VLEBRH, \ 1560 0xE601) /* type = VRX VECTOR LOAD BYTE REVERSED ELEMENT (16) */ \ 1561 V(vlebrf, VLEBRF, \ 1562 0xE603) /* type = VRX VECTOR LOAD BYTE REVERSED ELEMENT (32) */ \ 1563 V(vlebrg, VLEBRG, \ 1564 0xE602) /* type = VRX VECTOR LOAD BYTE REVERSED ELEMENT (64) */ \ 1565 V(vsteb, VSTEB, 0xE708) /* type = VRX VECTOR STORE ELEMENT (8) */ \ 1566 V(vsteh, VSTEH, 0xE709) /* type = VRX VECTOR STORE ELEMENT (16) */ \ 1567 V(vsteg, VSTEG, 0xE70A) /* type = VRX VECTOR STORE ELEMENT (64) */ \ 1568 V(vstef, VSTEF, 0xE70B) /* type = VRX VECTOR STORE ELEMENT (32) */ \ 1569 V(vst, VST, 0xE70E) /* type = VRX VECTOR STORE */ \ 1570 V(vstbr, VSTBR, \ 1571 0xE60E) /* type = VRX VECTOR STORE BYTE REVERSED ELEMENTS */ \ 1572 V(vstebrh, VSTEBRH, \ 1573 0xE609) /* type = VRX VECTOR STORE BYTE REVERSED ELEMENT (16) */ \ 1574 V(vstebrf, VSTEBRF, \ 1575 0xE60B) /* type = VRX VECTOR STORE BYTE REVERSED ELEMENT (32) */ \ 1576 V(vstebrg, VSTEBRG, \ 1577 0xE60A) /* type = VRX VECTOR STORE BYTE REVERSED ELEMENT (64) */ 1578 1579#define S390_RIE_G_OPCODE_LIST(V) \ 1580 V(lochi, LOCHI, \ 1581 0xEC42) /* type = RIE_G LOAD HALFWORD IMMEDIATE ON CONDITION (32<-16) */ \ 1582 V(locghi, LOCGHI, \ 1583 0xEC46) /* type = RIE_G LOAD HALFWORD IMMEDIATE ON CONDITION (64<-16) */ \ 1584 V(lochhi, LOCHHI, 0xEC4E) /* type = RIE_G LOAD HALFWORD HIGH IMMEDIATE */ \ 1585 /* ON CONDITION (32<-16) */ 1586 1587#define S390_RRS_OPCODE_LIST(V) \ 1588 V(cgrb, CGRB, 0xECE4) /* type = RRS COMPARE AND BRANCH (64) */ \ 1589 V(clgrb, CLGRB, 0xECE5) /* type = RRS COMPARE LOGICAL AND BRANCH (64) */ \ 1590 V(crb, CRB, 0xECF6) /* type = RRS COMPARE AND BRANCH (32) */ \ 1591 V(clrb, CLRB, 0xECF7) /* type = RRS COMPARE LOGICAL AND BRANCH (32) */ 1592 1593#define S390_OPCODE_LIST(V) \ 1594 S390_RSY_A_OPCODE_LIST(V) \ 1595 S390_RSY_B_OPCODE_LIST(V) \ 1596 S390_RXE_OPCODE_LIST(V) \ 1597 S390_RRF_A_OPCODE_LIST(V) \ 1598 S390_RXF_OPCODE_LIST(V) \ 1599 S390_IE_OPCODE_LIST(V) \ 1600 S390_RRF_B_OPCODE_LIST(V) \ 1601 S390_RRF_C_OPCODE_LIST(V) \ 1602 S390_MII_OPCODE_LIST(V) \ 1603 S390_RRF_D_OPCODE_LIST(V) \ 1604 S390_RRF_E_OPCODE_LIST(V) \ 1605 S390_VRR_A_OPCODE_LIST(V) \ 1606 S390_VRR_B_OPCODE_LIST(V) \ 1607 S390_VRR_C_OPCODE_LIST(V) \ 1608 S390_VRI_A_OPCODE_LIST(V) \ 1609 S390_VRR_D_OPCODE_LIST(V) \ 1610 S390_VRI_B_OPCODE_LIST(V) \ 1611 S390_VRR_E_OPCODE_LIST(V) \ 1612 S390_VRI_C_OPCODE_LIST(V) \ 1613 S390_VRI_D_OPCODE_LIST(V) \ 1614 S390_VRR_F_OPCODE_LIST(V) \ 1615 S390_RIS_OPCODE_LIST(V) \ 1616 S390_VRI_E_OPCODE_LIST(V) \ 1617 S390_RSL_A_OPCODE_LIST(V) \ 1618 S390_RSL_B_OPCODE_LIST(V) \ 1619 S390_SI_OPCODE_LIST(V) \ 1620 S390_SIL_OPCODE_LIST(V) \ 1621 S390_VRS_A_OPCODE_LIST(V) \ 1622 S390_RIL_A_OPCODE_LIST(V) \ 1623 S390_RIL_B_OPCODE_LIST(V) \ 1624 S390_VRS_B_OPCODE_LIST(V) \ 1625 S390_RIL_C_OPCODE_LIST(V) \ 1626 S390_VRS_C_OPCODE_LIST(V) \ 1627 S390_RI_A_OPCODE_LIST(V) \ 1628 S390_RSI_OPCODE_LIST(V) \ 1629 S390_RI_B_OPCODE_LIST(V) \ 1630 S390_RI_C_OPCODE_LIST(V) \ 1631 S390_SMI_OPCODE_LIST(V) \ 1632 S390_RXY_A_OPCODE_LIST(V) \ 1633 S390_RXY_B_OPCODE_LIST(V) \ 1634 S390_SIY_OPCODE_LIST(V) \ 1635 S390_SS_A_OPCODE_LIST(V) \ 1636 S390_E_OPCODE_LIST(V) \ 1637 S390_SS_B_OPCODE_LIST(V) \ 1638 S390_SS_C_OPCODE_LIST(V) \ 1639 S390_SS_D_OPCODE_LIST(V) \ 1640 S390_SS_E_OPCODE_LIST(V) \ 1641 S390_I_OPCODE_LIST(V) \ 1642 S390_SS_F_OPCODE_LIST(V) \ 1643 S390_SSE_OPCODE_LIST(V) \ 1644 S390_SSF_OPCODE_LIST(V) \ 1645 S390_RS_A_OPCODE_LIST(V) \ 1646 S390_RS_B_OPCODE_LIST(V) \ 1647 S390_S_OPCODE_LIST(V) \ 1648 S390_RX_A_OPCODE_LIST(V) \ 1649 S390_RX_B_OPCODE_LIST(V) \ 1650 S390_RIE_A_OPCODE_LIST(V) \ 1651 S390_RRD_OPCODE_LIST(V) \ 1652 S390_RIE_B_OPCODE_LIST(V) \ 1653 S390_RRE_OPCODE_LIST(V) \ 1654 S390_RIE_C_OPCODE_LIST(V) \ 1655 S390_RIE_D_OPCODE_LIST(V) \ 1656 S390_VRV_OPCODE_LIST(V) \ 1657 S390_RIE_E_OPCODE_LIST(V) \ 1658 S390_RR_OPCODE_LIST(V) \ 1659 S390_RIE_F_OPCODE_LIST(V) \ 1660 S390_VRX_OPCODE_LIST(V) \ 1661 S390_RIE_G_OPCODE_LIST(V) \ 1662 S390_RRS_OPCODE_LIST(V) 1663 1664// Opcodes as defined in Appendix B-2 table 1665enum Opcode { 1666#define DECLARE_OPCODES(name, opcode_name, opcode_value) \ 1667 opcode_name = opcode_value, 1668 S390_OPCODE_LIST(DECLARE_OPCODES) 1669#undef DECLARE_OPCODES 1670 1671 BKPT = 0x0001, // GDB Software Breakpoint 1672 DUMY = 0xE352 // Special dummy opcode 1673}; 1674 1675// Instruction encoding bits and masks. 1676enum { 1677 // Instruction encoding bit 1678 B1 = 1 << 1, 1679 B4 = 1 << 4, 1680 B5 = 1 << 5, 1681 B7 = 1 << 7, 1682 B8 = 1 << 8, 1683 B9 = 1 << 9, 1684 B12 = 1 << 12, 1685 B18 = 1 << 18, 1686 B19 = 1 << 19, 1687 B20 = 1 << 20, 1688 B22 = 1 << 22, 1689 B23 = 1 << 23, 1690 B24 = 1 << 24, 1691 B25 = 1 << 25, 1692 B26 = 1 << 26, 1693 B27 = 1 << 27, 1694 B28 = 1 << 28, 1695 1696 B6 = 1 << 6, 1697 B10 = 1 << 10, 1698 B11 = 1 << 11, 1699 B16 = 1 << 16, 1700 B17 = 1 << 17, 1701 B21 = 1 << 21, 1702 1703 // Instruction bit masks 1704 kCondMask = 0x1F << 21, 1705 kOff12Mask = (1 << 12) - 1, 1706 kImm24Mask = (1 << 24) - 1, 1707 kOff16Mask = (1 << 16) - 1, 1708 kImm16Mask = (1 << 16) - 1, 1709 kImm26Mask = (1 << 26) - 1, 1710 kBOfieldMask = 0x1f << 21, 1711 kOpcodeMask = 0x3f << 26, 1712 kExt2OpcodeMask = 0x1f << 1, 1713 kExt5OpcodeMask = 0x3 << 2, 1714 kBIMask = 0x1F << 16, 1715 kBDMask = 0x14 << 2, 1716 kAAMask = 0x01 << 1, 1717 kLKMask = 0x01, 1718 kRCMask = 0x01, 1719 kTOMask = 0x1f << 21 1720}; 1721 1722// S390 instructions requires bigger shifts, 1723// make them macros instead of enum because of the typing issue 1724#define B32 ((uint64_t)1 << 32) 1725#define B36 ((uint64_t)1 << 36) 1726#define B40 ((uint64_t)1 << 40) 1727const FourByteInstr kFourByteBrCondMask = 0xF << 20; 1728const SixByteInstr kSixByteBrCondMask = static_cast<SixByteInstr>(0xF) << 36; 1729 1730// ----------------------------------------------------------------------------- 1731// Addressing modes and instruction variants. 1732 1733// Overflow Exception 1734enum OEBit { 1735 SetOE = 1 << 10, // Set overflow exception 1736 LeaveOE = 0 << 10 // No overflow exception 1737}; 1738 1739// Record bit 1740enum RCBit { // Bit 0 1741 SetRC = 1, // LT,GT,EQ,SO 1742 LeaveRC = 0 // None 1743}; 1744 1745// Link bit 1746enum LKBit { // Bit 0 1747 SetLK = 1, // Load effective address of next instruction 1748 LeaveLK = 0 // No action 1749}; 1750 1751enum BOfield { // Bits 25-21 1752 DCBNZF = 0 << 21, // Decrement CTR; branch if CTR != 0 and condition false 1753 DCBEZF = 2 << 21, // Decrement CTR; branch if CTR == 0 and condition false 1754 BF = 4 << 21, // Branch if condition false 1755 DCBNZT = 8 << 21, // Decrement CTR; branch if CTR != 0 and condition true 1756 DCBEZT = 10 << 21, // Decrement CTR; branch if CTR == 0 and condition true 1757 BT = 12 << 21, // Branch if condition true 1758 DCBNZ = 16 << 21, // Decrement CTR; branch if CTR != 0 1759 DCBEZ = 18 << 21, // Decrement CTR; branch if CTR == 0 1760 BA = 20 << 21 // Branch always 1761}; 1762 1763#ifdef _AIX 1764#undef CR_LT 1765#undef CR_GT 1766#undef CR_EQ 1767#undef CR_SO 1768#endif 1769 1770enum CRBit { CR_LT = 0, CR_GT = 1, CR_EQ = 2, CR_SO = 3, CR_FU = 3 }; 1771 1772#define CRWIDTH 4 1773 1774// ----------------------------------------------------------------------------- 1775// Supervisor Call (svc) specific support. 1776 1777// Special Software Interrupt codes when used in the presence of the S390 1778// simulator. 1779// SVC provides a 24bit immediate value. Use bits 22:0 for standard 1780// SoftwareInterrupCode. Bit 23 is reserved for the stop feature. 1781enum SoftwareInterruptCodes { 1782 // Transition to C code 1783 kCallRtRedirected = 0x0010, 1784 // Breakpoint 1785 kBreakpoint = 0x0000, 1786 // Stop 1787 kStopCode = 1 << 23 1788}; 1789const uint32_t kStopCodeMask = kStopCode - 1; 1790const uint32_t kMaxStopCode = kStopCode - 1; 1791const int32_t kDefaultStopCode = -1; 1792 1793// FP rounding modes. 1794enum FPRoundingMode { 1795 CURRENT_ROUNDING_MODE = 0, 1796 ROUND_TO_NEAREST_AWAY_FROM_0 = 1, 1797 ROUND_TO_NEAREST_TO_EVEN = 4, 1798 ROUND_TOWARD_0 = 5, 1799 ROUND_TOWARD_POS_INF = 6, 1800 ROUND_TOWARD_NEG_INF = 7, 1801 1802 // Aliases. 1803 kRoundToNearest = ROUND_TO_NEAREST_TO_EVEN, 1804 kRoundToZero = ROUND_TOWARD_0, 1805 kRoundToPlusInf = ROUND_TOWARD_POS_INF, 1806 kRoundToMinusInf = ROUND_TOWARD_NEG_INF 1807}; 1808 1809const uint32_t kFPRoundingModeMask = 3; 1810 1811enum CheckForInexactConversion { 1812 kCheckForInexactConversion, 1813 kDontCheckForInexactConversion 1814}; 1815 1816// ----------------------------------------------------------------------------- 1817// Specific instructions, constants, and masks. 1818 1819// use TRAP4 to indicate redirection call for simulation mode 1820const Instr rtCallRedirInstr = TRAP4; 1821 1822// ----------------------------------------------------------------------------- 1823// Instruction abstraction. 1824 1825// The class Instruction enables access to individual fields defined in the 1826// z/Architecture instruction set encoding. 1827class Instruction { 1828 public: 1829 // S390 Opcode Format Types 1830 // Based on the first byte of the opcode, we can determine how to extract 1831 // the entire opcode of the instruction. The various favours include: 1832 enum OpcodeFormatType { 1833 ONE_BYTE_OPCODE, // One Byte - Bits 0 to 7 1834 TWO_BYTE_OPCODE, // Two Bytes - Bits 0 to 15 1835 TWO_BYTE_DISJOINT_OPCODE, // Two Bytes - Bits 0 to 7, 40 to 47 1836 THREE_NIBBLE_OPCODE // Three Nibbles - Bits 0 to 7, 12 to 15 1837 }; 1838 1839 static OpcodeFormatType OpcodeFormatTable[256]; 1840 1841 // Get the raw instruction bits. 1842 template <typename T> 1843 inline T InstructionBits() const { 1844 return Instruction::InstructionBits<T>(reinterpret_cast<const byte*>(this)); 1845 } 1846 inline Instr InstructionBits() const { 1847 return *reinterpret_cast<const Instr*>(this); 1848 } 1849 1850 // Set the raw instruction bits to value. 1851 template <typename T> 1852 inline void SetInstructionBits(T value) const { 1853 Instruction::SetInstructionBits<T>(reinterpret_cast<const byte*>(this), 1854 value); 1855 } 1856 inline void SetInstructionBits(Instr value) { 1857 *reinterpret_cast<Instr*>(this) = value; 1858 } 1859 1860 // Read one particular bit out of the instruction bits. 1861 inline int Bit(int nr) const { return (InstructionBits() >> nr) & 1; } 1862 1863 // Read a bit field's value out of the instruction bits. 1864 inline int Bits(int hi, int lo) const { 1865 return (InstructionBits() >> lo) & ((2 << (hi - lo)) - 1); 1866 } 1867 1868 // Read bits according to instruction type 1869 template <typename T, typename U> 1870 inline U Bits(int hi, int lo) const { 1871 return (InstructionBits<T>() >> lo) & ((2 << (hi - lo)) - 1); 1872 } 1873 1874 // Read a bit field out of the instruction bits. 1875 inline int BitField(int hi, int lo) const { 1876 return InstructionBits() & (((2 << (hi - lo)) - 1) << lo); 1877 } 1878 1879 // Determine the instruction length 1880 inline int InstructionLength() { 1881 return Instruction::InstructionLength(reinterpret_cast<const byte*>(this)); 1882 } 1883 // Extract the Instruction Opcode 1884 inline Opcode S390OpcodeValue() { 1885 return Instruction::S390OpcodeValue(reinterpret_cast<const byte*>(this)); 1886 } 1887 1888 // Static support. 1889 1890 // Read one particular bit out of the instruction bits. 1891 static inline int Bit(Instr instr, int nr) { return (instr >> nr) & 1; } 1892 1893 // Read the value of a bit field out of the instruction bits. 1894 static inline int Bits(Instr instr, int hi, int lo) { 1895 return (instr >> lo) & ((2 << (hi - lo)) - 1); 1896 } 1897 1898 // Read a bit field out of the instruction bits. 1899 static inline int BitField(Instr instr, int hi, int lo) { 1900 return instr & (((2 << (hi - lo)) - 1) << lo); 1901 } 1902 1903 // Determine the instruction length of the given instruction 1904 static inline int InstructionLength(const byte* instr) { 1905 // Length can be determined by the first nibble. 1906 // 0x0 to 0x3 => 2-bytes 1907 // 0x4 to 0xB => 4-bytes 1908 // 0xC to 0xF => 6-bytes 1909 byte topNibble = (*instr >> 4) & 0xF; 1910 if (topNibble <= 3) 1911 return 2; 1912 else if (topNibble <= 0xB) 1913 return 4; 1914 return 6; 1915 } 1916 1917 // Returns the instruction bits of the given instruction 1918 static inline uint64_t InstructionBits(const byte* instr) { 1919 int length = InstructionLength(instr); 1920 if (2 == length) 1921 return static_cast<uint64_t>(InstructionBits<TwoByteInstr>(instr)); 1922 else if (4 == length) 1923 return static_cast<uint64_t>(InstructionBits<FourByteInstr>(instr)); 1924 else 1925 return InstructionBits<SixByteInstr>(instr); 1926 } 1927 1928 // Extract the raw instruction bits 1929 template <typename T> 1930 static inline T InstructionBits(const byte* instr) { 1931#if !V8_TARGET_LITTLE_ENDIAN 1932 if (sizeof(T) <= 4) { 1933 return *reinterpret_cast<const T*>(instr); 1934 } else { 1935 // We cannot read 8-byte instructon address directly, because for a 1936 // six-byte instruction, the extra 2-byte address might not be 1937 // allocated. 1938 uint64_t fourBytes = *reinterpret_cast<const uint32_t*>(instr); 1939 uint16_t twoBytes = *reinterpret_cast<const uint16_t*>(instr + 4); 1940 return (fourBytes << 16 | twoBytes); 1941 } 1942#else 1943 // Even on little endian hosts (simulation), the instructions 1944 // are stored as big-endian in order to decode the opcode and 1945 // instruction length. 1946 T instr_bits = 0; 1947 1948 // 6-byte instrs are represented by uint64_t 1949 uint32_t size = (sizeof(T) == 8) ? 6 : sizeof(T); 1950 1951 for (T i = 0; i < size; i++) { 1952 instr_bits <<= 8; 1953 instr_bits |= *(instr + i); 1954 } 1955 return instr_bits; 1956#endif 1957 } 1958 1959 // Set the Instruction Bits to value 1960 template <typename T> 1961 static inline void SetInstructionBits(byte* instr, T value) { 1962#if V8_TARGET_LITTLE_ENDIAN 1963 // The instruction bits are stored in big endian format even on little 1964 // endian hosts, in order to decode instruction length and opcode. 1965 // The following code will reverse the bytes so that the stores later 1966 // (which are in native endianess) will effectively save the instruction 1967 // in big endian. 1968 if (sizeof(T) == 2) { 1969 // Two Byte Instruction 1970 value = ((value & 0x00FF) << 8) | ((value & 0xFF00) >> 8); 1971 } else if (sizeof(T) == 4) { 1972 // Four Byte Instruction 1973 value = ((value & 0x000000FF) << 24) | ((value & 0x0000FF00) << 8) | 1974 ((value & 0x00FF0000) >> 8) | ((value & 0xFF000000) >> 24); 1975 } else if (sizeof(T) == 8) { 1976 // Six Byte Instruction 1977 uint64_t orig_value = static_cast<uint64_t>(value); 1978 value = (static_cast<uint64_t>(orig_value & 0xFF) << 40) | 1979 (static_cast<uint64_t>((orig_value >> 8) & 0xFF) << 32) | 1980 (static_cast<uint64_t>((orig_value >> 16) & 0xFF) << 24) | 1981 (static_cast<uint64_t>((orig_value >> 24) & 0xFF) << 16) | 1982 (static_cast<uint64_t>((orig_value >> 32) & 0xFF) << 8) | 1983 (static_cast<uint64_t>((orig_value >> 40) & 0xFF)); 1984 } 1985#endif 1986 if (sizeof(T) <= 4) { 1987 *reinterpret_cast<T*>(instr) = value; 1988 } else { 1989#if V8_TARGET_LITTLE_ENDIAN 1990 uint64_t orig_value = static_cast<uint64_t>(value); 1991 *reinterpret_cast<uint32_t*>(instr) = static_cast<uint32_t>(value); 1992 *reinterpret_cast<uint16_t*>(instr + 4) = 1993 static_cast<uint16_t>((orig_value >> 32) & 0xFFFF); 1994#else 1995 *reinterpret_cast<uint32_t*>(instr) = static_cast<uint32_t>(value >> 16); 1996 *reinterpret_cast<uint16_t*>(instr + 4) = 1997 static_cast<uint16_t>(value & 0xFFFF); 1998#endif 1999 } 2000 } 2001 2002 // Get Instruction Format Type 2003 static OpcodeFormatType getOpcodeFormatType(const byte* instr) { 2004 const byte firstByte = *instr; 2005 return OpcodeFormatTable[firstByte]; 2006 } 2007 2008 // Extract the full opcode from the instruction. 2009 static inline Opcode S390OpcodeValue(const byte* instr) { 2010 OpcodeFormatType opcodeType = getOpcodeFormatType(instr); 2011 2012 // The native instructions are encoded in big-endian format 2013 // even if running on little-endian host. Hence, we need 2014 // to ensure we use byte* based bit-wise logic. 2015 switch (opcodeType) { 2016 case ONE_BYTE_OPCODE: 2017 // One Byte - Bits 0 to 7 2018 return static_cast<Opcode>(*instr); 2019 case TWO_BYTE_OPCODE: 2020 // Two Bytes - Bits 0 to 15 2021 return static_cast<Opcode>((*instr << 8) | (*(instr + 1))); 2022 case TWO_BYTE_DISJOINT_OPCODE: 2023 // Two Bytes - Bits 0 to 7, 40 to 47 2024 return static_cast<Opcode>((*instr << 8) | (*(instr + 5) & 0xFF)); 2025 default: 2026 // case THREE_NIBBLE_OPCODE: 2027 // Three Nibbles - Bits 0 to 7, 12 to 15 2028 return static_cast<Opcode>((*instr << 4) | (*(instr + 1) & 0xF)); 2029 } 2030 2031 UNREACHABLE(); 2032 } 2033 2034 // Fields used in Software interrupt instructions 2035 inline SoftwareInterruptCodes SvcValue() const { 2036 return static_cast<SoftwareInterruptCodes>(Bits<FourByteInstr, int>(15, 0)); 2037 } 2038 2039 // Instructions are read of out a code stream. The only way to get a 2040 // reference to an instruction is to convert a pointer. There is no way 2041 // to allocate or create instances of class Instruction. 2042 // Use the At(pc) function to create references to Instruction. 2043 static Instruction* At(byte* pc) { 2044 return reinterpret_cast<Instruction*>(pc); 2045 } 2046 2047 private: 2048 // We need to prevent the creation of instances of class Instruction. 2049 DISALLOW_IMPLICIT_CONSTRUCTORS(Instruction); 2050}; 2051 2052#define DECLARE_FIELD_FOR_TWO_BYTE_INSTR(name, T, lo, hi) \ 2053 inline int name() const { \ 2054 return Bits<TwoByteInstr, T>(15 - (lo), 15 - (hi) + 1); \ 2055 } 2056 2057#define DECLARE_FIELD_FOR_FOUR_BYTE_INSTR(name, T, lo, hi) \ 2058 inline int name() const { \ 2059 return Bits<FourByteInstr, T>(31 - (lo), 31 - (hi) + 1); \ 2060 } 2061 2062#define DECLARE_FIELD_FOR_SIX_BYTE_INSTR(name, T, lo, hi) \ 2063 inline int name() const { \ 2064 return Bits<SixByteInstr, T>(47 - (lo), 47 - (hi) + 1); \ 2065 } 2066 2067class TwoByteInstruction : public Instruction { 2068 public: 2069 inline int size() const { return 2; } 2070}; 2071 2072class FourByteInstruction : public Instruction { 2073 public: 2074 inline int size() const { return 4; } 2075}; 2076 2077class SixByteInstruction : public Instruction { 2078 public: 2079 inline int size() const { return 6; } 2080}; 2081 2082// I Instruction 2083class IInstruction : public TwoByteInstruction { 2084 public: 2085 DECLARE_FIELD_FOR_TWO_BYTE_INSTR(IValue, int, 8, 16) 2086}; 2087 2088// E Instruction 2089class EInstruction : public TwoByteInstruction {}; 2090 2091// IE Instruction 2092class IEInstruction : public FourByteInstruction { 2093 public: 2094 DECLARE_FIELD_FOR_FOUR_BYTE_INSTR(I1Value, int, 24, 28) 2095 DECLARE_FIELD_FOR_FOUR_BYTE_INSTR(I2Value, int, 28, 32) 2096}; 2097 2098// MII Instruction 2099class MIIInstruction : public SixByteInstruction { 2100 public: 2101 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(M1Value, uint32_t, 8, 12) 2102 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(RI2Value, int, 12, 24) 2103 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(RI3Value, int, 24, 47) 2104}; 2105 2106// RI Instruction 2107class RIInstruction : public FourByteInstruction { 2108 public: 2109 DECLARE_FIELD_FOR_FOUR_BYTE_INSTR(R1Value, int, 8, 12) 2110 DECLARE_FIELD_FOR_FOUR_BYTE_INSTR(I2Value, int, 16, 32) 2111 DECLARE_FIELD_FOR_FOUR_BYTE_INSTR(I2UnsignedValue, uint32_t, 16, 32) 2112 DECLARE_FIELD_FOR_FOUR_BYTE_INSTR(M1Value, uint32_t, 8, 12) 2113}; 2114 2115// RR Instruction 2116class RRInstruction : Instruction { 2117 public: 2118 inline int R1Value() const { 2119 // the high and low parameters of Bits is the number of bits from 2120 // rightmost place 2121 return Bits<TwoByteInstr, int>(7, 4); 2122 } 2123 inline int R2Value() const { return Bits<TwoByteInstr, int>(3, 0); } 2124 inline Condition M1Value() const { 2125 return static_cast<Condition>(Bits<TwoByteInstr, int>(7, 4)); 2126 } 2127 2128 inline int size() const { return 2; } 2129}; 2130 2131// RRE Instruction 2132class RREInstruction : Instruction { 2133 public: 2134 inline int R1Value() const { return Bits<FourByteInstr, int>(7, 4); } 2135 inline int R2Value() const { return Bits<FourByteInstr, int>(3, 0); } 2136 inline int M3Value() const { return Bits<FourByteInstr, int>(15, 12); } 2137 inline int M4Value() const { return Bits<FourByteInstr, int>(19, 16); } 2138 inline int size() const { return 4; } 2139}; 2140 2141// RRF Instruction 2142class RRFInstruction : Instruction { 2143 public: 2144 inline int R1Value() const { return Bits<FourByteInstr, int>(7, 4); } 2145 inline int R2Value() const { return Bits<FourByteInstr, int>(3, 0); } 2146 inline int R3Value() const { return Bits<FourByteInstr, int>(15, 12); } 2147 inline int M3Value() const { return Bits<FourByteInstr, int>(15, 12); } 2148 inline int M4Value() const { return Bits<FourByteInstr, int>(11, 8); } 2149 inline int size() const { return 4; } 2150}; 2151 2152// RRD Isntruction 2153class RRDInstruction : Instruction { 2154 public: 2155 inline int R1Value() const { return Bits<FourByteInstr, int>(15, 12); } 2156 inline int R2Value() const { return Bits<FourByteInstr, int>(3, 0); } 2157 inline int R3Value() const { return Bits<FourByteInstr, int>(7, 4); } 2158 inline int size() const { return 4; } 2159}; 2160 2161// RS Instruction 2162class RSInstruction : Instruction { 2163 public: 2164 inline int R1Value() const { return Bits<FourByteInstr, int>(23, 20); } 2165 inline int R3Value() const { return Bits<FourByteInstr, int>(19, 16); } 2166 inline int B2Value() const { return Bits<FourByteInstr, int>(15, 12); } 2167 inline unsigned int D2Value() const { 2168 return Bits<FourByteInstr, unsigned int>(11, 0); 2169 } 2170 inline int size() const { return 4; } 2171}; 2172 2173// RSI Instruction 2174class RSIInstruction : Instruction { 2175 public: 2176 inline int R1Value() const { return Bits<FourByteInstr, int>(23, 20); } 2177 inline int R3Value() const { return Bits<FourByteInstr, int>(19, 16); } 2178 inline int I2Value() const { 2179 return static_cast<int32_t>(Bits<FourByteInstr, int16_t>(15, 0)); 2180 } 2181 inline int size() const { return 4; } 2182}; 2183 2184// RSY Instruction 2185class RSYInstruction : Instruction { 2186 public: 2187 inline int R1Value() const { return Bits<SixByteInstr, int>(39, 36); } 2188 inline int R3Value() const { return Bits<SixByteInstr, int>(35, 32); } 2189 inline int B2Value() const { return Bits<SixByteInstr, int>(31, 28); } 2190 inline int32_t D2Value() const { 2191 int32_t value = Bits<SixByteInstr, int32_t>(27, 16); 2192 value += Bits<SixByteInstr, int8_t>(15, 8) << 12; 2193 return value; 2194 } 2195 inline int size() const { return 6; } 2196}; 2197 2198// RX Instruction 2199class RXInstruction : Instruction { 2200 public: 2201 inline int R1Value() const { return Bits<FourByteInstr, int>(23, 20); } 2202 inline int X2Value() const { return Bits<FourByteInstr, int>(19, 16); } 2203 inline int B2Value() const { return Bits<FourByteInstr, int>(15, 12); } 2204 inline uint32_t D2Value() const { 2205 return Bits<FourByteInstr, uint32_t>(11, 0); 2206 } 2207 inline int size() const { return 4; } 2208}; 2209 2210// RXY Instruction 2211class RXYInstruction : Instruction { 2212 public: 2213 inline int R1Value() const { return Bits<SixByteInstr, int>(39, 36); } 2214 inline int X2Value() const { return Bits<SixByteInstr, int>(35, 32); } 2215 inline int B2Value() const { return Bits<SixByteInstr, int>(31, 28); } 2216 inline int32_t D2Value() const { 2217 int32_t value = Bits<SixByteInstr, uint32_t>(27, 16); 2218 value += Bits<SixByteInstr, int8_t>(15, 8) << 12; 2219 return value; 2220 } 2221 inline int size() const { return 6; } 2222}; 2223 2224// RIL Instruction 2225class RILInstruction : Instruction { 2226 public: 2227 inline int R1Value() const { return Bits<SixByteInstr, int>(39, 36); } 2228 inline int32_t I2Value() const { return Bits<SixByteInstr, int32_t>(31, 0); } 2229 inline uint32_t I2UnsignedValue() const { 2230 return Bits<SixByteInstr, uint32_t>(31, 0); 2231 } 2232 inline int size() const { return 6; } 2233}; 2234 2235// SI Instruction 2236class SIInstruction : Instruction { 2237 public: 2238 inline int B1Value() const { return Bits<FourByteInstr, int>(15, 12); } 2239 inline uint32_t D1Value() const { 2240 return Bits<FourByteInstr, uint32_t>(11, 0); 2241 } 2242 inline uint8_t I2Value() const { 2243 return Bits<FourByteInstr, uint8_t>(23, 16); 2244 } 2245 inline int size() const { return 4; } 2246}; 2247 2248// SIY Instruction 2249class SIYInstruction : Instruction { 2250 public: 2251 inline int B1Value() const { return Bits<SixByteInstr, int>(31, 28); } 2252 inline int32_t D1Value() const { 2253 int32_t value = Bits<SixByteInstr, uint32_t>(27, 16); 2254 value += Bits<SixByteInstr, int8_t>(15, 8) << 12; 2255 return value; 2256 } 2257 inline uint8_t I2Value() const { return Bits<SixByteInstr, uint8_t>(39, 32); } 2258 inline int size() const { return 6; } 2259}; 2260 2261// SIL Instruction 2262class SILInstruction : Instruction { 2263 public: 2264 inline int B1Value() const { return Bits<SixByteInstr, int>(31, 28); } 2265 inline int D1Value() const { return Bits<SixByteInstr, int>(27, 16); } 2266 inline int I2Value() const { return Bits<SixByteInstr, int>(15, 0); } 2267 inline int size() const { return 6; } 2268}; 2269 2270// SS Instruction 2271class SSInstruction : Instruction { 2272 public: 2273 inline int B1Value() const { return Bits<SixByteInstr, int>(31, 28); } 2274 inline int B2Value() const { return Bits<SixByteInstr, int>(15, 12); } 2275 inline int D1Value() const { return Bits<SixByteInstr, int>(27, 16); } 2276 inline int D2Value() const { return Bits<SixByteInstr, int>(11, 0); } 2277 inline int Length() const { return Bits<SixByteInstr, int>(39, 32); } 2278 inline int size() const { return 6; } 2279}; 2280 2281// RXE Instruction 2282class RXEInstruction : Instruction { 2283 public: 2284 inline int R1Value() const { return Bits<SixByteInstr, int>(39, 36); } 2285 inline int X2Value() const { return Bits<SixByteInstr, int>(35, 32); } 2286 inline int B2Value() const { return Bits<SixByteInstr, int>(31, 28); } 2287 inline int D2Value() const { return Bits<SixByteInstr, int>(27, 16); } 2288 inline int size() const { return 6; } 2289}; 2290 2291// RIE Instruction 2292class RIEInstruction : Instruction { 2293 public: 2294 inline int R1Value() const { return Bits<SixByteInstr, int>(39, 36); } 2295 inline int R2Value() const { return Bits<SixByteInstr, int>(35, 32); } 2296 inline int I3Value() const { return Bits<SixByteInstr, uint32_t>(31, 24); } 2297 inline int I4Value() const { return Bits<SixByteInstr, uint32_t>(23, 16); } 2298 inline int I5Value() const { return Bits<SixByteInstr, uint32_t>(15, 8); } 2299 inline int I6Value() const { 2300 return static_cast<int32_t>(Bits<SixByteInstr, int16_t>(31, 16)); 2301 } 2302 inline int size() const { return 6; } 2303}; 2304 2305// VRR Instruction 2306class VRR_A_Instruction : SixByteInstruction { 2307 public: 2308 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R1Value, int, 8, 12) 2309 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R2Value, int, 12, 16) 2310 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(M5Value, uint32_t, 24, 28) 2311 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(M4Value, uint32_t, 28, 32) 2312 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(M3Value, uint32_t, 32, 36) 2313}; 2314 2315class VRR_B_Instruction : SixByteInstruction { 2316 public: 2317 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R1Value, int, 8, 12) 2318 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R2Value, int, 12, 16) 2319 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R3Value, int, 16, 20) 2320 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(M5Value, uint32_t, 24, 28) 2321 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(M4Value, uint32_t, 32, 36) 2322}; 2323 2324class VRR_C_Instruction : SixByteInstruction { 2325 public: 2326 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R1Value, int, 8, 12) 2327 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R2Value, int, 12, 16) 2328 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R3Value, int, 16, 20) 2329 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(M6Value, uint32_t, 24, 28) 2330 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(M5Value, uint32_t, 28, 32) 2331 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(M4Value, uint32_t, 32, 36) 2332}; 2333 2334class VRR_E_Instruction : SixByteInstruction { 2335 public: 2336 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R1Value, int, 8, 12) 2337 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R2Value, int, 12, 16) 2338 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R3Value, int, 16, 20) 2339 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R4Value, int, 32, 36) 2340 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(M6Value, uint32_t, 20, 24) 2341 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(M5Value, uint32_t, 28, 32) 2342}; 2343 2344class VRR_F_Instruction : SixByteInstruction { 2345 public: 2346 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R1Value, int, 8, 12) 2347 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R2Value, int, 12, 16) 2348 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R3Value, int, 16, 20) 2349}; 2350 2351class VRX_Instruction : SixByteInstruction { 2352 public: 2353 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R1Value, int, 8, 12) 2354 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(X2Value, int, 12, 16) 2355 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(B2Value, int, 16, 20) 2356 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(D2Value, int, 20, 32) 2357 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(M3Value, uint32_t, 32, 36) 2358}; 2359 2360class VRS_Instruction : SixByteInstruction { 2361 public: 2362 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R1Value, int, 8, 12) 2363 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R3Value, int, 12, 16) 2364 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(B2Value, int, 16, 20) 2365 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(D2Value, int, 20, 32) 2366 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(M4Value, uint32_t, 32, 36) 2367}; 2368 2369class VRI_A_Instruction : SixByteInstruction { 2370 public: 2371 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R1Value, int, 8, 12) 2372 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(I2Value, int, 16, 32) 2373 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(M3Value, uint32_t, 32, 36) 2374}; 2375 2376class VRI_C_Instruction : SixByteInstruction { 2377 public: 2378 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R1Value, int, 8, 12) 2379 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(R3Value, int, 12, 16) 2380 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(I2Value, int, 16, 32) 2381 DECLARE_FIELD_FOR_SIX_BYTE_INSTR(M4Value, uint32_t, 32, 36) 2382}; 2383 2384// Helper functions for converting between register numbers and names. 2385class Registers { 2386 public: 2387 // Lookup the register number for the name provided. 2388 static int Number(const char* name); 2389 2390 private: 2391 static const char* names_[kNumRegisters]; 2392}; 2393 2394// Helper functions for converting between FP register numbers and names. 2395class DoubleRegisters { 2396 public: 2397 // Lookup the register number for the name provided. 2398 static int Number(const char* name); 2399 2400 private: 2401 static const char* names_[kNumDoubleRegisters]; 2402}; 2403 2404} // namespace internal 2405} // namespace v8 2406 2407#endif // V8_CODEGEN_S390_CONSTANTS_S390_H_ 2408