• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2015, VIXL authors
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are met:
6 //
7 //   * Redistributions of source code must retain the above copyright notice,
8 //     this list of conditions and the following disclaimer.
9 //   * Redistributions in binary form must reproduce the above copyright notice,
10 //     this list of conditions and the following disclaimer in the documentation
11 //     and/or other materials provided with the distribution.
12 //   * Neither the name of ARM Limited nor the names of its contributors may be
13 //     used to endorse or promote products derived from this software without
14 //     specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND
17 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
20 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
23 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 
27 #ifndef VIXL_AARCH64_CONSTANTS_AARCH64_H_
28 #define VIXL_AARCH64_CONSTANTS_AARCH64_H_
29 
30 #include "../globals-vixl.h"
31 
32 namespace vixl {
33 namespace aarch64 {
34 
35 const unsigned kNumberOfRegisters = 32;
36 const unsigned kNumberOfVRegisters = 32;
37 const unsigned kNumberOfZRegisters = kNumberOfVRegisters;
38 const unsigned kNumberOfPRegisters = 16;
39 // Callee saved registers are x21-x30(lr).
40 const int kNumberOfCalleeSavedRegisters = 10;
41 const int kFirstCalleeSavedRegisterIndex = 21;
42 // Callee saved FP registers are d8-d15. Note that the high parts of v8-v15 are
43 // still caller-saved.
44 const int kNumberOfCalleeSavedFPRegisters = 8;
45 const int kFirstCalleeSavedFPRegisterIndex = 8;
46 // All predicated instructions accept at least p0-p7 as the governing predicate.
47 const unsigned kNumberOfGoverningPRegisters = 8;
48 
49 // clang-format off
50 #define AARCH64_P_REGISTER_CODE_LIST(R)                                        \
51   R(0)  R(1)  R(2)  R(3)  R(4)  R(5)  R(6)  R(7)                               \
52   R(8)  R(9)  R(10) R(11) R(12) R(13) R(14) R(15)
53 
54 #define AARCH64_REGISTER_CODE_LIST(R)                                          \
55   R(0)  R(1)  R(2)  R(3)  R(4)  R(5)  R(6)  R(7)                               \
56   R(8)  R(9)  R(10) R(11) R(12) R(13) R(14) R(15)                              \
57   R(16) R(17) R(18) R(19) R(20) R(21) R(22) R(23)                              \
58   R(24) R(25) R(26) R(27) R(28) R(29) R(30) R(31)
59 
60 // SVE loads and stores use "w" instead of "s" for word-sized accesses, so the
61 // mapping from the load/store variant to constants like k*RegSize is irregular.
62 #define VIXL_SVE_LOAD_STORE_VARIANT_LIST(V) \
63   V(b, B)                            \
64   V(h, H)                            \
65   V(w, S)                            \
66   V(d, D)
67 
68 // Sign-extending loads don't have double-word variants.
69 #define VIXL_SVE_LOAD_STORE_SIGNED_VARIANT_LIST(V) \
70   V(b, B)                            \
71   V(h, H)                            \
72   V(w, S)
73 
74 #define INSTRUCTION_FIELDS_LIST(V_)                                          \
75 /* Register fields */                                                        \
76 V_(Rd, 4, 0, ExtractBits)         /* Destination register.                */ \
77 V_(Rn, 9, 5, ExtractBits)         /* First source register.               */ \
78 V_(Rm, 20, 16, ExtractBits)       /* Second source register.              */ \
79 V_(RmLow16, 19, 16, ExtractBits)  /* Second source register (code 0-15).  */ \
80 V_(Ra, 14, 10, ExtractBits)       /* Third source register.               */ \
81 V_(Rt, 4, 0, ExtractBits)         /* Load/store register.                 */ \
82 V_(Rt2, 14, 10, ExtractBits)      /* Load/store second register.          */ \
83 V_(Rs, 20, 16, ExtractBits)       /* Exclusive access status.             */ \
84 V_(Pt, 3, 0, ExtractBits)         /* Load/store register (p0-p7).         */ \
85 V_(Pd, 3, 0, ExtractBits)         /* SVE destination predicate register.  */ \
86 V_(Pn, 8, 5, ExtractBits)         /* SVE first source predicate register. */ \
87 V_(Pm, 19, 16, ExtractBits)       /* SVE second source predicate register.*/ \
88 V_(PgLow8, 12, 10, ExtractBits)   /* Governing predicate (p0-p7).         */ \
89                                                                              \
90 /* Common bits */                                                            \
91 V_(SixtyFourBits, 31, 31, ExtractBits)                                       \
92 V_(FlagsUpdate, 29, 29, ExtractBits)                                         \
93                                                                              \
94 /* PC relative addressing */                                                 \
95 V_(ImmPCRelHi, 23, 5, ExtractSignedBits)                                     \
96 V_(ImmPCRelLo, 30, 29, ExtractBits)                                          \
97                                                                              \
98 /* Add/subtract/logical shift register */                                    \
99 V_(ShiftDP, 23, 22, ExtractBits)                                             \
100 V_(ImmDPShift, 15, 10, ExtractBits)                                          \
101                                                                              \
102 /* Add/subtract immediate */                                                 \
103 V_(ImmAddSub, 21, 10, ExtractBits)                                           \
104 V_(ImmAddSubShift, 22, 22, ExtractBits)                                      \
105                                                                              \
106 /* Add/substract extend */                                                   \
107 V_(ImmExtendShift, 12, 10, ExtractBits)                                      \
108 V_(ExtendMode, 15, 13, ExtractBits)                                          \
109                                                                              \
110 /* Move wide */                                                              \
111 V_(ImmMoveWide, 20, 5, ExtractBits)                                          \
112 V_(ShiftMoveWide, 22, 21, ExtractBits)                                       \
113                                                                              \
114 /* Logical immediate, bitfield and extract */                                \
115 V_(BitN, 22, 22, ExtractBits)                                                \
116 V_(ImmRotate, 21, 16, ExtractBits)                                           \
117 V_(ImmSetBits, 15, 10, ExtractBits)                                          \
118 V_(ImmR, 21, 16, ExtractBits)                                                \
119 V_(ImmS, 15, 10, ExtractBits)                                                \
120                                                                              \
121 /* Test and branch immediate */                                              \
122 V_(ImmTestBranch, 18, 5, ExtractSignedBits)                                  \
123 V_(ImmTestBranchBit40, 23, 19, ExtractBits)                                  \
124 V_(ImmTestBranchBit5, 31, 31, ExtractBits)                                   \
125                                                                              \
126 /* Conditionals */                                                           \
127 V_(Condition, 15, 12, ExtractBits)                                           \
128 V_(ConditionBranch, 3, 0, ExtractBits)                                       \
129 V_(Nzcv, 3, 0, ExtractBits)                                                  \
130 V_(ImmCondCmp, 20, 16, ExtractBits)                                          \
131 V_(ImmCondBranch, 23, 5, ExtractSignedBits)                                  \
132                                                                              \
133 /* Floating point */                                                         \
134 V_(FPType, 23, 22, ExtractBits)                                              \
135 V_(ImmFP, 20, 13, ExtractBits)                                               \
136 V_(FPScale, 15, 10, ExtractBits)                                             \
137                                                                              \
138 /* Load Store */                                                             \
139 V_(ImmLS, 20, 12, ExtractSignedBits)                                         \
140 V_(ImmLSUnsigned, 21, 10, ExtractBits)                                       \
141 V_(ImmLSPair, 21, 15, ExtractSignedBits)                                     \
142 V_(ImmShiftLS, 12, 12, ExtractBits)                                          \
143 V_(LSOpc, 23, 22, ExtractBits)                                               \
144 V_(LSVector, 26, 26, ExtractBits)                                            \
145 V_(LSSize, 31, 30, ExtractBits)                                              \
146 V_(ImmPrefetchOperation, 4, 0, ExtractBits)                                  \
147 V_(PrefetchHint, 4, 3, ExtractBits)                                          \
148 V_(PrefetchTarget, 2, 1, ExtractBits)                                        \
149 V_(PrefetchStream, 0, 0, ExtractBits)                                        \
150 V_(ImmLSPACHi, 22, 22, ExtractSignedBits)                                    \
151 V_(ImmLSPACLo, 20, 12, ExtractBits)                                          \
152                                                                              \
153 /* Other immediates */                                                       \
154 V_(ImmUncondBranch, 25, 0, ExtractSignedBits)                                \
155 V_(ImmCmpBranch, 23, 5, ExtractSignedBits)                                   \
156 V_(ImmLLiteral, 23, 5, ExtractSignedBits)                                    \
157 V_(ImmException, 20, 5, ExtractBits)                                         \
158 V_(ImmHint, 11, 5, ExtractBits)                                              \
159 V_(ImmBarrierDomain, 11, 10, ExtractBits)                                    \
160 V_(ImmBarrierType, 9, 8, ExtractBits)                                        \
161 V_(ImmUdf, 15, 0, ExtractBits)                                               \
162                                                                              \
163 /* System (MRS, MSR, SYS) */                                                 \
164 V_(ImmSystemRegister, 20, 5, ExtractBits)                                    \
165 V_(SysO0, 19, 19, ExtractBits)                                               \
166 V_(SysOp, 18, 5, ExtractBits)                                                \
167 V_(SysOp0, 20, 19, ExtractBits)                                              \
168 V_(SysOp1, 18, 16, ExtractBits)                                              \
169 V_(SysOp2, 7, 5, ExtractBits)                                                \
170 V_(CRn, 15, 12, ExtractBits)                                                 \
171 V_(CRm, 11, 8, ExtractBits)                                                  \
172 V_(ImmRMIFRotation, 20, 15, ExtractBits)                                     \
173                                                                              \
174 /* Load-/store-exclusive */                                                  \
175 V_(LdStXLoad, 22, 22, ExtractBits)                                           \
176 V_(LdStXNotExclusive, 23, 23, ExtractBits)                                   \
177 V_(LdStXAcquireRelease, 15, 15, ExtractBits)                                 \
178 V_(LdStXSizeLog2, 31, 30, ExtractBits)                                       \
179 V_(LdStXPair, 21, 21, ExtractBits)                                           \
180                                                                              \
181 /* NEON generic fields */                                                    \
182 V_(NEONQ, 30, 30, ExtractBits)                                               \
183 V_(NEONSize, 23, 22, ExtractBits)                                            \
184 V_(NEONLSSize, 11, 10, ExtractBits)                                          \
185 V_(NEONS, 12, 12, ExtractBits)                                               \
186 V_(NEONL, 21, 21, ExtractBits)                                               \
187 V_(NEONM, 20, 20, ExtractBits)                                               \
188 V_(NEONH, 11, 11, ExtractBits)                                               \
189 V_(ImmNEONExt, 14, 11, ExtractBits)                                          \
190 V_(ImmNEON5, 20, 16, ExtractBits)                                            \
191 V_(ImmNEON4, 14, 11, ExtractBits)                                            \
192                                                                              \
193 /* NEON extra fields */                                                      \
194 V_(ImmRotFcadd, 12, 12, ExtractBits)                                         \
195 V_(ImmRotFcmlaVec, 12, 11, ExtractBits)                                      \
196 V_(ImmRotFcmlaSca, 14, 13, ExtractBits)                                      \
197                                                                              \
198 /* NEON Modified Immediate fields */                                         \
199 V_(ImmNEONabc, 18, 16, ExtractBits)                                          \
200 V_(ImmNEONdefgh, 9, 5, ExtractBits)                                          \
201 V_(NEONModImmOp, 29, 29, ExtractBits)                                        \
202 V_(NEONCmode, 15, 12, ExtractBits)                                           \
203                                                                              \
204 /* NEON Shift Immediate fields */                                            \
205 V_(ImmNEONImmhImmb, 22, 16, ExtractBits)                                     \
206 V_(ImmNEONImmh, 22, 19, ExtractBits)                                         \
207 V_(ImmNEONImmb, 18, 16, ExtractBits)                                         \
208                                                                              \
209 /* SVE generic fields */                                                     \
210 V_(SVESize, 23, 22, ExtractBits)                                             \
211 V_(ImmSVEVLScale, 10, 5, ExtractSignedBits)                                  \
212 V_(ImmSVEIntWideSigned, 12, 5, ExtractSignedBits)                            \
213 V_(ImmSVEIntWideUnsigned, 12, 5, ExtractBits)                                \
214 V_(ImmSVEPredicateConstraint, 9, 5, ExtractBits)                             \
215                                                                              \
216 /* SVE Bitwise Immediate bitfield */                                         \
217 V_(SVEBitN, 17, 17, ExtractBits)                                             \
218 V_(SVEImmRotate, 16, 11, ExtractBits)                                        \
219 V_(SVEImmSetBits, 10, 5, ExtractBits)                                        \
220                                                                              \
221 V_(SVEImmPrefetchOperation, 3, 0, ExtractBits)                               \
222 V_(SVEPrefetchHint, 3, 3, ExtractBits)
223 
224 // clang-format on
225 
226 #define SYSTEM_REGISTER_FIELDS_LIST(V_, M_) \
227   /* NZCV */                                \
228   V_(Flags, 31, 28, ExtractBits)            \
229   V_(N, 31, 31, ExtractBits)                \
230   V_(Z, 30, 30, ExtractBits)                \
231   V_(C, 29, 29, ExtractBits)                \
232   V_(V, 28, 28, ExtractBits)                \
233   M_(NZCV, Flags_mask)                      \
234   /* FPCR */                                \
235   V_(AHP, 26, 26, ExtractBits)              \
236   V_(DN, 25, 25, ExtractBits)               \
237   V_(FZ, 24, 24, ExtractBits)               \
238   V_(RMode, 23, 22, ExtractBits)            \
239   M_(FPCR, AHP_mask | DN_mask | FZ_mask | RMode_mask)
240 
241 // Fields offsets.
242 #define DECLARE_FIELDS_OFFSETS(Name, HighBit, LowBit, X) \
243   const int Name##_offset = LowBit;                      \
244   const int Name##_width = HighBit - LowBit + 1;         \
245   const uint32_t Name##_mask = ((1 << Name##_width) - 1) << LowBit;
246 #define NOTHING(A, B)
247 INSTRUCTION_FIELDS_LIST(DECLARE_FIELDS_OFFSETS)
248 SYSTEM_REGISTER_FIELDS_LIST(DECLARE_FIELDS_OFFSETS, NOTHING)
249 #undef NOTHING
250 #undef DECLARE_FIELDS_BITS
251 
252 // ImmPCRel is a compound field (not present in INSTRUCTION_FIELDS_LIST), formed
253 // from ImmPCRelLo and ImmPCRelHi.
254 const int ImmPCRel_mask = ImmPCRelLo_mask | ImmPCRelHi_mask;
255 
256 // Disable `clang-format` for the `enum`s below. We care about the manual
257 // formatting that `clang-format` would destroy.
258 // clang-format off
259 
260 // Condition codes.
261 enum Condition {
262   eq = 0,   // Z set            Equal.
263   ne = 1,   // Z clear          Not equal.
264   cs = 2,   // C set            Carry set.
265   cc = 3,   // C clear          Carry clear.
266   mi = 4,   // N set            Negative.
267   pl = 5,   // N clear          Positive or zero.
268   vs = 6,   // V set            Overflow.
269   vc = 7,   // V clear          No overflow.
270   hi = 8,   // C set, Z clear   Unsigned higher.
271   ls = 9,   // C clear or Z set Unsigned lower or same.
272   ge = 10,  // N == V           Greater or equal.
273   lt = 11,  // N != V           Less than.
274   gt = 12,  // Z clear, N == V  Greater than.
275   le = 13,  // Z set or N != V  Less then or equal
276   al = 14,  //                  Always.
277   nv = 15,  // Behaves as always/al.
278 
279   // Aliases.
280   hs = cs,  // C set            Unsigned higher or same.
281   lo = cc,  // C clear          Unsigned lower.
282 
283   // Floating-point additional condition code.
284   uo,       // Unordered comparison.
285 
286   // SVE predicate condition aliases.
287   sve_none  = eq,  // No active elements were true.
288   sve_any   = ne,  // An active element was true.
289   sve_nlast = cs,  // The last element was not true.
290   sve_last  = cc,  // The last element was true.
291   sve_first = mi,  // The first element was true.
292   sve_nfrst = pl,  // The first element was not true.
293   sve_pmore = hi,  // An active element was true but not the last element.
294   sve_plast = ls,  // The last active element was true or no active elements were true.
295   sve_tcont = ge,  // CTERM termination condition not deleted.
296   sve_tstop = lt   // CTERM termination condition deleted.
297 };
298 
InvertCondition(Condition cond)299 inline Condition InvertCondition(Condition cond) {
300   // Conditions al and nv behave identically, as "always true". They can't be
301   // inverted, because there is no "always false" condition.
302   VIXL_ASSERT((cond != al) && (cond != nv));
303   return static_cast<Condition>(cond ^ 1);
304 }
305 
306 enum FPTrapFlags {
307   EnableTrap   = 1,
308   DisableTrap = 0
309 };
310 
311 enum FlagsUpdate {
312   SetFlags   = 1,
313   LeaveFlags = 0
314 };
315 
316 enum StatusFlags {
317   NoFlag    = 0,
318 
319   // Derive the flag combinations from the system register bit descriptions.
320   NFlag     = N_mask,
321   ZFlag     = Z_mask,
322   CFlag     = C_mask,
323   VFlag     = V_mask,
324   NZFlag    = NFlag | ZFlag,
325   NCFlag    = NFlag | CFlag,
326   NVFlag    = NFlag | VFlag,
327   ZCFlag    = ZFlag | CFlag,
328   ZVFlag    = ZFlag | VFlag,
329   CVFlag    = CFlag | VFlag,
330   NZCFlag   = NFlag | ZFlag | CFlag,
331   NZVFlag   = NFlag | ZFlag | VFlag,
332   NCVFlag   = NFlag | CFlag | VFlag,
333   ZCVFlag   = ZFlag | CFlag | VFlag,
334   NZCVFlag  = NFlag | ZFlag | CFlag | VFlag,
335 
336   // Floating-point comparison results.
337   FPEqualFlag       = ZCFlag,
338   FPLessThanFlag    = NFlag,
339   FPGreaterThanFlag = CFlag,
340   FPUnorderedFlag   = CVFlag,
341 
342   // SVE condition flags.
343   SVEFirstFlag   = NFlag,
344   SVENoneFlag    = ZFlag,
345   SVENotLastFlag = CFlag
346 };
347 
348 enum Shift {
349   NO_SHIFT = -1,
350   LSL = 0x0,
351   LSR = 0x1,
352   ASR = 0x2,
353   ROR = 0x3,
354   MSL = 0x4
355 };
356 
357 enum Extend {
358   NO_EXTEND = -1,
359   UXTB      = 0,
360   UXTH      = 1,
361   UXTW      = 2,
362   UXTX      = 3,
363   SXTB      = 4,
364   SXTH      = 5,
365   SXTW      = 6,
366   SXTX      = 7
367 };
368 
369 enum SVEOffsetModifier {
370   NO_SVE_OFFSET_MODIFIER,
371   // Multiply (each element of) the offset by either the vector or predicate
372   // length, according to the context.
373   SVE_MUL_VL,
374   // Shift or extend modifiers (as in `Shift` or `Extend`).
375   SVE_LSL,
376   SVE_UXTW,
377   SVE_SXTW
378 };
379 
380 enum SystemHint {
381   NOP    = 0,
382   YIELD  = 1,
383   WFE    = 2,
384   WFI    = 3,
385   SEV    = 4,
386   SEVL   = 5,
387   ESB    = 16,
388   CSDB   = 20,
389   BTI    = 32,
390   BTI_c  = 34,
391   BTI_j  = 36,
392   BTI_jc = 38
393 };
394 
395 enum BranchTargetIdentifier {
396   EmitBTI_none = NOP,
397   EmitBTI = BTI,
398   EmitBTI_c = BTI_c,
399   EmitBTI_j = BTI_j,
400   EmitBTI_jc = BTI_jc,
401 
402   // These correspond to the values of the CRm:op2 fields in the equivalent HINT
403   // instruction.
404   EmitPACIASP = 25,
405   EmitPACIBSP = 27
406 };
407 
408 enum BarrierDomain {
409   OuterShareable = 0,
410   NonShareable   = 1,
411   InnerShareable = 2,
412   FullSystem     = 3
413 };
414 
415 enum BarrierType {
416   BarrierOther  = 0,
417   BarrierReads  = 1,
418   BarrierWrites = 2,
419   BarrierAll    = 3
420 };
421 
422 enum PrefetchOperation {
423   PLDL1KEEP = 0x00,
424   PLDL1STRM = 0x01,
425   PLDL2KEEP = 0x02,
426   PLDL2STRM = 0x03,
427   PLDL3KEEP = 0x04,
428   PLDL3STRM = 0x05,
429 
430   PrfUnallocated06 = 0x06,
431   PrfUnallocated07 = 0x07,
432 
433   PLIL1KEEP = 0x08,
434   PLIL1STRM = 0x09,
435   PLIL2KEEP = 0x0a,
436   PLIL2STRM = 0x0b,
437   PLIL3KEEP = 0x0c,
438   PLIL3STRM = 0x0d,
439 
440   PrfUnallocated0e = 0x0e,
441   PrfUnallocated0f = 0x0f,
442 
443   PSTL1KEEP = 0x10,
444   PSTL1STRM = 0x11,
445   PSTL2KEEP = 0x12,
446   PSTL2STRM = 0x13,
447   PSTL3KEEP = 0x14,
448   PSTL3STRM = 0x15,
449 
450   PrfUnallocated16 = 0x16,
451   PrfUnallocated17 = 0x17,
452   PrfUnallocated18 = 0x18,
453   PrfUnallocated19 = 0x19,
454   PrfUnallocated1a = 0x1a,
455   PrfUnallocated1b = 0x1b,
456   PrfUnallocated1c = 0x1c,
457   PrfUnallocated1d = 0x1d,
458   PrfUnallocated1e = 0x1e,
459   PrfUnallocated1f = 0x1f,
460 };
461 
IsNamedPrefetchOperation(int op)462 constexpr bool IsNamedPrefetchOperation(int op) {
463   return ((op >= PLDL1KEEP) && (op <= PLDL3STRM)) ||
464       ((op >= PLIL1KEEP) && (op <= PLIL3STRM)) ||
465       ((op >= PSTL1KEEP) && (op <= PSTL3STRM));
466 }
467 
468 enum BType {
469   // Set when executing any instruction on a guarded page, except those cases
470   // listed below.
471   DefaultBType = 0,
472 
473   // Set when an indirect branch is taken from an unguarded page to a guarded
474   // page, or from a guarded page to ip0 or ip1 (x16 or x17), eg "br ip0".
475   BranchFromUnguardedOrToIP = 1,
476 
477   // Set when an indirect branch and link (call) is taken, eg. "blr x0".
478   BranchAndLink = 2,
479 
480   // Set when an indirect branch is taken from a guarded page to a register
481   // that is not ip0 or ip1 (x16 or x17), eg, "br x0".
482   BranchFromGuardedNotToIP = 3
483 };
484 
485 template<int op0, int op1, int crn, int crm, int op2>
486 class SystemRegisterEncoder {
487  public:
488   static const uint32_t value =
489       ((op0 << SysO0_offset) |
490        (op1 << SysOp1_offset) |
491        (crn << CRn_offset) |
492        (crm << CRm_offset) |
493        (op2 << SysOp2_offset)) >> ImmSystemRegister_offset;
494 };
495 
496 // System/special register names.
497 // This information is not encoded as one field but as the concatenation of
498 // multiple fields (Op0, Op1, Crn, Crm, Op2).
499 enum SystemRegister {
500   NZCV = SystemRegisterEncoder<3, 3, 4, 2, 0>::value,
501   FPCR = SystemRegisterEncoder<3, 3, 4, 4, 0>::value,
502   RNDR = SystemRegisterEncoder<3, 3, 2, 4, 0>::value,    // Random number.
503   RNDRRS = SystemRegisterEncoder<3, 3, 2, 4, 1>::value   // Reseeded random number.
504 };
505 
506 template<int op1, int crn, int crm, int op2>
507 class CacheOpEncoder {
508  public:
509   static const uint32_t value =
510       ((op1 << SysOp1_offset) |
511        (crn << CRn_offset) |
512        (crm << CRm_offset) |
513        (op2 << SysOp2_offset)) >> SysOp_offset;
514 };
515 
516 enum InstructionCacheOp {
517   IVAU = CacheOpEncoder<3, 7, 5, 1>::value
518 };
519 
520 enum DataCacheOp {
521   CVAC = CacheOpEncoder<3, 7, 10, 1>::value,
522   CVAU = CacheOpEncoder<3, 7, 11, 1>::value,
523   CVAP = CacheOpEncoder<3, 7, 12, 1>::value,
524   CVADP = CacheOpEncoder<3, 7, 13, 1>::value,
525   CIVAC = CacheOpEncoder<3, 7, 14, 1>::value,
526   ZVA = CacheOpEncoder<3, 7, 4, 1>::value
527 };
528 
529 // Some SVE instructions support a predicate constraint pattern. This is
530 // interpreted as a VL-dependent value, and is typically used to initialise
531 // predicates, or to otherwise limit the number of processed elements.
532 enum SVEPredicateConstraint {
533   // Select 2^N elements, for the largest possible N.
534   SVE_POW2 = 0x0,
535   // Each VL<N> selects exactly N elements if possible, or zero if N is greater
536   // than the number of elements. Note that the encoding values for VL<N> are
537   // not linearly related to N.
538   SVE_VL1 = 0x1,
539   SVE_VL2 = 0x2,
540   SVE_VL3 = 0x3,
541   SVE_VL4 = 0x4,
542   SVE_VL5 = 0x5,
543   SVE_VL6 = 0x6,
544   SVE_VL7 = 0x7,
545   SVE_VL8 = 0x8,
546   SVE_VL16 = 0x9,
547   SVE_VL32 = 0xa,
548   SVE_VL64 = 0xb,
549   SVE_VL128 = 0xc,
550   SVE_VL256 = 0xd,
551   // Each MUL<N> selects the largest multiple of N elements that the vector
552   // length supports. Note that for D-sized lanes, this can be zero.
553   SVE_MUL4 = 0x1d,
554   SVE_MUL3 = 0x1e,
555   // Select all elements.
556   SVE_ALL = 0x1f
557 };
558 
559 // Instruction enumerations.
560 //
561 // These are the masks that define a class of instructions, and the list of
562 // instructions within each class. Each enumeration has a Fixed, FMask and
563 // Mask value.
564 //
565 // Fixed: The fixed bits in this instruction class.
566 // FMask: The mask used to extract the fixed bits in the class.
567 // Mask:  The mask used to identify the instructions within a class.
568 //
569 // The enumerations can be used like this:
570 //
571 // VIXL_ASSERT(instr->Mask(PCRelAddressingFMask) == PCRelAddressingFixed);
572 // switch(instr->Mask(PCRelAddressingMask)) {
573 //   case ADR:  Format("adr 'Xd, 'AddrPCRelByte"); break;
574 //   case ADRP: Format("adrp 'Xd, 'AddrPCRelPage"); break;
575 //   default:   printf("Unknown instruction\n");
576 // }
577 
578 
579 // Generic fields.
580 enum GenericInstrField {
581   SixtyFourBits        = 0x80000000,
582   ThirtyTwoBits        = 0x00000000,
583 
584   FPTypeMask           = 0x00C00000,
585   FP16                 = 0x00C00000,
586   FP32                 = 0x00000000,
587   FP64                 = 0x00400000
588 };
589 
590 enum NEONFormatField {
591   NEONFormatFieldMask   = 0x40C00000,
592   NEON_Q                = 0x40000000,
593   NEON_8B               = 0x00000000,
594   NEON_16B              = NEON_8B | NEON_Q,
595   NEON_4H               = 0x00400000,
596   NEON_8H               = NEON_4H | NEON_Q,
597   NEON_2S               = 0x00800000,
598   NEON_4S               = NEON_2S | NEON_Q,
599   NEON_1D               = 0x00C00000,
600   NEON_2D               = 0x00C00000 | NEON_Q
601 };
602 
603 enum NEONFPFormatField {
604   NEONFPFormatFieldMask = 0x40400000,
605   NEON_FP_4H            = FP16,
606   NEON_FP_2S            = FP32,
607   NEON_FP_8H            = FP16 | NEON_Q,
608   NEON_FP_4S            = FP32 | NEON_Q,
609   NEON_FP_2D            = FP64 | NEON_Q
610 };
611 
612 enum NEONLSFormatField {
613   NEONLSFormatFieldMask = 0x40000C00,
614   LS_NEON_8B            = 0x00000000,
615   LS_NEON_16B           = LS_NEON_8B | NEON_Q,
616   LS_NEON_4H            = 0x00000400,
617   LS_NEON_8H            = LS_NEON_4H | NEON_Q,
618   LS_NEON_2S            = 0x00000800,
619   LS_NEON_4S            = LS_NEON_2S | NEON_Q,
620   LS_NEON_1D            = 0x00000C00,
621   LS_NEON_2D            = LS_NEON_1D | NEON_Q
622 };
623 
624 enum NEONScalarFormatField {
625   NEONScalarFormatFieldMask = 0x00C00000,
626   NEONScalar                = 0x10000000,
627   NEON_B                    = 0x00000000,
628   NEON_H                    = 0x00400000,
629   NEON_S                    = 0x00800000,
630   NEON_D                    = 0x00C00000
631 };
632 
633 enum SVESizeField {
634   SVESizeFieldMask = 0x00C00000,
635   SVE_B            = 0x00000000,
636   SVE_H            = 0x00400000,
637   SVE_S            = 0x00800000,
638   SVE_D            = 0x00C00000
639 };
640 
641 // PC relative addressing.
642 enum PCRelAddressingOp {
643   PCRelAddressingFixed = 0x10000000,
644   PCRelAddressingFMask = 0x1F000000,
645   PCRelAddressingMask  = 0x9F000000,
646   ADR                  = PCRelAddressingFixed | 0x00000000,
647   ADRP                 = PCRelAddressingFixed | 0x80000000
648 };
649 
650 // Add/sub (immediate, shifted and extended.)
651 const int kSFOffset = 31;
652 enum AddSubOp {
653   AddSubOpMask      = 0x60000000,
654   AddSubSetFlagsBit = 0x20000000,
655   ADD               = 0x00000000,
656   ADDS              = ADD | AddSubSetFlagsBit,
657   SUB               = 0x40000000,
658   SUBS              = SUB | AddSubSetFlagsBit
659 };
660 
661 #define ADD_SUB_OP_LIST(V)  \
662   V(ADD),                   \
663   V(ADDS),                  \
664   V(SUB),                   \
665   V(SUBS)
666 
667 enum AddSubImmediateOp {
668   AddSubImmediateFixed = 0x11000000,
669   AddSubImmediateFMask = 0x1F800000,
670   AddSubImmediateMask  = 0xFF800000,
671   #define ADD_SUB_IMMEDIATE(A)           \
672   A##_w_imm = AddSubImmediateFixed | A,  \
673   A##_x_imm = AddSubImmediateFixed | A | SixtyFourBits
674   ADD_SUB_OP_LIST(ADD_SUB_IMMEDIATE)
675   #undef ADD_SUB_IMMEDIATE
676 };
677 
678 enum AddSubShiftedOp {
679   AddSubShiftedFixed   = 0x0B000000,
680   AddSubShiftedFMask   = 0x1F200000,
681   AddSubShiftedMask    = 0xFF200000,
682   #define ADD_SUB_SHIFTED(A)             \
683   A##_w_shift = AddSubShiftedFixed | A,  \
684   A##_x_shift = AddSubShiftedFixed | A | SixtyFourBits
685   ADD_SUB_OP_LIST(ADD_SUB_SHIFTED)
686   #undef ADD_SUB_SHIFTED
687 };
688 
689 enum AddSubExtendedOp {
690   AddSubExtendedFixed  = 0x0B200000,
691   AddSubExtendedFMask  = 0x1F200000,
692   AddSubExtendedMask   = 0xFFE00000,
693   #define ADD_SUB_EXTENDED(A)           \
694   A##_w_ext = AddSubExtendedFixed | A,  \
695   A##_x_ext = AddSubExtendedFixed | A | SixtyFourBits
696   ADD_SUB_OP_LIST(ADD_SUB_EXTENDED)
697   #undef ADD_SUB_EXTENDED
698 };
699 
700 // Add/sub with carry.
701 enum AddSubWithCarryOp {
702   AddSubWithCarryFixed = 0x1A000000,
703   AddSubWithCarryFMask = 0x1FE00000,
704   AddSubWithCarryMask  = 0xFFE0FC00,
705   ADC_w                = AddSubWithCarryFixed | ADD,
706   ADC_x                = AddSubWithCarryFixed | ADD | SixtyFourBits,
707   ADC                  = ADC_w,
708   ADCS_w               = AddSubWithCarryFixed | ADDS,
709   ADCS_x               = AddSubWithCarryFixed | ADDS | SixtyFourBits,
710   SBC_w                = AddSubWithCarryFixed | SUB,
711   SBC_x                = AddSubWithCarryFixed | SUB | SixtyFourBits,
712   SBC                  = SBC_w,
713   SBCS_w               = AddSubWithCarryFixed | SUBS,
714   SBCS_x               = AddSubWithCarryFixed | SUBS | SixtyFourBits
715 };
716 
717 // Rotate right into flags.
718 enum RotateRightIntoFlagsOp {
719   RotateRightIntoFlagsFixed = 0x1A000400,
720   RotateRightIntoFlagsFMask = 0x1FE07C00,
721   RotateRightIntoFlagsMask  = 0xFFE07C10,
722   RMIF                      = RotateRightIntoFlagsFixed | 0xA0000000
723 };
724 
725 // Evaluate into flags.
726 enum EvaluateIntoFlagsOp {
727   EvaluateIntoFlagsFixed = 0x1A000800,
728   EvaluateIntoFlagsFMask = 0x1FE03C00,
729   EvaluateIntoFlagsMask  = 0xFFE07C1F,
730   SETF8                  = EvaluateIntoFlagsFixed | 0x2000000D,
731   SETF16                 = EvaluateIntoFlagsFixed | 0x2000400D
732 };
733 
734 
735 // Logical (immediate and shifted register).
736 enum LogicalOp {
737   LogicalOpMask = 0x60200000,
738   NOT   = 0x00200000,
739   AND   = 0x00000000,
740   BIC   = AND | NOT,
741   ORR   = 0x20000000,
742   ORN   = ORR | NOT,
743   EOR   = 0x40000000,
744   EON   = EOR | NOT,
745   ANDS  = 0x60000000,
746   BICS  = ANDS | NOT
747 };
748 
749 // Logical immediate.
750 enum LogicalImmediateOp {
751   LogicalImmediateFixed = 0x12000000,
752   LogicalImmediateFMask = 0x1F800000,
753   LogicalImmediateMask  = 0xFF800000,
754   AND_w_imm   = LogicalImmediateFixed | AND,
755   AND_x_imm   = LogicalImmediateFixed | AND | SixtyFourBits,
756   ORR_w_imm   = LogicalImmediateFixed | ORR,
757   ORR_x_imm   = LogicalImmediateFixed | ORR | SixtyFourBits,
758   EOR_w_imm   = LogicalImmediateFixed | EOR,
759   EOR_x_imm   = LogicalImmediateFixed | EOR | SixtyFourBits,
760   ANDS_w_imm  = LogicalImmediateFixed | ANDS,
761   ANDS_x_imm  = LogicalImmediateFixed | ANDS | SixtyFourBits
762 };
763 
764 // Logical shifted register.
765 enum LogicalShiftedOp {
766   LogicalShiftedFixed = 0x0A000000,
767   LogicalShiftedFMask = 0x1F000000,
768   LogicalShiftedMask  = 0xFF200000,
769   AND_w               = LogicalShiftedFixed | AND,
770   AND_x               = LogicalShiftedFixed | AND | SixtyFourBits,
771   AND_shift           = AND_w,
772   BIC_w               = LogicalShiftedFixed | BIC,
773   BIC_x               = LogicalShiftedFixed | BIC | SixtyFourBits,
774   BIC_shift           = BIC_w,
775   ORR_w               = LogicalShiftedFixed | ORR,
776   ORR_x               = LogicalShiftedFixed | ORR | SixtyFourBits,
777   ORR_shift           = ORR_w,
778   ORN_w               = LogicalShiftedFixed | ORN,
779   ORN_x               = LogicalShiftedFixed | ORN | SixtyFourBits,
780   ORN_shift           = ORN_w,
781   EOR_w               = LogicalShiftedFixed | EOR,
782   EOR_x               = LogicalShiftedFixed | EOR | SixtyFourBits,
783   EOR_shift           = EOR_w,
784   EON_w               = LogicalShiftedFixed | EON,
785   EON_x               = LogicalShiftedFixed | EON | SixtyFourBits,
786   EON_shift           = EON_w,
787   ANDS_w              = LogicalShiftedFixed | ANDS,
788   ANDS_x              = LogicalShiftedFixed | ANDS | SixtyFourBits,
789   ANDS_shift          = ANDS_w,
790   BICS_w              = LogicalShiftedFixed | BICS,
791   BICS_x              = LogicalShiftedFixed | BICS | SixtyFourBits,
792   BICS_shift          = BICS_w
793 };
794 
795 // Move wide immediate.
796 enum MoveWideImmediateOp {
797   MoveWideImmediateFixed = 0x12800000,
798   MoveWideImmediateFMask = 0x1F800000,
799   MoveWideImmediateMask  = 0xFF800000,
800   MOVN                   = 0x00000000,
801   MOVZ                   = 0x40000000,
802   MOVK                   = 0x60000000,
803   MOVN_w                 = MoveWideImmediateFixed | MOVN,
804   MOVN_x                 = MoveWideImmediateFixed | MOVN | SixtyFourBits,
805   MOVZ_w                 = MoveWideImmediateFixed | MOVZ,
806   MOVZ_x                 = MoveWideImmediateFixed | MOVZ | SixtyFourBits,
807   MOVK_w                 = MoveWideImmediateFixed | MOVK,
808   MOVK_x                 = MoveWideImmediateFixed | MOVK | SixtyFourBits
809 };
810 
811 // Bitfield.
812 const int kBitfieldNOffset = 22;
813 enum BitfieldOp {
814   BitfieldFixed = 0x13000000,
815   BitfieldFMask = 0x1F800000,
816   BitfieldMask  = 0xFF800000,
817   SBFM_w        = BitfieldFixed | 0x00000000,
818   SBFM_x        = BitfieldFixed | 0x80000000,
819   SBFM          = SBFM_w,
820   BFM_w         = BitfieldFixed | 0x20000000,
821   BFM_x         = BitfieldFixed | 0xA0000000,
822   BFM           = BFM_w,
823   UBFM_w        = BitfieldFixed | 0x40000000,
824   UBFM_x        = BitfieldFixed | 0xC0000000,
825   UBFM          = UBFM_w
826   // Bitfield N field.
827 };
828 
829 // Extract.
830 enum ExtractOp {
831   ExtractFixed = 0x13800000,
832   ExtractFMask = 0x1F800000,
833   ExtractMask  = 0xFFA00000,
834   EXTR_w       = ExtractFixed | 0x00000000,
835   EXTR_x       = ExtractFixed | 0x80000000,
836   EXTR         = EXTR_w
837 };
838 
839 // Unconditional branch.
840 enum UnconditionalBranchOp {
841   UnconditionalBranchFixed = 0x14000000,
842   UnconditionalBranchFMask = 0x7C000000,
843   UnconditionalBranchMask  = 0xFC000000,
844   B                        = UnconditionalBranchFixed | 0x00000000,
845   BL                       = UnconditionalBranchFixed | 0x80000000
846 };
847 
848 // Unconditional branch to register.
849 enum UnconditionalBranchToRegisterOp {
850   UnconditionalBranchToRegisterFixed = 0xD6000000,
851   UnconditionalBranchToRegisterFMask = 0xFE000000,
852   UnconditionalBranchToRegisterMask  = 0xFFFFFC00,
853   BR      = UnconditionalBranchToRegisterFixed | 0x001F0000,
854   BLR     = UnconditionalBranchToRegisterFixed | 0x003F0000,
855   RET     = UnconditionalBranchToRegisterFixed | 0x005F0000,
856 
857   BRAAZ  = UnconditionalBranchToRegisterFixed | 0x001F0800,
858   BRABZ  = UnconditionalBranchToRegisterFixed | 0x001F0C00,
859   BLRAAZ = UnconditionalBranchToRegisterFixed | 0x003F0800,
860   BLRABZ = UnconditionalBranchToRegisterFixed | 0x003F0C00,
861   RETAA  = UnconditionalBranchToRegisterFixed | 0x005F0800,
862   RETAB  = UnconditionalBranchToRegisterFixed | 0x005F0C00,
863   BRAA   = UnconditionalBranchToRegisterFixed | 0x011F0800,
864   BRAB   = UnconditionalBranchToRegisterFixed | 0x011F0C00,
865   BLRAA  = UnconditionalBranchToRegisterFixed | 0x013F0800,
866   BLRAB  = UnconditionalBranchToRegisterFixed | 0x013F0C00
867 };
868 
869 // Compare and branch.
870 enum CompareBranchOp {
871   CompareBranchFixed = 0x34000000,
872   CompareBranchFMask = 0x7E000000,
873   CompareBranchMask  = 0xFF000000,
874   CBZ_w              = CompareBranchFixed | 0x00000000,
875   CBZ_x              = CompareBranchFixed | 0x80000000,
876   CBZ                = CBZ_w,
877   CBNZ_w             = CompareBranchFixed | 0x01000000,
878   CBNZ_x             = CompareBranchFixed | 0x81000000,
879   CBNZ               = CBNZ_w
880 };
881 
882 // Test and branch.
883 enum TestBranchOp {
884   TestBranchFixed = 0x36000000,
885   TestBranchFMask = 0x7E000000,
886   TestBranchMask  = 0x7F000000,
887   TBZ             = TestBranchFixed | 0x00000000,
888   TBNZ            = TestBranchFixed | 0x01000000
889 };
890 
891 // Conditional branch.
892 enum ConditionalBranchOp {
893   ConditionalBranchFixed = 0x54000000,
894   ConditionalBranchFMask = 0xFE000000,
895   ConditionalBranchMask  = 0xFF000010,
896   B_cond                 = ConditionalBranchFixed | 0x00000000
897 };
898 
899 // System.
900 // System instruction encoding is complicated because some instructions use op
901 // and CR fields to encode parameters. To handle this cleanly, the system
902 // instructions are split into more than one enum.
903 
904 enum SystemOp {
905   SystemFixed = 0xD5000000,
906   SystemFMask = 0xFFC00000
907 };
908 
909 enum SystemSysRegOp {
910   SystemSysRegFixed = 0xD5100000,
911   SystemSysRegFMask = 0xFFD00000,
912   SystemSysRegMask  = 0xFFF00000,
913   MRS               = SystemSysRegFixed | 0x00200000,
914   MSR               = SystemSysRegFixed | 0x00000000
915 };
916 
917 enum SystemPStateOp {
918   SystemPStateFixed = 0xD5004000,
919   SystemPStateFMask = 0xFFF8F000,
920   SystemPStateMask  = 0xFFFFF0FF,
921   CFINV             = SystemPStateFixed | 0x0000001F,
922   XAFLAG            = SystemPStateFixed | 0x0000003F,
923   AXFLAG            = SystemPStateFixed | 0x0000005F
924 };
925 
926 enum SystemHintOp {
927   SystemHintFixed = 0xD503201F,
928   SystemHintFMask = 0xFFFFF01F,
929   SystemHintMask  = 0xFFFFF01F,
930   HINT            = SystemHintFixed | 0x00000000
931 };
932 
933 enum SystemSysOp {
934   SystemSysFixed  = 0xD5080000,
935   SystemSysFMask  = 0xFFF80000,
936   SystemSysMask   = 0xFFF80000,
937   SYS             = SystemSysFixed | 0x00000000
938 };
939 
940 // Exception.
941 enum ExceptionOp {
942   ExceptionFixed = 0xD4000000,
943   ExceptionFMask = 0xFF000000,
944   ExceptionMask  = 0xFFE0001F,
945   HLT            = ExceptionFixed | 0x00400000,
946   BRK            = ExceptionFixed | 0x00200000,
947   SVC            = ExceptionFixed | 0x00000001,
948   HVC            = ExceptionFixed | 0x00000002,
949   SMC            = ExceptionFixed | 0x00000003,
950   DCPS1          = ExceptionFixed | 0x00A00001,
951   DCPS2          = ExceptionFixed | 0x00A00002,
952   DCPS3          = ExceptionFixed | 0x00A00003
953 };
954 
955 enum MemBarrierOp {
956   MemBarrierFixed = 0xD503309F,
957   MemBarrierFMask = 0xFFFFF09F,
958   MemBarrierMask  = 0xFFFFF0FF,
959   DSB             = MemBarrierFixed | 0x00000000,
960   DMB             = MemBarrierFixed | 0x00000020,
961   ISB             = MemBarrierFixed | 0x00000040
962 };
963 
964 enum SystemExclusiveMonitorOp {
965   SystemExclusiveMonitorFixed = 0xD503305F,
966   SystemExclusiveMonitorFMask = 0xFFFFF0FF,
967   SystemExclusiveMonitorMask  = 0xFFFFF0FF,
968   CLREX                       = SystemExclusiveMonitorFixed
969 };
970 
971 enum SystemPAuthOp {
972   SystemPAuthFixed = 0xD503211F,
973   SystemPAuthFMask = 0xFFFFFD1F,
974   SystemPAuthMask  = 0xFFFFFFFF,
975   PACIA1716 = SystemPAuthFixed | 0x00000100,
976   PACIB1716 = SystemPAuthFixed | 0x00000140,
977   AUTIA1716 = SystemPAuthFixed | 0x00000180,
978   AUTIB1716 = SystemPAuthFixed | 0x000001C0,
979   PACIAZ    = SystemPAuthFixed | 0x00000300,
980   PACIASP   = SystemPAuthFixed | 0x00000320,
981   PACIBZ    = SystemPAuthFixed | 0x00000340,
982   PACIBSP   = SystemPAuthFixed | 0x00000360,
983   AUTIAZ    = SystemPAuthFixed | 0x00000380,
984   AUTIASP   = SystemPAuthFixed | 0x000003A0,
985   AUTIBZ    = SystemPAuthFixed | 0x000003C0,
986   AUTIBSP   = SystemPAuthFixed | 0x000003E0,
987 
988   // XPACLRI has the same fixed mask as System Hints and needs to be handled
989   // differently.
990   XPACLRI   = 0xD50320FF
991 };
992 
993 // Any load or store.
994 enum LoadStoreAnyOp {
995   LoadStoreAnyFMask = 0x0a000000,
996   LoadStoreAnyFixed = 0x08000000
997 };
998 
999 // Any load pair or store pair.
1000 enum LoadStorePairAnyOp {
1001   LoadStorePairAnyFMask = 0x3a000000,
1002   LoadStorePairAnyFixed = 0x28000000
1003 };
1004 
1005 #define LOAD_STORE_PAIR_OP_LIST(V)  \
1006   V(STP, w,   0x00000000),          \
1007   V(LDP, w,   0x00400000),          \
1008   V(LDPSW, x, 0x40400000),          \
1009   V(STP, x,   0x80000000),          \
1010   V(LDP, x,   0x80400000),          \
1011   V(STP, s,   0x04000000),          \
1012   V(LDP, s,   0x04400000),          \
1013   V(STP, d,   0x44000000),          \
1014   V(LDP, d,   0x44400000),          \
1015   V(STP, q,   0x84000000),          \
1016   V(LDP, q,   0x84400000)
1017 
1018 // Load/store pair (post, pre and offset.)
1019 enum LoadStorePairOp {
1020   LoadStorePairMask = 0xC4400000,
1021   LoadStorePairLBit = 1 << 22,
1022   #define LOAD_STORE_PAIR(A, B, C) \
1023   A##_##B = C
1024   LOAD_STORE_PAIR_OP_LIST(LOAD_STORE_PAIR)
1025   #undef LOAD_STORE_PAIR
1026 };
1027 
1028 enum LoadStorePairPostIndexOp {
1029   LoadStorePairPostIndexFixed = 0x28800000,
1030   LoadStorePairPostIndexFMask = 0x3B800000,
1031   LoadStorePairPostIndexMask  = 0xFFC00000,
1032   #define LOAD_STORE_PAIR_POST_INDEX(A, B, C)  \
1033   A##_##B##_post = LoadStorePairPostIndexFixed | A##_##B
1034   LOAD_STORE_PAIR_OP_LIST(LOAD_STORE_PAIR_POST_INDEX)
1035   #undef LOAD_STORE_PAIR_POST_INDEX
1036 };
1037 
1038 enum LoadStorePairPreIndexOp {
1039   LoadStorePairPreIndexFixed = 0x29800000,
1040   LoadStorePairPreIndexFMask = 0x3B800000,
1041   LoadStorePairPreIndexMask  = 0xFFC00000,
1042   #define LOAD_STORE_PAIR_PRE_INDEX(A, B, C)  \
1043   A##_##B##_pre = LoadStorePairPreIndexFixed | A##_##B
1044   LOAD_STORE_PAIR_OP_LIST(LOAD_STORE_PAIR_PRE_INDEX)
1045   #undef LOAD_STORE_PAIR_PRE_INDEX
1046 };
1047 
1048 enum LoadStorePairOffsetOp {
1049   LoadStorePairOffsetFixed = 0x29000000,
1050   LoadStorePairOffsetFMask = 0x3B800000,
1051   LoadStorePairOffsetMask  = 0xFFC00000,
1052   #define LOAD_STORE_PAIR_OFFSET(A, B, C)  \
1053   A##_##B##_off = LoadStorePairOffsetFixed | A##_##B
1054   LOAD_STORE_PAIR_OP_LIST(LOAD_STORE_PAIR_OFFSET)
1055   #undef LOAD_STORE_PAIR_OFFSET
1056 };
1057 
1058 enum LoadStorePairNonTemporalOp {
1059   LoadStorePairNonTemporalFixed = 0x28000000,
1060   LoadStorePairNonTemporalFMask = 0x3B800000,
1061   LoadStorePairNonTemporalMask  = 0xFFC00000,
1062   LoadStorePairNonTemporalLBit = 1 << 22,
1063   STNP_w = LoadStorePairNonTemporalFixed | STP_w,
1064   LDNP_w = LoadStorePairNonTemporalFixed | LDP_w,
1065   STNP_x = LoadStorePairNonTemporalFixed | STP_x,
1066   LDNP_x = LoadStorePairNonTemporalFixed | LDP_x,
1067   STNP_s = LoadStorePairNonTemporalFixed | STP_s,
1068   LDNP_s = LoadStorePairNonTemporalFixed | LDP_s,
1069   STNP_d = LoadStorePairNonTemporalFixed | STP_d,
1070   LDNP_d = LoadStorePairNonTemporalFixed | LDP_d,
1071   STNP_q = LoadStorePairNonTemporalFixed | STP_q,
1072   LDNP_q = LoadStorePairNonTemporalFixed | LDP_q
1073 };
1074 
1075 // Load with pointer authentication.
1076 enum LoadStorePACOp {
1077   LoadStorePACFixed  = 0xF8200400,
1078   LoadStorePACFMask  = 0xFF200400,
1079   LoadStorePACMask   = 0xFFA00C00,
1080   LoadStorePACPreBit = 0x00000800,
1081   LDRAA     = LoadStorePACFixed | 0x00000000,
1082   LDRAA_pre = LoadStorePACPreBit | LDRAA,
1083   LDRAB     = LoadStorePACFixed | 0x00800000,
1084   LDRAB_pre = LoadStorePACPreBit | LDRAB
1085 };
1086 
1087 // Load literal.
1088 enum LoadLiteralOp {
1089   LoadLiteralFixed = 0x18000000,
1090   LoadLiteralFMask = 0x3B000000,
1091   LoadLiteralMask  = 0xFF000000,
1092   LDR_w_lit        = LoadLiteralFixed | 0x00000000,
1093   LDR_x_lit        = LoadLiteralFixed | 0x40000000,
1094   LDRSW_x_lit      = LoadLiteralFixed | 0x80000000,
1095   PRFM_lit         = LoadLiteralFixed | 0xC0000000,
1096   LDR_s_lit        = LoadLiteralFixed | 0x04000000,
1097   LDR_d_lit        = LoadLiteralFixed | 0x44000000,
1098   LDR_q_lit        = LoadLiteralFixed | 0x84000000
1099 };
1100 
1101 #define LOAD_STORE_OP_LIST(V)     \
1102   V(ST, RB, w,  0x00000000),  \
1103   V(ST, RH, w,  0x40000000),  \
1104   V(ST, R, w,   0x80000000),  \
1105   V(ST, R, x,   0xC0000000),  \
1106   V(LD, RB, w,  0x00400000),  \
1107   V(LD, RH, w,  0x40400000),  \
1108   V(LD, R, w,   0x80400000),  \
1109   V(LD, R, x,   0xC0400000),  \
1110   V(LD, RSB, x, 0x00800000),  \
1111   V(LD, RSH, x, 0x40800000),  \
1112   V(LD, RSW, x, 0x80800000),  \
1113   V(LD, RSB, w, 0x00C00000),  \
1114   V(LD, RSH, w, 0x40C00000),  \
1115   V(ST, R, b,   0x04000000),  \
1116   V(ST, R, h,   0x44000000),  \
1117   V(ST, R, s,   0x84000000),  \
1118   V(ST, R, d,   0xC4000000),  \
1119   V(ST, R, q,   0x04800000),  \
1120   V(LD, R, b,   0x04400000),  \
1121   V(LD, R, h,   0x44400000),  \
1122   V(LD, R, s,   0x84400000),  \
1123   V(LD, R, d,   0xC4400000),  \
1124   V(LD, R, q,   0x04C00000)
1125 
1126 // Load/store (post, pre, offset and unsigned.)
1127 enum LoadStoreOp {
1128   LoadStoreMask = 0xC4C00000,
1129   LoadStoreVMask = 0x04000000,
1130   #define LOAD_STORE(A, B, C, D)  \
1131   A##B##_##C = D
1132   LOAD_STORE_OP_LIST(LOAD_STORE),
1133   #undef LOAD_STORE
1134   PRFM = 0xC0800000
1135 };
1136 
1137 // Load/store unscaled offset.
1138 enum LoadStoreUnscaledOffsetOp {
1139   LoadStoreUnscaledOffsetFixed = 0x38000000,
1140   LoadStoreUnscaledOffsetFMask = 0x3B200C00,
1141   LoadStoreUnscaledOffsetMask  = 0xFFE00C00,
1142   PRFUM                        = LoadStoreUnscaledOffsetFixed | PRFM,
1143   #define LOAD_STORE_UNSCALED(A, B, C, D)  \
1144   A##U##B##_##C = LoadStoreUnscaledOffsetFixed | D
1145   LOAD_STORE_OP_LIST(LOAD_STORE_UNSCALED)
1146   #undef LOAD_STORE_UNSCALED
1147 };
1148 
1149 // Load/store post index.
1150 enum LoadStorePostIndex {
1151   LoadStorePostIndexFixed = 0x38000400,
1152   LoadStorePostIndexFMask = 0x3B200C00,
1153   LoadStorePostIndexMask  = 0xFFE00C00,
1154   #define LOAD_STORE_POST_INDEX(A, B, C, D)  \
1155   A##B##_##C##_post = LoadStorePostIndexFixed | D
1156   LOAD_STORE_OP_LIST(LOAD_STORE_POST_INDEX)
1157   #undef LOAD_STORE_POST_INDEX
1158 };
1159 
1160 // Load/store pre index.
1161 enum LoadStorePreIndex {
1162   LoadStorePreIndexFixed = 0x38000C00,
1163   LoadStorePreIndexFMask = 0x3B200C00,
1164   LoadStorePreIndexMask  = 0xFFE00C00,
1165   #define LOAD_STORE_PRE_INDEX(A, B, C, D)  \
1166   A##B##_##C##_pre = LoadStorePreIndexFixed | D
1167   LOAD_STORE_OP_LIST(LOAD_STORE_PRE_INDEX)
1168   #undef LOAD_STORE_PRE_INDEX
1169 };
1170 
1171 // Load/store unsigned offset.
1172 enum LoadStoreUnsignedOffset {
1173   LoadStoreUnsignedOffsetFixed = 0x39000000,
1174   LoadStoreUnsignedOffsetFMask = 0x3B000000,
1175   LoadStoreUnsignedOffsetMask  = 0xFFC00000,
1176   PRFM_unsigned                = LoadStoreUnsignedOffsetFixed | PRFM,
1177   #define LOAD_STORE_UNSIGNED_OFFSET(A, B, C, D) \
1178   A##B##_##C##_unsigned = LoadStoreUnsignedOffsetFixed | D
1179   LOAD_STORE_OP_LIST(LOAD_STORE_UNSIGNED_OFFSET)
1180   #undef LOAD_STORE_UNSIGNED_OFFSET
1181 };
1182 
1183 // Load/store register offset.
1184 enum LoadStoreRegisterOffset {
1185   LoadStoreRegisterOffsetFixed = 0x38200800,
1186   LoadStoreRegisterOffsetFMask = 0x3B200C00,
1187   LoadStoreRegisterOffsetMask  = 0xFFE00C00,
1188   PRFM_reg                     = LoadStoreRegisterOffsetFixed | PRFM,
1189   #define LOAD_STORE_REGISTER_OFFSET(A, B, C, D) \
1190   A##B##_##C##_reg = LoadStoreRegisterOffsetFixed | D
1191   LOAD_STORE_OP_LIST(LOAD_STORE_REGISTER_OFFSET)
1192   #undef LOAD_STORE_REGISTER_OFFSET
1193 };
1194 
1195 enum LoadStoreExclusive {
1196   LoadStoreExclusiveFixed = 0x08000000,
1197   LoadStoreExclusiveFMask = 0x3F000000,
1198   LoadStoreExclusiveMask  = 0xFFE08000,
1199   STXRB_w  = LoadStoreExclusiveFixed | 0x00000000,
1200   STXRH_w  = LoadStoreExclusiveFixed | 0x40000000,
1201   STXR_w   = LoadStoreExclusiveFixed | 0x80000000,
1202   STXR_x   = LoadStoreExclusiveFixed | 0xC0000000,
1203   LDXRB_w  = LoadStoreExclusiveFixed | 0x00400000,
1204   LDXRH_w  = LoadStoreExclusiveFixed | 0x40400000,
1205   LDXR_w   = LoadStoreExclusiveFixed | 0x80400000,
1206   LDXR_x   = LoadStoreExclusiveFixed | 0xC0400000,
1207   STXP_w   = LoadStoreExclusiveFixed | 0x80200000,
1208   STXP_x   = LoadStoreExclusiveFixed | 0xC0200000,
1209   LDXP_w   = LoadStoreExclusiveFixed | 0x80600000,
1210   LDXP_x   = LoadStoreExclusiveFixed | 0xC0600000,
1211   STLXRB_w = LoadStoreExclusiveFixed | 0x00008000,
1212   STLXRH_w = LoadStoreExclusiveFixed | 0x40008000,
1213   STLXR_w  = LoadStoreExclusiveFixed | 0x80008000,
1214   STLXR_x  = LoadStoreExclusiveFixed | 0xC0008000,
1215   LDAXRB_w = LoadStoreExclusiveFixed | 0x00408000,
1216   LDAXRH_w = LoadStoreExclusiveFixed | 0x40408000,
1217   LDAXR_w  = LoadStoreExclusiveFixed | 0x80408000,
1218   LDAXR_x  = LoadStoreExclusiveFixed | 0xC0408000,
1219   STLXP_w  = LoadStoreExclusiveFixed | 0x80208000,
1220   STLXP_x  = LoadStoreExclusiveFixed | 0xC0208000,
1221   LDAXP_w  = LoadStoreExclusiveFixed | 0x80608000,
1222   LDAXP_x  = LoadStoreExclusiveFixed | 0xC0608000,
1223   STLRB_w  = LoadStoreExclusiveFixed | 0x00808000,
1224   STLRH_w  = LoadStoreExclusiveFixed | 0x40808000,
1225   STLR_w   = LoadStoreExclusiveFixed | 0x80808000,
1226   STLR_x   = LoadStoreExclusiveFixed | 0xC0808000,
1227   LDARB_w  = LoadStoreExclusiveFixed | 0x00C08000,
1228   LDARH_w  = LoadStoreExclusiveFixed | 0x40C08000,
1229   LDAR_w   = LoadStoreExclusiveFixed | 0x80C08000,
1230   LDAR_x   = LoadStoreExclusiveFixed | 0xC0C08000,
1231 
1232   // v8.1 Load/store LORegion ops
1233   STLLRB   = LoadStoreExclusiveFixed | 0x00800000,
1234   LDLARB   = LoadStoreExclusiveFixed | 0x00C00000,
1235   STLLRH   = LoadStoreExclusiveFixed | 0x40800000,
1236   LDLARH   = LoadStoreExclusiveFixed | 0x40C00000,
1237   STLLR_w  = LoadStoreExclusiveFixed | 0x80800000,
1238   LDLAR_w  = LoadStoreExclusiveFixed | 0x80C00000,
1239   STLLR_x  = LoadStoreExclusiveFixed | 0xC0800000,
1240   LDLAR_x  = LoadStoreExclusiveFixed | 0xC0C00000,
1241 
1242   // v8.1 Load/store exclusive ops
1243   LSEBit_l  = 0x00400000,
1244   LSEBit_o0 = 0x00008000,
1245   LSEBit_sz = 0x40000000,
1246   CASFixed  = LoadStoreExclusiveFixed | 0x80A00000,
1247   CASBFixed = LoadStoreExclusiveFixed | 0x00A00000,
1248   CASHFixed = LoadStoreExclusiveFixed | 0x40A00000,
1249   CASPFixed = LoadStoreExclusiveFixed | 0x00200000,
1250   CAS_w    = CASFixed,
1251   CAS_x    = CASFixed | LSEBit_sz,
1252   CASA_w   = CASFixed | LSEBit_l,
1253   CASA_x   = CASFixed | LSEBit_l | LSEBit_sz,
1254   CASL_w   = CASFixed | LSEBit_o0,
1255   CASL_x   = CASFixed | LSEBit_o0 | LSEBit_sz,
1256   CASAL_w  = CASFixed | LSEBit_l | LSEBit_o0,
1257   CASAL_x  = CASFixed | LSEBit_l | LSEBit_o0 | LSEBit_sz,
1258   CASB     = CASBFixed,
1259   CASAB    = CASBFixed | LSEBit_l,
1260   CASLB    = CASBFixed | LSEBit_o0,
1261   CASALB   = CASBFixed | LSEBit_l | LSEBit_o0,
1262   CASH     = CASHFixed,
1263   CASAH    = CASHFixed | LSEBit_l,
1264   CASLH    = CASHFixed | LSEBit_o0,
1265   CASALH   = CASHFixed | LSEBit_l | LSEBit_o0,
1266   CASP_w   = CASPFixed,
1267   CASP_x   = CASPFixed | LSEBit_sz,
1268   CASPA_w  = CASPFixed | LSEBit_l,
1269   CASPA_x  = CASPFixed | LSEBit_l | LSEBit_sz,
1270   CASPL_w  = CASPFixed | LSEBit_o0,
1271   CASPL_x  = CASPFixed | LSEBit_o0 | LSEBit_sz,
1272   CASPAL_w = CASPFixed | LSEBit_l | LSEBit_o0,
1273   CASPAL_x = CASPFixed | LSEBit_l | LSEBit_o0 | LSEBit_sz
1274 };
1275 
1276 // Load/store RCpc unscaled offset.
1277 enum LoadStoreRCpcUnscaledOffsetOp {
1278   LoadStoreRCpcUnscaledOffsetFixed = 0x19000000,
1279   LoadStoreRCpcUnscaledOffsetFMask = 0x3F200C00,
1280   LoadStoreRCpcUnscaledOffsetMask  = 0xFFE00C00,
1281   STLURB     = LoadStoreRCpcUnscaledOffsetFixed | 0x00000000,
1282   LDAPURB    = LoadStoreRCpcUnscaledOffsetFixed | 0x00400000,
1283   LDAPURSB_x = LoadStoreRCpcUnscaledOffsetFixed | 0x00800000,
1284   LDAPURSB_w = LoadStoreRCpcUnscaledOffsetFixed | 0x00C00000,
1285   STLURH     = LoadStoreRCpcUnscaledOffsetFixed | 0x40000000,
1286   LDAPURH    = LoadStoreRCpcUnscaledOffsetFixed | 0x40400000,
1287   LDAPURSH_x = LoadStoreRCpcUnscaledOffsetFixed | 0x40800000,
1288   LDAPURSH_w = LoadStoreRCpcUnscaledOffsetFixed | 0x40C00000,
1289   STLUR_w    = LoadStoreRCpcUnscaledOffsetFixed | 0x80000000,
1290   LDAPUR_w   = LoadStoreRCpcUnscaledOffsetFixed | 0x80400000,
1291   LDAPURSW   = LoadStoreRCpcUnscaledOffsetFixed | 0x80800000,
1292   STLUR_x    = LoadStoreRCpcUnscaledOffsetFixed | 0xC0000000,
1293   LDAPUR_x   = LoadStoreRCpcUnscaledOffsetFixed | 0xC0400000
1294 };
1295 
1296 #define ATOMIC_MEMORY_SIMPLE_OPC_LIST(V) \
1297   V(LDADD, 0x00000000),                  \
1298   V(LDCLR, 0x00001000),                  \
1299   V(LDEOR, 0x00002000),                  \
1300   V(LDSET, 0x00003000),                  \
1301   V(LDSMAX, 0x00004000),                 \
1302   V(LDSMIN, 0x00005000),                 \
1303   V(LDUMAX, 0x00006000),                 \
1304   V(LDUMIN, 0x00007000)
1305 
1306 // Atomic memory.
1307 enum AtomicMemoryOp {
1308   AtomicMemoryFixed = 0x38200000,
1309   AtomicMemoryFMask = 0x3B200C00,
1310   AtomicMemoryMask = 0xFFE0FC00,
1311   SWPB = AtomicMemoryFixed | 0x00008000,
1312   SWPAB = AtomicMemoryFixed | 0x00808000,
1313   SWPLB = AtomicMemoryFixed | 0x00408000,
1314   SWPALB = AtomicMemoryFixed | 0x00C08000,
1315   SWPH = AtomicMemoryFixed | 0x40008000,
1316   SWPAH = AtomicMemoryFixed | 0x40808000,
1317   SWPLH = AtomicMemoryFixed | 0x40408000,
1318   SWPALH = AtomicMemoryFixed | 0x40C08000,
1319   SWP_w = AtomicMemoryFixed | 0x80008000,
1320   SWPA_w = AtomicMemoryFixed | 0x80808000,
1321   SWPL_w = AtomicMemoryFixed | 0x80408000,
1322   SWPAL_w = AtomicMemoryFixed | 0x80C08000,
1323   SWP_x = AtomicMemoryFixed | 0xC0008000,
1324   SWPA_x = AtomicMemoryFixed | 0xC0808000,
1325   SWPL_x = AtomicMemoryFixed | 0xC0408000,
1326   SWPAL_x = AtomicMemoryFixed | 0xC0C08000,
1327   LDAPRB = AtomicMemoryFixed | 0x0080C000,
1328   LDAPRH = AtomicMemoryFixed | 0x4080C000,
1329   LDAPR_w = AtomicMemoryFixed | 0x8080C000,
1330   LDAPR_x = AtomicMemoryFixed | 0xC080C000,
1331 
1332   AtomicMemorySimpleFMask = 0x3B208C00,
1333   AtomicMemorySimpleOpMask = 0x00007000,
1334 #define ATOMIC_MEMORY_SIMPLE(N, OP)              \
1335   N##Op = OP,                                    \
1336   N##B = AtomicMemoryFixed | OP,                 \
1337   N##AB = AtomicMemoryFixed | OP | 0x00800000,   \
1338   N##LB = AtomicMemoryFixed | OP | 0x00400000,   \
1339   N##ALB = AtomicMemoryFixed | OP | 0x00C00000,  \
1340   N##H = AtomicMemoryFixed | OP | 0x40000000,    \
1341   N##AH = AtomicMemoryFixed | OP | 0x40800000,   \
1342   N##LH = AtomicMemoryFixed | OP | 0x40400000,   \
1343   N##ALH = AtomicMemoryFixed | OP | 0x40C00000,  \
1344   N##_w = AtomicMemoryFixed | OP | 0x80000000,   \
1345   N##A_w = AtomicMemoryFixed | OP | 0x80800000,  \
1346   N##L_w = AtomicMemoryFixed | OP | 0x80400000,  \
1347   N##AL_w = AtomicMemoryFixed | OP | 0x80C00000, \
1348   N##_x = AtomicMemoryFixed | OP | 0xC0000000,   \
1349   N##A_x = AtomicMemoryFixed | OP | 0xC0800000,  \
1350   N##L_x = AtomicMemoryFixed | OP | 0xC0400000,  \
1351   N##AL_x = AtomicMemoryFixed | OP | 0xC0C00000
1352 
1353   ATOMIC_MEMORY_SIMPLE_OPC_LIST(ATOMIC_MEMORY_SIMPLE)
1354 #undef ATOMIC_MEMORY_SIMPLE
1355 };
1356 
1357 // Conditional compare.
1358 enum ConditionalCompareOp {
1359   ConditionalCompareMask = 0x60000000,
1360   CCMN                   = 0x20000000,
1361   CCMP                   = 0x60000000
1362 };
1363 
1364 // Conditional compare register.
1365 enum ConditionalCompareRegisterOp {
1366   ConditionalCompareRegisterFixed = 0x1A400000,
1367   ConditionalCompareRegisterFMask = 0x1FE00800,
1368   ConditionalCompareRegisterMask  = 0xFFE00C10,
1369   CCMN_w = ConditionalCompareRegisterFixed | CCMN,
1370   CCMN_x = ConditionalCompareRegisterFixed | SixtyFourBits | CCMN,
1371   CCMP_w = ConditionalCompareRegisterFixed | CCMP,
1372   CCMP_x = ConditionalCompareRegisterFixed | SixtyFourBits | CCMP
1373 };
1374 
1375 // Conditional compare immediate.
1376 enum ConditionalCompareImmediateOp {
1377   ConditionalCompareImmediateFixed = 0x1A400800,
1378   ConditionalCompareImmediateFMask = 0x1FE00800,
1379   ConditionalCompareImmediateMask  = 0xFFE00C10,
1380   CCMN_w_imm = ConditionalCompareImmediateFixed | CCMN,
1381   CCMN_x_imm = ConditionalCompareImmediateFixed | SixtyFourBits | CCMN,
1382   CCMP_w_imm = ConditionalCompareImmediateFixed | CCMP,
1383   CCMP_x_imm = ConditionalCompareImmediateFixed | SixtyFourBits | CCMP
1384 };
1385 
1386 // Conditional select.
1387 enum ConditionalSelectOp {
1388   ConditionalSelectFixed = 0x1A800000,
1389   ConditionalSelectFMask = 0x1FE00000,
1390   ConditionalSelectMask  = 0xFFE00C00,
1391   CSEL_w                 = ConditionalSelectFixed | 0x00000000,
1392   CSEL_x                 = ConditionalSelectFixed | 0x80000000,
1393   CSEL                   = CSEL_w,
1394   CSINC_w                = ConditionalSelectFixed | 0x00000400,
1395   CSINC_x                = ConditionalSelectFixed | 0x80000400,
1396   CSINC                  = CSINC_w,
1397   CSINV_w                = ConditionalSelectFixed | 0x40000000,
1398   CSINV_x                = ConditionalSelectFixed | 0xC0000000,
1399   CSINV                  = CSINV_w,
1400   CSNEG_w                = ConditionalSelectFixed | 0x40000400,
1401   CSNEG_x                = ConditionalSelectFixed | 0xC0000400,
1402   CSNEG                  = CSNEG_w
1403 };
1404 
1405 // Data processing 1 source.
1406 enum DataProcessing1SourceOp {
1407   DataProcessing1SourceFixed = 0x5AC00000,
1408   DataProcessing1SourceFMask = 0x5FE00000,
1409   DataProcessing1SourceMask  = 0xFFFFFC00,
1410   RBIT    = DataProcessing1SourceFixed | 0x00000000,
1411   RBIT_w  = RBIT,
1412   RBIT_x  = RBIT | SixtyFourBits,
1413   REV16   = DataProcessing1SourceFixed | 0x00000400,
1414   REV16_w = REV16,
1415   REV16_x = REV16 | SixtyFourBits,
1416   REV     = DataProcessing1SourceFixed | 0x00000800,
1417   REV_w   = REV,
1418   REV32_x = REV | SixtyFourBits,
1419   REV_x   = DataProcessing1SourceFixed | SixtyFourBits | 0x00000C00,
1420   CLZ     = DataProcessing1SourceFixed | 0x00001000,
1421   CLZ_w   = CLZ,
1422   CLZ_x   = CLZ | SixtyFourBits,
1423   CLS     = DataProcessing1SourceFixed | 0x00001400,
1424   CLS_w   = CLS,
1425   CLS_x   = CLS | SixtyFourBits,
1426 
1427   // Pointer authentication instructions in Armv8.3.
1428   PACIA  = DataProcessing1SourceFixed | 0x80010000,
1429   PACIB  = DataProcessing1SourceFixed | 0x80010400,
1430   PACDA  = DataProcessing1SourceFixed | 0x80010800,
1431   PACDB  = DataProcessing1SourceFixed | 0x80010C00,
1432   AUTIA  = DataProcessing1SourceFixed | 0x80011000,
1433   AUTIB  = DataProcessing1SourceFixed | 0x80011400,
1434   AUTDA  = DataProcessing1SourceFixed | 0x80011800,
1435   AUTDB  = DataProcessing1SourceFixed | 0x80011C00,
1436   PACIZA = DataProcessing1SourceFixed | 0x80012000,
1437   PACIZB = DataProcessing1SourceFixed | 0x80012400,
1438   PACDZA = DataProcessing1SourceFixed | 0x80012800,
1439   PACDZB = DataProcessing1SourceFixed | 0x80012C00,
1440   AUTIZA = DataProcessing1SourceFixed | 0x80013000,
1441   AUTIZB = DataProcessing1SourceFixed | 0x80013400,
1442   AUTDZA = DataProcessing1SourceFixed | 0x80013800,
1443   AUTDZB = DataProcessing1SourceFixed | 0x80013C00,
1444   XPACI  = DataProcessing1SourceFixed | 0x80014000,
1445   XPACD  = DataProcessing1SourceFixed | 0x80014400
1446 };
1447 
1448 // Data processing 2 source.
1449 enum DataProcessing2SourceOp {
1450   DataProcessing2SourceFixed = 0x1AC00000,
1451   DataProcessing2SourceFMask = 0x5FE00000,
1452   DataProcessing2SourceMask  = 0xFFE0FC00,
1453   UDIV_w  = DataProcessing2SourceFixed | 0x00000800,
1454   UDIV_x  = DataProcessing2SourceFixed | 0x80000800,
1455   UDIV    = UDIV_w,
1456   SDIV_w  = DataProcessing2SourceFixed | 0x00000C00,
1457   SDIV_x  = DataProcessing2SourceFixed | 0x80000C00,
1458   SDIV    = SDIV_w,
1459   LSLV_w  = DataProcessing2SourceFixed | 0x00002000,
1460   LSLV_x  = DataProcessing2SourceFixed | 0x80002000,
1461   LSLV    = LSLV_w,
1462   LSRV_w  = DataProcessing2SourceFixed | 0x00002400,
1463   LSRV_x  = DataProcessing2SourceFixed | 0x80002400,
1464   LSRV    = LSRV_w,
1465   ASRV_w  = DataProcessing2SourceFixed | 0x00002800,
1466   ASRV_x  = DataProcessing2SourceFixed | 0x80002800,
1467   ASRV    = ASRV_w,
1468   RORV_w  = DataProcessing2SourceFixed | 0x00002C00,
1469   RORV_x  = DataProcessing2SourceFixed | 0x80002C00,
1470   RORV    = RORV_w,
1471   PACGA   = DataProcessing2SourceFixed | SixtyFourBits | 0x00003000,
1472   CRC32B  = DataProcessing2SourceFixed | 0x00004000,
1473   CRC32H  = DataProcessing2SourceFixed | 0x00004400,
1474   CRC32W  = DataProcessing2SourceFixed | 0x00004800,
1475   CRC32X  = DataProcessing2SourceFixed | SixtyFourBits | 0x00004C00,
1476   CRC32CB = DataProcessing2SourceFixed | 0x00005000,
1477   CRC32CH = DataProcessing2SourceFixed | 0x00005400,
1478   CRC32CW = DataProcessing2SourceFixed | 0x00005800,
1479   CRC32CX = DataProcessing2SourceFixed | SixtyFourBits | 0x00005C00
1480 };
1481 
1482 // Data processing 3 source.
1483 enum DataProcessing3SourceOp {
1484   DataProcessing3SourceFixed = 0x1B000000,
1485   DataProcessing3SourceFMask = 0x1F000000,
1486   DataProcessing3SourceMask  = 0xFFE08000,
1487   MADD_w                     = DataProcessing3SourceFixed | 0x00000000,
1488   MADD_x                     = DataProcessing3SourceFixed | 0x80000000,
1489   MADD                       = MADD_w,
1490   MSUB_w                     = DataProcessing3SourceFixed | 0x00008000,
1491   MSUB_x                     = DataProcessing3SourceFixed | 0x80008000,
1492   MSUB                       = MSUB_w,
1493   SMADDL_x                   = DataProcessing3SourceFixed | 0x80200000,
1494   SMSUBL_x                   = DataProcessing3SourceFixed | 0x80208000,
1495   SMULH_x                    = DataProcessing3SourceFixed | 0x80400000,
1496   UMADDL_x                   = DataProcessing3SourceFixed | 0x80A00000,
1497   UMSUBL_x                   = DataProcessing3SourceFixed | 0x80A08000,
1498   UMULH_x                    = DataProcessing3SourceFixed | 0x80C00000
1499 };
1500 
1501 // Floating point compare.
1502 enum FPCompareOp {
1503   FPCompareFixed = 0x1E202000,
1504   FPCompareFMask = 0x5F203C00,
1505   FPCompareMask  = 0xFFE0FC1F,
1506   FCMP_h         = FPCompareFixed | FP16 | 0x00000000,
1507   FCMP_s         = FPCompareFixed | 0x00000000,
1508   FCMP_d         = FPCompareFixed | FP64 | 0x00000000,
1509   FCMP           = FCMP_s,
1510   FCMP_h_zero    = FPCompareFixed | FP16 | 0x00000008,
1511   FCMP_s_zero    = FPCompareFixed | 0x00000008,
1512   FCMP_d_zero    = FPCompareFixed | FP64 | 0x00000008,
1513   FCMP_zero      = FCMP_s_zero,
1514   FCMPE_h        = FPCompareFixed | FP16 | 0x00000010,
1515   FCMPE_s        = FPCompareFixed | 0x00000010,
1516   FCMPE_d        = FPCompareFixed | FP64 | 0x00000010,
1517   FCMPE          = FCMPE_s,
1518   FCMPE_h_zero   = FPCompareFixed | FP16 | 0x00000018,
1519   FCMPE_s_zero   = FPCompareFixed | 0x00000018,
1520   FCMPE_d_zero   = FPCompareFixed | FP64 | 0x00000018,
1521   FCMPE_zero     = FCMPE_s_zero
1522 };
1523 
1524 // Floating point conditional compare.
1525 enum FPConditionalCompareOp {
1526   FPConditionalCompareFixed = 0x1E200400,
1527   FPConditionalCompareFMask = 0x5F200C00,
1528   FPConditionalCompareMask  = 0xFFE00C10,
1529   FCCMP_h                   = FPConditionalCompareFixed | FP16 | 0x00000000,
1530   FCCMP_s                   = FPConditionalCompareFixed | 0x00000000,
1531   FCCMP_d                   = FPConditionalCompareFixed | FP64 | 0x00000000,
1532   FCCMP                     = FCCMP_s,
1533   FCCMPE_h                  = FPConditionalCompareFixed | FP16 | 0x00000010,
1534   FCCMPE_s                  = FPConditionalCompareFixed | 0x00000010,
1535   FCCMPE_d                  = FPConditionalCompareFixed | FP64 | 0x00000010,
1536   FCCMPE                    = FCCMPE_s
1537 };
1538 
1539 // Floating point conditional select.
1540 enum FPConditionalSelectOp {
1541   FPConditionalSelectFixed = 0x1E200C00,
1542   FPConditionalSelectFMask = 0x5F200C00,
1543   FPConditionalSelectMask  = 0xFFE00C00,
1544   FCSEL_h                  = FPConditionalSelectFixed | FP16 | 0x00000000,
1545   FCSEL_s                  = FPConditionalSelectFixed | 0x00000000,
1546   FCSEL_d                  = FPConditionalSelectFixed | FP64 | 0x00000000,
1547   FCSEL                    = FCSEL_s
1548 };
1549 
1550 // Floating point immediate.
1551 enum FPImmediateOp {
1552   FPImmediateFixed = 0x1E201000,
1553   FPImmediateFMask = 0x5F201C00,
1554   FPImmediateMask  = 0xFFE01C00,
1555   FMOV_h_imm       = FPImmediateFixed | FP16 | 0x00000000,
1556   FMOV_s_imm       = FPImmediateFixed | 0x00000000,
1557   FMOV_d_imm       = FPImmediateFixed | FP64 | 0x00000000
1558 };
1559 
1560 // Floating point data processing 1 source.
1561 enum FPDataProcessing1SourceOp {
1562   FPDataProcessing1SourceFixed = 0x1E204000,
1563   FPDataProcessing1SourceFMask = 0x5F207C00,
1564   FPDataProcessing1SourceMask  = 0xFFFFFC00,
1565   FMOV_h   = FPDataProcessing1SourceFixed | FP16 | 0x00000000,
1566   FMOV_s   = FPDataProcessing1SourceFixed | 0x00000000,
1567   FMOV_d   = FPDataProcessing1SourceFixed | FP64 | 0x00000000,
1568   FMOV     = FMOV_s,
1569   FABS_h   = FPDataProcessing1SourceFixed | FP16 | 0x00008000,
1570   FABS_s   = FPDataProcessing1SourceFixed | 0x00008000,
1571   FABS_d   = FPDataProcessing1SourceFixed | FP64 | 0x00008000,
1572   FABS     = FABS_s,
1573   FNEG_h   = FPDataProcessing1SourceFixed | FP16 | 0x00010000,
1574   FNEG_s   = FPDataProcessing1SourceFixed | 0x00010000,
1575   FNEG_d   = FPDataProcessing1SourceFixed | FP64 | 0x00010000,
1576   FNEG     = FNEG_s,
1577   FSQRT_h  = FPDataProcessing1SourceFixed | FP16 | 0x00018000,
1578   FSQRT_s  = FPDataProcessing1SourceFixed | 0x00018000,
1579   FSQRT_d  = FPDataProcessing1SourceFixed | FP64 | 0x00018000,
1580   FSQRT    = FSQRT_s,
1581   FCVT_ds  = FPDataProcessing1SourceFixed | 0x00028000,
1582   FCVT_sd  = FPDataProcessing1SourceFixed | FP64 | 0x00020000,
1583   FCVT_hs  = FPDataProcessing1SourceFixed | 0x00038000,
1584   FCVT_hd  = FPDataProcessing1SourceFixed | FP64 | 0x00038000,
1585   FCVT_sh  = FPDataProcessing1SourceFixed | 0x00C20000,
1586   FCVT_dh  = FPDataProcessing1SourceFixed | 0x00C28000,
1587   FRINT32X_s = FPDataProcessing1SourceFixed | 0x00088000,
1588   FRINT32X_d = FPDataProcessing1SourceFixed | FP64 | 0x00088000,
1589   FRINT32X = FRINT32X_s,
1590   FRINT32Z_s = FPDataProcessing1SourceFixed | 0x00080000,
1591   FRINT32Z_d = FPDataProcessing1SourceFixed | FP64 | 0x00080000,
1592   FRINT32Z = FRINT32Z_s,
1593   FRINT64X_s = FPDataProcessing1SourceFixed | 0x00098000,
1594   FRINT64X_d = FPDataProcessing1SourceFixed | FP64 | 0x00098000,
1595   FRINT64X = FRINT64X_s,
1596   FRINT64Z_s = FPDataProcessing1SourceFixed | 0x00090000,
1597   FRINT64Z_d = FPDataProcessing1SourceFixed | FP64 | 0x00090000,
1598   FRINT64Z = FRINT64Z_s,
1599   FRINTN_h = FPDataProcessing1SourceFixed | FP16 | 0x00040000,
1600   FRINTN_s = FPDataProcessing1SourceFixed | 0x00040000,
1601   FRINTN_d = FPDataProcessing1SourceFixed | FP64 | 0x00040000,
1602   FRINTN   = FRINTN_s,
1603   FRINTP_h = FPDataProcessing1SourceFixed | FP16 | 0x00048000,
1604   FRINTP_s = FPDataProcessing1SourceFixed | 0x00048000,
1605   FRINTP_d = FPDataProcessing1SourceFixed | FP64 | 0x00048000,
1606   FRINTP   = FRINTP_s,
1607   FRINTM_h = FPDataProcessing1SourceFixed | FP16 | 0x00050000,
1608   FRINTM_s = FPDataProcessing1SourceFixed | 0x00050000,
1609   FRINTM_d = FPDataProcessing1SourceFixed | FP64 | 0x00050000,
1610   FRINTM   = FRINTM_s,
1611   FRINTZ_h = FPDataProcessing1SourceFixed | FP16 | 0x00058000,
1612   FRINTZ_s = FPDataProcessing1SourceFixed | 0x00058000,
1613   FRINTZ_d = FPDataProcessing1SourceFixed | FP64 | 0x00058000,
1614   FRINTZ   = FRINTZ_s,
1615   FRINTA_h = FPDataProcessing1SourceFixed | FP16 | 0x00060000,
1616   FRINTA_s = FPDataProcessing1SourceFixed | 0x00060000,
1617   FRINTA_d = FPDataProcessing1SourceFixed | FP64 | 0x00060000,
1618   FRINTA   = FRINTA_s,
1619   FRINTX_h = FPDataProcessing1SourceFixed | FP16 | 0x00070000,
1620   FRINTX_s = FPDataProcessing1SourceFixed | 0x00070000,
1621   FRINTX_d = FPDataProcessing1SourceFixed | FP64 | 0x00070000,
1622   FRINTX   = FRINTX_s,
1623   FRINTI_h = FPDataProcessing1SourceFixed | FP16 | 0x00078000,
1624   FRINTI_s = FPDataProcessing1SourceFixed | 0x00078000,
1625   FRINTI_d = FPDataProcessing1SourceFixed | FP64 | 0x00078000,
1626   FRINTI   = FRINTI_s
1627 };
1628 
1629 // Floating point data processing 2 source.
1630 enum FPDataProcessing2SourceOp {
1631   FPDataProcessing2SourceFixed = 0x1E200800,
1632   FPDataProcessing2SourceFMask = 0x5F200C00,
1633   FPDataProcessing2SourceMask  = 0xFFE0FC00,
1634   FMUL     = FPDataProcessing2SourceFixed | 0x00000000,
1635   FMUL_h   = FMUL | FP16,
1636   FMUL_s   = FMUL,
1637   FMUL_d   = FMUL | FP64,
1638   FDIV     = FPDataProcessing2SourceFixed | 0x00001000,
1639   FDIV_h   = FDIV | FP16,
1640   FDIV_s   = FDIV,
1641   FDIV_d   = FDIV | FP64,
1642   FADD     = FPDataProcessing2SourceFixed | 0x00002000,
1643   FADD_h   = FADD | FP16,
1644   FADD_s   = FADD,
1645   FADD_d   = FADD | FP64,
1646   FSUB     = FPDataProcessing2SourceFixed | 0x00003000,
1647   FSUB_h   = FSUB | FP16,
1648   FSUB_s   = FSUB,
1649   FSUB_d   = FSUB | FP64,
1650   FMAX     = FPDataProcessing2SourceFixed | 0x00004000,
1651   FMAX_h   = FMAX | FP16,
1652   FMAX_s   = FMAX,
1653   FMAX_d   = FMAX | FP64,
1654   FMIN     = FPDataProcessing2SourceFixed | 0x00005000,
1655   FMIN_h   = FMIN | FP16,
1656   FMIN_s   = FMIN,
1657   FMIN_d   = FMIN | FP64,
1658   FMAXNM   = FPDataProcessing2SourceFixed | 0x00006000,
1659   FMAXNM_h = FMAXNM | FP16,
1660   FMAXNM_s = FMAXNM,
1661   FMAXNM_d = FMAXNM | FP64,
1662   FMINNM   = FPDataProcessing2SourceFixed | 0x00007000,
1663   FMINNM_h = FMINNM | FP16,
1664   FMINNM_s = FMINNM,
1665   FMINNM_d = FMINNM | FP64,
1666   FNMUL    = FPDataProcessing2SourceFixed | 0x00008000,
1667   FNMUL_h  = FNMUL | FP16,
1668   FNMUL_s  = FNMUL,
1669   FNMUL_d  = FNMUL | FP64
1670 };
1671 
1672 // Floating point data processing 3 source.
1673 enum FPDataProcessing3SourceOp {
1674   FPDataProcessing3SourceFixed = 0x1F000000,
1675   FPDataProcessing3SourceFMask = 0x5F000000,
1676   FPDataProcessing3SourceMask  = 0xFFE08000,
1677   FMADD_h                      = FPDataProcessing3SourceFixed | 0x00C00000,
1678   FMSUB_h                      = FPDataProcessing3SourceFixed | 0x00C08000,
1679   FNMADD_h                     = FPDataProcessing3SourceFixed | 0x00E00000,
1680   FNMSUB_h                     = FPDataProcessing3SourceFixed | 0x00E08000,
1681   FMADD_s                      = FPDataProcessing3SourceFixed | 0x00000000,
1682   FMSUB_s                      = FPDataProcessing3SourceFixed | 0x00008000,
1683   FNMADD_s                     = FPDataProcessing3SourceFixed | 0x00200000,
1684   FNMSUB_s                     = FPDataProcessing3SourceFixed | 0x00208000,
1685   FMADD_d                      = FPDataProcessing3SourceFixed | 0x00400000,
1686   FMSUB_d                      = FPDataProcessing3SourceFixed | 0x00408000,
1687   FNMADD_d                     = FPDataProcessing3SourceFixed | 0x00600000,
1688   FNMSUB_d                     = FPDataProcessing3SourceFixed | 0x00608000
1689 };
1690 
1691 // Conversion between floating point and integer.
1692 enum FPIntegerConvertOp {
1693   FPIntegerConvertFixed = 0x1E200000,
1694   FPIntegerConvertFMask = 0x5F20FC00,
1695   FPIntegerConvertMask  = 0xFFFFFC00,
1696   FCVTNS    = FPIntegerConvertFixed | 0x00000000,
1697   FCVTNS_wh = FCVTNS | FP16,
1698   FCVTNS_xh = FCVTNS | SixtyFourBits | FP16,
1699   FCVTNS_ws = FCVTNS,
1700   FCVTNS_xs = FCVTNS | SixtyFourBits,
1701   FCVTNS_wd = FCVTNS | FP64,
1702   FCVTNS_xd = FCVTNS | SixtyFourBits | FP64,
1703   FCVTNU    = FPIntegerConvertFixed | 0x00010000,
1704   FCVTNU_wh = FCVTNU | FP16,
1705   FCVTNU_xh = FCVTNU | SixtyFourBits | FP16,
1706   FCVTNU_ws = FCVTNU,
1707   FCVTNU_xs = FCVTNU | SixtyFourBits,
1708   FCVTNU_wd = FCVTNU | FP64,
1709   FCVTNU_xd = FCVTNU | SixtyFourBits | FP64,
1710   FCVTPS    = FPIntegerConvertFixed | 0x00080000,
1711   FCVTPS_wh = FCVTPS | FP16,
1712   FCVTPS_xh = FCVTPS | SixtyFourBits | FP16,
1713   FCVTPS_ws = FCVTPS,
1714   FCVTPS_xs = FCVTPS | SixtyFourBits,
1715   FCVTPS_wd = FCVTPS | FP64,
1716   FCVTPS_xd = FCVTPS | SixtyFourBits | FP64,
1717   FCVTPU    = FPIntegerConvertFixed | 0x00090000,
1718   FCVTPU_wh = FCVTPU | FP16,
1719   FCVTPU_xh = FCVTPU | SixtyFourBits | FP16,
1720   FCVTPU_ws = FCVTPU,
1721   FCVTPU_xs = FCVTPU | SixtyFourBits,
1722   FCVTPU_wd = FCVTPU | FP64,
1723   FCVTPU_xd = FCVTPU | SixtyFourBits | FP64,
1724   FCVTMS    = FPIntegerConvertFixed | 0x00100000,
1725   FCVTMS_wh = FCVTMS | FP16,
1726   FCVTMS_xh = FCVTMS | SixtyFourBits | FP16,
1727   FCVTMS_ws = FCVTMS,
1728   FCVTMS_xs = FCVTMS | SixtyFourBits,
1729   FCVTMS_wd = FCVTMS | FP64,
1730   FCVTMS_xd = FCVTMS | SixtyFourBits | FP64,
1731   FCVTMU    = FPIntegerConvertFixed | 0x00110000,
1732   FCVTMU_wh = FCVTMU | FP16,
1733   FCVTMU_xh = FCVTMU | SixtyFourBits | FP16,
1734   FCVTMU_ws = FCVTMU,
1735   FCVTMU_xs = FCVTMU | SixtyFourBits,
1736   FCVTMU_wd = FCVTMU | FP64,
1737   FCVTMU_xd = FCVTMU | SixtyFourBits | FP64,
1738   FCVTZS    = FPIntegerConvertFixed | 0x00180000,
1739   FCVTZS_wh = FCVTZS | FP16,
1740   FCVTZS_xh = FCVTZS | SixtyFourBits | FP16,
1741   FCVTZS_ws = FCVTZS,
1742   FCVTZS_xs = FCVTZS | SixtyFourBits,
1743   FCVTZS_wd = FCVTZS | FP64,
1744   FCVTZS_xd = FCVTZS | SixtyFourBits | FP64,
1745   FCVTZU    = FPIntegerConvertFixed | 0x00190000,
1746   FCVTZU_wh = FCVTZU | FP16,
1747   FCVTZU_xh = FCVTZU | SixtyFourBits | FP16,
1748   FCVTZU_ws = FCVTZU,
1749   FCVTZU_xs = FCVTZU | SixtyFourBits,
1750   FCVTZU_wd = FCVTZU | FP64,
1751   FCVTZU_xd = FCVTZU | SixtyFourBits | FP64,
1752   SCVTF     = FPIntegerConvertFixed | 0x00020000,
1753   SCVTF_hw  = SCVTF | FP16,
1754   SCVTF_hx  = SCVTF | SixtyFourBits | FP16,
1755   SCVTF_sw  = SCVTF,
1756   SCVTF_sx  = SCVTF | SixtyFourBits,
1757   SCVTF_dw  = SCVTF | FP64,
1758   SCVTF_dx  = SCVTF | SixtyFourBits | FP64,
1759   UCVTF     = FPIntegerConvertFixed | 0x00030000,
1760   UCVTF_hw  = UCVTF | FP16,
1761   UCVTF_hx  = UCVTF | SixtyFourBits | FP16,
1762   UCVTF_sw  = UCVTF,
1763   UCVTF_sx  = UCVTF | SixtyFourBits,
1764   UCVTF_dw  = UCVTF | FP64,
1765   UCVTF_dx  = UCVTF | SixtyFourBits | FP64,
1766   FCVTAS    = FPIntegerConvertFixed | 0x00040000,
1767   FCVTAS_wh = FCVTAS | FP16,
1768   FCVTAS_xh = FCVTAS | SixtyFourBits | FP16,
1769   FCVTAS_ws = FCVTAS,
1770   FCVTAS_xs = FCVTAS | SixtyFourBits,
1771   FCVTAS_wd = FCVTAS | FP64,
1772   FCVTAS_xd = FCVTAS | SixtyFourBits | FP64,
1773   FCVTAU    = FPIntegerConvertFixed | 0x00050000,
1774   FCVTAU_wh = FCVTAU | FP16,
1775   FCVTAU_xh = FCVTAU | SixtyFourBits | FP16,
1776   FCVTAU_ws = FCVTAU,
1777   FCVTAU_xs = FCVTAU | SixtyFourBits,
1778   FCVTAU_wd = FCVTAU | FP64,
1779   FCVTAU_xd = FCVTAU | SixtyFourBits | FP64,
1780   FMOV_wh   = FPIntegerConvertFixed | 0x00060000 | FP16,
1781   FMOV_hw   = FPIntegerConvertFixed | 0x00070000 | FP16,
1782   FMOV_xh   = FMOV_wh | SixtyFourBits,
1783   FMOV_hx   = FMOV_hw | SixtyFourBits,
1784   FMOV_ws   = FPIntegerConvertFixed | 0x00060000,
1785   FMOV_sw   = FPIntegerConvertFixed | 0x00070000,
1786   FMOV_xd   = FMOV_ws | SixtyFourBits | FP64,
1787   FMOV_dx   = FMOV_sw | SixtyFourBits | FP64,
1788   FMOV_d1_x = FPIntegerConvertFixed | SixtyFourBits | 0x008F0000,
1789   FMOV_x_d1 = FPIntegerConvertFixed | SixtyFourBits | 0x008E0000,
1790   FJCVTZS   = FPIntegerConvertFixed | FP64 | 0x001E0000
1791 };
1792 
1793 // Conversion between fixed point and floating point.
1794 enum FPFixedPointConvertOp {
1795   FPFixedPointConvertFixed = 0x1E000000,
1796   FPFixedPointConvertFMask = 0x5F200000,
1797   FPFixedPointConvertMask  = 0xFFFF0000,
1798   FCVTZS_fixed    = FPFixedPointConvertFixed | 0x00180000,
1799   FCVTZS_wh_fixed = FCVTZS_fixed | FP16,
1800   FCVTZS_xh_fixed = FCVTZS_fixed | SixtyFourBits | FP16,
1801   FCVTZS_ws_fixed = FCVTZS_fixed,
1802   FCVTZS_xs_fixed = FCVTZS_fixed | SixtyFourBits,
1803   FCVTZS_wd_fixed = FCVTZS_fixed | FP64,
1804   FCVTZS_xd_fixed = FCVTZS_fixed | SixtyFourBits | FP64,
1805   FCVTZU_fixed    = FPFixedPointConvertFixed | 0x00190000,
1806   FCVTZU_wh_fixed = FCVTZU_fixed | FP16,
1807   FCVTZU_xh_fixed = FCVTZU_fixed | SixtyFourBits | FP16,
1808   FCVTZU_ws_fixed = FCVTZU_fixed,
1809   FCVTZU_xs_fixed = FCVTZU_fixed | SixtyFourBits,
1810   FCVTZU_wd_fixed = FCVTZU_fixed | FP64,
1811   FCVTZU_xd_fixed = FCVTZU_fixed | SixtyFourBits | FP64,
1812   SCVTF_fixed     = FPFixedPointConvertFixed | 0x00020000,
1813   SCVTF_hw_fixed  = SCVTF_fixed | FP16,
1814   SCVTF_hx_fixed  = SCVTF_fixed | SixtyFourBits | FP16,
1815   SCVTF_sw_fixed  = SCVTF_fixed,
1816   SCVTF_sx_fixed  = SCVTF_fixed | SixtyFourBits,
1817   SCVTF_dw_fixed  = SCVTF_fixed | FP64,
1818   SCVTF_dx_fixed  = SCVTF_fixed | SixtyFourBits | FP64,
1819   UCVTF_fixed     = FPFixedPointConvertFixed | 0x00030000,
1820   UCVTF_hw_fixed  = UCVTF_fixed | FP16,
1821   UCVTF_hx_fixed  = UCVTF_fixed | SixtyFourBits | FP16,
1822   UCVTF_sw_fixed  = UCVTF_fixed,
1823   UCVTF_sx_fixed  = UCVTF_fixed | SixtyFourBits,
1824   UCVTF_dw_fixed  = UCVTF_fixed | FP64,
1825   UCVTF_dx_fixed  = UCVTF_fixed | SixtyFourBits | FP64
1826 };
1827 
1828 // Crypto - two register SHA.
1829 enum Crypto2RegSHAOp {
1830   Crypto2RegSHAFixed = 0x5E280800,
1831   Crypto2RegSHAFMask = 0xFF3E0C00
1832 };
1833 
1834 // Crypto - three register SHA.
1835 enum Crypto3RegSHAOp {
1836   Crypto3RegSHAFixed = 0x5E000000,
1837   Crypto3RegSHAFMask = 0xFF208C00
1838 };
1839 
1840 // Crypto - AES.
1841 enum CryptoAESOp {
1842   CryptoAESFixed = 0x4E280800,
1843   CryptoAESFMask = 0xFF3E0C00
1844 };
1845 
1846 // NEON instructions with two register operands.
1847 enum NEON2RegMiscOp {
1848   NEON2RegMiscFixed = 0x0E200800,
1849   NEON2RegMiscFMask = 0x9F3E0C00,
1850   NEON2RegMiscMask  = 0xBF3FFC00,
1851   NEON2RegMiscUBit  = 0x20000000,
1852   NEON_REV64     = NEON2RegMiscFixed | 0x00000000,
1853   NEON_REV32     = NEON2RegMiscFixed | 0x20000000,
1854   NEON_REV16     = NEON2RegMiscFixed | 0x00001000,
1855   NEON_SADDLP    = NEON2RegMiscFixed | 0x00002000,
1856   NEON_UADDLP    = NEON_SADDLP | NEON2RegMiscUBit,
1857   NEON_SUQADD    = NEON2RegMiscFixed | 0x00003000,
1858   NEON_USQADD    = NEON_SUQADD | NEON2RegMiscUBit,
1859   NEON_CLS       = NEON2RegMiscFixed | 0x00004000,
1860   NEON_CLZ       = NEON2RegMiscFixed | 0x20004000,
1861   NEON_CNT       = NEON2RegMiscFixed | 0x00005000,
1862   NEON_RBIT_NOT  = NEON2RegMiscFixed | 0x20005000,
1863   NEON_SADALP    = NEON2RegMiscFixed | 0x00006000,
1864   NEON_UADALP    = NEON_SADALP | NEON2RegMiscUBit,
1865   NEON_SQABS     = NEON2RegMiscFixed | 0x00007000,
1866   NEON_SQNEG     = NEON2RegMiscFixed | 0x20007000,
1867   NEON_CMGT_zero = NEON2RegMiscFixed | 0x00008000,
1868   NEON_CMGE_zero = NEON2RegMiscFixed | 0x20008000,
1869   NEON_CMEQ_zero = NEON2RegMiscFixed | 0x00009000,
1870   NEON_CMLE_zero = NEON2RegMiscFixed | 0x20009000,
1871   NEON_CMLT_zero = NEON2RegMiscFixed | 0x0000A000,
1872   NEON_ABS       = NEON2RegMiscFixed | 0x0000B000,
1873   NEON_NEG       = NEON2RegMiscFixed | 0x2000B000,
1874   NEON_XTN       = NEON2RegMiscFixed | 0x00012000,
1875   NEON_SQXTUN    = NEON2RegMiscFixed | 0x20012000,
1876   NEON_SHLL      = NEON2RegMiscFixed | 0x20013000,
1877   NEON_SQXTN     = NEON2RegMiscFixed | 0x00014000,
1878   NEON_UQXTN     = NEON_SQXTN | NEON2RegMiscUBit,
1879 
1880   NEON2RegMiscOpcode = 0x0001F000,
1881   NEON_RBIT_NOT_opcode = NEON_RBIT_NOT & NEON2RegMiscOpcode,
1882   NEON_NEG_opcode = NEON_NEG & NEON2RegMiscOpcode,
1883   NEON_XTN_opcode = NEON_XTN & NEON2RegMiscOpcode,
1884   NEON_UQXTN_opcode = NEON_UQXTN & NEON2RegMiscOpcode,
1885 
1886   // These instructions use only one bit of the size field. The other bit is
1887   // used to distinguish between instructions.
1888   NEON2RegMiscFPMask = NEON2RegMiscMask | 0x00800000,
1889   NEON_FABS   = NEON2RegMiscFixed | 0x0080F000,
1890   NEON_FNEG   = NEON2RegMiscFixed | 0x2080F000,
1891   NEON_FCVTN  = NEON2RegMiscFixed | 0x00016000,
1892   NEON_FCVTXN = NEON2RegMiscFixed | 0x20016000,
1893   NEON_FCVTL  = NEON2RegMiscFixed | 0x00017000,
1894   NEON_FRINT32X = NEON2RegMiscFixed | 0x2001E000,
1895   NEON_FRINT32Z = NEON2RegMiscFixed | 0x0001E000,
1896   NEON_FRINT64X = NEON2RegMiscFixed | 0x2001F000,
1897   NEON_FRINT64Z = NEON2RegMiscFixed | 0x0001F000,
1898   NEON_FRINTN = NEON2RegMiscFixed | 0x00018000,
1899   NEON_FRINTA = NEON2RegMiscFixed | 0x20018000,
1900   NEON_FRINTP = NEON2RegMiscFixed | 0x00818000,
1901   NEON_FRINTM = NEON2RegMiscFixed | 0x00019000,
1902   NEON_FRINTX = NEON2RegMiscFixed | 0x20019000,
1903   NEON_FRINTZ = NEON2RegMiscFixed | 0x00819000,
1904   NEON_FRINTI = NEON2RegMiscFixed | 0x20819000,
1905   NEON_FCVTNS = NEON2RegMiscFixed | 0x0001A000,
1906   NEON_FCVTNU = NEON_FCVTNS | NEON2RegMiscUBit,
1907   NEON_FCVTPS = NEON2RegMiscFixed | 0x0081A000,
1908   NEON_FCVTPU = NEON_FCVTPS | NEON2RegMiscUBit,
1909   NEON_FCVTMS = NEON2RegMiscFixed | 0x0001B000,
1910   NEON_FCVTMU = NEON_FCVTMS | NEON2RegMiscUBit,
1911   NEON_FCVTZS = NEON2RegMiscFixed | 0x0081B000,
1912   NEON_FCVTZU = NEON_FCVTZS | NEON2RegMiscUBit,
1913   NEON_FCVTAS = NEON2RegMiscFixed | 0x0001C000,
1914   NEON_FCVTAU = NEON_FCVTAS | NEON2RegMiscUBit,
1915   NEON_FSQRT  = NEON2RegMiscFixed | 0x2081F000,
1916   NEON_SCVTF  = NEON2RegMiscFixed | 0x0001D000,
1917   NEON_UCVTF  = NEON_SCVTF | NEON2RegMiscUBit,
1918   NEON_URSQRTE = NEON2RegMiscFixed | 0x2081C000,
1919   NEON_URECPE  = NEON2RegMiscFixed | 0x0081C000,
1920   NEON_FRSQRTE = NEON2RegMiscFixed | 0x2081D000,
1921   NEON_FRECPE  = NEON2RegMiscFixed | 0x0081D000,
1922   NEON_FCMGT_zero = NEON2RegMiscFixed | 0x0080C000,
1923   NEON_FCMGE_zero = NEON2RegMiscFixed | 0x2080C000,
1924   NEON_FCMEQ_zero = NEON2RegMiscFixed | 0x0080D000,
1925   NEON_FCMLE_zero = NEON2RegMiscFixed | 0x2080D000,
1926   NEON_FCMLT_zero = NEON2RegMiscFixed | 0x0080E000,
1927 
1928   NEON_FCVTL_opcode = NEON_FCVTL & NEON2RegMiscOpcode,
1929   NEON_FCVTN_opcode = NEON_FCVTN & NEON2RegMiscOpcode
1930 };
1931 
1932 // NEON instructions with two register operands (FP16).
1933 enum NEON2RegMiscFP16Op {
1934   NEON2RegMiscFP16Fixed = 0x0E780800,
1935   NEON2RegMiscFP16FMask = 0x9F7E0C00,
1936   NEON2RegMiscFP16Mask  = 0xBFFFFC00,
1937   NEON_FRINTN_H     = NEON2RegMiscFP16Fixed | 0x00018000,
1938   NEON_FRINTM_H     = NEON2RegMiscFP16Fixed | 0x00019000,
1939   NEON_FCVTNS_H     = NEON2RegMiscFP16Fixed | 0x0001A000,
1940   NEON_FCVTMS_H     = NEON2RegMiscFP16Fixed | 0x0001B000,
1941   NEON_FCVTAS_H     = NEON2RegMiscFP16Fixed | 0x0001C000,
1942   NEON_SCVTF_H      = NEON2RegMiscFP16Fixed | 0x0001D000,
1943   NEON_FCMGT_H_zero = NEON2RegMiscFP16Fixed | 0x0080C000,
1944   NEON_FCMEQ_H_zero = NEON2RegMiscFP16Fixed | 0x0080D000,
1945   NEON_FCMLT_H_zero = NEON2RegMiscFP16Fixed | 0x0080E000,
1946   NEON_FABS_H       = NEON2RegMiscFP16Fixed | 0x0080F000,
1947   NEON_FRINTP_H     = NEON2RegMiscFP16Fixed | 0x00818000,
1948   NEON_FRINTZ_H     = NEON2RegMiscFP16Fixed | 0x00819000,
1949   NEON_FCVTPS_H     = NEON2RegMiscFP16Fixed | 0x0081A000,
1950   NEON_FCVTZS_H     = NEON2RegMiscFP16Fixed | 0x0081B000,
1951   NEON_FRECPE_H     = NEON2RegMiscFP16Fixed | 0x0081D000,
1952   NEON_FRINTA_H     = NEON2RegMiscFP16Fixed | 0x20018000,
1953   NEON_FRINTX_H     = NEON2RegMiscFP16Fixed | 0x20019000,
1954   NEON_FCVTNU_H     = NEON2RegMiscFP16Fixed | 0x2001A000,
1955   NEON_FCVTMU_H     = NEON2RegMiscFP16Fixed | 0x2001B000,
1956   NEON_FCVTAU_H     = NEON2RegMiscFP16Fixed | 0x2001C000,
1957   NEON_UCVTF_H      = NEON2RegMiscFP16Fixed | 0x2001D000,
1958   NEON_FCMGE_H_zero = NEON2RegMiscFP16Fixed | 0x2080C000,
1959   NEON_FCMLE_H_zero = NEON2RegMiscFP16Fixed | 0x2080D000,
1960   NEON_FNEG_H       = NEON2RegMiscFP16Fixed | 0x2080F000,
1961   NEON_FRINTI_H     = NEON2RegMiscFP16Fixed | 0x20819000,
1962   NEON_FCVTPU_H     = NEON2RegMiscFP16Fixed | 0x2081A000,
1963   NEON_FCVTZU_H     = NEON2RegMiscFP16Fixed | 0x2081B000,
1964   NEON_FRSQRTE_H    = NEON2RegMiscFP16Fixed | 0x2081D000,
1965   NEON_FSQRT_H      = NEON2RegMiscFP16Fixed | 0x2081F000
1966 };
1967 
1968 // NEON instructions with three same-type operands.
1969 enum NEON3SameOp {
1970   NEON3SameFixed = 0x0E200400,
1971   NEON3SameFMask = 0x9F200400,
1972   NEON3SameMask =  0xBF20FC00,
1973   NEON3SameUBit =  0x20000000,
1974   NEON_ADD    = NEON3SameFixed | 0x00008000,
1975   NEON_ADDP   = NEON3SameFixed | 0x0000B800,
1976   NEON_SHADD  = NEON3SameFixed | 0x00000000,
1977   NEON_SHSUB  = NEON3SameFixed | 0x00002000,
1978   NEON_SRHADD = NEON3SameFixed | 0x00001000,
1979   NEON_CMEQ   = NEON3SameFixed | NEON3SameUBit | 0x00008800,
1980   NEON_CMGE   = NEON3SameFixed | 0x00003800,
1981   NEON_CMGT   = NEON3SameFixed | 0x00003000,
1982   NEON_CMHI   = NEON3SameFixed | NEON3SameUBit | NEON_CMGT,
1983   NEON_CMHS   = NEON3SameFixed | NEON3SameUBit | NEON_CMGE,
1984   NEON_CMTST  = NEON3SameFixed | 0x00008800,
1985   NEON_MLA    = NEON3SameFixed | 0x00009000,
1986   NEON_MLS    = NEON3SameFixed | 0x20009000,
1987   NEON_MUL    = NEON3SameFixed | 0x00009800,
1988   NEON_PMUL   = NEON3SameFixed | 0x20009800,
1989   NEON_SRSHL  = NEON3SameFixed | 0x00005000,
1990   NEON_SQSHL  = NEON3SameFixed | 0x00004800,
1991   NEON_SQRSHL = NEON3SameFixed | 0x00005800,
1992   NEON_SSHL   = NEON3SameFixed | 0x00004000,
1993   NEON_SMAX   = NEON3SameFixed | 0x00006000,
1994   NEON_SMAXP  = NEON3SameFixed | 0x0000A000,
1995   NEON_SMIN   = NEON3SameFixed | 0x00006800,
1996   NEON_SMINP  = NEON3SameFixed | 0x0000A800,
1997   NEON_SABD   = NEON3SameFixed | 0x00007000,
1998   NEON_SABA   = NEON3SameFixed | 0x00007800,
1999   NEON_UABD   = NEON3SameFixed | NEON3SameUBit | NEON_SABD,
2000   NEON_UABA   = NEON3SameFixed | NEON3SameUBit | NEON_SABA,
2001   NEON_SQADD  = NEON3SameFixed | 0x00000800,
2002   NEON_SQSUB  = NEON3SameFixed | 0x00002800,
2003   NEON_SUB    = NEON3SameFixed | NEON3SameUBit | 0x00008000,
2004   NEON_UHADD  = NEON3SameFixed | NEON3SameUBit | NEON_SHADD,
2005   NEON_UHSUB  = NEON3SameFixed | NEON3SameUBit | NEON_SHSUB,
2006   NEON_URHADD = NEON3SameFixed | NEON3SameUBit | NEON_SRHADD,
2007   NEON_UMAX   = NEON3SameFixed | NEON3SameUBit | NEON_SMAX,
2008   NEON_UMAXP  = NEON3SameFixed | NEON3SameUBit | NEON_SMAXP,
2009   NEON_UMIN   = NEON3SameFixed | NEON3SameUBit | NEON_SMIN,
2010   NEON_UMINP  = NEON3SameFixed | NEON3SameUBit | NEON_SMINP,
2011   NEON_URSHL  = NEON3SameFixed | NEON3SameUBit | NEON_SRSHL,
2012   NEON_UQADD  = NEON3SameFixed | NEON3SameUBit | NEON_SQADD,
2013   NEON_UQRSHL = NEON3SameFixed | NEON3SameUBit | NEON_SQRSHL,
2014   NEON_UQSHL  = NEON3SameFixed | NEON3SameUBit | NEON_SQSHL,
2015   NEON_UQSUB  = NEON3SameFixed | NEON3SameUBit | NEON_SQSUB,
2016   NEON_USHL   = NEON3SameFixed | NEON3SameUBit | NEON_SSHL,
2017   NEON_SQDMULH  = NEON3SameFixed | 0x0000B000,
2018   NEON_SQRDMULH = NEON3SameFixed | 0x2000B000,
2019 
2020   // NEON floating point instructions with three same-type operands.
2021   NEON3SameFPFixed = NEON3SameFixed | 0x0000C000,
2022   NEON3SameFPFMask = NEON3SameFMask | 0x0000C000,
2023   NEON3SameFPMask = NEON3SameMask | 0x00800000,
2024   NEON_FADD    = NEON3SameFixed | 0x0000D000,
2025   NEON_FSUB    = NEON3SameFixed | 0x0080D000,
2026   NEON_FMUL    = NEON3SameFixed | 0x2000D800,
2027   NEON_FDIV    = NEON3SameFixed | 0x2000F800,
2028   NEON_FMAX    = NEON3SameFixed | 0x0000F000,
2029   NEON_FMAXNM  = NEON3SameFixed | 0x0000C000,
2030   NEON_FMAXP   = NEON3SameFixed | 0x2000F000,
2031   NEON_FMAXNMP = NEON3SameFixed | 0x2000C000,
2032   NEON_FMIN    = NEON3SameFixed | 0x0080F000,
2033   NEON_FMINNM  = NEON3SameFixed | 0x0080C000,
2034   NEON_FMINP   = NEON3SameFixed | 0x2080F000,
2035   NEON_FMINNMP = NEON3SameFixed | 0x2080C000,
2036   NEON_FMLA    = NEON3SameFixed | 0x0000C800,
2037   NEON_FMLS    = NEON3SameFixed | 0x0080C800,
2038   NEON_FMULX   = NEON3SameFixed | 0x0000D800,
2039   NEON_FRECPS  = NEON3SameFixed | 0x0000F800,
2040   NEON_FRSQRTS = NEON3SameFixed | 0x0080F800,
2041   NEON_FABD    = NEON3SameFixed | 0x2080D000,
2042   NEON_FADDP   = NEON3SameFixed | 0x2000D000,
2043   NEON_FCMEQ   = NEON3SameFixed | 0x0000E000,
2044   NEON_FCMGE   = NEON3SameFixed | 0x2000E000,
2045   NEON_FCMGT   = NEON3SameFixed | 0x2080E000,
2046   NEON_FACGE   = NEON3SameFixed | 0x2000E800,
2047   NEON_FACGT   = NEON3SameFixed | 0x2080E800,
2048 
2049   // NEON logical instructions with three same-type operands.
2050   NEON3SameLogicalFixed = NEON3SameFixed | 0x00001800,
2051   NEON3SameLogicalFMask = NEON3SameFMask | 0x0000F800,
2052   NEON3SameLogicalMask = 0xBFE0FC00,
2053   NEON3SameLogicalFormatMask = NEON_Q,
2054   NEON_AND = NEON3SameLogicalFixed | 0x00000000,
2055   NEON_ORR = NEON3SameLogicalFixed | 0x00A00000,
2056   NEON_ORN = NEON3SameLogicalFixed | 0x00C00000,
2057   NEON_EOR = NEON3SameLogicalFixed | 0x20000000,
2058   NEON_BIC = NEON3SameLogicalFixed | 0x00400000,
2059   NEON_BIF = NEON3SameLogicalFixed | 0x20C00000,
2060   NEON_BIT = NEON3SameLogicalFixed | 0x20800000,
2061   NEON_BSL = NEON3SameLogicalFixed | 0x20400000,
2062 
2063   // FHM (FMLAL-like) instructions have an oddball encoding scheme under 3Same.
2064   NEON3SameFHMMask = 0xBFE0FC00,                // U  size  opcode
2065   NEON_FMLAL   = NEON3SameFixed | 0x0000E800,   // 0    00   11101
2066   NEON_FMLAL2  = NEON3SameFixed | 0x2000C800,   // 1    00   11001
2067   NEON_FMLSL   = NEON3SameFixed | 0x0080E800,   // 0    10   11101
2068   NEON_FMLSL2  = NEON3SameFixed | 0x2080C800    // 1    10   11001
2069 };
2070 
2071 
2072 enum NEON3SameFP16 {
2073   NEON3SameFP16Fixed = 0x0E400400,
2074   NEON3SameFP16FMask = 0x9F60C400,
2075   NEON3SameFP16Mask =  0xBFE0FC00,
2076   NEON_FMAXNM_H  = NEON3SameFP16Fixed | 0x00000000,
2077   NEON_FMLA_H    = NEON3SameFP16Fixed | 0x00000800,
2078   NEON_FADD_H    = NEON3SameFP16Fixed | 0x00001000,
2079   NEON_FMULX_H   = NEON3SameFP16Fixed | 0x00001800,
2080   NEON_FCMEQ_H   = NEON3SameFP16Fixed | 0x00002000,
2081   NEON_FMAX_H    = NEON3SameFP16Fixed | 0x00003000,
2082   NEON_FRECPS_H  = NEON3SameFP16Fixed | 0x00003800,
2083   NEON_FMINNM_H  = NEON3SameFP16Fixed | 0x00800000,
2084   NEON_FMLS_H    = NEON3SameFP16Fixed | 0x00800800,
2085   NEON_FSUB_H    = NEON3SameFP16Fixed | 0x00801000,
2086   NEON_FMIN_H    = NEON3SameFP16Fixed | 0x00803000,
2087   NEON_FRSQRTS_H = NEON3SameFP16Fixed | 0x00803800,
2088   NEON_FMAXNMP_H = NEON3SameFP16Fixed | 0x20000000,
2089   NEON_FADDP_H   = NEON3SameFP16Fixed | 0x20001000,
2090   NEON_FMUL_H    = NEON3SameFP16Fixed | 0x20001800,
2091   NEON_FCMGE_H   = NEON3SameFP16Fixed | 0x20002000,
2092   NEON_FACGE_H   = NEON3SameFP16Fixed | 0x20002800,
2093   NEON_FMAXP_H   = NEON3SameFP16Fixed | 0x20003000,
2094   NEON_FDIV_H    = NEON3SameFP16Fixed | 0x20003800,
2095   NEON_FMINNMP_H = NEON3SameFP16Fixed | 0x20800000,
2096   NEON_FABD_H    = NEON3SameFP16Fixed | 0x20801000,
2097   NEON_FCMGT_H   = NEON3SameFP16Fixed | 0x20802000,
2098   NEON_FACGT_H   = NEON3SameFP16Fixed | 0x20802800,
2099   NEON_FMINP_H   = NEON3SameFP16Fixed | 0x20803000
2100 };
2101 
2102 
2103 // 'Extra' NEON instructions with three same-type operands.
2104 enum NEON3SameExtraOp {
2105   NEON3SameExtraFixed = 0x0E008400,
2106   NEON3SameExtraUBit = 0x20000000,
2107   NEON3SameExtraFMask = 0x9E208400,
2108   NEON3SameExtraMask = 0xBE20FC00,
2109   NEON_SQRDMLAH = NEON3SameExtraFixed | NEON3SameExtraUBit,
2110   NEON_SQRDMLSH = NEON3SameExtraFixed | NEON3SameExtraUBit | 0x00000800,
2111   NEON_SDOT = NEON3SameExtraFixed | 0x00001000,
2112   NEON_UDOT = NEON3SameExtraFixed | NEON3SameExtraUBit | 0x00001000,
2113 
2114   /* v8.3 Complex Numbers */
2115   NEON3SameExtraFCFixed = 0x2E00C400,
2116   NEON3SameExtraFCFMask = 0xBF20C400,
2117   // FCMLA fixes opcode<3:2>, and uses opcode<1:0> to encode <rotate>.
2118   NEON3SameExtraFCMLAMask = NEON3SameExtraFCFMask | 0x00006000,
2119   NEON_FCMLA = NEON3SameExtraFCFixed,
2120   // FCADD fixes opcode<3:2, 0>, and uses opcode<1> to encode <rotate>.
2121   NEON3SameExtraFCADDMask = NEON3SameExtraFCFMask | 0x00006800,
2122   NEON_FCADD = NEON3SameExtraFCFixed | 0x00002000
2123   // Other encodings under NEON3SameExtraFCFMask are UNALLOCATED.
2124 };
2125 
2126 // NEON instructions with three different-type operands.
2127 enum NEON3DifferentOp {
2128   NEON3DifferentFixed = 0x0E200000,
2129   NEON3DifferentFMask = 0x9F200C00,
2130   NEON3DifferentMask  = 0xFF20FC00,
2131   NEON_ADDHN    = NEON3DifferentFixed | 0x00004000,
2132   NEON_ADDHN2   = NEON_ADDHN | NEON_Q,
2133   NEON_PMULL    = NEON3DifferentFixed | 0x0000E000,
2134   NEON_PMULL2   = NEON_PMULL | NEON_Q,
2135   NEON_RADDHN   = NEON3DifferentFixed | 0x20004000,
2136   NEON_RADDHN2  = NEON_RADDHN | NEON_Q,
2137   NEON_RSUBHN   = NEON3DifferentFixed | 0x20006000,
2138   NEON_RSUBHN2  = NEON_RSUBHN | NEON_Q,
2139   NEON_SABAL    = NEON3DifferentFixed | 0x00005000,
2140   NEON_SABAL2   = NEON_SABAL | NEON_Q,
2141   NEON_SABDL    = NEON3DifferentFixed | 0x00007000,
2142   NEON_SABDL2   = NEON_SABDL | NEON_Q,
2143   NEON_SADDL    = NEON3DifferentFixed | 0x00000000,
2144   NEON_SADDL2   = NEON_SADDL | NEON_Q,
2145   NEON_SADDW    = NEON3DifferentFixed | 0x00001000,
2146   NEON_SADDW2   = NEON_SADDW | NEON_Q,
2147   NEON_SMLAL    = NEON3DifferentFixed | 0x00008000,
2148   NEON_SMLAL2   = NEON_SMLAL | NEON_Q,
2149   NEON_SMLSL    = NEON3DifferentFixed | 0x0000A000,
2150   NEON_SMLSL2   = NEON_SMLSL | NEON_Q,
2151   NEON_SMULL    = NEON3DifferentFixed | 0x0000C000,
2152   NEON_SMULL2   = NEON_SMULL | NEON_Q,
2153   NEON_SSUBL    = NEON3DifferentFixed | 0x00002000,
2154   NEON_SSUBL2   = NEON_SSUBL | NEON_Q,
2155   NEON_SSUBW    = NEON3DifferentFixed | 0x00003000,
2156   NEON_SSUBW2   = NEON_SSUBW | NEON_Q,
2157   NEON_SQDMLAL  = NEON3DifferentFixed | 0x00009000,
2158   NEON_SQDMLAL2 = NEON_SQDMLAL | NEON_Q,
2159   NEON_SQDMLSL  = NEON3DifferentFixed | 0x0000B000,
2160   NEON_SQDMLSL2 = NEON_SQDMLSL | NEON_Q,
2161   NEON_SQDMULL  = NEON3DifferentFixed | 0x0000D000,
2162   NEON_SQDMULL2 = NEON_SQDMULL | NEON_Q,
2163   NEON_SUBHN    = NEON3DifferentFixed | 0x00006000,
2164   NEON_SUBHN2   = NEON_SUBHN | NEON_Q,
2165   NEON_UABAL    = NEON_SABAL | NEON3SameUBit,
2166   NEON_UABAL2   = NEON_UABAL | NEON_Q,
2167   NEON_UABDL    = NEON_SABDL | NEON3SameUBit,
2168   NEON_UABDL2   = NEON_UABDL | NEON_Q,
2169   NEON_UADDL    = NEON_SADDL | NEON3SameUBit,
2170   NEON_UADDL2   = NEON_UADDL | NEON_Q,
2171   NEON_UADDW    = NEON_SADDW | NEON3SameUBit,
2172   NEON_UADDW2   = NEON_UADDW | NEON_Q,
2173   NEON_UMLAL    = NEON_SMLAL | NEON3SameUBit,
2174   NEON_UMLAL2   = NEON_UMLAL | NEON_Q,
2175   NEON_UMLSL    = NEON_SMLSL | NEON3SameUBit,
2176   NEON_UMLSL2   = NEON_UMLSL | NEON_Q,
2177   NEON_UMULL    = NEON_SMULL | NEON3SameUBit,
2178   NEON_UMULL2   = NEON_UMULL | NEON_Q,
2179   NEON_USUBL    = NEON_SSUBL | NEON3SameUBit,
2180   NEON_USUBL2   = NEON_USUBL | NEON_Q,
2181   NEON_USUBW    = NEON_SSUBW | NEON3SameUBit,
2182   NEON_USUBW2   = NEON_USUBW | NEON_Q
2183 };
2184 
2185 // NEON instructions operating across vectors.
2186 enum NEONAcrossLanesOp {
2187   NEONAcrossLanesFixed = 0x0E300800,
2188   NEONAcrossLanesFMask = 0x9F3E0C00,
2189   NEONAcrossLanesMask  = 0xBF3FFC00,
2190   NEON_ADDV   = NEONAcrossLanesFixed | 0x0001B000,
2191   NEON_SADDLV = NEONAcrossLanesFixed | 0x00003000,
2192   NEON_UADDLV = NEONAcrossLanesFixed | 0x20003000,
2193   NEON_SMAXV  = NEONAcrossLanesFixed | 0x0000A000,
2194   NEON_SMINV  = NEONAcrossLanesFixed | 0x0001A000,
2195   NEON_UMAXV  = NEONAcrossLanesFixed | 0x2000A000,
2196   NEON_UMINV  = NEONAcrossLanesFixed | 0x2001A000,
2197 
2198   NEONAcrossLanesFP16Fixed = NEONAcrossLanesFixed | 0x0000C000,
2199   NEONAcrossLanesFP16FMask = NEONAcrossLanesFMask | 0x2000C000,
2200   NEONAcrossLanesFP16Mask  = NEONAcrossLanesMask  | 0x20800000,
2201   NEON_FMAXNMV_H = NEONAcrossLanesFP16Fixed | 0x00000000,
2202   NEON_FMAXV_H   = NEONAcrossLanesFP16Fixed | 0x00003000,
2203   NEON_FMINNMV_H = NEONAcrossLanesFP16Fixed | 0x00800000,
2204   NEON_FMINV_H   = NEONAcrossLanesFP16Fixed | 0x00803000,
2205 
2206   // NEON floating point across instructions.
2207   NEONAcrossLanesFPFixed = NEONAcrossLanesFixed | 0x2000C000,
2208   NEONAcrossLanesFPFMask = NEONAcrossLanesFMask | 0x2000C000,
2209   NEONAcrossLanesFPMask  = NEONAcrossLanesMask  | 0x20800000,
2210 
2211   NEON_FMAXV   = NEONAcrossLanesFPFixed | 0x2000F000,
2212   NEON_FMINV   = NEONAcrossLanesFPFixed | 0x2080F000,
2213   NEON_FMAXNMV = NEONAcrossLanesFPFixed | 0x2000C000,
2214   NEON_FMINNMV = NEONAcrossLanesFPFixed | 0x2080C000
2215 };
2216 
2217 // NEON instructions with indexed element operand.
2218 enum NEONByIndexedElementOp {
2219   NEONByIndexedElementFixed = 0x0F000000,
2220   NEONByIndexedElementFMask = 0x9F000400,
2221   NEONByIndexedElementMask  = 0xBF00F400,
2222   NEON_MUL_byelement   = NEONByIndexedElementFixed | 0x00008000,
2223   NEON_MLA_byelement   = NEONByIndexedElementFixed | 0x20000000,
2224   NEON_MLS_byelement   = NEONByIndexedElementFixed | 0x20004000,
2225   NEON_SMULL_byelement = NEONByIndexedElementFixed | 0x0000A000,
2226   NEON_SMLAL_byelement = NEONByIndexedElementFixed | 0x00002000,
2227   NEON_SMLSL_byelement = NEONByIndexedElementFixed | 0x00006000,
2228   NEON_UMULL_byelement = NEONByIndexedElementFixed | 0x2000A000,
2229   NEON_UMLAL_byelement = NEONByIndexedElementFixed | 0x20002000,
2230   NEON_UMLSL_byelement = NEONByIndexedElementFixed | 0x20006000,
2231   NEON_SQDMULL_byelement = NEONByIndexedElementFixed | 0x0000B000,
2232   NEON_SQDMLAL_byelement = NEONByIndexedElementFixed | 0x00003000,
2233   NEON_SQDMLSL_byelement = NEONByIndexedElementFixed | 0x00007000,
2234   NEON_SQDMULH_byelement  = NEONByIndexedElementFixed | 0x0000C000,
2235   NEON_SQRDMULH_byelement = NEONByIndexedElementFixed | 0x0000D000,
2236   NEON_SDOT_byelement = NEONByIndexedElementFixed | 0x0000E000,
2237   NEON_SQRDMLAH_byelement = NEONByIndexedElementFixed | 0x2000D000,
2238   NEON_UDOT_byelement = NEONByIndexedElementFixed | 0x2000E000,
2239   NEON_SQRDMLSH_byelement = NEONByIndexedElementFixed | 0x2000F000,
2240 
2241   NEON_FMLA_H_byelement   = NEONByIndexedElementFixed | 0x00001000,
2242   NEON_FMLS_H_byelement   = NEONByIndexedElementFixed | 0x00005000,
2243   NEON_FMUL_H_byelement   = NEONByIndexedElementFixed | 0x00009000,
2244   NEON_FMULX_H_byelement  = NEONByIndexedElementFixed | 0x20009000,
2245 
2246   // Floating point instructions.
2247   NEONByIndexedElementFPFixed = NEONByIndexedElementFixed | 0x00800000,
2248   NEONByIndexedElementFPMask = NEONByIndexedElementMask | 0x00800000,
2249   NEON_FMLA_byelement  = NEONByIndexedElementFPFixed | 0x00001000,
2250   NEON_FMLS_byelement  = NEONByIndexedElementFPFixed | 0x00005000,
2251   NEON_FMUL_byelement  = NEONByIndexedElementFPFixed | 0x00009000,
2252   NEON_FMULX_byelement = NEONByIndexedElementFPFixed | 0x20009000,
2253 
2254   // FMLAL-like instructions.
2255   // For all cases: U = x, size = 10, opcode = xx00
2256   NEONByIndexedElementFPLongFixed = NEONByIndexedElementFixed | 0x00800000,
2257   NEONByIndexedElementFPLongFMask = NEONByIndexedElementFMask | 0x00C03000,
2258   NEONByIndexedElementFPLongMask = 0xBFC0F400,
2259   NEON_FMLAL_H_byelement  = NEONByIndexedElementFixed | 0x00800000,
2260   NEON_FMLAL2_H_byelement = NEONByIndexedElementFixed | 0x20808000,
2261   NEON_FMLSL_H_byelement  = NEONByIndexedElementFixed | 0x00804000,
2262   NEON_FMLSL2_H_byelement = NEONByIndexedElementFixed | 0x2080C000,
2263 
2264   // Complex instruction(s).
2265   // This is necessary because the 'rot' encoding moves into the
2266   // NEONByIndex..Mask space.
2267   NEONByIndexedElementFPComplexMask = 0xBF009400,
2268   NEON_FCMLA_byelement = NEONByIndexedElementFixed | 0x20001000
2269 };
2270 
2271 // NEON register copy.
2272 enum NEONCopyOp {
2273   NEONCopyFixed = 0x0E000400,
2274   NEONCopyFMask = 0x9FE08400,
2275   NEONCopyMask  = 0x3FE08400,
2276   NEONCopyInsElementMask = NEONCopyMask | 0x40000000,
2277   NEONCopyInsGeneralMask = NEONCopyMask | 0x40007800,
2278   NEONCopyDupElementMask = NEONCopyMask | 0x20007800,
2279   NEONCopyDupGeneralMask = NEONCopyDupElementMask,
2280   NEONCopyUmovMask       = NEONCopyMask | 0x20007800,
2281   NEONCopySmovMask       = NEONCopyMask | 0x20007800,
2282   NEON_INS_ELEMENT       = NEONCopyFixed | 0x60000000,
2283   NEON_INS_GENERAL       = NEONCopyFixed | 0x40001800,
2284   NEON_DUP_ELEMENT       = NEONCopyFixed | 0x00000000,
2285   NEON_DUP_GENERAL       = NEONCopyFixed | 0x00000800,
2286   NEON_SMOV              = NEONCopyFixed | 0x00002800,
2287   NEON_UMOV              = NEONCopyFixed | 0x00003800
2288 };
2289 
2290 // NEON extract.
2291 enum NEONExtractOp {
2292   NEONExtractFixed = 0x2E000000,
2293   NEONExtractFMask = 0xBF208400,
2294   NEONExtractMask =  0xBFE08400,
2295   NEON_EXT = NEONExtractFixed | 0x00000000
2296 };
2297 
2298 enum NEONLoadStoreMultiOp {
2299   NEONLoadStoreMultiL    = 0x00400000,
2300   NEONLoadStoreMulti1_1v = 0x00007000,
2301   NEONLoadStoreMulti1_2v = 0x0000A000,
2302   NEONLoadStoreMulti1_3v = 0x00006000,
2303   NEONLoadStoreMulti1_4v = 0x00002000,
2304   NEONLoadStoreMulti2    = 0x00008000,
2305   NEONLoadStoreMulti3    = 0x00004000,
2306   NEONLoadStoreMulti4    = 0x00000000
2307 };
2308 
2309 // NEON load/store multiple structures.
2310 enum NEONLoadStoreMultiStructOp {
2311   NEONLoadStoreMultiStructFixed = 0x0C000000,
2312   NEONLoadStoreMultiStructFMask = 0xBFBF0000,
2313   NEONLoadStoreMultiStructMask  = 0xBFFFF000,
2314   NEONLoadStoreMultiStructStore = NEONLoadStoreMultiStructFixed,
2315   NEONLoadStoreMultiStructLoad  = NEONLoadStoreMultiStructFixed |
2316                                   NEONLoadStoreMultiL,
2317   NEON_LD1_1v = NEONLoadStoreMultiStructLoad | NEONLoadStoreMulti1_1v,
2318   NEON_LD1_2v = NEONLoadStoreMultiStructLoad | NEONLoadStoreMulti1_2v,
2319   NEON_LD1_3v = NEONLoadStoreMultiStructLoad | NEONLoadStoreMulti1_3v,
2320   NEON_LD1_4v = NEONLoadStoreMultiStructLoad | NEONLoadStoreMulti1_4v,
2321   NEON_LD2    = NEONLoadStoreMultiStructLoad | NEONLoadStoreMulti2,
2322   NEON_LD3    = NEONLoadStoreMultiStructLoad | NEONLoadStoreMulti3,
2323   NEON_LD4    = NEONLoadStoreMultiStructLoad | NEONLoadStoreMulti4,
2324   NEON_ST1_1v = NEONLoadStoreMultiStructStore | NEONLoadStoreMulti1_1v,
2325   NEON_ST1_2v = NEONLoadStoreMultiStructStore | NEONLoadStoreMulti1_2v,
2326   NEON_ST1_3v = NEONLoadStoreMultiStructStore | NEONLoadStoreMulti1_3v,
2327   NEON_ST1_4v = NEONLoadStoreMultiStructStore | NEONLoadStoreMulti1_4v,
2328   NEON_ST2    = NEONLoadStoreMultiStructStore | NEONLoadStoreMulti2,
2329   NEON_ST3    = NEONLoadStoreMultiStructStore | NEONLoadStoreMulti3,
2330   NEON_ST4    = NEONLoadStoreMultiStructStore | NEONLoadStoreMulti4
2331 };
2332 
2333 // NEON load/store multiple structures with post-index addressing.
2334 enum NEONLoadStoreMultiStructPostIndexOp {
2335   NEONLoadStoreMultiStructPostIndexFixed = 0x0C800000,
2336   NEONLoadStoreMultiStructPostIndexFMask = 0xBFA00000,
2337   NEONLoadStoreMultiStructPostIndexMask  = 0xBFE0F000,
2338   NEONLoadStoreMultiStructPostIndex = 0x00800000,
2339   NEON_LD1_1v_post = NEON_LD1_1v | NEONLoadStoreMultiStructPostIndex,
2340   NEON_LD1_2v_post = NEON_LD1_2v | NEONLoadStoreMultiStructPostIndex,
2341   NEON_LD1_3v_post = NEON_LD1_3v | NEONLoadStoreMultiStructPostIndex,
2342   NEON_LD1_4v_post = NEON_LD1_4v | NEONLoadStoreMultiStructPostIndex,
2343   NEON_LD2_post = NEON_LD2 | NEONLoadStoreMultiStructPostIndex,
2344   NEON_LD3_post = NEON_LD3 | NEONLoadStoreMultiStructPostIndex,
2345   NEON_LD4_post = NEON_LD4 | NEONLoadStoreMultiStructPostIndex,
2346   NEON_ST1_1v_post = NEON_ST1_1v | NEONLoadStoreMultiStructPostIndex,
2347   NEON_ST1_2v_post = NEON_ST1_2v | NEONLoadStoreMultiStructPostIndex,
2348   NEON_ST1_3v_post = NEON_ST1_3v | NEONLoadStoreMultiStructPostIndex,
2349   NEON_ST1_4v_post = NEON_ST1_4v | NEONLoadStoreMultiStructPostIndex,
2350   NEON_ST2_post = NEON_ST2 | NEONLoadStoreMultiStructPostIndex,
2351   NEON_ST3_post = NEON_ST3 | NEONLoadStoreMultiStructPostIndex,
2352   NEON_ST4_post = NEON_ST4 | NEONLoadStoreMultiStructPostIndex
2353 };
2354 
2355 enum NEONLoadStoreSingleOp {
2356   NEONLoadStoreSingle1        = 0x00000000,
2357   NEONLoadStoreSingle2        = 0x00200000,
2358   NEONLoadStoreSingle3        = 0x00002000,
2359   NEONLoadStoreSingle4        = 0x00202000,
2360   NEONLoadStoreSingleL        = 0x00400000,
2361   NEONLoadStoreSingle_b       = 0x00000000,
2362   NEONLoadStoreSingle_h       = 0x00004000,
2363   NEONLoadStoreSingle_s       = 0x00008000,
2364   NEONLoadStoreSingle_d       = 0x00008400,
2365   NEONLoadStoreSingleAllLanes = 0x0000C000,
2366   NEONLoadStoreSingleLenMask  = 0x00202000
2367 };
2368 
2369 // NEON load/store single structure.
2370 enum NEONLoadStoreSingleStructOp {
2371   NEONLoadStoreSingleStructFixed = 0x0D000000,
2372   NEONLoadStoreSingleStructFMask = 0xBF9F0000,
2373   NEONLoadStoreSingleStructMask  = 0xBFFFE000,
2374   NEONLoadStoreSingleStructStore = NEONLoadStoreSingleStructFixed,
2375   NEONLoadStoreSingleStructLoad  = NEONLoadStoreSingleStructFixed |
2376                                    NEONLoadStoreSingleL,
2377   NEONLoadStoreSingleStructLoad1 = NEONLoadStoreSingle1 |
2378                                    NEONLoadStoreSingleStructLoad,
2379   NEONLoadStoreSingleStructLoad2 = NEONLoadStoreSingle2 |
2380                                    NEONLoadStoreSingleStructLoad,
2381   NEONLoadStoreSingleStructLoad3 = NEONLoadStoreSingle3 |
2382                                    NEONLoadStoreSingleStructLoad,
2383   NEONLoadStoreSingleStructLoad4 = NEONLoadStoreSingle4 |
2384                                    NEONLoadStoreSingleStructLoad,
2385   NEONLoadStoreSingleStructStore1 = NEONLoadStoreSingle1 |
2386                                     NEONLoadStoreSingleStructFixed,
2387   NEONLoadStoreSingleStructStore2 = NEONLoadStoreSingle2 |
2388                                     NEONLoadStoreSingleStructFixed,
2389   NEONLoadStoreSingleStructStore3 = NEONLoadStoreSingle3 |
2390                                     NEONLoadStoreSingleStructFixed,
2391   NEONLoadStoreSingleStructStore4 = NEONLoadStoreSingle4 |
2392                                     NEONLoadStoreSingleStructFixed,
2393   NEON_LD1_b = NEONLoadStoreSingleStructLoad1 | NEONLoadStoreSingle_b,
2394   NEON_LD1_h = NEONLoadStoreSingleStructLoad1 | NEONLoadStoreSingle_h,
2395   NEON_LD1_s = NEONLoadStoreSingleStructLoad1 | NEONLoadStoreSingle_s,
2396   NEON_LD1_d = NEONLoadStoreSingleStructLoad1 | NEONLoadStoreSingle_d,
2397   NEON_LD1R  = NEONLoadStoreSingleStructLoad1 | NEONLoadStoreSingleAllLanes,
2398   NEON_ST1_b = NEONLoadStoreSingleStructStore1 | NEONLoadStoreSingle_b,
2399   NEON_ST1_h = NEONLoadStoreSingleStructStore1 | NEONLoadStoreSingle_h,
2400   NEON_ST1_s = NEONLoadStoreSingleStructStore1 | NEONLoadStoreSingle_s,
2401   NEON_ST1_d = NEONLoadStoreSingleStructStore1 | NEONLoadStoreSingle_d,
2402 
2403   NEON_LD2_b = NEONLoadStoreSingleStructLoad2 | NEONLoadStoreSingle_b,
2404   NEON_LD2_h = NEONLoadStoreSingleStructLoad2 | NEONLoadStoreSingle_h,
2405   NEON_LD2_s = NEONLoadStoreSingleStructLoad2 | NEONLoadStoreSingle_s,
2406   NEON_LD2_d = NEONLoadStoreSingleStructLoad2 | NEONLoadStoreSingle_d,
2407   NEON_LD2R  = NEONLoadStoreSingleStructLoad2 | NEONLoadStoreSingleAllLanes,
2408   NEON_ST2_b = NEONLoadStoreSingleStructStore2 | NEONLoadStoreSingle_b,
2409   NEON_ST2_h = NEONLoadStoreSingleStructStore2 | NEONLoadStoreSingle_h,
2410   NEON_ST2_s = NEONLoadStoreSingleStructStore2 | NEONLoadStoreSingle_s,
2411   NEON_ST2_d = NEONLoadStoreSingleStructStore2 | NEONLoadStoreSingle_d,
2412 
2413   NEON_LD3_b = NEONLoadStoreSingleStructLoad3 | NEONLoadStoreSingle_b,
2414   NEON_LD3_h = NEONLoadStoreSingleStructLoad3 | NEONLoadStoreSingle_h,
2415   NEON_LD3_s = NEONLoadStoreSingleStructLoad3 | NEONLoadStoreSingle_s,
2416   NEON_LD3_d = NEONLoadStoreSingleStructLoad3 | NEONLoadStoreSingle_d,
2417   NEON_LD3R  = NEONLoadStoreSingleStructLoad3 | NEONLoadStoreSingleAllLanes,
2418   NEON_ST3_b = NEONLoadStoreSingleStructStore3 | NEONLoadStoreSingle_b,
2419   NEON_ST3_h = NEONLoadStoreSingleStructStore3 | NEONLoadStoreSingle_h,
2420   NEON_ST3_s = NEONLoadStoreSingleStructStore3 | NEONLoadStoreSingle_s,
2421   NEON_ST3_d = NEONLoadStoreSingleStructStore3 | NEONLoadStoreSingle_d,
2422 
2423   NEON_LD4_b = NEONLoadStoreSingleStructLoad4 | NEONLoadStoreSingle_b,
2424   NEON_LD4_h = NEONLoadStoreSingleStructLoad4 | NEONLoadStoreSingle_h,
2425   NEON_LD4_s = NEONLoadStoreSingleStructLoad4 | NEONLoadStoreSingle_s,
2426   NEON_LD4_d = NEONLoadStoreSingleStructLoad4 | NEONLoadStoreSingle_d,
2427   NEON_LD4R  = NEONLoadStoreSingleStructLoad4 | NEONLoadStoreSingleAllLanes,
2428   NEON_ST4_b = NEONLoadStoreSingleStructStore4 | NEONLoadStoreSingle_b,
2429   NEON_ST4_h = NEONLoadStoreSingleStructStore4 | NEONLoadStoreSingle_h,
2430   NEON_ST4_s = NEONLoadStoreSingleStructStore4 | NEONLoadStoreSingle_s,
2431   NEON_ST4_d = NEONLoadStoreSingleStructStore4 | NEONLoadStoreSingle_d
2432 };
2433 
2434 // NEON load/store single structure with post-index addressing.
2435 enum NEONLoadStoreSingleStructPostIndexOp {
2436   NEONLoadStoreSingleStructPostIndexFixed = 0x0D800000,
2437   NEONLoadStoreSingleStructPostIndexFMask = 0xBF800000,
2438   NEONLoadStoreSingleStructPostIndexMask  = 0xBFE0E000,
2439   NEONLoadStoreSingleStructPostIndex =      0x00800000,
2440   NEON_LD1_b_post = NEON_LD1_b | NEONLoadStoreSingleStructPostIndex,
2441   NEON_LD1_h_post = NEON_LD1_h | NEONLoadStoreSingleStructPostIndex,
2442   NEON_LD1_s_post = NEON_LD1_s | NEONLoadStoreSingleStructPostIndex,
2443   NEON_LD1_d_post = NEON_LD1_d | NEONLoadStoreSingleStructPostIndex,
2444   NEON_LD1R_post  = NEON_LD1R | NEONLoadStoreSingleStructPostIndex,
2445   NEON_ST1_b_post = NEON_ST1_b | NEONLoadStoreSingleStructPostIndex,
2446   NEON_ST1_h_post = NEON_ST1_h | NEONLoadStoreSingleStructPostIndex,
2447   NEON_ST1_s_post = NEON_ST1_s | NEONLoadStoreSingleStructPostIndex,
2448   NEON_ST1_d_post = NEON_ST1_d | NEONLoadStoreSingleStructPostIndex,
2449 
2450   NEON_LD2_b_post = NEON_LD2_b | NEONLoadStoreSingleStructPostIndex,
2451   NEON_LD2_h_post = NEON_LD2_h | NEONLoadStoreSingleStructPostIndex,
2452   NEON_LD2_s_post = NEON_LD2_s | NEONLoadStoreSingleStructPostIndex,
2453   NEON_LD2_d_post = NEON_LD2_d | NEONLoadStoreSingleStructPostIndex,
2454   NEON_LD2R_post  = NEON_LD2R | NEONLoadStoreSingleStructPostIndex,
2455   NEON_ST2_b_post = NEON_ST2_b | NEONLoadStoreSingleStructPostIndex,
2456   NEON_ST2_h_post = NEON_ST2_h | NEONLoadStoreSingleStructPostIndex,
2457   NEON_ST2_s_post = NEON_ST2_s | NEONLoadStoreSingleStructPostIndex,
2458   NEON_ST2_d_post = NEON_ST2_d | NEONLoadStoreSingleStructPostIndex,
2459 
2460   NEON_LD3_b_post = NEON_LD3_b | NEONLoadStoreSingleStructPostIndex,
2461   NEON_LD3_h_post = NEON_LD3_h | NEONLoadStoreSingleStructPostIndex,
2462   NEON_LD3_s_post = NEON_LD3_s | NEONLoadStoreSingleStructPostIndex,
2463   NEON_LD3_d_post = NEON_LD3_d | NEONLoadStoreSingleStructPostIndex,
2464   NEON_LD3R_post  = NEON_LD3R | NEONLoadStoreSingleStructPostIndex,
2465   NEON_ST3_b_post = NEON_ST3_b | NEONLoadStoreSingleStructPostIndex,
2466   NEON_ST3_h_post = NEON_ST3_h | NEONLoadStoreSingleStructPostIndex,
2467   NEON_ST3_s_post = NEON_ST3_s | NEONLoadStoreSingleStructPostIndex,
2468   NEON_ST3_d_post = NEON_ST3_d | NEONLoadStoreSingleStructPostIndex,
2469 
2470   NEON_LD4_b_post = NEON_LD4_b | NEONLoadStoreSingleStructPostIndex,
2471   NEON_LD4_h_post = NEON_LD4_h | NEONLoadStoreSingleStructPostIndex,
2472   NEON_LD4_s_post = NEON_LD4_s | NEONLoadStoreSingleStructPostIndex,
2473   NEON_LD4_d_post = NEON_LD4_d | NEONLoadStoreSingleStructPostIndex,
2474   NEON_LD4R_post  = NEON_LD4R | NEONLoadStoreSingleStructPostIndex,
2475   NEON_ST4_b_post = NEON_ST4_b | NEONLoadStoreSingleStructPostIndex,
2476   NEON_ST4_h_post = NEON_ST4_h | NEONLoadStoreSingleStructPostIndex,
2477   NEON_ST4_s_post = NEON_ST4_s | NEONLoadStoreSingleStructPostIndex,
2478   NEON_ST4_d_post = NEON_ST4_d | NEONLoadStoreSingleStructPostIndex
2479 };
2480 
2481 // NEON modified immediate.
2482 enum NEONModifiedImmediateOp {
2483   NEONModifiedImmediateFixed = 0x0F000400,
2484   NEONModifiedImmediateFMask = 0x9FF80400,
2485   NEONModifiedImmediateOpBit = 0x20000000,
2486   NEONModifiedImmediate_FMOV = NEONModifiedImmediateFixed | 0x00000800,
2487   NEONModifiedImmediate_MOVI = NEONModifiedImmediateFixed | 0x00000000,
2488   NEONModifiedImmediate_MVNI = NEONModifiedImmediateFixed | 0x20000000,
2489   NEONModifiedImmediate_ORR  = NEONModifiedImmediateFixed | 0x00001000,
2490   NEONModifiedImmediate_BIC  = NEONModifiedImmediateFixed | 0x20001000
2491 };
2492 
2493 // NEON shift immediate.
2494 enum NEONShiftImmediateOp {
2495   NEONShiftImmediateFixed = 0x0F000400,
2496   NEONShiftImmediateFMask = 0x9F800400,
2497   NEONShiftImmediateMask  = 0xBF80FC00,
2498   NEONShiftImmediateUBit  = 0x20000000,
2499   NEON_SHL      = NEONShiftImmediateFixed | 0x00005000,
2500   NEON_SSHLL    = NEONShiftImmediateFixed | 0x0000A000,
2501   NEON_USHLL    = NEONShiftImmediateFixed | 0x2000A000,
2502   NEON_SLI      = NEONShiftImmediateFixed | 0x20005000,
2503   NEON_SRI      = NEONShiftImmediateFixed | 0x20004000,
2504   NEON_SHRN     = NEONShiftImmediateFixed | 0x00008000,
2505   NEON_RSHRN    = NEONShiftImmediateFixed | 0x00008800,
2506   NEON_UQSHRN   = NEONShiftImmediateFixed | 0x20009000,
2507   NEON_UQRSHRN  = NEONShiftImmediateFixed | 0x20009800,
2508   NEON_SQSHRN   = NEONShiftImmediateFixed | 0x00009000,
2509   NEON_SQRSHRN  = NEONShiftImmediateFixed | 0x00009800,
2510   NEON_SQSHRUN  = NEONShiftImmediateFixed | 0x20008000,
2511   NEON_SQRSHRUN = NEONShiftImmediateFixed | 0x20008800,
2512   NEON_SSHR     = NEONShiftImmediateFixed | 0x00000000,
2513   NEON_SRSHR    = NEONShiftImmediateFixed | 0x00002000,
2514   NEON_USHR     = NEONShiftImmediateFixed | 0x20000000,
2515   NEON_URSHR    = NEONShiftImmediateFixed | 0x20002000,
2516   NEON_SSRA     = NEONShiftImmediateFixed | 0x00001000,
2517   NEON_SRSRA    = NEONShiftImmediateFixed | 0x00003000,
2518   NEON_USRA     = NEONShiftImmediateFixed | 0x20001000,
2519   NEON_URSRA    = NEONShiftImmediateFixed | 0x20003000,
2520   NEON_SQSHLU   = NEONShiftImmediateFixed | 0x20006000,
2521   NEON_SCVTF_imm = NEONShiftImmediateFixed | 0x0000E000,
2522   NEON_UCVTF_imm = NEONShiftImmediateFixed | 0x2000E000,
2523   NEON_FCVTZS_imm = NEONShiftImmediateFixed | 0x0000F800,
2524   NEON_FCVTZU_imm = NEONShiftImmediateFixed | 0x2000F800,
2525   NEON_SQSHL_imm = NEONShiftImmediateFixed | 0x00007000,
2526   NEON_UQSHL_imm = NEONShiftImmediateFixed | 0x20007000
2527 };
2528 
2529 // NEON table.
2530 enum NEONTableOp {
2531   NEONTableFixed = 0x0E000000,
2532   NEONTableFMask = 0xBF208C00,
2533   NEONTableExt   = 0x00001000,
2534   NEONTableMask  = 0xBF20FC00,
2535   NEON_TBL_1v    = NEONTableFixed | 0x00000000,
2536   NEON_TBL_2v    = NEONTableFixed | 0x00002000,
2537   NEON_TBL_3v    = NEONTableFixed | 0x00004000,
2538   NEON_TBL_4v    = NEONTableFixed | 0x00006000,
2539   NEON_TBX_1v    = NEON_TBL_1v | NEONTableExt,
2540   NEON_TBX_2v    = NEON_TBL_2v | NEONTableExt,
2541   NEON_TBX_3v    = NEON_TBL_3v | NEONTableExt,
2542   NEON_TBX_4v    = NEON_TBL_4v | NEONTableExt
2543 };
2544 
2545 // NEON perm.
2546 enum NEONPermOp {
2547   NEONPermFixed = 0x0E000800,
2548   NEONPermFMask = 0xBF208C00,
2549   NEONPermMask  = 0x3F20FC00,
2550   NEON_UZP1 = NEONPermFixed | 0x00001000,
2551   NEON_TRN1 = NEONPermFixed | 0x00002000,
2552   NEON_ZIP1 = NEONPermFixed | 0x00003000,
2553   NEON_UZP2 = NEONPermFixed | 0x00005000,
2554   NEON_TRN2 = NEONPermFixed | 0x00006000,
2555   NEON_ZIP2 = NEONPermFixed | 0x00007000
2556 };
2557 
2558 // NEON scalar instructions with two register operands.
2559 enum NEONScalar2RegMiscOp {
2560   NEONScalar2RegMiscFixed = 0x5E200800,
2561   NEONScalar2RegMiscFMask = 0xDF3E0C00,
2562   NEONScalar2RegMiscMask = NEON_Q | NEONScalar | NEON2RegMiscMask,
2563   NEON_CMGT_zero_scalar = NEON_Q | NEONScalar | NEON_CMGT_zero,
2564   NEON_CMEQ_zero_scalar = NEON_Q | NEONScalar | NEON_CMEQ_zero,
2565   NEON_CMLT_zero_scalar = NEON_Q | NEONScalar | NEON_CMLT_zero,
2566   NEON_CMGE_zero_scalar = NEON_Q | NEONScalar | NEON_CMGE_zero,
2567   NEON_CMLE_zero_scalar = NEON_Q | NEONScalar | NEON_CMLE_zero,
2568   NEON_ABS_scalar       = NEON_Q | NEONScalar | NEON_ABS,
2569   NEON_SQABS_scalar     = NEON_Q | NEONScalar | NEON_SQABS,
2570   NEON_NEG_scalar       = NEON_Q | NEONScalar | NEON_NEG,
2571   NEON_SQNEG_scalar     = NEON_Q | NEONScalar | NEON_SQNEG,
2572   NEON_SQXTN_scalar     = NEON_Q | NEONScalar | NEON_SQXTN,
2573   NEON_UQXTN_scalar     = NEON_Q | NEONScalar | NEON_UQXTN,
2574   NEON_SQXTUN_scalar    = NEON_Q | NEONScalar | NEON_SQXTUN,
2575   NEON_SUQADD_scalar    = NEON_Q | NEONScalar | NEON_SUQADD,
2576   NEON_USQADD_scalar    = NEON_Q | NEONScalar | NEON_USQADD,
2577 
2578   NEONScalar2RegMiscOpcode = NEON2RegMiscOpcode,
2579   NEON_NEG_scalar_opcode = NEON_NEG_scalar & NEONScalar2RegMiscOpcode,
2580 
2581   NEONScalar2RegMiscFPMask  = NEONScalar2RegMiscMask | 0x00800000,
2582   NEON_FRSQRTE_scalar    = NEON_Q | NEONScalar | NEON_FRSQRTE,
2583   NEON_FRECPE_scalar     = NEON_Q | NEONScalar | NEON_FRECPE,
2584   NEON_SCVTF_scalar      = NEON_Q | NEONScalar | NEON_SCVTF,
2585   NEON_UCVTF_scalar      = NEON_Q | NEONScalar | NEON_UCVTF,
2586   NEON_FCMGT_zero_scalar = NEON_Q | NEONScalar | NEON_FCMGT_zero,
2587   NEON_FCMEQ_zero_scalar = NEON_Q | NEONScalar | NEON_FCMEQ_zero,
2588   NEON_FCMLT_zero_scalar = NEON_Q | NEONScalar | NEON_FCMLT_zero,
2589   NEON_FCMGE_zero_scalar = NEON_Q | NEONScalar | NEON_FCMGE_zero,
2590   NEON_FCMLE_zero_scalar = NEON_Q | NEONScalar | NEON_FCMLE_zero,
2591   NEON_FRECPX_scalar     = NEONScalar2RegMiscFixed | 0x0081F000,
2592   NEON_FCVTNS_scalar     = NEON_Q | NEONScalar | NEON_FCVTNS,
2593   NEON_FCVTNU_scalar     = NEON_Q | NEONScalar | NEON_FCVTNU,
2594   NEON_FCVTPS_scalar     = NEON_Q | NEONScalar | NEON_FCVTPS,
2595   NEON_FCVTPU_scalar     = NEON_Q | NEONScalar | NEON_FCVTPU,
2596   NEON_FCVTMS_scalar     = NEON_Q | NEONScalar | NEON_FCVTMS,
2597   NEON_FCVTMU_scalar     = NEON_Q | NEONScalar | NEON_FCVTMU,
2598   NEON_FCVTZS_scalar     = NEON_Q | NEONScalar | NEON_FCVTZS,
2599   NEON_FCVTZU_scalar     = NEON_Q | NEONScalar | NEON_FCVTZU,
2600   NEON_FCVTAS_scalar     = NEON_Q | NEONScalar | NEON_FCVTAS,
2601   NEON_FCVTAU_scalar     = NEON_Q | NEONScalar | NEON_FCVTAU,
2602   NEON_FCVTXN_scalar     = NEON_Q | NEONScalar | NEON_FCVTXN
2603 };
2604 
2605 // NEON instructions with two register operands (FP16).
2606 enum NEONScalar2RegMiscFP16Op {
2607   NEONScalar2RegMiscFP16Fixed = 0x5E780800,
2608   NEONScalar2RegMiscFP16FMask = 0xDF7E0C00,
2609   NEONScalar2RegMiscFP16Mask  = 0xFFFFFC00,
2610   NEON_FCVTNS_H_scalar     = NEON_Q | NEONScalar | NEON_FCVTNS_H,
2611   NEON_FCVTMS_H_scalar     = NEON_Q | NEONScalar | NEON_FCVTMS_H,
2612   NEON_FCVTAS_H_scalar     = NEON_Q | NEONScalar | NEON_FCVTAS_H,
2613   NEON_SCVTF_H_scalar      = NEON_Q | NEONScalar | NEON_SCVTF_H,
2614   NEON_FCMGT_H_zero_scalar = NEON_Q | NEONScalar | NEON_FCMGT_H_zero,
2615   NEON_FCMEQ_H_zero_scalar = NEON_Q | NEONScalar | NEON_FCMEQ_H_zero,
2616   NEON_FCMLT_H_zero_scalar = NEON_Q | NEONScalar | NEON_FCMLT_H_zero,
2617   NEON_FCVTPS_H_scalar     = NEON_Q | NEONScalar | NEON_FCVTPS_H,
2618   NEON_FCVTZS_H_scalar     = NEON_Q | NEONScalar | NEON_FCVTZS_H,
2619   NEON_FRECPE_H_scalar     = NEON_Q | NEONScalar | NEON_FRECPE_H,
2620   NEON_FRECPX_H_scalar     = NEONScalar2RegMiscFP16Fixed | 0x0081F000,
2621   NEON_FCVTNU_H_scalar     = NEON_Q | NEONScalar | NEON_FCVTNU_H,
2622   NEON_FCVTMU_H_scalar     = NEON_Q | NEONScalar | NEON_FCVTMU_H,
2623   NEON_FCVTAU_H_scalar     = NEON_Q | NEONScalar | NEON_FCVTAU_H,
2624   NEON_UCVTF_H_scalar      = NEON_Q | NEONScalar | NEON_UCVTF_H,
2625   NEON_FCMGE_H_zero_scalar = NEON_Q | NEONScalar | NEON_FCMGE_H_zero,
2626   NEON_FCMLE_H_zero_scalar = NEON_Q | NEONScalar | NEON_FCMLE_H_zero,
2627   NEON_FCVTPU_H_scalar     = NEON_Q | NEONScalar | NEON_FCVTPU_H,
2628   NEON_FCVTZU_H_scalar     = NEON_Q | NEONScalar | NEON_FCVTZU_H,
2629   NEON_FRSQRTE_H_scalar    = NEON_Q | NEONScalar | NEON_FRSQRTE_H
2630 };
2631 
2632 // NEON scalar instructions with three same-type operands.
2633 enum NEONScalar3SameOp {
2634   NEONScalar3SameFixed = 0x5E200400,
2635   NEONScalar3SameFMask = 0xDF200400,
2636   NEONScalar3SameMask  = 0xFF20FC00,
2637   NEON_ADD_scalar    = NEON_Q | NEONScalar | NEON_ADD,
2638   NEON_CMEQ_scalar   = NEON_Q | NEONScalar | NEON_CMEQ,
2639   NEON_CMGE_scalar   = NEON_Q | NEONScalar | NEON_CMGE,
2640   NEON_CMGT_scalar   = NEON_Q | NEONScalar | NEON_CMGT,
2641   NEON_CMHI_scalar   = NEON_Q | NEONScalar | NEON_CMHI,
2642   NEON_CMHS_scalar   = NEON_Q | NEONScalar | NEON_CMHS,
2643   NEON_CMTST_scalar  = NEON_Q | NEONScalar | NEON_CMTST,
2644   NEON_SUB_scalar    = NEON_Q | NEONScalar | NEON_SUB,
2645   NEON_UQADD_scalar  = NEON_Q | NEONScalar | NEON_UQADD,
2646   NEON_SQADD_scalar  = NEON_Q | NEONScalar | NEON_SQADD,
2647   NEON_UQSUB_scalar  = NEON_Q | NEONScalar | NEON_UQSUB,
2648   NEON_SQSUB_scalar  = NEON_Q | NEONScalar | NEON_SQSUB,
2649   NEON_USHL_scalar   = NEON_Q | NEONScalar | NEON_USHL,
2650   NEON_SSHL_scalar   = NEON_Q | NEONScalar | NEON_SSHL,
2651   NEON_UQSHL_scalar  = NEON_Q | NEONScalar | NEON_UQSHL,
2652   NEON_SQSHL_scalar  = NEON_Q | NEONScalar | NEON_SQSHL,
2653   NEON_URSHL_scalar  = NEON_Q | NEONScalar | NEON_URSHL,
2654   NEON_SRSHL_scalar  = NEON_Q | NEONScalar | NEON_SRSHL,
2655   NEON_UQRSHL_scalar = NEON_Q | NEONScalar | NEON_UQRSHL,
2656   NEON_SQRSHL_scalar = NEON_Q | NEONScalar | NEON_SQRSHL,
2657   NEON_SQDMULH_scalar = NEON_Q | NEONScalar | NEON_SQDMULH,
2658   NEON_SQRDMULH_scalar = NEON_Q | NEONScalar | NEON_SQRDMULH,
2659 
2660   // NEON floating point scalar instructions with three same-type operands.
2661   NEONScalar3SameFPFixed = NEONScalar3SameFixed | 0x0000C000,
2662   NEONScalar3SameFPFMask = NEONScalar3SameFMask | 0x0000C000,
2663   NEONScalar3SameFPMask  = NEONScalar3SameMask | 0x00800000,
2664   NEON_FACGE_scalar   = NEON_Q | NEONScalar | NEON_FACGE,
2665   NEON_FACGT_scalar   = NEON_Q | NEONScalar | NEON_FACGT,
2666   NEON_FCMEQ_scalar   = NEON_Q | NEONScalar | NEON_FCMEQ,
2667   NEON_FCMGE_scalar   = NEON_Q | NEONScalar | NEON_FCMGE,
2668   NEON_FCMGT_scalar   = NEON_Q | NEONScalar | NEON_FCMGT,
2669   NEON_FMULX_scalar   = NEON_Q | NEONScalar | NEON_FMULX,
2670   NEON_FRECPS_scalar  = NEON_Q | NEONScalar | NEON_FRECPS,
2671   NEON_FRSQRTS_scalar = NEON_Q | NEONScalar | NEON_FRSQRTS,
2672   NEON_FABD_scalar    = NEON_Q | NEONScalar | NEON_FABD
2673 };
2674 
2675 // NEON scalar FP16 instructions with three same-type operands.
2676 enum NEONScalar3SameFP16Op {
2677   NEONScalar3SameFP16Fixed = 0x5E400400,
2678   NEONScalar3SameFP16FMask = 0xDF60C400,
2679   NEONScalar3SameFP16Mask  = 0xFFE0FC00,
2680   NEON_FABD_H_scalar    = NEON_Q | NEONScalar | NEON_FABD_H,
2681   NEON_FMULX_H_scalar   = NEON_Q | NEONScalar | NEON_FMULX_H,
2682   NEON_FCMEQ_H_scalar   = NEON_Q | NEONScalar | NEON_FCMEQ_H,
2683   NEON_FCMGE_H_scalar   = NEON_Q | NEONScalar | NEON_FCMGE_H,
2684   NEON_FCMGT_H_scalar   = NEON_Q | NEONScalar | NEON_FCMGT_H,
2685   NEON_FACGE_H_scalar   = NEON_Q | NEONScalar | NEON_FACGE_H,
2686   NEON_FACGT_H_scalar   = NEON_Q | NEONScalar | NEON_FACGT_H,
2687   NEON_FRECPS_H_scalar  = NEON_Q | NEONScalar | NEON_FRECPS_H,
2688   NEON_FRSQRTS_H_scalar = NEON_Q | NEONScalar | NEON_FRSQRTS_H
2689 };
2690 
2691 // 'Extra' NEON scalar instructions with three same-type operands.
2692 enum NEONScalar3SameExtraOp {
2693   NEONScalar3SameExtraFixed = 0x5E008400,
2694   NEONScalar3SameExtraFMask = 0xDF208400,
2695   NEONScalar3SameExtraMask = 0xFF20FC00,
2696   NEON_SQRDMLAH_scalar = NEON_Q | NEONScalar | NEON_SQRDMLAH,
2697   NEON_SQRDMLSH_scalar = NEON_Q | NEONScalar | NEON_SQRDMLSH
2698 };
2699 
2700 // NEON scalar instructions with three different-type operands.
2701 enum NEONScalar3DiffOp {
2702   NEONScalar3DiffFixed = 0x5E200000,
2703   NEONScalar3DiffFMask = 0xDF200C00,
2704   NEONScalar3DiffMask  = NEON_Q | NEONScalar | NEON3DifferentMask,
2705   NEON_SQDMLAL_scalar  = NEON_Q | NEONScalar | NEON_SQDMLAL,
2706   NEON_SQDMLSL_scalar  = NEON_Q | NEONScalar | NEON_SQDMLSL,
2707   NEON_SQDMULL_scalar  = NEON_Q | NEONScalar | NEON_SQDMULL
2708 };
2709 
2710 // NEON scalar instructions with indexed element operand.
2711 enum NEONScalarByIndexedElementOp {
2712   NEONScalarByIndexedElementFixed = 0x5F000000,
2713   NEONScalarByIndexedElementFMask = 0xDF000400,
2714   NEONScalarByIndexedElementMask  = 0xFF00F400,
2715   NEON_SQDMLAL_byelement_scalar  = NEON_Q | NEONScalar | NEON_SQDMLAL_byelement,
2716   NEON_SQDMLSL_byelement_scalar  = NEON_Q | NEONScalar | NEON_SQDMLSL_byelement,
2717   NEON_SQDMULL_byelement_scalar  = NEON_Q | NEONScalar | NEON_SQDMULL_byelement,
2718   NEON_SQDMULH_byelement_scalar  = NEON_Q | NEONScalar | NEON_SQDMULH_byelement,
2719   NEON_SQRDMULH_byelement_scalar
2720     = NEON_Q | NEONScalar | NEON_SQRDMULH_byelement,
2721   NEON_SQRDMLAH_byelement_scalar
2722     = NEON_Q | NEONScalar | NEON_SQRDMLAH_byelement,
2723   NEON_SQRDMLSH_byelement_scalar
2724     = NEON_Q | NEONScalar | NEON_SQRDMLSH_byelement,
2725   NEON_FMLA_H_byelement_scalar  = NEON_Q | NEONScalar | NEON_FMLA_H_byelement,
2726   NEON_FMLS_H_byelement_scalar  = NEON_Q | NEONScalar | NEON_FMLS_H_byelement,
2727   NEON_FMUL_H_byelement_scalar  = NEON_Q | NEONScalar | NEON_FMUL_H_byelement,
2728   NEON_FMULX_H_byelement_scalar = NEON_Q | NEONScalar | NEON_FMULX_H_byelement,
2729 
2730   // Floating point instructions.
2731   NEONScalarByIndexedElementFPFixed
2732     = NEONScalarByIndexedElementFixed | 0x00800000,
2733   NEONScalarByIndexedElementFPMask
2734     = NEONScalarByIndexedElementMask | 0x00800000,
2735   NEON_FMLA_byelement_scalar  = NEON_Q | NEONScalar | NEON_FMLA_byelement,
2736   NEON_FMLS_byelement_scalar  = NEON_Q | NEONScalar | NEON_FMLS_byelement,
2737   NEON_FMUL_byelement_scalar  = NEON_Q | NEONScalar | NEON_FMUL_byelement,
2738   NEON_FMULX_byelement_scalar = NEON_Q | NEONScalar | NEON_FMULX_byelement
2739 };
2740 
2741 // NEON scalar register copy.
2742 enum NEONScalarCopyOp {
2743   NEONScalarCopyFixed = 0x5E000400,
2744   NEONScalarCopyFMask = 0xDFE08400,
2745   NEONScalarCopyMask  = 0xFFE0FC00,
2746   NEON_DUP_ELEMENT_scalar = NEON_Q | NEONScalar | NEON_DUP_ELEMENT
2747 };
2748 
2749 // NEON scalar pairwise instructions.
2750 enum NEONScalarPairwiseOp {
2751   NEONScalarPairwiseFixed = 0x5E300800,
2752   NEONScalarPairwiseFMask = 0xDF3E0C00,
2753   NEONScalarPairwiseMask  = 0xFFB1F800,
2754   NEON_ADDP_scalar      = NEONScalarPairwiseFixed | 0x0081B000,
2755   NEON_FMAXNMP_h_scalar = NEONScalarPairwiseFixed | 0x0000C000,
2756   NEON_FADDP_h_scalar   = NEONScalarPairwiseFixed | 0x0000D000,
2757   NEON_FMAXP_h_scalar   = NEONScalarPairwiseFixed | 0x0000F000,
2758   NEON_FMINNMP_h_scalar = NEONScalarPairwiseFixed | 0x0080C000,
2759   NEON_FMINP_h_scalar   = NEONScalarPairwiseFixed | 0x0080F000,
2760   NEON_FMAXNMP_scalar   = NEONScalarPairwiseFixed | 0x2000C000,
2761   NEON_FMINNMP_scalar   = NEONScalarPairwiseFixed | 0x2080C000,
2762   NEON_FADDP_scalar     = NEONScalarPairwiseFixed | 0x2000D000,
2763   NEON_FMAXP_scalar     = NEONScalarPairwiseFixed | 0x2000F000,
2764   NEON_FMINP_scalar     = NEONScalarPairwiseFixed | 0x2080F000
2765 };
2766 
2767 // NEON scalar shift immediate.
2768 enum NEONScalarShiftImmediateOp {
2769   NEONScalarShiftImmediateFixed = 0x5F000400,
2770   NEONScalarShiftImmediateFMask = 0xDF800400,
2771   NEONScalarShiftImmediateMask  = 0xFF80FC00,
2772   NEON_SHL_scalar  =       NEON_Q | NEONScalar | NEON_SHL,
2773   NEON_SLI_scalar  =       NEON_Q | NEONScalar | NEON_SLI,
2774   NEON_SRI_scalar  =       NEON_Q | NEONScalar | NEON_SRI,
2775   NEON_SSHR_scalar =       NEON_Q | NEONScalar | NEON_SSHR,
2776   NEON_USHR_scalar =       NEON_Q | NEONScalar | NEON_USHR,
2777   NEON_SRSHR_scalar =      NEON_Q | NEONScalar | NEON_SRSHR,
2778   NEON_URSHR_scalar =      NEON_Q | NEONScalar | NEON_URSHR,
2779   NEON_SSRA_scalar =       NEON_Q | NEONScalar | NEON_SSRA,
2780   NEON_USRA_scalar =       NEON_Q | NEONScalar | NEON_USRA,
2781   NEON_SRSRA_scalar =      NEON_Q | NEONScalar | NEON_SRSRA,
2782   NEON_URSRA_scalar =      NEON_Q | NEONScalar | NEON_URSRA,
2783   NEON_UQSHRN_scalar =     NEON_Q | NEONScalar | NEON_UQSHRN,
2784   NEON_UQRSHRN_scalar =    NEON_Q | NEONScalar | NEON_UQRSHRN,
2785   NEON_SQSHRN_scalar =     NEON_Q | NEONScalar | NEON_SQSHRN,
2786   NEON_SQRSHRN_scalar =    NEON_Q | NEONScalar | NEON_SQRSHRN,
2787   NEON_SQSHRUN_scalar =    NEON_Q | NEONScalar | NEON_SQSHRUN,
2788   NEON_SQRSHRUN_scalar =   NEON_Q | NEONScalar | NEON_SQRSHRUN,
2789   NEON_SQSHLU_scalar =     NEON_Q | NEONScalar | NEON_SQSHLU,
2790   NEON_SQSHL_imm_scalar  = NEON_Q | NEONScalar | NEON_SQSHL_imm,
2791   NEON_UQSHL_imm_scalar  = NEON_Q | NEONScalar | NEON_UQSHL_imm,
2792   NEON_SCVTF_imm_scalar =  NEON_Q | NEONScalar | NEON_SCVTF_imm,
2793   NEON_UCVTF_imm_scalar =  NEON_Q | NEONScalar | NEON_UCVTF_imm,
2794   NEON_FCVTZS_imm_scalar = NEON_Q | NEONScalar | NEON_FCVTZS_imm,
2795   NEON_FCVTZU_imm_scalar = NEON_Q | NEONScalar | NEON_FCVTZU_imm
2796 };
2797 
2798 enum SVE32BitGatherLoadHalfwords_ScalarPlus32BitScaledOffsetsOp {
2799   SVE32BitGatherLoadHalfwords_ScalarPlus32BitScaledOffsetsFixed = 0x84A00000,
2800   SVE32BitGatherLoadHalfwords_ScalarPlus32BitScaledOffsetsFMask = 0xFFA08000,
2801   SVE32BitGatherLoadHalfwords_ScalarPlus32BitScaledOffsetsMask = 0xFFA0E000,
2802   LD1SH_z_p_bz_s_x32_scaled = SVE32BitGatherLoadHalfwords_ScalarPlus32BitScaledOffsetsFixed,
2803   LDFF1SH_z_p_bz_s_x32_scaled = SVE32BitGatherLoadHalfwords_ScalarPlus32BitScaledOffsetsFixed | 0x00002000,
2804   LD1H_z_p_bz_s_x32_scaled = SVE32BitGatherLoadHalfwords_ScalarPlus32BitScaledOffsetsFixed | 0x00004000,
2805   LDFF1H_z_p_bz_s_x32_scaled = SVE32BitGatherLoadHalfwords_ScalarPlus32BitScaledOffsetsFixed | 0x00006000
2806 };
2807 
2808 enum SVE32BitGatherLoadWords_ScalarPlus32BitScaledOffsetsOp {
2809   SVE32BitGatherLoadWords_ScalarPlus32BitScaledOffsetsFixed = 0x85200000,
2810   SVE32BitGatherLoadWords_ScalarPlus32BitScaledOffsetsFMask = 0xFFA08000,
2811   SVE32BitGatherLoadWords_ScalarPlus32BitScaledOffsetsMask = 0xFFA0E000,
2812   LD1W_z_p_bz_s_x32_scaled = SVE32BitGatherLoadWords_ScalarPlus32BitScaledOffsetsFixed | 0x00004000,
2813   LDFF1W_z_p_bz_s_x32_scaled = SVE32BitGatherLoadWords_ScalarPlus32BitScaledOffsetsFixed | 0x00006000
2814 };
2815 
2816 enum SVE32BitGatherLoad_ScalarPlus32BitUnscaledOffsetsOp {
2817   SVE32BitGatherLoad_ScalarPlus32BitUnscaledOffsetsFixed = 0x84000000,
2818   SVE32BitGatherLoad_ScalarPlus32BitUnscaledOffsetsFMask = 0xFE208000,
2819   SVE32BitGatherLoad_ScalarPlus32BitUnscaledOffsetsMask = 0xFFA0E000,
2820   LD1SB_z_p_bz_s_x32_unscaled = SVE32BitGatherLoad_ScalarPlus32BitUnscaledOffsetsFixed,
2821   LDFF1SB_z_p_bz_s_x32_unscaled = SVE32BitGatherLoad_ScalarPlus32BitUnscaledOffsetsFixed | 0x00002000,
2822   LD1B_z_p_bz_s_x32_unscaled = SVE32BitGatherLoad_ScalarPlus32BitUnscaledOffsetsFixed | 0x00004000,
2823   LDFF1B_z_p_bz_s_x32_unscaled = SVE32BitGatherLoad_ScalarPlus32BitUnscaledOffsetsFixed | 0x00006000,
2824   LD1SH_z_p_bz_s_x32_unscaled = SVE32BitGatherLoad_ScalarPlus32BitUnscaledOffsetsFixed | 0x00800000,
2825   LDFF1SH_z_p_bz_s_x32_unscaled = SVE32BitGatherLoad_ScalarPlus32BitUnscaledOffsetsFixed | 0x00802000,
2826   LD1H_z_p_bz_s_x32_unscaled = SVE32BitGatherLoad_ScalarPlus32BitUnscaledOffsetsFixed | 0x00804000,
2827   LDFF1H_z_p_bz_s_x32_unscaled = SVE32BitGatherLoad_ScalarPlus32BitUnscaledOffsetsFixed | 0x00806000,
2828   LD1W_z_p_bz_s_x32_unscaled = SVE32BitGatherLoad_ScalarPlus32BitUnscaledOffsetsFixed | 0x01004000,
2829   LDFF1W_z_p_bz_s_x32_unscaled = SVE32BitGatherLoad_ScalarPlus32BitUnscaledOffsetsFixed | 0x01006000
2830 };
2831 
2832 enum SVE32BitGatherLoad_VectorPlusImmOp {
2833   SVE32BitGatherLoad_VectorPlusImmFixed = 0x84208000,
2834   SVE32BitGatherLoad_VectorPlusImmFMask = 0xFE608000,
2835   SVE32BitGatherLoad_VectorPlusImmMask = 0xFFE0E000,
2836   LD1SB_z_p_ai_s = SVE32BitGatherLoad_VectorPlusImmFixed,
2837   LDFF1SB_z_p_ai_s = SVE32BitGatherLoad_VectorPlusImmFixed | 0x00002000,
2838   LD1B_z_p_ai_s = SVE32BitGatherLoad_VectorPlusImmFixed | 0x00004000,
2839   LDFF1B_z_p_ai_s = SVE32BitGatherLoad_VectorPlusImmFixed | 0x00006000,
2840   LD1SH_z_p_ai_s = SVE32BitGatherLoad_VectorPlusImmFixed | 0x00800000,
2841   LDFF1SH_z_p_ai_s = SVE32BitGatherLoad_VectorPlusImmFixed | 0x00802000,
2842   LD1H_z_p_ai_s = SVE32BitGatherLoad_VectorPlusImmFixed | 0x00804000,
2843   LDFF1H_z_p_ai_s = SVE32BitGatherLoad_VectorPlusImmFixed | 0x00806000,
2844   LD1W_z_p_ai_s = SVE32BitGatherLoad_VectorPlusImmFixed | 0x01004000,
2845   LDFF1W_z_p_ai_s = SVE32BitGatherLoad_VectorPlusImmFixed | 0x01006000
2846 };
2847 
2848 enum SVE32BitGatherPrefetch_ScalarPlus32BitScaledOffsetsOp {
2849   SVE32BitGatherPrefetch_ScalarPlus32BitScaledOffsetsFixed = 0x84200000,
2850   SVE32BitGatherPrefetch_ScalarPlus32BitScaledOffsetsFMask = 0xFFA08010,
2851   SVE32BitGatherPrefetch_ScalarPlus32BitScaledOffsetsMask = 0xFFA0E010,
2852   PRFB_i_p_bz_s_x32_scaled = SVE32BitGatherPrefetch_ScalarPlus32BitScaledOffsetsFixed,
2853   PRFH_i_p_bz_s_x32_scaled = SVE32BitGatherPrefetch_ScalarPlus32BitScaledOffsetsFixed | 0x00002000,
2854   PRFW_i_p_bz_s_x32_scaled = SVE32BitGatherPrefetch_ScalarPlus32BitScaledOffsetsFixed | 0x00004000,
2855   PRFD_i_p_bz_s_x32_scaled = SVE32BitGatherPrefetch_ScalarPlus32BitScaledOffsetsFixed | 0x00006000
2856 };
2857 
2858 enum SVE32BitGatherPrefetch_VectorPlusImmOp {
2859   SVE32BitGatherPrefetch_VectorPlusImmFixed = 0x8400E000,
2860   SVE32BitGatherPrefetch_VectorPlusImmFMask = 0xFE60E010,
2861   SVE32BitGatherPrefetch_VectorPlusImmMask = 0xFFE0E010,
2862   PRFB_i_p_ai_s = SVE32BitGatherPrefetch_VectorPlusImmFixed,
2863   PRFH_i_p_ai_s = SVE32BitGatherPrefetch_VectorPlusImmFixed | 0x00800000,
2864   PRFW_i_p_ai_s = SVE32BitGatherPrefetch_VectorPlusImmFixed | 0x01000000,
2865   PRFD_i_p_ai_s = SVE32BitGatherPrefetch_VectorPlusImmFixed | 0x01800000
2866 };
2867 
2868 enum SVE32BitScatterStore_ScalarPlus32BitScaledOffsetsOp {
2869   SVE32BitScatterStore_ScalarPlus32BitScaledOffsetsFixed = 0xE4608000,
2870   SVE32BitScatterStore_ScalarPlus32BitScaledOffsetsFMask = 0xFE60A000,
2871   SVE32BitScatterStore_ScalarPlus32BitScaledOffsetsMask = 0xFFE0A000,
2872   ST1H_z_p_bz_s_x32_scaled = SVE32BitScatterStore_ScalarPlus32BitScaledOffsetsFixed | 0x00800000,
2873   ST1W_z_p_bz_s_x32_scaled = SVE32BitScatterStore_ScalarPlus32BitScaledOffsetsFixed | 0x01000000
2874 };
2875 
2876 enum SVE32BitScatterStore_ScalarPlus32BitUnscaledOffsetsOp {
2877   SVE32BitScatterStore_ScalarPlus32BitUnscaledOffsetsFixed = 0xE4408000,
2878   SVE32BitScatterStore_ScalarPlus32BitUnscaledOffsetsFMask = 0xFE60A000,
2879   SVE32BitScatterStore_ScalarPlus32BitUnscaledOffsetsMask = 0xFFE0A000,
2880   ST1B_z_p_bz_s_x32_unscaled = SVE32BitScatterStore_ScalarPlus32BitUnscaledOffsetsFixed,
2881   ST1H_z_p_bz_s_x32_unscaled = SVE32BitScatterStore_ScalarPlus32BitUnscaledOffsetsFixed | 0x00800000,
2882   ST1W_z_p_bz_s_x32_unscaled = SVE32BitScatterStore_ScalarPlus32BitUnscaledOffsetsFixed | 0x01000000
2883 };
2884 
2885 enum SVE32BitScatterStore_VectorPlusImmOp {
2886   SVE32BitScatterStore_VectorPlusImmFixed = 0xE460A000,
2887   SVE32BitScatterStore_VectorPlusImmFMask = 0xFE60E000,
2888   SVE32BitScatterStore_VectorPlusImmMask = 0xFFE0E000,
2889   ST1B_z_p_ai_s = SVE32BitScatterStore_VectorPlusImmFixed,
2890   ST1H_z_p_ai_s = SVE32BitScatterStore_VectorPlusImmFixed | 0x00800000,
2891   ST1W_z_p_ai_s = SVE32BitScatterStore_VectorPlusImmFixed | 0x01000000
2892 };
2893 
2894 enum SVE64BitGatherLoad_ScalarPlus32BitUnpackedScaledOffsetsOp {
2895   SVE64BitGatherLoad_ScalarPlus32BitUnpackedScaledOffsetsFixed = 0xC4200000,
2896   SVE64BitGatherLoad_ScalarPlus32BitUnpackedScaledOffsetsFMask = 0xFE208000,
2897   SVE64BitGatherLoad_ScalarPlus32BitUnpackedScaledOffsetsMask = 0xFFA0E000,
2898   LD1SH_z_p_bz_d_x32_scaled = SVE64BitGatherLoad_ScalarPlus32BitUnpackedScaledOffsetsFixed | 0x00800000,
2899   LDFF1SH_z_p_bz_d_x32_scaled = SVE64BitGatherLoad_ScalarPlus32BitUnpackedScaledOffsetsFixed | 0x00802000,
2900   LD1H_z_p_bz_d_x32_scaled = SVE64BitGatherLoad_ScalarPlus32BitUnpackedScaledOffsetsFixed | 0x00804000,
2901   LDFF1H_z_p_bz_d_x32_scaled = SVE64BitGatherLoad_ScalarPlus32BitUnpackedScaledOffsetsFixed | 0x00806000,
2902   LD1SW_z_p_bz_d_x32_scaled = SVE64BitGatherLoad_ScalarPlus32BitUnpackedScaledOffsetsFixed | 0x01000000,
2903   LDFF1SW_z_p_bz_d_x32_scaled = SVE64BitGatherLoad_ScalarPlus32BitUnpackedScaledOffsetsFixed | 0x01002000,
2904   LD1W_z_p_bz_d_x32_scaled = SVE64BitGatherLoad_ScalarPlus32BitUnpackedScaledOffsetsFixed | 0x01004000,
2905   LDFF1W_z_p_bz_d_x32_scaled = SVE64BitGatherLoad_ScalarPlus32BitUnpackedScaledOffsetsFixed | 0x01006000,
2906   LD1D_z_p_bz_d_x32_scaled = SVE64BitGatherLoad_ScalarPlus32BitUnpackedScaledOffsetsFixed | 0x01804000,
2907   LDFF1D_z_p_bz_d_x32_scaled = SVE64BitGatherLoad_ScalarPlus32BitUnpackedScaledOffsetsFixed | 0x01806000
2908 };
2909 
2910 enum SVE64BitGatherLoad_ScalarPlus64BitScaledOffsetsOp {
2911   SVE64BitGatherLoad_ScalarPlus64BitScaledOffsetsFixed = 0xC4608000,
2912   SVE64BitGatherLoad_ScalarPlus64BitScaledOffsetsFMask = 0xFE608000,
2913   SVE64BitGatherLoad_ScalarPlus64BitScaledOffsetsMask = 0xFFE0E000,
2914   LD1SH_z_p_bz_d_64_scaled = SVE64BitGatherLoad_ScalarPlus64BitScaledOffsetsFixed | 0x00800000,
2915   LDFF1SH_z_p_bz_d_64_scaled = SVE64BitGatherLoad_ScalarPlus64BitScaledOffsetsFixed | 0x00802000,
2916   LD1H_z_p_bz_d_64_scaled = SVE64BitGatherLoad_ScalarPlus64BitScaledOffsetsFixed | 0x00804000,
2917   LDFF1H_z_p_bz_d_64_scaled = SVE64BitGatherLoad_ScalarPlus64BitScaledOffsetsFixed | 0x00806000,
2918   LD1SW_z_p_bz_d_64_scaled = SVE64BitGatherLoad_ScalarPlus64BitScaledOffsetsFixed | 0x01000000,
2919   LDFF1SW_z_p_bz_d_64_scaled = SVE64BitGatherLoad_ScalarPlus64BitScaledOffsetsFixed | 0x01002000,
2920   LD1W_z_p_bz_d_64_scaled = SVE64BitGatherLoad_ScalarPlus64BitScaledOffsetsFixed | 0x01004000,
2921   LDFF1W_z_p_bz_d_64_scaled = SVE64BitGatherLoad_ScalarPlus64BitScaledOffsetsFixed | 0x01006000,
2922   LD1D_z_p_bz_d_64_scaled = SVE64BitGatherLoad_ScalarPlus64BitScaledOffsetsFixed | 0x01804000,
2923   LDFF1D_z_p_bz_d_64_scaled = SVE64BitGatherLoad_ScalarPlus64BitScaledOffsetsFixed | 0x01806000
2924 };
2925 
2926 enum SVE64BitGatherLoad_ScalarPlus64BitUnscaledOffsetsOp {
2927   SVE64BitGatherLoad_ScalarPlus64BitUnscaledOffsetsFixed = 0xC4408000,
2928   SVE64BitGatherLoad_ScalarPlus64BitUnscaledOffsetsFMask = 0xFE608000,
2929   SVE64BitGatherLoad_ScalarPlus64BitUnscaledOffsetsMask = 0xFFE0E000,
2930   LD1SB_z_p_bz_d_64_unscaled = SVE64BitGatherLoad_ScalarPlus64BitUnscaledOffsetsFixed,
2931   LDFF1SB_z_p_bz_d_64_unscaled = SVE64BitGatherLoad_ScalarPlus64BitUnscaledOffsetsFixed | 0x00002000,
2932   LD1B_z_p_bz_d_64_unscaled = SVE64BitGatherLoad_ScalarPlus64BitUnscaledOffsetsFixed | 0x00004000,
2933   LDFF1B_z_p_bz_d_64_unscaled = SVE64BitGatherLoad_ScalarPlus64BitUnscaledOffsetsFixed | 0x00006000,
2934   LD1SH_z_p_bz_d_64_unscaled = SVE64BitGatherLoad_ScalarPlus64BitUnscaledOffsetsFixed | 0x00800000,
2935   LDFF1SH_z_p_bz_d_64_unscaled = SVE64BitGatherLoad_ScalarPlus64BitUnscaledOffsetsFixed | 0x00802000,
2936   LD1H_z_p_bz_d_64_unscaled = SVE64BitGatherLoad_ScalarPlus64BitUnscaledOffsetsFixed | 0x00804000,
2937   LDFF1H_z_p_bz_d_64_unscaled = SVE64BitGatherLoad_ScalarPlus64BitUnscaledOffsetsFixed | 0x00806000,
2938   LD1SW_z_p_bz_d_64_unscaled = SVE64BitGatherLoad_ScalarPlus64BitUnscaledOffsetsFixed | 0x01000000,
2939   LDFF1SW_z_p_bz_d_64_unscaled = SVE64BitGatherLoad_ScalarPlus64BitUnscaledOffsetsFixed | 0x01002000,
2940   LD1W_z_p_bz_d_64_unscaled = SVE64BitGatherLoad_ScalarPlus64BitUnscaledOffsetsFixed | 0x01004000,
2941   LDFF1W_z_p_bz_d_64_unscaled = SVE64BitGatherLoad_ScalarPlus64BitUnscaledOffsetsFixed | 0x01006000,
2942   LD1D_z_p_bz_d_64_unscaled = SVE64BitGatherLoad_ScalarPlus64BitUnscaledOffsetsFixed | 0x01804000,
2943   LDFF1D_z_p_bz_d_64_unscaled = SVE64BitGatherLoad_ScalarPlus64BitUnscaledOffsetsFixed | 0x01806000
2944 };
2945 
2946 enum SVE64BitGatherLoad_ScalarPlusUnpacked32BitUnscaledOffsetsOp {
2947   SVE64BitGatherLoad_ScalarPlusUnpacked32BitUnscaledOffsetsFixed = 0xC4000000,
2948   SVE64BitGatherLoad_ScalarPlusUnpacked32BitUnscaledOffsetsFMask = 0xFE208000,
2949   SVE64BitGatherLoad_ScalarPlusUnpacked32BitUnscaledOffsetsMask = 0xFFA0E000,
2950   LD1SB_z_p_bz_d_x32_unscaled = SVE64BitGatherLoad_ScalarPlusUnpacked32BitUnscaledOffsetsFixed,
2951   LDFF1SB_z_p_bz_d_x32_unscaled = SVE64BitGatherLoad_ScalarPlusUnpacked32BitUnscaledOffsetsFixed | 0x00002000,
2952   LD1B_z_p_bz_d_x32_unscaled = SVE64BitGatherLoad_ScalarPlusUnpacked32BitUnscaledOffsetsFixed | 0x00004000,
2953   LDFF1B_z_p_bz_d_x32_unscaled = SVE64BitGatherLoad_ScalarPlusUnpacked32BitUnscaledOffsetsFixed | 0x00006000,
2954   LD1SH_z_p_bz_d_x32_unscaled = SVE64BitGatherLoad_ScalarPlusUnpacked32BitUnscaledOffsetsFixed | 0x00800000,
2955   LDFF1SH_z_p_bz_d_x32_unscaled = SVE64BitGatherLoad_ScalarPlusUnpacked32BitUnscaledOffsetsFixed | 0x00802000,
2956   LD1H_z_p_bz_d_x32_unscaled = SVE64BitGatherLoad_ScalarPlusUnpacked32BitUnscaledOffsetsFixed | 0x00804000,
2957   LDFF1H_z_p_bz_d_x32_unscaled = SVE64BitGatherLoad_ScalarPlusUnpacked32BitUnscaledOffsetsFixed | 0x00806000,
2958   LD1SW_z_p_bz_d_x32_unscaled = SVE64BitGatherLoad_ScalarPlusUnpacked32BitUnscaledOffsetsFixed | 0x01000000,
2959   LDFF1SW_z_p_bz_d_x32_unscaled = SVE64BitGatherLoad_ScalarPlusUnpacked32BitUnscaledOffsetsFixed | 0x01002000,
2960   LD1W_z_p_bz_d_x32_unscaled = SVE64BitGatherLoad_ScalarPlusUnpacked32BitUnscaledOffsetsFixed | 0x01004000,
2961   LDFF1W_z_p_bz_d_x32_unscaled = SVE64BitGatherLoad_ScalarPlusUnpacked32BitUnscaledOffsetsFixed | 0x01006000,
2962   LD1D_z_p_bz_d_x32_unscaled = SVE64BitGatherLoad_ScalarPlusUnpacked32BitUnscaledOffsetsFixed | 0x01804000,
2963   LDFF1D_z_p_bz_d_x32_unscaled = SVE64BitGatherLoad_ScalarPlusUnpacked32BitUnscaledOffsetsFixed | 0x01806000
2964 };
2965 
2966 enum SVE64BitGatherLoad_VectorPlusImmOp {
2967   SVE64BitGatherLoad_VectorPlusImmFixed = 0xC4208000,
2968   SVE64BitGatherLoad_VectorPlusImmFMask = 0xFE608000,
2969   SVE64BitGatherLoad_VectorPlusImmMask = 0xFFE0E000,
2970   LD1SB_z_p_ai_d = SVE64BitGatherLoad_VectorPlusImmFixed,
2971   LDFF1SB_z_p_ai_d = SVE64BitGatherLoad_VectorPlusImmFixed | 0x00002000,
2972   LD1B_z_p_ai_d = SVE64BitGatherLoad_VectorPlusImmFixed | 0x00004000,
2973   LDFF1B_z_p_ai_d = SVE64BitGatherLoad_VectorPlusImmFixed | 0x00006000,
2974   LD1SH_z_p_ai_d = SVE64BitGatherLoad_VectorPlusImmFixed | 0x00800000,
2975   LDFF1SH_z_p_ai_d = SVE64BitGatherLoad_VectorPlusImmFixed | 0x00802000,
2976   LD1H_z_p_ai_d = SVE64BitGatherLoad_VectorPlusImmFixed | 0x00804000,
2977   LDFF1H_z_p_ai_d = SVE64BitGatherLoad_VectorPlusImmFixed | 0x00806000,
2978   LD1SW_z_p_ai_d = SVE64BitGatherLoad_VectorPlusImmFixed | 0x01000000,
2979   LDFF1SW_z_p_ai_d = SVE64BitGatherLoad_VectorPlusImmFixed | 0x01002000,
2980   LD1W_z_p_ai_d = SVE64BitGatherLoad_VectorPlusImmFixed | 0x01004000,
2981   LDFF1W_z_p_ai_d = SVE64BitGatherLoad_VectorPlusImmFixed | 0x01006000,
2982   LD1D_z_p_ai_d = SVE64BitGatherLoad_VectorPlusImmFixed | 0x01804000,
2983   LDFF1D_z_p_ai_d = SVE64BitGatherLoad_VectorPlusImmFixed | 0x01806000
2984 };
2985 
2986 enum SVE64BitGatherPrefetch_ScalarPlus64BitScaledOffsetsOp {
2987   SVE64BitGatherPrefetch_ScalarPlus64BitScaledOffsetsFixed = 0xC4608000,
2988   SVE64BitGatherPrefetch_ScalarPlus64BitScaledOffsetsFMask = 0xFFE08010,
2989   SVE64BitGatherPrefetch_ScalarPlus64BitScaledOffsetsMask = 0xFFE0E010,
2990   PRFB_i_p_bz_d_64_scaled = SVE64BitGatherPrefetch_ScalarPlus64BitScaledOffsetsFixed,
2991   PRFH_i_p_bz_d_64_scaled = SVE64BitGatherPrefetch_ScalarPlus64BitScaledOffsetsFixed | 0x00002000,
2992   PRFW_i_p_bz_d_64_scaled = SVE64BitGatherPrefetch_ScalarPlus64BitScaledOffsetsFixed | 0x00004000,
2993   PRFD_i_p_bz_d_64_scaled = SVE64BitGatherPrefetch_ScalarPlus64BitScaledOffsetsFixed | 0x00006000
2994 };
2995 
2996 enum SVE64BitGatherPrefetch_ScalarPlusUnpacked32BitScaledOffsetsOp {
2997   SVE64BitGatherPrefetch_ScalarPlusUnpacked32BitScaledOffsetsFixed = 0xC4200000,
2998   SVE64BitGatherPrefetch_ScalarPlusUnpacked32BitScaledOffsetsFMask = 0xFFA08010,
2999   SVE64BitGatherPrefetch_ScalarPlusUnpacked32BitScaledOffsetsMask = 0xFFA0E010,
3000   PRFB_i_p_bz_d_x32_scaled = SVE64BitGatherPrefetch_ScalarPlusUnpacked32BitScaledOffsetsFixed,
3001   PRFH_i_p_bz_d_x32_scaled = SVE64BitGatherPrefetch_ScalarPlusUnpacked32BitScaledOffsetsFixed | 0x00002000,
3002   PRFW_i_p_bz_d_x32_scaled = SVE64BitGatherPrefetch_ScalarPlusUnpacked32BitScaledOffsetsFixed | 0x00004000,
3003   PRFD_i_p_bz_d_x32_scaled = SVE64BitGatherPrefetch_ScalarPlusUnpacked32BitScaledOffsetsFixed | 0x00006000
3004 };
3005 
3006 enum SVE64BitGatherPrefetch_VectorPlusImmOp {
3007   SVE64BitGatherPrefetch_VectorPlusImmFixed = 0xC400E000,
3008   SVE64BitGatherPrefetch_VectorPlusImmFMask = 0xFE60E010,
3009   SVE64BitGatherPrefetch_VectorPlusImmMask = 0xFFE0E010,
3010   PRFB_i_p_ai_d = SVE64BitGatherPrefetch_VectorPlusImmFixed,
3011   PRFH_i_p_ai_d = SVE64BitGatherPrefetch_VectorPlusImmFixed | 0x00800000,
3012   PRFW_i_p_ai_d = SVE64BitGatherPrefetch_VectorPlusImmFixed | 0x01000000,
3013   PRFD_i_p_ai_d = SVE64BitGatherPrefetch_VectorPlusImmFixed | 0x01800000
3014 };
3015 
3016 enum SVE64BitScatterStore_ScalarPlus64BitScaledOffsetsOp {
3017   SVE64BitScatterStore_ScalarPlus64BitScaledOffsetsFixed = 0xE420A000,
3018   SVE64BitScatterStore_ScalarPlus64BitScaledOffsetsFMask = 0xFE60E000,
3019   SVE64BitScatterStore_ScalarPlus64BitScaledOffsetsMask = 0xFFE0E000,
3020   ST1H_z_p_bz_d_64_scaled = SVE64BitScatterStore_ScalarPlus64BitScaledOffsetsFixed | 0x00800000,
3021   ST1W_z_p_bz_d_64_scaled = SVE64BitScatterStore_ScalarPlus64BitScaledOffsetsFixed | 0x01000000,
3022   ST1D_z_p_bz_d_64_scaled = SVE64BitScatterStore_ScalarPlus64BitScaledOffsetsFixed | 0x01800000
3023 };
3024 
3025 enum SVE64BitScatterStore_ScalarPlus64BitUnscaledOffsetsOp {
3026   SVE64BitScatterStore_ScalarPlus64BitUnscaledOffsetsFixed = 0xE400A000,
3027   SVE64BitScatterStore_ScalarPlus64BitUnscaledOffsetsFMask = 0xFE60E000,
3028   SVE64BitScatterStore_ScalarPlus64BitUnscaledOffsetsMask = 0xFFE0E000,
3029   ST1B_z_p_bz_d_64_unscaled = SVE64BitScatterStore_ScalarPlus64BitUnscaledOffsetsFixed,
3030   ST1H_z_p_bz_d_64_unscaled = SVE64BitScatterStore_ScalarPlus64BitUnscaledOffsetsFixed | 0x00800000,
3031   ST1W_z_p_bz_d_64_unscaled = SVE64BitScatterStore_ScalarPlus64BitUnscaledOffsetsFixed | 0x01000000,
3032   ST1D_z_p_bz_d_64_unscaled = SVE64BitScatterStore_ScalarPlus64BitUnscaledOffsetsFixed | 0x01800000
3033 };
3034 
3035 enum SVE64BitScatterStore_ScalarPlusUnpacked32BitScaledOffsetsOp {
3036   SVE64BitScatterStore_ScalarPlusUnpacked32BitScaledOffsetsFixed = 0xE4208000,
3037   SVE64BitScatterStore_ScalarPlusUnpacked32BitScaledOffsetsFMask = 0xFE60A000,
3038   SVE64BitScatterStore_ScalarPlusUnpacked32BitScaledOffsetsMask = 0xFFE0A000,
3039   ST1H_z_p_bz_d_x32_scaled = SVE64BitScatterStore_ScalarPlusUnpacked32BitScaledOffsetsFixed | 0x00800000,
3040   ST1W_z_p_bz_d_x32_scaled = SVE64BitScatterStore_ScalarPlusUnpacked32BitScaledOffsetsFixed | 0x01000000,
3041   ST1D_z_p_bz_d_x32_scaled = SVE64BitScatterStore_ScalarPlusUnpacked32BitScaledOffsetsFixed | 0x01800000
3042 };
3043 
3044 enum SVE64BitScatterStore_ScalarPlusUnpacked32BitUnscaledOffsetsOp {
3045   SVE64BitScatterStore_ScalarPlusUnpacked32BitUnscaledOffsetsFixed = 0xE4008000,
3046   SVE64BitScatterStore_ScalarPlusUnpacked32BitUnscaledOffsetsFMask = 0xFE60A000,
3047   SVE64BitScatterStore_ScalarPlusUnpacked32BitUnscaledOffsetsMask = 0xFFE0A000,
3048   ST1B_z_p_bz_d_x32_unscaled = SVE64BitScatterStore_ScalarPlusUnpacked32BitUnscaledOffsetsFixed,
3049   ST1H_z_p_bz_d_x32_unscaled = SVE64BitScatterStore_ScalarPlusUnpacked32BitUnscaledOffsetsFixed | 0x00800000,
3050   ST1W_z_p_bz_d_x32_unscaled = SVE64BitScatterStore_ScalarPlusUnpacked32BitUnscaledOffsetsFixed | 0x01000000,
3051   ST1D_z_p_bz_d_x32_unscaled = SVE64BitScatterStore_ScalarPlusUnpacked32BitUnscaledOffsetsFixed | 0x01800000
3052 };
3053 
3054 enum SVE64BitScatterStore_VectorPlusImmOp {
3055   SVE64BitScatterStore_VectorPlusImmFixed = 0xE440A000,
3056   SVE64BitScatterStore_VectorPlusImmFMask = 0xFE60E000,
3057   SVE64BitScatterStore_VectorPlusImmMask = 0xFFE0E000,
3058   ST1B_z_p_ai_d = SVE64BitScatterStore_VectorPlusImmFixed,
3059   ST1H_z_p_ai_d = SVE64BitScatterStore_VectorPlusImmFixed | 0x00800000,
3060   ST1W_z_p_ai_d = SVE64BitScatterStore_VectorPlusImmFixed | 0x01000000,
3061   ST1D_z_p_ai_d = SVE64BitScatterStore_VectorPlusImmFixed | 0x01800000
3062 };
3063 
3064 enum SVEAddressGenerationOp {
3065   SVEAddressGenerationFixed = 0x0420A000,
3066   SVEAddressGenerationFMask = 0xFF20F000,
3067   SVEAddressGenerationMask = 0xFFE0F000,
3068   ADR_z_az_d_s32_scaled = SVEAddressGenerationFixed,
3069   ADR_z_az_d_u32_scaled = SVEAddressGenerationFixed | 0x00400000,
3070   ADR_z_az_s_same_scaled = SVEAddressGenerationFixed | 0x00800000,
3071   ADR_z_az_d_same_scaled = SVEAddressGenerationFixed | 0x00C00000
3072 };
3073 
3074 enum SVEBitwiseLogicalUnpredicatedOp {
3075   SVEBitwiseLogicalUnpredicatedFixed = 0x04202000,
3076   SVEBitwiseLogicalUnpredicatedFMask = 0xFF20E000,
3077   SVEBitwiseLogicalUnpredicatedMask = 0xFFE0FC00,
3078   AND_z_zz = SVEBitwiseLogicalUnpredicatedFixed | 0x00001000,
3079   ORR_z_zz = SVEBitwiseLogicalUnpredicatedFixed | 0x00401000,
3080   EOR_z_zz = SVEBitwiseLogicalUnpredicatedFixed | 0x00801000,
3081   BIC_z_zz = SVEBitwiseLogicalUnpredicatedFixed | 0x00C01000
3082 };
3083 
3084 enum SVEBitwiseLogicalWithImm_UnpredicatedOp {
3085   SVEBitwiseLogicalWithImm_UnpredicatedFixed = 0x05000000,
3086   SVEBitwiseLogicalWithImm_UnpredicatedFMask = 0xFF3C0000,
3087   SVEBitwiseLogicalWithImm_UnpredicatedMask = 0xFFFC0000,
3088   ORR_z_zi = SVEBitwiseLogicalWithImm_UnpredicatedFixed,
3089   EOR_z_zi = SVEBitwiseLogicalWithImm_UnpredicatedFixed | 0x00400000,
3090   AND_z_zi = SVEBitwiseLogicalWithImm_UnpredicatedFixed | 0x00800000
3091 };
3092 
3093 enum SVEBitwiseLogical_PredicatedOp {
3094   SVEBitwiseLogical_PredicatedFixed = 0x04180000,
3095   SVEBitwiseLogical_PredicatedFMask = 0xFF38E000,
3096   SVEBitwiseLogical_PredicatedMask = 0xFF3FE000,
3097   ORR_z_p_zz = SVEBitwiseLogical_PredicatedFixed,
3098   EOR_z_p_zz = SVEBitwiseLogical_PredicatedFixed | 0x00010000,
3099   AND_z_p_zz = SVEBitwiseLogical_PredicatedFixed | 0x00020000,
3100   BIC_z_p_zz = SVEBitwiseLogical_PredicatedFixed | 0x00030000
3101 };
3102 
3103 enum SVEBitwiseShiftByImm_PredicatedOp {
3104   SVEBitwiseShiftByImm_PredicatedFixed = 0x04008000,
3105   SVEBitwiseShiftByImm_PredicatedFMask = 0xFF30E000,
3106   SVEBitwiseShiftByImm_PredicatedMask = 0xFF3FE000,
3107   ASR_z_p_zi = SVEBitwiseShiftByImm_PredicatedFixed,
3108   LSR_z_p_zi = SVEBitwiseShiftByImm_PredicatedFixed | 0x00010000,
3109   LSL_z_p_zi = SVEBitwiseShiftByImm_PredicatedFixed | 0x00030000,
3110   ASRD_z_p_zi = SVEBitwiseShiftByImm_PredicatedFixed | 0x00040000
3111 };
3112 
3113 enum SVEBitwiseShiftByVector_PredicatedOp {
3114   SVEBitwiseShiftByVector_PredicatedFixed = 0x04108000,
3115   SVEBitwiseShiftByVector_PredicatedFMask = 0xFF38E000,
3116   SVEBitwiseShiftByVector_PredicatedMask = 0xFF3FE000,
3117   ASR_z_p_zz = SVEBitwiseShiftByVector_PredicatedFixed,
3118   LSR_z_p_zz = SVEBitwiseShiftByVector_PredicatedFixed | 0x00010000,
3119   LSL_z_p_zz = SVEBitwiseShiftByVector_PredicatedFixed | 0x00030000,
3120   ASRR_z_p_zz = SVEBitwiseShiftByVector_PredicatedFixed | 0x00040000,
3121   LSRR_z_p_zz = SVEBitwiseShiftByVector_PredicatedFixed | 0x00050000,
3122   LSLR_z_p_zz = SVEBitwiseShiftByVector_PredicatedFixed | 0x00070000
3123 };
3124 
3125 enum SVEBitwiseShiftByWideElements_PredicatedOp {
3126   SVEBitwiseShiftByWideElements_PredicatedFixed = 0x04188000,
3127   SVEBitwiseShiftByWideElements_PredicatedFMask = 0xFF38E000,
3128   SVEBitwiseShiftByWideElements_PredicatedMask = 0xFF3FE000,
3129   ASR_z_p_zw = SVEBitwiseShiftByWideElements_PredicatedFixed,
3130   LSR_z_p_zw = SVEBitwiseShiftByWideElements_PredicatedFixed | 0x00010000,
3131   LSL_z_p_zw = SVEBitwiseShiftByWideElements_PredicatedFixed | 0x00030000
3132 };
3133 
3134 enum SVEBitwiseShiftUnpredicatedOp {
3135   SVEBitwiseShiftUnpredicatedFixed = 0x04208000,
3136   SVEBitwiseShiftUnpredicatedFMask = 0xFF20E000,
3137   SVEBitwiseShiftUnpredicatedMask = 0xFF20FC00,
3138   ASR_z_zw = SVEBitwiseShiftUnpredicatedFixed,
3139   LSR_z_zw = SVEBitwiseShiftUnpredicatedFixed | 0x00000400,
3140   LSL_z_zw = SVEBitwiseShiftUnpredicatedFixed | 0x00000C00,
3141   ASR_z_zi = SVEBitwiseShiftUnpredicatedFixed | 0x00001000,
3142   LSR_z_zi = SVEBitwiseShiftUnpredicatedFixed | 0x00001400,
3143   LSL_z_zi = SVEBitwiseShiftUnpredicatedFixed | 0x00001C00
3144 };
3145 
3146 enum SVEBroadcastBitmaskImmOp {
3147   SVEBroadcastBitmaskImmFixed = 0x05C00000,
3148   SVEBroadcastBitmaskImmFMask = 0xFFFC0000,
3149   SVEBroadcastBitmaskImmMask = 0xFFFC0000,
3150   DUPM_z_i = SVEBroadcastBitmaskImmFixed
3151 };
3152 
3153 enum SVEBroadcastFPImm_UnpredicatedOp {
3154   SVEBroadcastFPImm_UnpredicatedFixed = 0x2539C000,
3155   SVEBroadcastFPImm_UnpredicatedFMask = 0xFF39C000,
3156   SVEBroadcastFPImm_UnpredicatedMask = 0xFF3FE000,
3157   FDUP_z_i = SVEBroadcastFPImm_UnpredicatedFixed
3158 };
3159 
3160 enum SVEBroadcastGeneralRegisterOp {
3161   SVEBroadcastGeneralRegisterFixed = 0x05203800,
3162   SVEBroadcastGeneralRegisterFMask = 0xFF3FFC00,
3163   SVEBroadcastGeneralRegisterMask = 0xFF3FFC00,
3164   DUP_z_r = SVEBroadcastGeneralRegisterFixed
3165 };
3166 
3167 enum SVEBroadcastIndexElementOp {
3168   SVEBroadcastIndexElementFixed = 0x05202000,
3169   SVEBroadcastIndexElementFMask = 0xFF20FC00,
3170   SVEBroadcastIndexElementMask = 0xFF20FC00,
3171   DUP_z_zi = SVEBroadcastIndexElementFixed
3172 };
3173 
3174 enum SVEBroadcastIntImm_UnpredicatedOp {
3175   SVEBroadcastIntImm_UnpredicatedFixed = 0x2538C000,
3176   SVEBroadcastIntImm_UnpredicatedFMask = 0xFF39C000,
3177   SVEBroadcastIntImm_UnpredicatedMask = 0xFF3FC000,
3178   DUP_z_i = SVEBroadcastIntImm_UnpredicatedFixed
3179 };
3180 
3181 enum SVECompressActiveElementsOp {
3182   SVECompressActiveElementsFixed = 0x05A18000,
3183   SVECompressActiveElementsFMask = 0xFFBFE000,
3184   SVECompressActiveElementsMask = 0xFFBFE000,
3185   COMPACT_z_p_z = SVECompressActiveElementsFixed
3186 };
3187 
3188 enum SVEConditionallyBroadcastElementToVectorOp {
3189   SVEConditionallyBroadcastElementToVectorFixed = 0x05288000,
3190   SVEConditionallyBroadcastElementToVectorFMask = 0xFF3EE000,
3191   SVEConditionallyBroadcastElementToVectorMask = 0xFF3FE000,
3192   CLASTA_z_p_zz = SVEConditionallyBroadcastElementToVectorFixed,
3193   CLASTB_z_p_zz = SVEConditionallyBroadcastElementToVectorFixed | 0x00010000
3194 };
3195 
3196 enum SVEConditionallyExtractElementToGeneralRegisterOp {
3197   SVEConditionallyExtractElementToGeneralRegisterFixed = 0x0530A000,
3198   SVEConditionallyExtractElementToGeneralRegisterFMask = 0xFF3EE000,
3199   SVEConditionallyExtractElementToGeneralRegisterMask = 0xFF3FE000,
3200   CLASTA_r_p_z = SVEConditionallyExtractElementToGeneralRegisterFixed,
3201   CLASTB_r_p_z = SVEConditionallyExtractElementToGeneralRegisterFixed | 0x00010000
3202 };
3203 
3204 enum SVEConditionallyExtractElementToSIMDFPScalarOp {
3205   SVEConditionallyExtractElementToSIMDFPScalarFixed = 0x052A8000,
3206   SVEConditionallyExtractElementToSIMDFPScalarFMask = 0xFF3EE000,
3207   SVEConditionallyExtractElementToSIMDFPScalarMask = 0xFF3FE000,
3208   CLASTA_v_p_z = SVEConditionallyExtractElementToSIMDFPScalarFixed,
3209   CLASTB_v_p_z = SVEConditionallyExtractElementToSIMDFPScalarFixed | 0x00010000
3210 };
3211 
3212 enum SVEConditionallyTerminateScalarsOp {
3213   SVEConditionallyTerminateScalarsFixed = 0x25202000,
3214   SVEConditionallyTerminateScalarsFMask = 0xFF20FC0F,
3215   SVEConditionallyTerminateScalarsMask = 0xFFA0FC1F,
3216   CTERMEQ_rr = SVEConditionallyTerminateScalarsFixed | 0x00800000,
3217   CTERMNE_rr = SVEConditionallyTerminateScalarsFixed | 0x00800010
3218 };
3219 
3220 enum SVEConstructivePrefix_UnpredicatedOp {
3221   SVEConstructivePrefix_UnpredicatedFixed = 0x0420BC00,
3222   SVEConstructivePrefix_UnpredicatedFMask = 0xFF20FC00,
3223   SVEConstructivePrefix_UnpredicatedMask = 0xFFFFFC00,
3224   MOVPRFX_z_z = SVEConstructivePrefix_UnpredicatedFixed
3225 };
3226 
3227 enum SVEContiguousFirstFaultLoad_ScalarPlusScalarOp {
3228   SVEContiguousFirstFaultLoad_ScalarPlusScalarFixed = 0xA4006000,
3229   SVEContiguousFirstFaultLoad_ScalarPlusScalarFMask = 0xFE00E000,
3230   SVEContiguousFirstFaultLoad_ScalarPlusScalarMask = 0xFFE0E000,
3231   LDFF1B_z_p_br_u8 = SVEContiguousFirstFaultLoad_ScalarPlusScalarFixed,
3232   LDFF1B_z_p_br_u16 = SVEContiguousFirstFaultLoad_ScalarPlusScalarFixed | 0x00200000,
3233   LDFF1B_z_p_br_u32 = SVEContiguousFirstFaultLoad_ScalarPlusScalarFixed | 0x00400000,
3234   LDFF1B_z_p_br_u64 = SVEContiguousFirstFaultLoad_ScalarPlusScalarFixed | 0x00600000,
3235   LDFF1SW_z_p_br_s64 = SVEContiguousFirstFaultLoad_ScalarPlusScalarFixed | 0x00800000,
3236   LDFF1H_z_p_br_u16 = SVEContiguousFirstFaultLoad_ScalarPlusScalarFixed | 0x00A00000,
3237   LDFF1H_z_p_br_u32 = SVEContiguousFirstFaultLoad_ScalarPlusScalarFixed | 0x00C00000,
3238   LDFF1H_z_p_br_u64 = SVEContiguousFirstFaultLoad_ScalarPlusScalarFixed | 0x00E00000,
3239   LDFF1SH_z_p_br_s64 = SVEContiguousFirstFaultLoad_ScalarPlusScalarFixed | 0x01000000,
3240   LDFF1SH_z_p_br_s32 = SVEContiguousFirstFaultLoad_ScalarPlusScalarFixed | 0x01200000,
3241   LDFF1W_z_p_br_u32 = SVEContiguousFirstFaultLoad_ScalarPlusScalarFixed | 0x01400000,
3242   LDFF1W_z_p_br_u64 = SVEContiguousFirstFaultLoad_ScalarPlusScalarFixed | 0x01600000,
3243   LDFF1SB_z_p_br_s64 = SVEContiguousFirstFaultLoad_ScalarPlusScalarFixed | 0x01800000,
3244   LDFF1SB_z_p_br_s32 = SVEContiguousFirstFaultLoad_ScalarPlusScalarFixed | 0x01A00000,
3245   LDFF1SB_z_p_br_s16 = SVEContiguousFirstFaultLoad_ScalarPlusScalarFixed | 0x01C00000,
3246   LDFF1D_z_p_br_u64 = SVEContiguousFirstFaultLoad_ScalarPlusScalarFixed | 0x01E00000
3247 };
3248 
3249 enum SVEContiguousLoad_ScalarPlusImmOp {
3250   SVEContiguousLoad_ScalarPlusImmFixed = 0xA400A000,
3251   SVEContiguousLoad_ScalarPlusImmFMask = 0xFE10E000,
3252   SVEContiguousLoad_ScalarPlusImmMask = 0xFFF0E000,
3253   LD1B_z_p_bi_u8 = SVEContiguousLoad_ScalarPlusImmFixed,
3254   LD1B_z_p_bi_u16 = SVEContiguousLoad_ScalarPlusImmFixed | 0x00200000,
3255   LD1B_z_p_bi_u32 = SVEContiguousLoad_ScalarPlusImmFixed | 0x00400000,
3256   LD1B_z_p_bi_u64 = SVEContiguousLoad_ScalarPlusImmFixed | 0x00600000,
3257   LD1SW_z_p_bi_s64 = SVEContiguousLoad_ScalarPlusImmFixed | 0x00800000,
3258   LD1H_z_p_bi_u16 = SVEContiguousLoad_ScalarPlusImmFixed | 0x00A00000,
3259   LD1H_z_p_bi_u32 = SVEContiguousLoad_ScalarPlusImmFixed | 0x00C00000,
3260   LD1H_z_p_bi_u64 = SVEContiguousLoad_ScalarPlusImmFixed | 0x00E00000,
3261   LD1SH_z_p_bi_s64 = SVEContiguousLoad_ScalarPlusImmFixed | 0x01000000,
3262   LD1SH_z_p_bi_s32 = SVEContiguousLoad_ScalarPlusImmFixed | 0x01200000,
3263   LD1W_z_p_bi_u32 = SVEContiguousLoad_ScalarPlusImmFixed | 0x01400000,
3264   LD1W_z_p_bi_u64 = SVEContiguousLoad_ScalarPlusImmFixed | 0x01600000,
3265   LD1SB_z_p_bi_s64 = SVEContiguousLoad_ScalarPlusImmFixed | 0x01800000,
3266   LD1SB_z_p_bi_s32 = SVEContiguousLoad_ScalarPlusImmFixed | 0x01A00000,
3267   LD1SB_z_p_bi_s16 = SVEContiguousLoad_ScalarPlusImmFixed | 0x01C00000,
3268   LD1D_z_p_bi_u64 = SVEContiguousLoad_ScalarPlusImmFixed | 0x01E00000
3269 };
3270 
3271 enum SVEContiguousLoad_ScalarPlusScalarOp {
3272   SVEContiguousLoad_ScalarPlusScalarFixed = 0xA4004000,
3273   SVEContiguousLoad_ScalarPlusScalarFMask = 0xFE00E000,
3274   SVEContiguousLoad_ScalarPlusScalarMask = 0xFFE0E000,
3275   LD1B_z_p_br_u8 = SVEContiguousLoad_ScalarPlusScalarFixed,
3276   LD1B_z_p_br_u16 = SVEContiguousLoad_ScalarPlusScalarFixed | 0x00200000,
3277   LD1B_z_p_br_u32 = SVEContiguousLoad_ScalarPlusScalarFixed | 0x00400000,
3278   LD1B_z_p_br_u64 = SVEContiguousLoad_ScalarPlusScalarFixed | 0x00600000,
3279   LD1SW_z_p_br_s64 = SVEContiguousLoad_ScalarPlusScalarFixed | 0x00800000,
3280   LD1H_z_p_br_u16 = SVEContiguousLoad_ScalarPlusScalarFixed | 0x00A00000,
3281   LD1H_z_p_br_u32 = SVEContiguousLoad_ScalarPlusScalarFixed | 0x00C00000,
3282   LD1H_z_p_br_u64 = SVEContiguousLoad_ScalarPlusScalarFixed | 0x00E00000,
3283   LD1SH_z_p_br_s64 = SVEContiguousLoad_ScalarPlusScalarFixed | 0x01000000,
3284   LD1SH_z_p_br_s32 = SVEContiguousLoad_ScalarPlusScalarFixed | 0x01200000,
3285   LD1W_z_p_br_u32 = SVEContiguousLoad_ScalarPlusScalarFixed | 0x01400000,
3286   LD1W_z_p_br_u64 = SVEContiguousLoad_ScalarPlusScalarFixed | 0x01600000,
3287   LD1SB_z_p_br_s64 = SVEContiguousLoad_ScalarPlusScalarFixed | 0x01800000,
3288   LD1SB_z_p_br_s32 = SVEContiguousLoad_ScalarPlusScalarFixed | 0x01A00000,
3289   LD1SB_z_p_br_s16 = SVEContiguousLoad_ScalarPlusScalarFixed | 0x01C00000,
3290   LD1D_z_p_br_u64 = SVEContiguousLoad_ScalarPlusScalarFixed | 0x01E00000
3291 };
3292 
3293 enum SVEContiguousNonFaultLoad_ScalarPlusImmOp {
3294   SVEContiguousNonFaultLoad_ScalarPlusImmFixed = 0xA410A000,
3295   SVEContiguousNonFaultLoad_ScalarPlusImmFMask = 0xFE10E000,
3296   SVEContiguousNonFaultLoad_ScalarPlusImmMask = 0xFFF0E000,
3297   LDNF1B_z_p_bi_u8 = SVEContiguousNonFaultLoad_ScalarPlusImmFixed,
3298   LDNF1B_z_p_bi_u16 = SVEContiguousNonFaultLoad_ScalarPlusImmFixed | 0x00200000,
3299   LDNF1B_z_p_bi_u32 = SVEContiguousNonFaultLoad_ScalarPlusImmFixed | 0x00400000,
3300   LDNF1B_z_p_bi_u64 = SVEContiguousNonFaultLoad_ScalarPlusImmFixed | 0x00600000,
3301   LDNF1SW_z_p_bi_s64 = SVEContiguousNonFaultLoad_ScalarPlusImmFixed | 0x00800000,
3302   LDNF1H_z_p_bi_u16 = SVEContiguousNonFaultLoad_ScalarPlusImmFixed | 0x00A00000,
3303   LDNF1H_z_p_bi_u32 = SVEContiguousNonFaultLoad_ScalarPlusImmFixed | 0x00C00000,
3304   LDNF1H_z_p_bi_u64 = SVEContiguousNonFaultLoad_ScalarPlusImmFixed | 0x00E00000,
3305   LDNF1SH_z_p_bi_s64 = SVEContiguousNonFaultLoad_ScalarPlusImmFixed | 0x01000000,
3306   LDNF1SH_z_p_bi_s32 = SVEContiguousNonFaultLoad_ScalarPlusImmFixed | 0x01200000,
3307   LDNF1W_z_p_bi_u32 = SVEContiguousNonFaultLoad_ScalarPlusImmFixed | 0x01400000,
3308   LDNF1W_z_p_bi_u64 = SVEContiguousNonFaultLoad_ScalarPlusImmFixed | 0x01600000,
3309   LDNF1SB_z_p_bi_s64 = SVEContiguousNonFaultLoad_ScalarPlusImmFixed | 0x01800000,
3310   LDNF1SB_z_p_bi_s32 = SVEContiguousNonFaultLoad_ScalarPlusImmFixed | 0x01A00000,
3311   LDNF1SB_z_p_bi_s16 = SVEContiguousNonFaultLoad_ScalarPlusImmFixed | 0x01C00000,
3312   LDNF1D_z_p_bi_u64 = SVEContiguousNonFaultLoad_ScalarPlusImmFixed | 0x01E00000
3313 };
3314 
3315 enum SVEContiguousNonTemporalLoad_ScalarPlusImmOp {
3316   SVEContiguousNonTemporalLoad_ScalarPlusImmFixed = 0xA400E000,
3317   SVEContiguousNonTemporalLoad_ScalarPlusImmFMask = 0xFE70E000,
3318   SVEContiguousNonTemporalLoad_ScalarPlusImmMask = 0xFFF0E000,
3319   LDNT1B_z_p_bi_contiguous = SVEContiguousNonTemporalLoad_ScalarPlusImmFixed,
3320   LDNT1H_z_p_bi_contiguous = SVEContiguousNonTemporalLoad_ScalarPlusImmFixed | 0x00800000,
3321   LDNT1W_z_p_bi_contiguous = SVEContiguousNonTemporalLoad_ScalarPlusImmFixed | 0x01000000,
3322   LDNT1D_z_p_bi_contiguous = SVEContiguousNonTemporalLoad_ScalarPlusImmFixed | 0x01800000
3323 };
3324 
3325 enum SVEContiguousNonTemporalLoad_ScalarPlusScalarOp {
3326   SVEContiguousNonTemporalLoad_ScalarPlusScalarFixed = 0xA400C000,
3327   SVEContiguousNonTemporalLoad_ScalarPlusScalarFMask = 0xFE60E000,
3328   SVEContiguousNonTemporalLoad_ScalarPlusScalarMask = 0xFFE0E000,
3329   LDNT1B_z_p_br_contiguous = SVEContiguousNonTemporalLoad_ScalarPlusScalarFixed,
3330   LDNT1H_z_p_br_contiguous = SVEContiguousNonTemporalLoad_ScalarPlusScalarFixed | 0x00800000,
3331   LDNT1W_z_p_br_contiguous = SVEContiguousNonTemporalLoad_ScalarPlusScalarFixed | 0x01000000,
3332   LDNT1D_z_p_br_contiguous = SVEContiguousNonTemporalLoad_ScalarPlusScalarFixed | 0x01800000
3333 };
3334 
3335 enum SVEContiguousNonTemporalStore_ScalarPlusImmOp {
3336   SVEContiguousNonTemporalStore_ScalarPlusImmFixed = 0xE410E000,
3337   SVEContiguousNonTemporalStore_ScalarPlusImmFMask = 0xFE70E000,
3338   SVEContiguousNonTemporalStore_ScalarPlusImmMask = 0xFFF0E000,
3339   STNT1B_z_p_bi_contiguous = SVEContiguousNonTemporalStore_ScalarPlusImmFixed,
3340   STNT1H_z_p_bi_contiguous = SVEContiguousNonTemporalStore_ScalarPlusImmFixed | 0x00800000,
3341   STNT1W_z_p_bi_contiguous = SVEContiguousNonTemporalStore_ScalarPlusImmFixed | 0x01000000,
3342   STNT1D_z_p_bi_contiguous = SVEContiguousNonTemporalStore_ScalarPlusImmFixed | 0x01800000
3343 };
3344 
3345 enum SVEContiguousNonTemporalStore_ScalarPlusScalarOp {
3346   SVEContiguousNonTemporalStore_ScalarPlusScalarFixed = 0xE4006000,
3347   SVEContiguousNonTemporalStore_ScalarPlusScalarFMask = 0xFE60E000,
3348   SVEContiguousNonTemporalStore_ScalarPlusScalarMask = 0xFFE0E000,
3349   STNT1B_z_p_br_contiguous = SVEContiguousNonTemporalStore_ScalarPlusScalarFixed,
3350   STNT1H_z_p_br_contiguous = SVEContiguousNonTemporalStore_ScalarPlusScalarFixed | 0x00800000,
3351   STNT1W_z_p_br_contiguous = SVEContiguousNonTemporalStore_ScalarPlusScalarFixed | 0x01000000,
3352   STNT1D_z_p_br_contiguous = SVEContiguousNonTemporalStore_ScalarPlusScalarFixed | 0x01800000
3353 };
3354 
3355 enum SVEContiguousPrefetch_ScalarPlusImmOp {
3356   SVEContiguousPrefetch_ScalarPlusImmFixed = 0x85C00000,
3357   SVEContiguousPrefetch_ScalarPlusImmFMask = 0xFFC08010,
3358   SVEContiguousPrefetch_ScalarPlusImmMask = 0xFFC0E010,
3359   PRFB_i_p_bi_s = SVEContiguousPrefetch_ScalarPlusImmFixed,
3360   PRFH_i_p_bi_s = SVEContiguousPrefetch_ScalarPlusImmFixed | 0x00002000,
3361   PRFW_i_p_bi_s = SVEContiguousPrefetch_ScalarPlusImmFixed | 0x00004000,
3362   PRFD_i_p_bi_s = SVEContiguousPrefetch_ScalarPlusImmFixed | 0x00006000
3363 };
3364 
3365 enum SVEContiguousPrefetch_ScalarPlusScalarOp {
3366   SVEContiguousPrefetch_ScalarPlusScalarFixed = 0x8400C000,
3367   SVEContiguousPrefetch_ScalarPlusScalarFMask = 0xFE60E010,
3368   SVEContiguousPrefetch_ScalarPlusScalarMask = 0xFFE0E010,
3369   PRFB_i_p_br_s = SVEContiguousPrefetch_ScalarPlusScalarFixed,
3370   PRFH_i_p_br_s = SVEContiguousPrefetch_ScalarPlusScalarFixed | 0x00800000,
3371   PRFW_i_p_br_s = SVEContiguousPrefetch_ScalarPlusScalarFixed | 0x01000000,
3372   PRFD_i_p_br_s = SVEContiguousPrefetch_ScalarPlusScalarFixed | 0x01800000
3373 };
3374 
3375 enum SVEContiguousStore_ScalarPlusImmOp {
3376   SVEContiguousStore_ScalarPlusImmFixed = 0xE400E000,
3377   SVEContiguousStore_ScalarPlusImmFMask = 0xFE10E000,
3378   SVEContiguousStore_ScalarPlusImmMask = 0xFF90E000,
3379   ST1B_z_p_bi = SVEContiguousStore_ScalarPlusImmFixed,
3380   ST1H_z_p_bi = SVEContiguousStore_ScalarPlusImmFixed | 0x00800000,
3381   ST1W_z_p_bi = SVEContiguousStore_ScalarPlusImmFixed | 0x01000000,
3382   ST1D_z_p_bi = SVEContiguousStore_ScalarPlusImmFixed | 0x01800000
3383 };
3384 
3385 enum SVEContiguousStore_ScalarPlusScalarOp {
3386   SVEContiguousStore_ScalarPlusScalarFixed = 0xE4004000,
3387   SVEContiguousStore_ScalarPlusScalarFMask = 0xFE00E000,
3388   SVEContiguousStore_ScalarPlusScalarMask = 0xFF80E000,
3389   ST1B_z_p_br = SVEContiguousStore_ScalarPlusScalarFixed,
3390   ST1H_z_p_br = SVEContiguousStore_ScalarPlusScalarFixed | 0x00800000,
3391   ST1W_z_p_br = SVEContiguousStore_ScalarPlusScalarFixed | 0x01000000,
3392   ST1D_z_p_br = SVEContiguousStore_ScalarPlusScalarFixed | 0x01800000
3393 };
3394 
3395 enum SVECopyFPImm_PredicatedOp {
3396   SVECopyFPImm_PredicatedFixed = 0x0510C000,
3397   SVECopyFPImm_PredicatedFMask = 0xFF30E000,
3398   SVECopyFPImm_PredicatedMask = 0xFF30E000,
3399   FCPY_z_p_i = SVECopyFPImm_PredicatedFixed
3400 };
3401 
3402 enum SVECopyGeneralRegisterToVector_PredicatedOp {
3403   SVECopyGeneralRegisterToVector_PredicatedFixed = 0x0528A000,
3404   SVECopyGeneralRegisterToVector_PredicatedFMask = 0xFF3FE000,
3405   SVECopyGeneralRegisterToVector_PredicatedMask = 0xFF3FE000,
3406   CPY_z_p_r = SVECopyGeneralRegisterToVector_PredicatedFixed
3407 };
3408 
3409 enum SVECopyIntImm_PredicatedOp {
3410   SVECopyIntImm_PredicatedFixed = 0x05100000,
3411   SVECopyIntImm_PredicatedFMask = 0xFF308000,
3412   SVECopyIntImm_PredicatedMask = 0xFF308000,
3413   CPY_z_p_i = SVECopyIntImm_PredicatedFixed
3414 };
3415 
3416 enum SVECopySIMDFPScalarRegisterToVector_PredicatedOp {
3417   SVECopySIMDFPScalarRegisterToVector_PredicatedFixed = 0x05208000,
3418   SVECopySIMDFPScalarRegisterToVector_PredicatedFMask = 0xFF3FE000,
3419   SVECopySIMDFPScalarRegisterToVector_PredicatedMask = 0xFF3FE000,
3420   CPY_z_p_v = SVECopySIMDFPScalarRegisterToVector_PredicatedFixed
3421 };
3422 
3423 enum SVEElementCountOp {
3424   SVEElementCountFixed = 0x0420E000,
3425   SVEElementCountFMask = 0xFF30F800,
3426   SVEElementCountMask = 0xFFF0FC00,
3427   CNTB_r_s = SVEElementCountFixed,
3428   CNTH_r_s = SVEElementCountFixed | 0x00400000,
3429   CNTW_r_s = SVEElementCountFixed | 0x00800000,
3430   CNTD_r_s = SVEElementCountFixed | 0x00C00000
3431 };
3432 
3433 enum SVEExtractElementToGeneralRegisterOp {
3434   SVEExtractElementToGeneralRegisterFixed = 0x0520A000,
3435   SVEExtractElementToGeneralRegisterFMask = 0xFF3EE000,
3436   SVEExtractElementToGeneralRegisterMask = 0xFF3FE000,
3437   LASTA_r_p_z = SVEExtractElementToGeneralRegisterFixed,
3438   LASTB_r_p_z = SVEExtractElementToGeneralRegisterFixed | 0x00010000
3439 };
3440 
3441 enum SVEExtractElementToSIMDFPScalarRegisterOp {
3442   SVEExtractElementToSIMDFPScalarRegisterFixed = 0x05228000,
3443   SVEExtractElementToSIMDFPScalarRegisterFMask = 0xFF3EE000,
3444   SVEExtractElementToSIMDFPScalarRegisterMask = 0xFF3FE000,
3445   LASTA_v_p_z = SVEExtractElementToSIMDFPScalarRegisterFixed,
3446   LASTB_v_p_z = SVEExtractElementToSIMDFPScalarRegisterFixed | 0x00010000
3447 };
3448 
3449 enum SVEFFRInitialiseOp {
3450   SVEFFRInitialiseFixed = 0x252C9000,
3451   SVEFFRInitialiseFMask = 0xFF3FFFFF,
3452   SVEFFRInitialiseMask = 0xFFFFFFFF,
3453   SETFFR_f = SVEFFRInitialiseFixed
3454 };
3455 
3456 enum SVEFFRWriteFromPredicateOp {
3457   SVEFFRWriteFromPredicateFixed = 0x25289000,
3458   SVEFFRWriteFromPredicateFMask = 0xFF3FFE1F,
3459   SVEFFRWriteFromPredicateMask = 0xFFFFFE1F,
3460   WRFFR_f_p = SVEFFRWriteFromPredicateFixed
3461 };
3462 
3463 enum SVEFPAccumulatingReductionOp {
3464   SVEFPAccumulatingReductionFixed = 0x65182000,
3465   SVEFPAccumulatingReductionFMask = 0xFF38E000,
3466   SVEFPAccumulatingReductionMask = 0xFF3FE000,
3467   FADDA_v_p_z = SVEFPAccumulatingReductionFixed
3468 };
3469 
3470 enum SVEFPArithmeticUnpredicatedOp {
3471   SVEFPArithmeticUnpredicatedFixed = 0x65000000,
3472   SVEFPArithmeticUnpredicatedFMask = 0xFF20E000,
3473   SVEFPArithmeticUnpredicatedMask = 0xFF20FC00,
3474   FADD_z_zz = SVEFPArithmeticUnpredicatedFixed,
3475   FSUB_z_zz = SVEFPArithmeticUnpredicatedFixed | 0x00000400,
3476   FMUL_z_zz = SVEFPArithmeticUnpredicatedFixed | 0x00000800,
3477   FTSMUL_z_zz = SVEFPArithmeticUnpredicatedFixed | 0x00000C00,
3478   FRECPS_z_zz = SVEFPArithmeticUnpredicatedFixed | 0x00001800,
3479   FRSQRTS_z_zz = SVEFPArithmeticUnpredicatedFixed | 0x00001C00
3480 };
3481 
3482 enum SVEFPArithmeticWithImm_PredicatedOp {
3483   SVEFPArithmeticWithImm_PredicatedFixed = 0x65188000,
3484   SVEFPArithmeticWithImm_PredicatedFMask = 0xFF38E3C0,
3485   SVEFPArithmeticWithImm_PredicatedMask = 0xFF3FE3C0,
3486   FADD_z_p_zs = SVEFPArithmeticWithImm_PredicatedFixed,
3487   FSUB_z_p_zs = SVEFPArithmeticWithImm_PredicatedFixed | 0x00010000,
3488   FMUL_z_p_zs = SVEFPArithmeticWithImm_PredicatedFixed | 0x00020000,
3489   FSUBR_z_p_zs = SVEFPArithmeticWithImm_PredicatedFixed | 0x00030000,
3490   FMAXNM_z_p_zs = SVEFPArithmeticWithImm_PredicatedFixed | 0x00040000,
3491   FMINNM_z_p_zs = SVEFPArithmeticWithImm_PredicatedFixed | 0x00050000,
3492   FMAX_z_p_zs = SVEFPArithmeticWithImm_PredicatedFixed | 0x00060000,
3493   FMIN_z_p_zs = SVEFPArithmeticWithImm_PredicatedFixed | 0x00070000
3494 };
3495 
3496 enum SVEFPArithmetic_PredicatedOp {
3497   SVEFPArithmetic_PredicatedFixed = 0x65008000,
3498   SVEFPArithmetic_PredicatedFMask = 0xFF30E000,
3499   SVEFPArithmetic_PredicatedMask = 0xFF3FE000,
3500   FADD_z_p_zz = SVEFPArithmetic_PredicatedFixed,
3501   FSUB_z_p_zz = SVEFPArithmetic_PredicatedFixed | 0x00010000,
3502   FMUL_z_p_zz = SVEFPArithmetic_PredicatedFixed | 0x00020000,
3503   FSUBR_z_p_zz = SVEFPArithmetic_PredicatedFixed | 0x00030000,
3504   FMAXNM_z_p_zz = SVEFPArithmetic_PredicatedFixed | 0x00040000,
3505   FMINNM_z_p_zz = SVEFPArithmetic_PredicatedFixed | 0x00050000,
3506   FMAX_z_p_zz = SVEFPArithmetic_PredicatedFixed | 0x00060000,
3507   FMIN_z_p_zz = SVEFPArithmetic_PredicatedFixed | 0x00070000,
3508   FABD_z_p_zz = SVEFPArithmetic_PredicatedFixed | 0x00080000,
3509   FSCALE_z_p_zz = SVEFPArithmetic_PredicatedFixed | 0x00090000,
3510   FMULX_z_p_zz = SVEFPArithmetic_PredicatedFixed | 0x000A0000,
3511   FDIVR_z_p_zz = SVEFPArithmetic_PredicatedFixed | 0x000C0000,
3512   FDIV_z_p_zz = SVEFPArithmetic_PredicatedFixed | 0x000D0000
3513 };
3514 
3515 enum SVEFPCompareVectorsOp {
3516   SVEFPCompareVectorsFixed = 0x65004000,
3517   SVEFPCompareVectorsFMask = 0xFF204000,
3518   SVEFPCompareVectorsMask = 0xFF20E010,
3519   FCMGE_p_p_zz = SVEFPCompareVectorsFixed,
3520   FCMGT_p_p_zz = SVEFPCompareVectorsFixed | 0x00000010,
3521   FCMEQ_p_p_zz = SVEFPCompareVectorsFixed | 0x00002000,
3522   FCMNE_p_p_zz = SVEFPCompareVectorsFixed | 0x00002010,
3523   FCMUO_p_p_zz = SVEFPCompareVectorsFixed | 0x00008000,
3524   FACGE_p_p_zz = SVEFPCompareVectorsFixed | 0x00008010,
3525   FACGT_p_p_zz = SVEFPCompareVectorsFixed | 0x0000A010
3526 };
3527 
3528 enum SVEFPCompareWithZeroOp {
3529   SVEFPCompareWithZeroFixed = 0x65102000,
3530   SVEFPCompareWithZeroFMask = 0xFF38E000,
3531   SVEFPCompareWithZeroMask = 0xFF3FE010,
3532   FCMGE_p_p_z0 = SVEFPCompareWithZeroFixed,
3533   FCMGT_p_p_z0 = SVEFPCompareWithZeroFixed | 0x00000010,
3534   FCMLT_p_p_z0 = SVEFPCompareWithZeroFixed | 0x00010000,
3535   FCMLE_p_p_z0 = SVEFPCompareWithZeroFixed | 0x00010010,
3536   FCMEQ_p_p_z0 = SVEFPCompareWithZeroFixed | 0x00020000,
3537   FCMNE_p_p_z0 = SVEFPCompareWithZeroFixed | 0x00030000
3538 };
3539 
3540 enum SVEFPComplexAdditionOp {
3541   SVEFPComplexAdditionFixed = 0x64008000,
3542   SVEFPComplexAdditionFMask = 0xFF3EE000,
3543   SVEFPComplexAdditionMask = 0xFF3EE000,
3544   FCADD_z_p_zz = SVEFPComplexAdditionFixed
3545 };
3546 
3547 enum SVEFPComplexMulAddOp {
3548   SVEFPComplexMulAddFixed = 0x64000000,
3549   SVEFPComplexMulAddFMask = 0xFF208000,
3550   SVEFPComplexMulAddMask = 0xFF208000,
3551   FCMLA_z_p_zzz = SVEFPComplexMulAddFixed
3552 };
3553 
3554 enum SVEFPComplexMulAddIndexOp {
3555   SVEFPComplexMulAddIndexFixed = 0x64201000,
3556   SVEFPComplexMulAddIndexFMask = 0xFF20F000,
3557   SVEFPComplexMulAddIndexMask = 0xFFE0F000,
3558   FCMLA_z_zzzi_h = SVEFPComplexMulAddIndexFixed | 0x00800000,
3559   FCMLA_z_zzzi_s = SVEFPComplexMulAddIndexFixed | 0x00C00000
3560 };
3561 
3562 enum SVEFPConvertPrecisionOp {
3563   SVEFPConvertPrecisionFixed = 0x6508A000,
3564   SVEFPConvertPrecisionFMask = 0xFF3CE000,
3565   SVEFPConvertPrecisionMask = 0xFFFFE000,
3566   FCVT_z_p_z_s2h = SVEFPConvertPrecisionFixed | 0x00800000,
3567   FCVT_z_p_z_h2s = SVEFPConvertPrecisionFixed | 0x00810000,
3568   FCVT_z_p_z_d2h = SVEFPConvertPrecisionFixed | 0x00C00000,
3569   FCVT_z_p_z_h2d = SVEFPConvertPrecisionFixed | 0x00C10000,
3570   FCVT_z_p_z_d2s = SVEFPConvertPrecisionFixed | 0x00C20000,
3571   FCVT_z_p_z_s2d = SVEFPConvertPrecisionFixed | 0x00C30000
3572 };
3573 
3574 enum SVEFPConvertToIntOp {
3575   SVEFPConvertToIntFixed = 0x6518A000,
3576   SVEFPConvertToIntFMask = 0xFF38E000,
3577   SVEFPConvertToIntMask = 0xFFFFE000,
3578   FCVTZS_z_p_z_fp162h = SVEFPConvertToIntFixed | 0x00420000,
3579   FCVTZU_z_p_z_fp162h = SVEFPConvertToIntFixed | 0x00430000,
3580   FCVTZS_z_p_z_fp162w = SVEFPConvertToIntFixed | 0x00440000,
3581   FCVTZU_z_p_z_fp162w = SVEFPConvertToIntFixed | 0x00450000,
3582   FCVTZS_z_p_z_fp162x = SVEFPConvertToIntFixed | 0x00460000,
3583   FCVTZU_z_p_z_fp162x = SVEFPConvertToIntFixed | 0x00470000,
3584   FCVTZS_z_p_z_s2w = SVEFPConvertToIntFixed | 0x00840000,
3585   FCVTZU_z_p_z_s2w = SVEFPConvertToIntFixed | 0x00850000,
3586   FCVTZS_z_p_z_d2w = SVEFPConvertToIntFixed | 0x00C00000,
3587   FCVTZU_z_p_z_d2w = SVEFPConvertToIntFixed | 0x00C10000,
3588   FCVTZS_z_p_z_s2x = SVEFPConvertToIntFixed | 0x00C40000,
3589   FCVTZU_z_p_z_s2x = SVEFPConvertToIntFixed | 0x00C50000,
3590   FCVTZS_z_p_z_d2x = SVEFPConvertToIntFixed | 0x00C60000,
3591   FCVTZU_z_p_z_d2x = SVEFPConvertToIntFixed | 0x00C70000
3592 };
3593 
3594 enum SVEFPExponentialAcceleratorOp {
3595   SVEFPExponentialAcceleratorFixed = 0x0420B800,
3596   SVEFPExponentialAcceleratorFMask = 0xFF20FC00,
3597   SVEFPExponentialAcceleratorMask = 0xFF3FFC00,
3598   FEXPA_z_z = SVEFPExponentialAcceleratorFixed
3599 };
3600 
3601 enum SVEFPFastReductionOp {
3602   SVEFPFastReductionFixed = 0x65002000,
3603   SVEFPFastReductionFMask = 0xFF38E000,
3604   SVEFPFastReductionMask = 0xFF3FE000,
3605   FADDV_v_p_z = SVEFPFastReductionFixed,
3606   FMAXNMV_v_p_z = SVEFPFastReductionFixed | 0x00040000,
3607   FMINNMV_v_p_z = SVEFPFastReductionFixed | 0x00050000,
3608   FMAXV_v_p_z = SVEFPFastReductionFixed | 0x00060000,
3609   FMINV_v_p_z = SVEFPFastReductionFixed | 0x00070000
3610 };
3611 
3612 enum SVEFPMulAddOp {
3613   SVEFPMulAddFixed = 0x65200000,
3614   SVEFPMulAddFMask = 0xFF200000,
3615   SVEFPMulAddMask = 0xFF20E000,
3616   FMLA_z_p_zzz = SVEFPMulAddFixed,
3617   FMLS_z_p_zzz = SVEFPMulAddFixed | 0x00002000,
3618   FNMLA_z_p_zzz = SVEFPMulAddFixed | 0x00004000,
3619   FNMLS_z_p_zzz = SVEFPMulAddFixed | 0x00006000,
3620   FMAD_z_p_zzz = SVEFPMulAddFixed | 0x00008000,
3621   FMSB_z_p_zzz = SVEFPMulAddFixed | 0x0000A000,
3622   FNMAD_z_p_zzz = SVEFPMulAddFixed | 0x0000C000,
3623   FNMSB_z_p_zzz = SVEFPMulAddFixed | 0x0000E000
3624 };
3625 
3626 enum SVEFPMulAddIndexOp {
3627   SVEFPMulAddIndexFixed = 0x64200000,
3628   SVEFPMulAddIndexFMask = 0xFF20F800,
3629   SVEFPMulAddIndexMask = 0xFFE0FC00,
3630   FMLA_z_zzzi_h = SVEFPMulAddIndexFixed,
3631   FMLA_z_zzzi_h_i3h = FMLA_z_zzzi_h | 0x00400000,
3632   FMLS_z_zzzi_h = SVEFPMulAddIndexFixed | 0x00000400,
3633   FMLS_z_zzzi_h_i3h = FMLS_z_zzzi_h | 0x00400000,
3634   FMLA_z_zzzi_s = SVEFPMulAddIndexFixed | 0x00800000,
3635   FMLS_z_zzzi_s = SVEFPMulAddIndexFixed | 0x00800400,
3636   FMLA_z_zzzi_d = SVEFPMulAddIndexFixed | 0x00C00000,
3637   FMLS_z_zzzi_d = SVEFPMulAddIndexFixed | 0x00C00400
3638 };
3639 
3640 enum SVEFPMulIndexOp {
3641   SVEFPMulIndexFixed = 0x64202000,
3642   SVEFPMulIndexFMask = 0xFF20FC00,
3643   SVEFPMulIndexMask = 0xFFE0FC00,
3644   FMUL_z_zzi_h = SVEFPMulIndexFixed,
3645   FMUL_z_zzi_h_i3h = FMUL_z_zzi_h | 0x00400000,
3646   FMUL_z_zzi_s = SVEFPMulIndexFixed | 0x00800000,
3647   FMUL_z_zzi_d = SVEFPMulIndexFixed | 0x00C00000
3648 };
3649 
3650 enum SVEFPRoundToIntegralValueOp {
3651   SVEFPRoundToIntegralValueFixed = 0x6500A000,
3652   SVEFPRoundToIntegralValueFMask = 0xFF38E000,
3653   SVEFPRoundToIntegralValueMask = 0xFF3FE000,
3654   FRINTN_z_p_z = SVEFPRoundToIntegralValueFixed,
3655   FRINTP_z_p_z = SVEFPRoundToIntegralValueFixed | 0x00010000,
3656   FRINTM_z_p_z = SVEFPRoundToIntegralValueFixed | 0x00020000,
3657   FRINTZ_z_p_z = SVEFPRoundToIntegralValueFixed | 0x00030000,
3658   FRINTA_z_p_z = SVEFPRoundToIntegralValueFixed | 0x00040000,
3659   FRINTX_z_p_z = SVEFPRoundToIntegralValueFixed | 0x00060000,
3660   FRINTI_z_p_z = SVEFPRoundToIntegralValueFixed | 0x00070000
3661 };
3662 
3663 enum SVEFPTrigMulAddCoefficientOp {
3664   SVEFPTrigMulAddCoefficientFixed = 0x65108000,
3665   SVEFPTrigMulAddCoefficientFMask = 0xFF38FC00,
3666   SVEFPTrigMulAddCoefficientMask = 0xFF38FC00,
3667   FTMAD_z_zzi = SVEFPTrigMulAddCoefficientFixed
3668 };
3669 
3670 enum SVEFPTrigSelectCoefficientOp {
3671   SVEFPTrigSelectCoefficientFixed = 0x0420B000,
3672   SVEFPTrigSelectCoefficientFMask = 0xFF20F800,
3673   SVEFPTrigSelectCoefficientMask = 0xFF20FC00,
3674   FTSSEL_z_zz = SVEFPTrigSelectCoefficientFixed
3675 };
3676 
3677 enum SVEFPUnaryOpOp {
3678   SVEFPUnaryOpFixed = 0x650CA000,
3679   SVEFPUnaryOpFMask = 0xFF3CE000,
3680   SVEFPUnaryOpMask = 0xFF3FE000,
3681   FRECPX_z_p_z = SVEFPUnaryOpFixed,
3682   FSQRT_z_p_z = SVEFPUnaryOpFixed | 0x00010000
3683 };
3684 
3685 enum SVEFPUnaryOpUnpredicatedOp {
3686   SVEFPUnaryOpUnpredicatedFixed = 0x65083000,
3687   SVEFPUnaryOpUnpredicatedFMask = 0xFF38F000,
3688   SVEFPUnaryOpUnpredicatedMask = 0xFF3FFC00,
3689   FRECPE_z_z = SVEFPUnaryOpUnpredicatedFixed | 0x00060000,
3690   FRSQRTE_z_z = SVEFPUnaryOpUnpredicatedFixed | 0x00070000
3691 };
3692 
3693 enum SVEIncDecByPredicateCountOp {
3694   SVEIncDecByPredicateCountFixed = 0x25288000,
3695   SVEIncDecByPredicateCountFMask = 0xFF38F000,
3696   SVEIncDecByPredicateCountMask = 0xFF3FFE00,
3697   SQINCP_z_p_z = SVEIncDecByPredicateCountFixed,
3698   SQINCP_r_p_r_sx = SVEIncDecByPredicateCountFixed | 0x00000800,
3699   SQINCP_r_p_r_x = SVEIncDecByPredicateCountFixed | 0x00000C00,
3700   UQINCP_z_p_z = SVEIncDecByPredicateCountFixed | 0x00010000,
3701   UQINCP_r_p_r_uw = SVEIncDecByPredicateCountFixed | 0x00010800,
3702   UQINCP_r_p_r_x = SVEIncDecByPredicateCountFixed | 0x00010C00,
3703   SQDECP_z_p_z = SVEIncDecByPredicateCountFixed | 0x00020000,
3704   SQDECP_r_p_r_sx = SVEIncDecByPredicateCountFixed | 0x00020800,
3705   SQDECP_r_p_r_x = SVEIncDecByPredicateCountFixed | 0x00020C00,
3706   UQDECP_z_p_z = SVEIncDecByPredicateCountFixed | 0x00030000,
3707   UQDECP_r_p_r_uw = SVEIncDecByPredicateCountFixed | 0x00030800,
3708   UQDECP_r_p_r_x = SVEIncDecByPredicateCountFixed | 0x00030C00,
3709   INCP_z_p_z = SVEIncDecByPredicateCountFixed | 0x00040000,
3710   INCP_r_p_r = SVEIncDecByPredicateCountFixed | 0x00040800,
3711   DECP_z_p_z = SVEIncDecByPredicateCountFixed | 0x00050000,
3712   DECP_r_p_r = SVEIncDecByPredicateCountFixed | 0x00050800
3713 };
3714 
3715 enum SVEIncDecRegisterByElementCountOp {
3716   SVEIncDecRegisterByElementCountFixed = 0x0430E000,
3717   SVEIncDecRegisterByElementCountFMask = 0xFF30F800,
3718   SVEIncDecRegisterByElementCountMask = 0xFFF0FC00,
3719   INCB_r_rs = SVEIncDecRegisterByElementCountFixed,
3720   DECB_r_rs = SVEIncDecRegisterByElementCountFixed | 0x00000400,
3721   INCH_r_rs = SVEIncDecRegisterByElementCountFixed | 0x00400000,
3722   DECH_r_rs = SVEIncDecRegisterByElementCountFixed | 0x00400400,
3723   INCW_r_rs = SVEIncDecRegisterByElementCountFixed | 0x00800000,
3724   DECW_r_rs = SVEIncDecRegisterByElementCountFixed | 0x00800400,
3725   INCD_r_rs = SVEIncDecRegisterByElementCountFixed | 0x00C00000,
3726   DECD_r_rs = SVEIncDecRegisterByElementCountFixed | 0x00C00400
3727 };
3728 
3729 enum SVEIncDecVectorByElementCountOp {
3730   SVEIncDecVectorByElementCountFixed = 0x0430C000,
3731   SVEIncDecVectorByElementCountFMask = 0xFF30F800,
3732   SVEIncDecVectorByElementCountMask = 0xFFF0FC00,
3733   INCH_z_zs = SVEIncDecVectorByElementCountFixed | 0x00400000,
3734   DECH_z_zs = SVEIncDecVectorByElementCountFixed | 0x00400400,
3735   INCW_z_zs = SVEIncDecVectorByElementCountFixed | 0x00800000,
3736   DECW_z_zs = SVEIncDecVectorByElementCountFixed | 0x00800400,
3737   INCD_z_zs = SVEIncDecVectorByElementCountFixed | 0x00C00000,
3738   DECD_z_zs = SVEIncDecVectorByElementCountFixed | 0x00C00400
3739 };
3740 
3741 enum SVEIndexGenerationOp {
3742   SVEIndexGenerationFixed = 0x04204000,
3743   SVEIndexGenerationFMask = 0xFF20F000,
3744   SVEIndexGenerationMask = 0xFF20FC00,
3745   INDEX_z_ii = SVEIndexGenerationFixed,
3746   INDEX_z_ri = SVEIndexGenerationFixed | 0x00000400,
3747   INDEX_z_ir = SVEIndexGenerationFixed | 0x00000800,
3748   INDEX_z_rr = SVEIndexGenerationFixed | 0x00000C00
3749 };
3750 
3751 enum SVEInsertGeneralRegisterOp {
3752   SVEInsertGeneralRegisterFixed = 0x05243800,
3753   SVEInsertGeneralRegisterFMask = 0xFF3FFC00,
3754   SVEInsertGeneralRegisterMask = 0xFF3FFC00,
3755   INSR_z_r = SVEInsertGeneralRegisterFixed
3756 };
3757 
3758 enum SVEInsertSIMDFPScalarRegisterOp {
3759   SVEInsertSIMDFPScalarRegisterFixed = 0x05343800,
3760   SVEInsertSIMDFPScalarRegisterFMask = 0xFF3FFC00,
3761   SVEInsertSIMDFPScalarRegisterMask = 0xFF3FFC00,
3762   INSR_z_v = SVEInsertSIMDFPScalarRegisterFixed
3763 };
3764 
3765 enum SVEIntAddSubtractImm_UnpredicatedOp {
3766   SVEIntAddSubtractImm_UnpredicatedFixed = 0x2520C000,
3767   SVEIntAddSubtractImm_UnpredicatedFMask = 0xFF38C000,
3768   SVEIntAddSubtractImm_UnpredicatedMask = 0xFF3FC000,
3769   ADD_z_zi = SVEIntAddSubtractImm_UnpredicatedFixed,
3770   SUB_z_zi = SVEIntAddSubtractImm_UnpredicatedFixed | 0x00010000,
3771   SUBR_z_zi = SVEIntAddSubtractImm_UnpredicatedFixed | 0x00030000,
3772   SQADD_z_zi = SVEIntAddSubtractImm_UnpredicatedFixed | 0x00040000,
3773   UQADD_z_zi = SVEIntAddSubtractImm_UnpredicatedFixed | 0x00050000,
3774   SQSUB_z_zi = SVEIntAddSubtractImm_UnpredicatedFixed | 0x00060000,
3775   UQSUB_z_zi = SVEIntAddSubtractImm_UnpredicatedFixed | 0x00070000
3776 };
3777 
3778 enum SVEIntAddSubtractVectors_PredicatedOp {
3779   SVEIntAddSubtractVectors_PredicatedFixed = 0x04000000,
3780   SVEIntAddSubtractVectors_PredicatedFMask = 0xFF38E000,
3781   SVEIntAddSubtractVectors_PredicatedMask = 0xFF3FE000,
3782   ADD_z_p_zz = SVEIntAddSubtractVectors_PredicatedFixed,
3783   SUB_z_p_zz = SVEIntAddSubtractVectors_PredicatedFixed | 0x00010000,
3784   SUBR_z_p_zz = SVEIntAddSubtractVectors_PredicatedFixed | 0x00030000
3785 };
3786 
3787 enum SVEIntArithmeticUnpredicatedOp {
3788   SVEIntArithmeticUnpredicatedFixed = 0x04200000,
3789   SVEIntArithmeticUnpredicatedFMask = 0xFF20E000,
3790   SVEIntArithmeticUnpredicatedMask = 0xFF20FC00,
3791   ADD_z_zz = SVEIntArithmeticUnpredicatedFixed,
3792   SUB_z_zz = SVEIntArithmeticUnpredicatedFixed | 0x00000400,
3793   SQADD_z_zz = SVEIntArithmeticUnpredicatedFixed | 0x00001000,
3794   UQADD_z_zz = SVEIntArithmeticUnpredicatedFixed | 0x00001400,
3795   SQSUB_z_zz = SVEIntArithmeticUnpredicatedFixed | 0x00001800,
3796   UQSUB_z_zz = SVEIntArithmeticUnpredicatedFixed | 0x00001C00
3797 };
3798 
3799 enum SVEIntCompareScalarCountAndLimitOp {
3800   SVEIntCompareScalarCountAndLimitFixed = 0x25200000,
3801   SVEIntCompareScalarCountAndLimitFMask = 0xFF20E000,
3802   SVEIntCompareScalarCountAndLimitMask = 0xFF20EC10,
3803   WHILELT_p_p_rr = SVEIntCompareScalarCountAndLimitFixed | 0x00000400,
3804   WHILELE_p_p_rr = SVEIntCompareScalarCountAndLimitFixed | 0x00000410,
3805   WHILELO_p_p_rr = SVEIntCompareScalarCountAndLimitFixed | 0x00000C00,
3806   WHILELS_p_p_rr = SVEIntCompareScalarCountAndLimitFixed | 0x00000C10
3807 };
3808 
3809 enum SVEIntCompareSignedImmOp {
3810   SVEIntCompareSignedImmFixed = 0x25000000,
3811   SVEIntCompareSignedImmFMask = 0xFF204000,
3812   SVEIntCompareSignedImmMask = 0xFF20E010,
3813   CMPGE_p_p_zi = SVEIntCompareSignedImmFixed,
3814   CMPGT_p_p_zi = SVEIntCompareSignedImmFixed | 0x00000010,
3815   CMPLT_p_p_zi = SVEIntCompareSignedImmFixed | 0x00002000,
3816   CMPLE_p_p_zi = SVEIntCompareSignedImmFixed | 0x00002010,
3817   CMPEQ_p_p_zi = SVEIntCompareSignedImmFixed | 0x00008000,
3818   CMPNE_p_p_zi = SVEIntCompareSignedImmFixed | 0x00008010
3819 };
3820 
3821 enum SVEIntCompareUnsignedImmOp {
3822   SVEIntCompareUnsignedImmFixed = 0x24200000,
3823   SVEIntCompareUnsignedImmFMask = 0xFF200000,
3824   SVEIntCompareUnsignedImmMask = 0xFF202010,
3825   CMPHS_p_p_zi = SVEIntCompareUnsignedImmFixed,
3826   CMPHI_p_p_zi = SVEIntCompareUnsignedImmFixed | 0x00000010,
3827   CMPLO_p_p_zi = SVEIntCompareUnsignedImmFixed | 0x00002000,
3828   CMPLS_p_p_zi = SVEIntCompareUnsignedImmFixed | 0x00002010
3829 };
3830 
3831 enum SVEIntCompareVectorsOp {
3832   SVEIntCompareVectorsFixed = 0x24000000,
3833   SVEIntCompareVectorsFMask = 0xFF200000,
3834   SVEIntCompareVectorsMask = 0xFF20E010,
3835   CMPHS_p_p_zz = SVEIntCompareVectorsFixed,
3836   CMPHI_p_p_zz = SVEIntCompareVectorsFixed | 0x00000010,
3837   CMPEQ_p_p_zw = SVEIntCompareVectorsFixed | 0x00002000,
3838   CMPNE_p_p_zw = SVEIntCompareVectorsFixed | 0x00002010,
3839   CMPGE_p_p_zw = SVEIntCompareVectorsFixed | 0x00004000,
3840   CMPGT_p_p_zw = SVEIntCompareVectorsFixed | 0x00004010,
3841   CMPLT_p_p_zw = SVEIntCompareVectorsFixed | 0x00006000,
3842   CMPLE_p_p_zw = SVEIntCompareVectorsFixed | 0x00006010,
3843   CMPGE_p_p_zz = SVEIntCompareVectorsFixed | 0x00008000,
3844   CMPGT_p_p_zz = SVEIntCompareVectorsFixed | 0x00008010,
3845   CMPEQ_p_p_zz = SVEIntCompareVectorsFixed | 0x0000A000,
3846   CMPNE_p_p_zz = SVEIntCompareVectorsFixed | 0x0000A010,
3847   CMPHS_p_p_zw = SVEIntCompareVectorsFixed | 0x0000C000,
3848   CMPHI_p_p_zw = SVEIntCompareVectorsFixed | 0x0000C010,
3849   CMPLO_p_p_zw = SVEIntCompareVectorsFixed | 0x0000E000,
3850   CMPLS_p_p_zw = SVEIntCompareVectorsFixed | 0x0000E010
3851 };
3852 
3853 enum SVEIntConvertToFPOp {
3854   SVEIntConvertToFPFixed = 0x6510A000,
3855   SVEIntConvertToFPFMask = 0xFF38E000,
3856   SVEIntConvertToFPMask = 0xFFFFE000,
3857   SCVTF_z_p_z_h2fp16 = SVEIntConvertToFPFixed | 0x00420000,
3858   UCVTF_z_p_z_h2fp16 = SVEIntConvertToFPFixed | 0x00430000,
3859   SCVTF_z_p_z_w2fp16 = SVEIntConvertToFPFixed | 0x00440000,
3860   UCVTF_z_p_z_w2fp16 = SVEIntConvertToFPFixed | 0x00450000,
3861   SCVTF_z_p_z_x2fp16 = SVEIntConvertToFPFixed | 0x00460000,
3862   UCVTF_z_p_z_x2fp16 = SVEIntConvertToFPFixed | 0x00470000,
3863   SCVTF_z_p_z_w2s = SVEIntConvertToFPFixed | 0x00840000,
3864   UCVTF_z_p_z_w2s = SVEIntConvertToFPFixed | 0x00850000,
3865   SCVTF_z_p_z_w2d = SVEIntConvertToFPFixed | 0x00C00000,
3866   UCVTF_z_p_z_w2d = SVEIntConvertToFPFixed | 0x00C10000,
3867   SCVTF_z_p_z_x2s = SVEIntConvertToFPFixed | 0x00C40000,
3868   UCVTF_z_p_z_x2s = SVEIntConvertToFPFixed | 0x00C50000,
3869   SCVTF_z_p_z_x2d = SVEIntConvertToFPFixed | 0x00C60000,
3870   UCVTF_z_p_z_x2d = SVEIntConvertToFPFixed | 0x00C70000
3871 };
3872 
3873 enum SVEIntDivideVectors_PredicatedOp {
3874   SVEIntDivideVectors_PredicatedFixed = 0x04140000,
3875   SVEIntDivideVectors_PredicatedFMask = 0xFF3CE000,
3876   SVEIntDivideVectors_PredicatedMask = 0xFF3FE000,
3877   SDIV_z_p_zz = SVEIntDivideVectors_PredicatedFixed,
3878   UDIV_z_p_zz = SVEIntDivideVectors_PredicatedFixed | 0x00010000,
3879   SDIVR_z_p_zz = SVEIntDivideVectors_PredicatedFixed | 0x00020000,
3880   UDIVR_z_p_zz = SVEIntDivideVectors_PredicatedFixed | 0x00030000
3881 };
3882 
3883 enum SVEIntMinMaxDifference_PredicatedOp {
3884   SVEIntMinMaxDifference_PredicatedFixed = 0x04080000,
3885   SVEIntMinMaxDifference_PredicatedFMask = 0xFF38E000,
3886   SVEIntMinMaxDifference_PredicatedMask = 0xFF3FE000,
3887   SMAX_z_p_zz = SVEIntMinMaxDifference_PredicatedFixed,
3888   UMAX_z_p_zz = SVEIntMinMaxDifference_PredicatedFixed | 0x00010000,
3889   SMIN_z_p_zz = SVEIntMinMaxDifference_PredicatedFixed | 0x00020000,
3890   UMIN_z_p_zz = SVEIntMinMaxDifference_PredicatedFixed | 0x00030000,
3891   SABD_z_p_zz = SVEIntMinMaxDifference_PredicatedFixed | 0x00040000,
3892   UABD_z_p_zz = SVEIntMinMaxDifference_PredicatedFixed | 0x00050000
3893 };
3894 
3895 enum SVEIntMinMaxImm_UnpredicatedOp {
3896   SVEIntMinMaxImm_UnpredicatedFixed = 0x2528C000,
3897   SVEIntMinMaxImm_UnpredicatedFMask = 0xFF38C000,
3898   SVEIntMinMaxImm_UnpredicatedMask = 0xFF3FE000,
3899   SMAX_z_zi = SVEIntMinMaxImm_UnpredicatedFixed,
3900   UMAX_z_zi = SVEIntMinMaxImm_UnpredicatedFixed | 0x00010000,
3901   SMIN_z_zi = SVEIntMinMaxImm_UnpredicatedFixed | 0x00020000,
3902   UMIN_z_zi = SVEIntMinMaxImm_UnpredicatedFixed | 0x00030000
3903 };
3904 
3905 enum SVEIntMulAddPredicatedOp {
3906   SVEIntMulAddPredicatedFixed = 0x04004000,
3907   SVEIntMulAddPredicatedFMask = 0xFF204000,
3908   SVEIntMulAddPredicatedMask = 0xFF20E000,
3909   MLA_z_p_zzz = SVEIntMulAddPredicatedFixed,
3910   MLS_z_p_zzz = SVEIntMulAddPredicatedFixed | 0x00002000,
3911   MAD_z_p_zzz = SVEIntMulAddPredicatedFixed | 0x00008000,
3912   MSB_z_p_zzz = SVEIntMulAddPredicatedFixed | 0x0000A000
3913 };
3914 
3915 enum SVEIntMulAddUnpredicatedOp {
3916   SVEIntMulAddUnpredicatedFixed = 0x44000000,
3917   SVEIntMulAddUnpredicatedFMask = 0xFF208000,
3918   SVEIntMulAddUnpredicatedMask = 0xFF20FC00,
3919   SDOT_z_zzz = SVEIntMulAddUnpredicatedFixed,
3920   UDOT_z_zzz = SVEIntMulAddUnpredicatedFixed | 0x00000400
3921 };
3922 
3923 enum SVEIntMulImm_UnpredicatedOp {
3924   SVEIntMulImm_UnpredicatedFixed = 0x2530C000,
3925   SVEIntMulImm_UnpredicatedFMask = 0xFF38C000,
3926   SVEIntMulImm_UnpredicatedMask = 0xFF3FE000,
3927   MUL_z_zi = SVEIntMulImm_UnpredicatedFixed
3928 };
3929 
3930 enum SVEIntMulVectors_PredicatedOp {
3931   SVEIntMulVectors_PredicatedFixed = 0x04100000,
3932   SVEIntMulVectors_PredicatedFMask = 0xFF3CE000,
3933   SVEIntMulVectors_PredicatedMask = 0xFF3FE000,
3934   MUL_z_p_zz = SVEIntMulVectors_PredicatedFixed,
3935   SMULH_z_p_zz = SVEIntMulVectors_PredicatedFixed | 0x00020000,
3936   UMULH_z_p_zz = SVEIntMulVectors_PredicatedFixed | 0x00030000
3937 };
3938 
3939 enum SVEMovprfxOp {
3940   SVEMovprfxFixed = 0x04002000,
3941   SVEMovprfxFMask = 0xFF20E000,
3942   SVEMovprfxMask = 0xFF3EE000,
3943   MOVPRFX_z_p_z = SVEMovprfxFixed | 0x00100000
3944 };
3945 
3946 enum SVEIntReductionOp {
3947   SVEIntReductionFixed = 0x04002000,
3948   SVEIntReductionFMask = 0xFF20E000,
3949   SVEIntReductionMask = 0xFF3FE000,
3950   SADDV_r_p_z = SVEIntReductionFixed,
3951   UADDV_r_p_z = SVEIntReductionFixed | 0x00010000,
3952   SMAXV_r_p_z = SVEIntReductionFixed | 0x00080000,
3953   UMAXV_r_p_z = SVEIntReductionFixed | 0x00090000,
3954   SMINV_r_p_z = SVEIntReductionFixed | 0x000A0000,
3955   UMINV_r_p_z = SVEIntReductionFixed | 0x000B0000
3956 };
3957 
3958 enum SVEIntReductionLogicalOp {
3959   SVEIntReductionLogicalFixed = 0x04182000,
3960   SVEIntReductionLogicalFMask = 0xFF38E000,
3961   SVEIntReductionLogicalMask = 0xFF3FE000,
3962   ORV_r_p_z = SVEIntReductionLogicalFixed | 0x00180000,
3963   EORV_r_p_z = SVEIntReductionLogicalFixed | 0x00190000,
3964   ANDV_r_p_z = SVEIntReductionLogicalFixed | 0x001A0000
3965 };
3966 
3967 enum SVEIntUnaryArithmeticPredicatedOp {
3968   SVEIntUnaryArithmeticPredicatedFixed = 0x0400A000,
3969   SVEIntUnaryArithmeticPredicatedFMask = 0xFF20E000,
3970   SVEIntUnaryArithmeticPredicatedMask = 0xFF3FE000,
3971   SXTB_z_p_z = SVEIntUnaryArithmeticPredicatedFixed | 0x00100000,
3972   UXTB_z_p_z = SVEIntUnaryArithmeticPredicatedFixed | 0x00110000,
3973   SXTH_z_p_z = SVEIntUnaryArithmeticPredicatedFixed | 0x00120000,
3974   UXTH_z_p_z = SVEIntUnaryArithmeticPredicatedFixed | 0x00130000,
3975   SXTW_z_p_z = SVEIntUnaryArithmeticPredicatedFixed | 0x00140000,
3976   UXTW_z_p_z = SVEIntUnaryArithmeticPredicatedFixed | 0x00150000,
3977   ABS_z_p_z = SVEIntUnaryArithmeticPredicatedFixed | 0x00160000,
3978   NEG_z_p_z = SVEIntUnaryArithmeticPredicatedFixed | 0x00170000,
3979   CLS_z_p_z = SVEIntUnaryArithmeticPredicatedFixed | 0x00180000,
3980   CLZ_z_p_z = SVEIntUnaryArithmeticPredicatedFixed | 0x00190000,
3981   CNT_z_p_z = SVEIntUnaryArithmeticPredicatedFixed | 0x001A0000,
3982   CNOT_z_p_z = SVEIntUnaryArithmeticPredicatedFixed | 0x001B0000,
3983   FABS_z_p_z = SVEIntUnaryArithmeticPredicatedFixed | 0x001C0000,
3984   FNEG_z_p_z = SVEIntUnaryArithmeticPredicatedFixed | 0x001D0000,
3985   NOT_z_p_z = SVEIntUnaryArithmeticPredicatedFixed | 0x001E0000
3986 };
3987 
3988 enum SVELoadAndBroadcastElementOp {
3989   SVELoadAndBroadcastElementFixed = 0x84408000,
3990   SVELoadAndBroadcastElementFMask = 0xFE408000,
3991   SVELoadAndBroadcastElementMask = 0xFFC0E000,
3992   LD1RB_z_p_bi_u8 = SVELoadAndBroadcastElementFixed,
3993   LD1RB_z_p_bi_u16 = SVELoadAndBroadcastElementFixed | 0x00002000,
3994   LD1RB_z_p_bi_u32 = SVELoadAndBroadcastElementFixed | 0x00004000,
3995   LD1RB_z_p_bi_u64 = SVELoadAndBroadcastElementFixed | 0x00006000,
3996   LD1RSW_z_p_bi_s64 = SVELoadAndBroadcastElementFixed | 0x00800000,
3997   LD1RH_z_p_bi_u16 = SVELoadAndBroadcastElementFixed | 0x00802000,
3998   LD1RH_z_p_bi_u32 = SVELoadAndBroadcastElementFixed | 0x00804000,
3999   LD1RH_z_p_bi_u64 = SVELoadAndBroadcastElementFixed | 0x00806000,
4000   LD1RSH_z_p_bi_s64 = SVELoadAndBroadcastElementFixed | 0x01000000,
4001   LD1RSH_z_p_bi_s32 = SVELoadAndBroadcastElementFixed | 0x01002000,
4002   LD1RW_z_p_bi_u32 = SVELoadAndBroadcastElementFixed | 0x01004000,
4003   LD1RW_z_p_bi_u64 = SVELoadAndBroadcastElementFixed | 0x01006000,
4004   LD1RSB_z_p_bi_s64 = SVELoadAndBroadcastElementFixed | 0x01800000,
4005   LD1RSB_z_p_bi_s32 = SVELoadAndBroadcastElementFixed | 0x01802000,
4006   LD1RSB_z_p_bi_s16 = SVELoadAndBroadcastElementFixed | 0x01804000,
4007   LD1RD_z_p_bi_u64 = SVELoadAndBroadcastElementFixed | 0x01806000
4008 };
4009 
4010 enum SVELoadAndBroadcastQuadword_ScalarPlusImmOp {
4011   SVELoadAndBroadcastQuadword_ScalarPlusImmFixed = 0xA4002000,
4012   SVELoadAndBroadcastQuadword_ScalarPlusImmFMask = 0xFE10E000,
4013   SVELoadAndBroadcastQuadword_ScalarPlusImmMask = 0xFFF0E000,
4014   LD1RQB_z_p_bi_u8 = SVELoadAndBroadcastQuadword_ScalarPlusImmFixed,
4015   LD1RQH_z_p_bi_u16 = SVELoadAndBroadcastQuadword_ScalarPlusImmFixed | 0x00800000,
4016   LD1RQW_z_p_bi_u32 = SVELoadAndBroadcastQuadword_ScalarPlusImmFixed | 0x01000000,
4017   LD1RQD_z_p_bi_u64 = SVELoadAndBroadcastQuadword_ScalarPlusImmFixed | 0x01800000
4018 };
4019 
4020 enum SVELoadAndBroadcastQuadword_ScalarPlusScalarOp {
4021   SVELoadAndBroadcastQuadword_ScalarPlusScalarFixed = 0xA4000000,
4022   SVELoadAndBroadcastQuadword_ScalarPlusScalarFMask = 0xFE00E000,
4023   SVELoadAndBroadcastQuadword_ScalarPlusScalarMask = 0xFFE0E000,
4024   LD1RQB_z_p_br_contiguous = SVELoadAndBroadcastQuadword_ScalarPlusScalarFixed,
4025   LD1RQH_z_p_br_contiguous = SVELoadAndBroadcastQuadword_ScalarPlusScalarFixed | 0x00800000,
4026   LD1RQW_z_p_br_contiguous = SVELoadAndBroadcastQuadword_ScalarPlusScalarFixed | 0x01000000,
4027   LD1RQD_z_p_br_contiguous = SVELoadAndBroadcastQuadword_ScalarPlusScalarFixed | 0x01800000
4028 };
4029 
4030 enum SVELoadMultipleStructures_ScalarPlusImmOp {
4031   SVELoadMultipleStructures_ScalarPlusImmFixed = 0xA400E000,
4032   SVELoadMultipleStructures_ScalarPlusImmFMask = 0xFE10E000,
4033   SVELoadMultipleStructures_ScalarPlusImmMask = 0xFFF0E000,
4034   LD2B_z_p_bi_contiguous = SVELoadMultipleStructures_ScalarPlusImmFixed | 0x00200000,
4035   LD3B_z_p_bi_contiguous = SVELoadMultipleStructures_ScalarPlusImmFixed | 0x00400000,
4036   LD4B_z_p_bi_contiguous = SVELoadMultipleStructures_ScalarPlusImmFixed | 0x00600000,
4037   LD2H_z_p_bi_contiguous = SVELoadMultipleStructures_ScalarPlusImmFixed | 0x00A00000,
4038   LD3H_z_p_bi_contiguous = SVELoadMultipleStructures_ScalarPlusImmFixed | 0x00C00000,
4039   LD4H_z_p_bi_contiguous = SVELoadMultipleStructures_ScalarPlusImmFixed | 0x00E00000,
4040   LD2W_z_p_bi_contiguous = SVELoadMultipleStructures_ScalarPlusImmFixed | 0x01200000,
4041   LD3W_z_p_bi_contiguous = SVELoadMultipleStructures_ScalarPlusImmFixed | 0x01400000,
4042   LD4W_z_p_bi_contiguous = SVELoadMultipleStructures_ScalarPlusImmFixed | 0x01600000,
4043   LD2D_z_p_bi_contiguous = SVELoadMultipleStructures_ScalarPlusImmFixed | 0x01A00000,
4044   LD3D_z_p_bi_contiguous = SVELoadMultipleStructures_ScalarPlusImmFixed | 0x01C00000,
4045   LD4D_z_p_bi_contiguous = SVELoadMultipleStructures_ScalarPlusImmFixed | 0x01E00000
4046 };
4047 
4048 enum SVELoadMultipleStructures_ScalarPlusScalarOp {
4049   SVELoadMultipleStructures_ScalarPlusScalarFixed = 0xA400C000,
4050   SVELoadMultipleStructures_ScalarPlusScalarFMask = 0xFE00E000,
4051   SVELoadMultipleStructures_ScalarPlusScalarMask = 0xFFE0E000,
4052   LD2B_z_p_br_contiguous = SVELoadMultipleStructures_ScalarPlusScalarFixed | 0x00200000,
4053   LD3B_z_p_br_contiguous = SVELoadMultipleStructures_ScalarPlusScalarFixed | 0x00400000,
4054   LD4B_z_p_br_contiguous = SVELoadMultipleStructures_ScalarPlusScalarFixed | 0x00600000,
4055   LD2H_z_p_br_contiguous = SVELoadMultipleStructures_ScalarPlusScalarFixed | 0x00A00000,
4056   LD3H_z_p_br_contiguous = SVELoadMultipleStructures_ScalarPlusScalarFixed | 0x00C00000,
4057   LD4H_z_p_br_contiguous = SVELoadMultipleStructures_ScalarPlusScalarFixed | 0x00E00000,
4058   LD2W_z_p_br_contiguous = SVELoadMultipleStructures_ScalarPlusScalarFixed | 0x01200000,
4059   LD3W_z_p_br_contiguous = SVELoadMultipleStructures_ScalarPlusScalarFixed | 0x01400000,
4060   LD4W_z_p_br_contiguous = SVELoadMultipleStructures_ScalarPlusScalarFixed | 0x01600000,
4061   LD2D_z_p_br_contiguous = SVELoadMultipleStructures_ScalarPlusScalarFixed | 0x01A00000,
4062   LD3D_z_p_br_contiguous = SVELoadMultipleStructures_ScalarPlusScalarFixed | 0x01C00000,
4063   LD4D_z_p_br_contiguous = SVELoadMultipleStructures_ScalarPlusScalarFixed | 0x01E00000
4064 };
4065 
4066 enum SVELoadPredicateRegisterOp {
4067   SVELoadPredicateRegisterFixed = 0x85800000,
4068   SVELoadPredicateRegisterFMask = 0xFFC0E010,
4069   SVELoadPredicateRegisterMask = 0xFFC0E010,
4070   LDR_p_bi = SVELoadPredicateRegisterFixed
4071 };
4072 
4073 enum SVELoadVectorRegisterOp {
4074   SVELoadVectorRegisterFixed = 0x85804000,
4075   SVELoadVectorRegisterFMask = 0xFFC0E000,
4076   SVELoadVectorRegisterMask = 0xFFC0E000,
4077   LDR_z_bi = SVELoadVectorRegisterFixed
4078 };
4079 
4080 enum SVEMulIndexOp {
4081   SVEMulIndexFixed = 0x44200000,
4082   SVEMulIndexFMask = 0xFF200000,
4083   SVEMulIndexMask = 0xFFE0FC00,
4084   SDOT_z_zzzi_s = SVEMulIndexFixed | 0x00800000,
4085   UDOT_z_zzzi_s = SVEMulIndexFixed | 0x00800400,
4086   SDOT_z_zzzi_d = SVEMulIndexFixed | 0x00C00000,
4087   UDOT_z_zzzi_d = SVEMulIndexFixed | 0x00C00400
4088 };
4089 
4090 enum SVEPartitionBreakConditionOp {
4091   SVEPartitionBreakConditionFixed = 0x25104000,
4092   SVEPartitionBreakConditionFMask = 0xFF3FC200,
4093   SVEPartitionBreakConditionMask = 0xFFFFC200,
4094   BRKA_p_p_p = SVEPartitionBreakConditionFixed,
4095   BRKAS_p_p_p_z = SVEPartitionBreakConditionFixed | 0x00400000,
4096   BRKB_p_p_p = SVEPartitionBreakConditionFixed | 0x00800000,
4097   BRKBS_p_p_p_z = SVEPartitionBreakConditionFixed | 0x00C00000
4098 };
4099 
4100 enum SVEPermutePredicateElementsOp {
4101   SVEPermutePredicateElementsFixed = 0x05204000,
4102   SVEPermutePredicateElementsFMask = 0xFF30E210,
4103   SVEPermutePredicateElementsMask = 0xFF30FE10,
4104   ZIP1_p_pp = SVEPermutePredicateElementsFixed,
4105   ZIP2_p_pp = SVEPermutePredicateElementsFixed | 0x00000400,
4106   UZP1_p_pp = SVEPermutePredicateElementsFixed | 0x00000800,
4107   UZP2_p_pp = SVEPermutePredicateElementsFixed | 0x00000C00,
4108   TRN1_p_pp = SVEPermutePredicateElementsFixed | 0x00001000,
4109   TRN2_p_pp = SVEPermutePredicateElementsFixed | 0x00001400
4110 };
4111 
4112 enum SVEPermuteVectorExtractOp {
4113   SVEPermuteVectorExtractFixed = 0x05200000,
4114   SVEPermuteVectorExtractFMask = 0xFF20E000,
4115   SVEPermuteVectorExtractMask = 0xFFE0E000,
4116   EXT_z_zi_des = SVEPermuteVectorExtractFixed
4117 };
4118 
4119 enum SVEPermuteVectorInterleavingOp {
4120   SVEPermuteVectorInterleavingFixed = 0x05206000,
4121   SVEPermuteVectorInterleavingFMask = 0xFF20E000,
4122   SVEPermuteVectorInterleavingMask = 0xFF20FC00,
4123   ZIP1_z_zz = SVEPermuteVectorInterleavingFixed,
4124   ZIP2_z_zz = SVEPermuteVectorInterleavingFixed | 0x00000400,
4125   UZP1_z_zz = SVEPermuteVectorInterleavingFixed | 0x00000800,
4126   UZP2_z_zz = SVEPermuteVectorInterleavingFixed | 0x00000C00,
4127   TRN1_z_zz = SVEPermuteVectorInterleavingFixed | 0x00001000,
4128   TRN2_z_zz = SVEPermuteVectorInterleavingFixed | 0x00001400
4129 };
4130 
4131 enum SVEPredicateCountOp {
4132   SVEPredicateCountFixed = 0x25208000,
4133   SVEPredicateCountFMask = 0xFF38C000,
4134   SVEPredicateCountMask = 0xFF3FC200,
4135   CNTP_r_p_p = SVEPredicateCountFixed
4136 };
4137 
4138 enum SVEPredicateFirstActiveOp {
4139   SVEPredicateFirstActiveFixed = 0x2518C000,
4140   SVEPredicateFirstActiveFMask = 0xFF3FFE10,
4141   SVEPredicateFirstActiveMask = 0xFFFFFE10,
4142   PFIRST_p_p_p = SVEPredicateFirstActiveFixed | 0x00400000
4143 };
4144 
4145 enum SVEPredicateInitializeOp {
4146   SVEPredicateInitializeFixed = 0x2518E000,
4147   SVEPredicateInitializeFMask = 0xFF3EFC10,
4148   SVEPredicateInitializeMask = 0xFF3FFC10,
4149   SVEPredicateInitializeSetFlagsBit = 0x00010000,
4150   PTRUE_p_s = SVEPredicateInitializeFixed | 0x00000000,
4151   PTRUES_p_s = SVEPredicateInitializeFixed | SVEPredicateInitializeSetFlagsBit
4152 };
4153 
4154 enum SVEPredicateLogicalOp {
4155   SVEPredicateLogicalFixed = 0x25004000,
4156   SVEPredicateLogicalFMask = 0xFF30C000,
4157   SVEPredicateLogicalMask = 0xFFF0C210,
4158   SVEPredicateLogicalSetFlagsBit = 0x00400000,
4159   AND_p_p_pp_z = SVEPredicateLogicalFixed,
4160   ANDS_p_p_pp_z = AND_p_p_pp_z | SVEPredicateLogicalSetFlagsBit,
4161   BIC_p_p_pp_z = SVEPredicateLogicalFixed | 0x00000010,
4162   BICS_p_p_pp_z = BIC_p_p_pp_z | SVEPredicateLogicalSetFlagsBit,
4163   EOR_p_p_pp_z = SVEPredicateLogicalFixed | 0x00000200,
4164   EORS_p_p_pp_z = EOR_p_p_pp_z | SVEPredicateLogicalSetFlagsBit,
4165   ORR_p_p_pp_z = SVEPredicateLogicalFixed | 0x00800000,
4166   ORRS_p_p_pp_z = ORR_p_p_pp_z | SVEPredicateLogicalSetFlagsBit,
4167   ORN_p_p_pp_z = SVEPredicateLogicalFixed | 0x00800010,
4168   ORNS_p_p_pp_z = ORN_p_p_pp_z | SVEPredicateLogicalSetFlagsBit,
4169   NAND_p_p_pp_z = SVEPredicateLogicalFixed | 0x00800210,
4170   NANDS_p_p_pp_z = NAND_p_p_pp_z | SVEPredicateLogicalSetFlagsBit,
4171   NOR_p_p_pp_z = SVEPredicateLogicalFixed | 0x00800200,
4172   NORS_p_p_pp_z = NOR_p_p_pp_z | SVEPredicateLogicalSetFlagsBit,
4173   SEL_p_p_pp = SVEPredicateLogicalFixed | 0x00000210
4174 };
4175 
4176 enum SVEPredicateNextActiveOp {
4177   SVEPredicateNextActiveFixed = 0x2519C400,
4178   SVEPredicateNextActiveFMask = 0xFF3FFE10,
4179   SVEPredicateNextActiveMask = 0xFF3FFE10,
4180   PNEXT_p_p_p = SVEPredicateNextActiveFixed
4181 };
4182 
4183 enum SVEPredicateReadFromFFR_PredicatedOp {
4184   SVEPredicateReadFromFFR_PredicatedFixed = 0x2518F000,
4185   SVEPredicateReadFromFFR_PredicatedFMask = 0xFF3FFE10,
4186   SVEPredicateReadFromFFR_PredicatedMask = 0xFFFFFE10,
4187   RDFFR_p_p_f = SVEPredicateReadFromFFR_PredicatedFixed,
4188   RDFFRS_p_p_f = SVEPredicateReadFromFFR_PredicatedFixed | 0x00400000
4189 };
4190 
4191 enum SVEPredicateReadFromFFR_UnpredicatedOp {
4192   SVEPredicateReadFromFFR_UnpredicatedFixed = 0x2519F000,
4193   SVEPredicateReadFromFFR_UnpredicatedFMask = 0xFF3FFFF0,
4194   SVEPredicateReadFromFFR_UnpredicatedMask = 0xFFFFFFF0,
4195   RDFFR_p_f = SVEPredicateReadFromFFR_UnpredicatedFixed
4196 };
4197 
4198 enum SVEPredicateTestOp {
4199   SVEPredicateTestFixed = 0x2510C000,
4200   SVEPredicateTestFMask = 0xFF3FC210,
4201   SVEPredicateTestMask = 0xFFFFC21F,
4202   PTEST_p_p = SVEPredicateTestFixed | 0x00400000
4203 };
4204 
4205 enum SVEPredicateZeroOp {
4206   SVEPredicateZeroFixed = 0x2518E400,
4207   SVEPredicateZeroFMask = 0xFF3FFFF0,
4208   SVEPredicateZeroMask = 0xFFFFFFF0,
4209   PFALSE_p = SVEPredicateZeroFixed
4210 };
4211 
4212 enum SVEPropagateBreakOp {
4213   SVEPropagateBreakFixed = 0x2500C000,
4214   SVEPropagateBreakFMask = 0xFF30C000,
4215   SVEPropagateBreakMask = 0xFFF0C210,
4216   BRKPA_p_p_pp = SVEPropagateBreakFixed,
4217   BRKPB_p_p_pp = SVEPropagateBreakFixed | 0x00000010,
4218   BRKPAS_p_p_pp = SVEPropagateBreakFixed | 0x00400000,
4219   BRKPBS_p_p_pp = SVEPropagateBreakFixed | 0x00400010
4220 };
4221 
4222 enum SVEPropagateBreakToNextPartitionOp {
4223   SVEPropagateBreakToNextPartitionFixed = 0x25184000,
4224   SVEPropagateBreakToNextPartitionFMask = 0xFFBFC210,
4225   SVEPropagateBreakToNextPartitionMask = 0xFFFFC210,
4226   BRKN_p_p_pp = SVEPropagateBreakToNextPartitionFixed,
4227   BRKNS_p_p_pp = SVEPropagateBreakToNextPartitionFixed | 0x00400000
4228 };
4229 
4230 enum SVEReversePredicateElementsOp {
4231   SVEReversePredicateElementsFixed = 0x05344000,
4232   SVEReversePredicateElementsFMask = 0xFF3FFE10,
4233   SVEReversePredicateElementsMask = 0xFF3FFE10,
4234   REV_p_p = SVEReversePredicateElementsFixed
4235 };
4236 
4237 enum SVEReverseVectorElementsOp {
4238   SVEReverseVectorElementsFixed = 0x05383800,
4239   SVEReverseVectorElementsFMask = 0xFF3FFC00,
4240   SVEReverseVectorElementsMask = 0xFF3FFC00,
4241   REV_z_z = SVEReverseVectorElementsFixed
4242 };
4243 
4244 enum SVEReverseWithinElementsOp {
4245   SVEReverseWithinElementsFixed = 0x05248000,
4246   SVEReverseWithinElementsFMask = 0xFF3CE000,
4247   SVEReverseWithinElementsMask = 0xFF3FE000,
4248   REVB_z_z = SVEReverseWithinElementsFixed,
4249   REVH_z_z = SVEReverseWithinElementsFixed | 0x00010000,
4250   REVW_z_z = SVEReverseWithinElementsFixed | 0x00020000,
4251   RBIT_z_p_z = SVEReverseWithinElementsFixed | 0x00030000
4252 };
4253 
4254 enum SVESaturatingIncDecRegisterByElementCountOp {
4255   SVESaturatingIncDecRegisterByElementCountFixed = 0x0420F000,
4256   SVESaturatingIncDecRegisterByElementCountFMask = 0xFF20F000,
4257   SVESaturatingIncDecRegisterByElementCountMask = 0xFFF0FC00,
4258   SQINCB_r_rs_sx = SVESaturatingIncDecRegisterByElementCountFixed,
4259   UQINCB_r_rs_uw = SVESaturatingIncDecRegisterByElementCountFixed | 0x00000400,
4260   SQDECB_r_rs_sx = SVESaturatingIncDecRegisterByElementCountFixed | 0x00000800,
4261   UQDECB_r_rs_uw = SVESaturatingIncDecRegisterByElementCountFixed | 0x00000C00,
4262   SQINCB_r_rs_x = SVESaturatingIncDecRegisterByElementCountFixed | 0x00100000,
4263   UQINCB_r_rs_x = SVESaturatingIncDecRegisterByElementCountFixed | 0x00100400,
4264   SQDECB_r_rs_x = SVESaturatingIncDecRegisterByElementCountFixed | 0x00100800,
4265   UQDECB_r_rs_x = SVESaturatingIncDecRegisterByElementCountFixed | 0x00100C00,
4266   SQINCH_r_rs_sx = SVESaturatingIncDecRegisterByElementCountFixed | 0x00400000,
4267   UQINCH_r_rs_uw = SVESaturatingIncDecRegisterByElementCountFixed | 0x00400400,
4268   SQDECH_r_rs_sx = SVESaturatingIncDecRegisterByElementCountFixed | 0x00400800,
4269   UQDECH_r_rs_uw = SVESaturatingIncDecRegisterByElementCountFixed | 0x00400C00,
4270   SQINCH_r_rs_x = SVESaturatingIncDecRegisterByElementCountFixed | 0x00500000,
4271   UQINCH_r_rs_x = SVESaturatingIncDecRegisterByElementCountFixed | 0x00500400,
4272   SQDECH_r_rs_x = SVESaturatingIncDecRegisterByElementCountFixed | 0x00500800,
4273   UQDECH_r_rs_x = SVESaturatingIncDecRegisterByElementCountFixed | 0x00500C00,
4274   SQINCW_r_rs_sx = SVESaturatingIncDecRegisterByElementCountFixed | 0x00800000,
4275   UQINCW_r_rs_uw = SVESaturatingIncDecRegisterByElementCountFixed | 0x00800400,
4276   SQDECW_r_rs_sx = SVESaturatingIncDecRegisterByElementCountFixed | 0x00800800,
4277   UQDECW_r_rs_uw = SVESaturatingIncDecRegisterByElementCountFixed | 0x00800C00,
4278   SQINCW_r_rs_x = SVESaturatingIncDecRegisterByElementCountFixed | 0x00900000,
4279   UQINCW_r_rs_x = SVESaturatingIncDecRegisterByElementCountFixed | 0x00900400,
4280   SQDECW_r_rs_x = SVESaturatingIncDecRegisterByElementCountFixed | 0x00900800,
4281   UQDECW_r_rs_x = SVESaturatingIncDecRegisterByElementCountFixed | 0x00900C00,
4282   SQINCD_r_rs_sx = SVESaturatingIncDecRegisterByElementCountFixed | 0x00C00000,
4283   UQINCD_r_rs_uw = SVESaturatingIncDecRegisterByElementCountFixed | 0x00C00400,
4284   SQDECD_r_rs_sx = SVESaturatingIncDecRegisterByElementCountFixed | 0x00C00800,
4285   UQDECD_r_rs_uw = SVESaturatingIncDecRegisterByElementCountFixed | 0x00C00C00,
4286   SQINCD_r_rs_x = SVESaturatingIncDecRegisterByElementCountFixed | 0x00D00000,
4287   UQINCD_r_rs_x = SVESaturatingIncDecRegisterByElementCountFixed | 0x00D00400,
4288   SQDECD_r_rs_x = SVESaturatingIncDecRegisterByElementCountFixed | 0x00D00800,
4289   UQDECD_r_rs_x = SVESaturatingIncDecRegisterByElementCountFixed | 0x00D00C00
4290 };
4291 
4292 enum SVESaturatingIncDecVectorByElementCountOp {
4293   SVESaturatingIncDecVectorByElementCountFixed = 0x0420C000,
4294   SVESaturatingIncDecVectorByElementCountFMask = 0xFF30F000,
4295   SVESaturatingIncDecVectorByElementCountMask = 0xFFF0FC00,
4296   SQINCH_z_zs = SVESaturatingIncDecVectorByElementCountFixed | 0x00400000,
4297   UQINCH_z_zs = SVESaturatingIncDecVectorByElementCountFixed | 0x00400400,
4298   SQDECH_z_zs = SVESaturatingIncDecVectorByElementCountFixed | 0x00400800,
4299   UQDECH_z_zs = SVESaturatingIncDecVectorByElementCountFixed | 0x00400C00,
4300   SQINCW_z_zs = SVESaturatingIncDecVectorByElementCountFixed | 0x00800000,
4301   UQINCW_z_zs = SVESaturatingIncDecVectorByElementCountFixed | 0x00800400,
4302   SQDECW_z_zs = SVESaturatingIncDecVectorByElementCountFixed | 0x00800800,
4303   UQDECW_z_zs = SVESaturatingIncDecVectorByElementCountFixed | 0x00800C00,
4304   SQINCD_z_zs = SVESaturatingIncDecVectorByElementCountFixed | 0x00C00000,
4305   UQINCD_z_zs = SVESaturatingIncDecVectorByElementCountFixed | 0x00C00400,
4306   SQDECD_z_zs = SVESaturatingIncDecVectorByElementCountFixed | 0x00C00800,
4307   UQDECD_z_zs = SVESaturatingIncDecVectorByElementCountFixed | 0x00C00C00
4308 };
4309 
4310 enum SVEStackFrameAdjustmentOp {
4311   SVEStackFrameAdjustmentFixed = 0x04205000,
4312   SVEStackFrameAdjustmentFMask = 0xFFA0F800,
4313   SVEStackFrameAdjustmentMask = 0xFFE0F800,
4314   ADDVL_r_ri = SVEStackFrameAdjustmentFixed,
4315   ADDPL_r_ri = SVEStackFrameAdjustmentFixed | 0x00400000
4316 };
4317 
4318 enum SVEStackFrameSizeOp {
4319   SVEStackFrameSizeFixed = 0x04BF5000,
4320   SVEStackFrameSizeFMask = 0xFFFFF800,
4321   SVEStackFrameSizeMask = 0xFFFFF800,
4322   RDVL_r_i = SVEStackFrameSizeFixed
4323 };
4324 
4325 enum SVEStoreMultipleStructures_ScalarPlusImmOp {
4326   SVEStoreMultipleStructures_ScalarPlusImmFixed = 0xE410E000,
4327   SVEStoreMultipleStructures_ScalarPlusImmFMask = 0xFE10E000,
4328   SVEStoreMultipleStructures_ScalarPlusImmMask = 0xFFF0E000,
4329   ST2B_z_p_bi_contiguous = SVEStoreMultipleStructures_ScalarPlusImmFixed | 0x00200000,
4330   ST3B_z_p_bi_contiguous = SVEStoreMultipleStructures_ScalarPlusImmFixed | 0x00400000,
4331   ST4B_z_p_bi_contiguous = SVEStoreMultipleStructures_ScalarPlusImmFixed | 0x00600000,
4332   ST2H_z_p_bi_contiguous = SVEStoreMultipleStructures_ScalarPlusImmFixed | 0x00A00000,
4333   ST3H_z_p_bi_contiguous = SVEStoreMultipleStructures_ScalarPlusImmFixed | 0x00C00000,
4334   ST4H_z_p_bi_contiguous = SVEStoreMultipleStructures_ScalarPlusImmFixed | 0x00E00000,
4335   ST2W_z_p_bi_contiguous = SVEStoreMultipleStructures_ScalarPlusImmFixed | 0x01200000,
4336   ST3W_z_p_bi_contiguous = SVEStoreMultipleStructures_ScalarPlusImmFixed | 0x01400000,
4337   ST4W_z_p_bi_contiguous = SVEStoreMultipleStructures_ScalarPlusImmFixed | 0x01600000,
4338   ST2D_z_p_bi_contiguous = SVEStoreMultipleStructures_ScalarPlusImmFixed | 0x01A00000,
4339   ST3D_z_p_bi_contiguous = SVEStoreMultipleStructures_ScalarPlusImmFixed | 0x01C00000,
4340   ST4D_z_p_bi_contiguous = SVEStoreMultipleStructures_ScalarPlusImmFixed | 0x01E00000
4341 };
4342 
4343 enum SVEStoreMultipleStructures_ScalarPlusScalarOp {
4344   SVEStoreMultipleStructures_ScalarPlusScalarFixed = 0xE4006000,
4345   SVEStoreMultipleStructures_ScalarPlusScalarFMask = 0xFE00E000,
4346   SVEStoreMultipleStructures_ScalarPlusScalarMask = 0xFFE0E000,
4347   ST2B_z_p_br_contiguous = SVEStoreMultipleStructures_ScalarPlusScalarFixed | 0x00200000,
4348   ST3B_z_p_br_contiguous = SVEStoreMultipleStructures_ScalarPlusScalarFixed | 0x00400000,
4349   ST4B_z_p_br_contiguous = SVEStoreMultipleStructures_ScalarPlusScalarFixed | 0x00600000,
4350   ST2H_z_p_br_contiguous = SVEStoreMultipleStructures_ScalarPlusScalarFixed | 0x00A00000,
4351   ST3H_z_p_br_contiguous = SVEStoreMultipleStructures_ScalarPlusScalarFixed | 0x00C00000,
4352   ST4H_z_p_br_contiguous = SVEStoreMultipleStructures_ScalarPlusScalarFixed | 0x00E00000,
4353   ST2W_z_p_br_contiguous = SVEStoreMultipleStructures_ScalarPlusScalarFixed | 0x01200000,
4354   ST3W_z_p_br_contiguous = SVEStoreMultipleStructures_ScalarPlusScalarFixed | 0x01400000,
4355   ST4W_z_p_br_contiguous = SVEStoreMultipleStructures_ScalarPlusScalarFixed | 0x01600000,
4356   ST2D_z_p_br_contiguous = SVEStoreMultipleStructures_ScalarPlusScalarFixed | 0x01A00000,
4357   ST3D_z_p_br_contiguous = SVEStoreMultipleStructures_ScalarPlusScalarFixed | 0x01C00000,
4358   ST4D_z_p_br_contiguous = SVEStoreMultipleStructures_ScalarPlusScalarFixed | 0x01E00000
4359 };
4360 
4361 enum SVEStorePredicateRegisterOp {
4362   SVEStorePredicateRegisterFixed = 0xE5800000,
4363   SVEStorePredicateRegisterFMask = 0xFFC0E010,
4364   SVEStorePredicateRegisterMask = 0xFFC0E010,
4365   STR_p_bi = SVEStorePredicateRegisterFixed
4366 };
4367 
4368 enum SVEStoreVectorRegisterOp {
4369   SVEStoreVectorRegisterFixed = 0xE5804000,
4370   SVEStoreVectorRegisterFMask = 0xFFC0E000,
4371   SVEStoreVectorRegisterMask = 0xFFC0E000,
4372   STR_z_bi = SVEStoreVectorRegisterFixed
4373 };
4374 
4375 enum SVETableLookupOp {
4376   SVETableLookupFixed = 0x05203000,
4377   SVETableLookupFMask = 0xFF20FC00,
4378   SVETableLookupMask = 0xFF20FC00,
4379   TBL_z_zz_1 = SVETableLookupFixed
4380 };
4381 
4382 enum SVEUnpackPredicateElementsOp {
4383   SVEUnpackPredicateElementsFixed = 0x05304000,
4384   SVEUnpackPredicateElementsFMask = 0xFFFEFE10,
4385   SVEUnpackPredicateElementsMask = 0xFFFFFE10,
4386   PUNPKLO_p_p = SVEUnpackPredicateElementsFixed,
4387   PUNPKHI_p_p = SVEUnpackPredicateElementsFixed | 0x00010000
4388 };
4389 
4390 enum SVEUnpackVectorElementsOp {
4391   SVEUnpackVectorElementsFixed = 0x05303800,
4392   SVEUnpackVectorElementsFMask = 0xFF3CFC00,
4393   SVEUnpackVectorElementsMask = 0xFF3FFC00,
4394   SUNPKLO_z_z = SVEUnpackVectorElementsFixed,
4395   SUNPKHI_z_z = SVEUnpackVectorElementsFixed | 0x00010000,
4396   UUNPKLO_z_z = SVEUnpackVectorElementsFixed | 0x00020000,
4397   UUNPKHI_z_z = SVEUnpackVectorElementsFixed | 0x00030000
4398 };
4399 
4400 enum SVEVectorSelectOp {
4401   SVEVectorSelectFixed = 0x0520C000,
4402   SVEVectorSelectFMask = 0xFF20C000,
4403   SVEVectorSelectMask = 0xFF20C000,
4404   SEL_z_p_zz = SVEVectorSelectFixed
4405 };
4406 
4407 enum SVEVectorSplice_DestructiveOp {
4408   SVEVectorSplice_DestructiveFixed = 0x052C8000,
4409   SVEVectorSplice_DestructiveFMask = 0xFF3FE000,
4410   SVEVectorSplice_DestructiveMask = 0xFF3FE000,
4411   SPLICE_z_p_zz_des = SVEVectorSplice_DestructiveFixed
4412 };
4413 
4414 enum ReservedOp {
4415   ReservedFixed = 0x00000000,
4416   ReservedFMask = 0x1E000000,
4417   ReservedMask = 0xFFFF0000,
4418   UDF = ReservedFixed | 0x00000000
4419 };
4420 
4421 // Unimplemented and unallocated instructions. These are defined to make fixed
4422 // bit assertion easier.
4423 enum UnimplementedOp {
4424   UnimplementedFixed = 0x00000000,
4425   UnimplementedFMask = 0x00000000
4426 };
4427 
4428 enum UnallocatedOp {
4429   UnallocatedFixed = 0x00000000,
4430   UnallocatedFMask = 0x00000000
4431 };
4432 
4433 // Re-enable `clang-format` after the `enum`s.
4434 // clang-format on
4435 
4436 }  // namespace aarch64
4437 }  // namespace vixl
4438 
4439 #endif  // VIXL_AARCH64_CONSTANTS_AARCH64_H_
4440