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