1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* * RISCV Disassembler *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* *|
7\*===----------------------------------------------------------------------===*/
8
9
10#include "llvm/MC/MCInst.h"
11#include "llvm/MC/MCSubtargetInfo.h"
12#include "llvm/Support/DataTypes.h"
13#include "llvm/Support/Debug.h"
14#include "llvm/Support/LEB128.h"
15#include "llvm/Support/raw_ostream.h"
16#include "llvm/TargetParser/SubtargetFeature.h"
17#include <assert.h>
18
19namespace {
20
21// InsnBitWidth is essentially a type trait used by the decoder emitter to query
22// the supported bitwidth for a given type. But default, the value is 0, making
23// it an invalid type for use as `InsnType` when instantiating the decoder.
24// Individual targets are expected to provide specializations for these based
25// on their usage.
26template <typename T> constexpr uint32_t InsnBitWidth = 0;
27
28static const uint8_t DecoderTable16[611] = {
29 16, // 0: BitWidth 16
30 OPC_SwitchField, 13, 3, // 1: switch Inst[15:13] {
31 0, 63, // 4: case 0x0: {
32 OPC_SwitchField, 0, 2, // 6: switch Inst[1:0] {
33 0, 18, // 9: case 0x0: {
34 OPC_Scope, 10, // 11: try {
35 OPC_CheckField, 2, 11, 0, // 13: check Inst[12:2] == 0x0
36 OPC_CheckPredicate, 0, // 17: check predicate 0
37 OPC_Decode, 144, 114, 0, // 19: decode to C_UNIMP using decoder 0
38 // 19: } else try {
39 OPC_CheckPredicate, 0, // 23: check predicate 0
40 OPC_Decode, 206, 113, 1, // 25: decode to C_ADDI4SPN using decoder 1
41 // 25: }
42 // 25: }
43 1, 30, // 29: case 0x1: {
44 OPC_Scope, 10, // 31: try {
45 OPC_CheckField, 2, 11, 0, // 33: check Inst[12:2] == 0x0
46 OPC_CheckPredicate, 0, // 37: check predicate 0
47 OPC_Decode, 248, 113, 0, // 39: decode to C_NOP using decoder 0
48 OPC_Scope, 10, // 43: } else try {
49 OPC_CheckField, 7, 5, 0, // 45: check Inst[11:7] == 0x0
50 OPC_CheckPredicate, 0, // 49: check predicate 0
51 OPC_Decode, 249, 113, 2, // 51: decode to C_NOP_HINT using decoder 2
52 // 51: } else try {
53 OPC_CheckPredicate, 0, // 55: check predicate 0
54 OPC_Decode, 204, 113, 3, // 57: decode to C_ADDI using decoder 3
55 // 57: }
56 // 57: }
57 2, 0, // 61: case 0x2: {
58 OPC_CheckPredicate, 0, // 63: check predicate 0
59 OPC_Decode, 133, 114, 4, // 65: decode to C_SLLI using decoder 4
60 // 65: }
61 // 65: } // switch Inst[1:0]
62 // 65: }
63 1, 27, // 69: case 0x1: {
64 OPC_SwitchField, 0, 2, // 71: switch Inst[1:0] {
65 0, 6, // 74: case 0x0: {
66 OPC_CheckPredicate, 1, // 76: check predicate 1
67 OPC_Decode, 214, 113, 5, // 78: decode to C_FLD using decoder 5
68 // 78: }
69 1, 6, // 82: case 0x1: {
70 OPC_CheckPredicate, 2, // 84: check predicate 2
71 OPC_Decode, 207, 113, 3, // 86: decode to C_ADDIW using decoder 3
72 // 86: }
73 2, 0, // 90: case 0x2: {
74 OPC_CheckPredicate, 1, // 92: check predicate 1
75 OPC_Decode, 215, 113, 6, // 94: decode to C_FLDSP using decoder 6
76 // 94: }
77 // 94: } // switch Inst[1:0]
78 // 94: }
79 2, 27, // 98: case 0x2: {
80 OPC_SwitchField, 0, 2, // 100: switch Inst[1:0] {
81 0, 6, // 103: case 0x0: {
82 OPC_CheckPredicate, 0, // 105: check predicate 0
83 OPC_Decode, 236, 113, 7, // 107: decode to C_LW using decoder 7
84 // 107: }
85 1, 6, // 111: case 0x1: {
86 OPC_CheckPredicate, 0, // 113: check predicate 0
87 OPC_Decode, 234, 113, 8, // 115: decode to C_LI using decoder 8
88 // 115: }
89 2, 0, // 119: case 0x2: {
90 OPC_CheckPredicate, 0, // 121: check predicate 0
91 OPC_Decode, 237, 113, 9, // 123: decode to C_LWSP using decoder 9
92 // 123: }
93 // 123: } // switch Inst[1:0]
94 // 123: }
95 3, 114, // 127: case 0x3: {
96 OPC_SwitchField, 0, 2, // 129: switch Inst[1:0] {
97 0, 6, // 132: case 0x0: {
98 OPC_CheckPredicate, 2, // 134: check predicate 2
99 OPC_Decode, 227, 113, 10, // 136: decode to C_LD using decoder 10
100 // 136: }
101 1, 93, // 140: case 0x1: {
102 OPC_Scope, 73, // 142: try {
103 OPC_SwitchField, 2, 11, // 144: switch Inst[12:2] {
104 32, 6, // 147: case 0x20: {
105 OPC_CheckPredicate, 3, // 149: check predicate 3
106 OPC_Decode, 137, 114, 11, // 151: decode to C_SSPUSH using decoder 11
107 // 151: }
108 96, 6, // 155: case 0x60: {
109 OPC_CheckPredicate, 3, // 157: check predicate 3
110 OPC_Decode, 243, 113, 0, // 159: decode to C_MOP_3 using decoder 0
111 // 159: }
112 160, 1, 6, // 163: case 0xa0: {
113 OPC_CheckPredicate, 3, // 166: check predicate 3
114 OPC_Decode, 136, 114, 12, // 168: decode to C_SSPOPCHK using decoder 12
115 // 168: }
116 224, 1, 6, // 172: case 0xe0: {
117 OPC_CheckPredicate, 3, // 175: check predicate 3
118 OPC_Decode, 244, 113, 0, // 177: decode to C_MOP_7 using decoder 0
119 // 177: }
120 160, 2, 6, // 181: case 0x120: {
121 OPC_CheckPredicate, 3, // 184: check predicate 3
122 OPC_Decode, 245, 113, 0, // 186: decode to C_MOP_9 using decoder 0
123 // 186: }
124 224, 2, 6, // 190: case 0x160: {
125 OPC_CheckPredicate, 3, // 193: check predicate 3
126 OPC_Decode, 240, 113, 0, // 195: decode to C_MOP_11 using decoder 0
127 // 195: }
128 160, 3, 6, // 199: case 0x1a0: {
129 OPC_CheckPredicate, 3, // 202: check predicate 3
130 OPC_Decode, 241, 113, 0, // 204: decode to C_MOP_13 using decoder 0
131 // 204: }
132 224, 3, 0, // 208: case 0x1e0: {
133 OPC_CheckPredicate, 3, // 211: check predicate 3
134 OPC_Decode, 242, 113, 0, // 213: decode to C_MOP_15 using decoder 0
135 // 213: }
136 // 213: } // switch Inst[12:2]
137 OPC_Scope, 10, // 217: } else try {
138 OPC_CheckField, 7, 5, 2, // 219: check Inst[11:7] == 0x2
139 OPC_CheckPredicate, 0, // 223: check predicate 0
140 OPC_Decode, 205, 113, 13, // 225: decode to C_ADDI16SP using decoder 13
141 // 225: } else try {
142 OPC_CheckPredicate, 0, // 229: check predicate 0
143 OPC_Decode, 235, 113, 14, // 231: decode to C_LUI using decoder 14
144 // 231: }
145 // 231: }
146 2, 0, // 235: case 0x2: {
147 OPC_CheckPredicate, 2, // 237: check predicate 2
148 OPC_Decode, 228, 113, 15, // 239: decode to C_LDSP using decoder 15
149 // 239: }
150 // 239: } // switch Inst[1:0]
151 // 239: }
152 4, 150, 2, // 243: case 0x4: {
153 OPC_SwitchField, 0, 2, // 246: switch Inst[1:0] {
154 0, 52, // 249: case 0x0: {
155 OPC_SwitchField, 10, 3, // 251: switch Inst[12:10] {
156 0, 6, // 254: case 0x0: {
157 OPC_CheckPredicate, 4, // 256: check predicate 4
158 OPC_Decode, 226, 113, 16, // 258: decode to C_LBU using decoder 16
159 // 258: }
160 1, 19, // 262: case 0x1: {
161 OPC_SwitchField, 6, 1, // 264: switch Inst[6] {
162 0, 6, // 267: case 0x0: {
163 OPC_CheckPredicate, 4, // 269: check predicate 4
164 OPC_Decode, 232, 113, 17, // 271: decode to C_LHU using decoder 17
165 // 271: }
166 1, 0, // 275: case 0x1: {
167 OPC_CheckPredicate, 4, // 277: check predicate 4
168 OPC_Decode, 231, 113, 17, // 279: decode to C_LH using decoder 17
169 // 279: }
170 // 279: } // switch Inst[6]
171 // 279: }
172 2, 6, // 283: case 0x2: {
173 OPC_CheckPredicate, 4, // 285: check predicate 4
174 OPC_Decode, 252, 113, 16, // 287: decode to C_SB using decoder 16
175 // 287: }
176 3, 0, // 291: case 0x3: {
177 OPC_CheckPredicate, 4, // 293: check predicate 4
178 OPC_CheckField, 6, 1, 0, // 295: check Inst[6] == 0x0
179 OPC_Decode, 131, 114, 17, // 299: decode to C_SH using decoder 17
180 // 299: }
181 // 299: } // switch Inst[12:10]
182 // 299: }
183 1, 161, 1, // 303: case 0x1: {
184 OPC_SwitchField, 10, 2, // 306: switch Inst[11:10] {
185 0, 6, // 309: case 0x0: {
186 OPC_CheckPredicate, 0, // 311: check predicate 0
187 OPC_Decode, 135, 114, 18, // 313: decode to C_SRLI using decoder 18
188 // 313: }
189 1, 6, // 317: case 0x1: {
190 OPC_CheckPredicate, 0, // 319: check predicate 0
191 OPC_Decode, 134, 114, 18, // 321: decode to C_SRAI using decoder 18
192 // 321: }
193 2, 6, // 325: case 0x2: {
194 OPC_CheckPredicate, 0, // 327: check predicate 0
195 OPC_Decode, 210, 113, 19, // 329: decode to C_ANDI using decoder 19
196 // 329: }
197 3, 0, // 333: case 0x3: {
198 OPC_SwitchField, 5, 2, // 335: switch Inst[6:5] {
199 0, 19, // 338: case 0x0: {
200 OPC_SwitchField, 12, 1, // 340: switch Inst[12] {
201 0, 6, // 343: case 0x0: {
202 OPC_CheckPredicate, 0, // 345: check predicate 0
203 OPC_Decode, 138, 114, 20, // 347: decode to C_SUB using decoder 20
204 // 347: }
205 1, 0, // 351: case 0x1: {
206 OPC_CheckPredicate, 2, // 353: check predicate 2
207 OPC_Decode, 139, 114, 20, // 355: decode to C_SUBW using decoder 20
208 // 355: }
209 // 355: } // switch Inst[12]
210 // 355: }
211 1, 19, // 359: case 0x1: {
212 OPC_SwitchField, 12, 1, // 361: switch Inst[12] {
213 0, 6, // 364: case 0x0: {
214 OPC_CheckPredicate, 0, // 366: check predicate 0
215 OPC_Decode, 145, 114, 20, // 368: decode to C_XOR using decoder 20
216 // 368: }
217 1, 0, // 372: case 0x1: {
218 OPC_CheckPredicate, 2, // 374: check predicate 2
219 OPC_Decode, 208, 113, 20, // 376: decode to C_ADDW using decoder 20
220 // 376: }
221 // 376: } // switch Inst[12]
222 // 376: }
223 2, 19, // 380: case 0x2: {
224 OPC_SwitchField, 12, 1, // 382: switch Inst[12] {
225 0, 6, // 385: case 0x0: {
226 OPC_CheckPredicate, 0, // 387: check predicate 0
227 OPC_Decode, 251, 113, 20, // 389: decode to C_OR using decoder 20
228 // 389: }
229 1, 0, // 393: case 0x1: {
230 OPC_CheckPredicate, 5, // 395: check predicate 5
231 OPC_Decode, 246, 113, 20, // 397: decode to C_MUL using decoder 20
232 // 397: }
233 // 397: } // switch Inst[12]
234 // 397: }
235 3, 0, // 401: case 0x3: {
236 OPC_SwitchField, 12, 1, // 403: switch Inst[12] {
237 0, 6, // 406: case 0x0: {
238 OPC_CheckPredicate, 0, // 408: check predicate 0
239 OPC_Decode, 209, 113, 20, // 410: decode to C_AND using decoder 20
240 // 410: }
241 1, 0, // 414: case 0x1: {
242 OPC_SwitchField, 2, 3, // 416: switch Inst[4:2] {
243 0, 6, // 419: case 0x0: {
244 OPC_CheckPredicate, 4, // 421: check predicate 4
245 OPC_Decode, 146, 114, 21, // 423: decode to C_ZEXT_B using decoder 21
246 // 423: }
247 1, 6, // 427: case 0x1: {
248 OPC_CheckPredicate, 6, // 429: check predicate 6
249 OPC_Decode, 129, 114, 21, // 431: decode to C_SEXT_B using decoder 21
250 // 431: }
251 2, 6, // 435: case 0x2: {
252 OPC_CheckPredicate, 6, // 437: check predicate 6
253 OPC_Decode, 147, 114, 21, // 439: decode to C_ZEXT_H using decoder 21
254 // 439: }
255 3, 6, // 443: case 0x3: {
256 OPC_CheckPredicate, 6, // 445: check predicate 6
257 OPC_Decode, 130, 114, 21, // 447: decode to C_SEXT_H using decoder 21
258 // 447: }
259 4, 6, // 451: case 0x4: {
260 OPC_CheckPredicate, 7, // 453: check predicate 7
261 OPC_Decode, 148, 114, 21, // 455: decode to C_ZEXT_W using decoder 21
262 // 455: }
263 5, 0, // 459: case 0x5: {
264 OPC_CheckPredicate, 4, // 461: check predicate 4
265 OPC_Decode, 250, 113, 21, // 463: decode to C_NOT using decoder 21
266 // 463: }
267 // 463: } // switch Inst[4:2]
268 // 463: }
269 // 463: } // switch Inst[12]
270 // 463: }
271 // 463: } // switch Inst[6:5]
272 // 463: }
273 // 463: } // switch Inst[11:10]
274 // 463: }
275 2, 0, // 467: case 0x2: {
276 OPC_SwitchField, 12, 1, // 469: switch Inst[12] {
277 0, 18, // 472: case 0x0: {
278 OPC_Scope, 10, // 474: try {
279 OPC_CheckField, 2, 5, 0, // 476: check Inst[6:2] == 0x0
280 OPC_CheckPredicate, 0, // 480: check predicate 0
281 OPC_Decode, 225, 113, 22, // 482: decode to C_JR using decoder 22
282 // 482: } else try {
283 OPC_CheckPredicate, 0, // 486: check predicate 0
284 OPC_Decode, 247, 113, 23, // 488: decode to C_MV using decoder 23
285 // 488: }
286 // 488: }
287 1, 0, // 492: case 0x1: {
288 OPC_Scope, 10, // 494: try {
289 OPC_CheckField, 2, 10, 0, // 496: check Inst[11:2] == 0x0
290 OPC_CheckPredicate, 0, // 500: check predicate 0
291 OPC_Decode, 213, 113, 0, // 502: decode to C_EBREAK using decoder 0
292 OPC_Scope, 10, // 506: } else try {
293 OPC_CheckField, 2, 5, 0, // 508: check Inst[6:2] == 0x0
294 OPC_CheckPredicate, 0, // 512: check predicate 0
295 OPC_Decode, 224, 113, 22, // 514: decode to C_JALR using decoder 22
296 // 514: } else try {
297 OPC_CheckPredicate, 0, // 518: check predicate 0
298 OPC_Decode, 203, 113, 24, // 520: decode to C_ADD using decoder 24
299 // 520: }
300 // 520: }
301 // 520: } // switch Inst[12]
302 // 520: }
303 // 520: } // switch Inst[1:0]
304 // 520: }
305 5, 27, // 524: case 0x5: {
306 OPC_SwitchField, 0, 2, // 526: switch Inst[1:0] {
307 0, 6, // 529: case 0x0: {
308 OPC_CheckPredicate, 1, // 531: check predicate 1
309 OPC_Decode, 218, 113, 5, // 533: decode to C_FSD using decoder 5
310 // 533: }
311 1, 6, // 537: case 0x1: {
312 OPC_CheckPredicate, 0, // 539: check predicate 0
313 OPC_Decode, 222, 113, 25, // 541: decode to C_J using decoder 25
314 // 541: }
315 2, 0, // 545: case 0x2: {
316 OPC_CheckPredicate, 1, // 547: check predicate 1
317 OPC_Decode, 219, 113, 26, // 549: decode to C_FSDSP using decoder 26
318 // 549: }
319 // 549: } // switch Inst[1:0]
320 // 549: }
321 6, 27, // 553: case 0x6: {
322 OPC_SwitchField, 0, 2, // 555: switch Inst[1:0] {
323 0, 6, // 558: case 0x0: {
324 OPC_CheckPredicate, 0, // 560: check predicate 0
325 OPC_Decode, 140, 114, 7, // 562: decode to C_SW using decoder 7
326 // 562: }
327 1, 6, // 566: case 0x1: {
328 OPC_CheckPredicate, 0, // 568: check predicate 0
329 OPC_Decode, 211, 113, 27, // 570: decode to C_BEQZ using decoder 27
330 // 570: }
331 2, 0, // 574: case 0x2: {
332 OPC_CheckPredicate, 0, // 576: check predicate 0
333 OPC_Decode, 141, 114, 28, // 578: decode to C_SWSP using decoder 28
334 // 578: }
335 // 578: } // switch Inst[1:0]
336 // 578: }
337 7, 0, // 582: case 0x7: {
338 OPC_SwitchField, 0, 2, // 584: switch Inst[1:0] {
339 0, 6, // 587: case 0x0: {
340 OPC_CheckPredicate, 2, // 589: check predicate 2
341 OPC_Decode, 253, 113, 10, // 591: decode to C_SD using decoder 10
342 // 591: }
343 1, 6, // 595: case 0x1: {
344 OPC_CheckPredicate, 0, // 597: check predicate 0
345 OPC_Decode, 212, 113, 27, // 599: decode to C_BNEZ using decoder 27
346 // 599: }
347 2, 0, // 603: case 0x2: {
348 OPC_CheckPredicate, 2, // 605: check predicate 2
349 OPC_Decode, 254, 113, 29, // 607: decode to C_SDSP using decoder 29
350 // 607: }
351 // 607: } // switch Inst[1:0]
352 // 607: }
353 // 607: } // switch Inst[15:13]
354};
355static const uint8_t DecoderTableRV32Only16[58] = {
356 16, // 0: BitWidth 16
357 OPC_SwitchField, 0, 2, // 1: switch Inst[1:0] {
358 0, 19, // 4: case 0x0: {
359 OPC_SwitchField, 13, 3, // 6: switch Inst[15:13] {
360 3, 6, // 9: case 0x3: {
361 OPC_CheckPredicate, 8, // 11: check predicate 8
362 OPC_Decode, 216, 113, 30, // 13: decode to C_FLW using decoder 30
363 // 13: }
364 7, 0, // 17: case 0x7: {
365 OPC_CheckPredicate, 8, // 19: check predicate 8
366 OPC_Decode, 220, 113, 30, // 21: decode to C_FSW using decoder 30
367 // 21: }
368 // 21: } // switch Inst[15:13]
369 // 21: }
370 1, 10, // 25: case 0x1: {
371 OPC_CheckPredicate, 9, // 27: check predicate 9
372 OPC_CheckField, 13, 3, 1, // 29: check Inst[15:13] == 0x1
373 OPC_Decode, 223, 113, 25, // 33: decode to C_JAL using decoder 25
374 // 33: }
375 2, 0, // 37: case 0x2: {
376 OPC_SwitchField, 13, 3, // 39: switch Inst[15:13] {
377 3, 6, // 42: case 0x3: {
378 OPC_CheckPredicate, 8, // 44: check predicate 8
379 OPC_Decode, 217, 113, 31, // 46: decode to C_FLWSP using decoder 31
380 // 46: }
381 7, 0, // 50: case 0x7: {
382 OPC_CheckPredicate, 8, // 52: check predicate 8
383 OPC_Decode, 221, 113, 32, // 54: decode to C_FSWSP using decoder 32
384 // 54: }
385 // 54: } // switch Inst[15:13]
386 // 54: }
387 // 54: } // switch Inst[1:0]
388};
389static const uint8_t DecoderTableXqccmi16[15] = {
390 16, // 0: BitWidth 16
391 OPC_CheckPredicate, 10, // 1: check predicate 10
392 OPC_CheckField, 13, 3, 1, // 3: check Inst[15:13] == 0x1
393 OPC_CheckField, 0, 2, 0, // 7: check Inst[1:0] == 0x0
394 OPC_Decode, 179, 122, 33, // 11: decode to QC_CM_ILUT using decoder 33
395};
396static const uint8_t DecoderTableXqccmp16[103] = {
397 16, // 0: BitWidth 16
398 OPC_SwitchField, 10, 6, // 1: switch Inst[15:10] {
399 43, 27, // 4: case 0x2b: {
400 OPC_SwitchField, 5, 2, // 6: switch Inst[6:5] {
401 1, 10, // 9: case 0x1: {
402 OPC_CheckPredicate, 11, // 11: check predicate 11
403 OPC_CheckField, 0, 2, 2, // 13: check Inst[1:0] == 0x2
404 OPC_Decode, 183, 122, 34, // 17: decode to QC_CM_MVSA01 using decoder 34
405 // 17: }
406 3, 0, // 21: case 0x3: {
407 OPC_CheckPredicate, 11, // 23: check predicate 11
408 OPC_CheckField, 0, 2, 2, // 25: check Inst[1:0] == 0x2
409 OPC_Decode, 182, 122, 35, // 29: decode to QC_CM_MVA01S using decoder 35
410 // 29: }
411 // 29: } // switch Inst[6:5]
412 // 29: }
413 46, 39, // 33: case 0x2e: {
414 OPC_SwitchField, 8, 2, // 35: switch Inst[9:8] {
415 0, 10, // 38: case 0x0: {
416 OPC_CheckPredicate, 11, // 40: check predicate 11
417 OPC_CheckField, 0, 2, 2, // 42: check Inst[1:0] == 0x2
418 OPC_Decode, 187, 122, 36, // 46: decode to QC_CM_PUSH using decoder 36
419 // 46: }
420 1, 10, // 50: case 0x1: {
421 OPC_CheckPredicate, 11, // 52: check predicate 11
422 OPC_CheckField, 0, 2, 2, // 54: check Inst[1:0] == 0x2
423 OPC_Decode, 188, 122, 37, // 58: decode to QC_CM_PUSHFP using decoder 37
424 // 58: }
425 2, 0, // 62: case 0x2: {
426 OPC_CheckPredicate, 11, // 64: check predicate 11
427 OPC_CheckField, 0, 2, 2, // 66: check Inst[1:0] == 0x2
428 OPC_Decode, 184, 122, 36, // 70: decode to QC_CM_POP using decoder 36
429 // 70: }
430 // 70: } // switch Inst[9:8]
431 // 70: }
432 47, 0, // 74: case 0x2f: {
433 OPC_SwitchField, 8, 2, // 76: switch Inst[9:8] {
434 0, 10, // 79: case 0x0: {
435 OPC_CheckPredicate, 11, // 81: check predicate 11
436 OPC_CheckField, 0, 2, 2, // 83: check Inst[1:0] == 0x2
437 OPC_Decode, 186, 122, 36, // 87: decode to QC_CM_POPRETZ using decoder 36
438 // 87: }
439 2, 0, // 91: case 0x2: {
440 OPC_CheckPredicate, 11, // 93: check predicate 11
441 OPC_CheckField, 0, 2, 2, // 95: check Inst[1:0] == 0x2
442 OPC_Decode, 185, 122, 36, // 99: decode to QC_CM_POPRET using decoder 36
443 // 99: }
444 // 99: } // switch Inst[9:8]
445 // 99: }
446 // 99: } // switch Inst[15:10]
447};
448static const uint8_t DecoderTableXqccmt16[27] = {
449 16, // 0: BitWidth 16
450 OPC_CheckField, 0, 2, 2, // 1: check Inst[1:0] == 0x2
451 OPC_CheckField, 10, 6, 40, // 5: check Inst[15:10] == 0x28
452 OPC_Scope, 10, // 9: try {
453 OPC_CheckField, 7, 3, 0, // 11: check Inst[9:7] == 0x0
454 OPC_CheckPredicate, 12, // 15: check predicate 12
455 OPC_Decode, 181, 122, 38, // 17: decode to QC_CM_JT using decoder 38
456 // 17: } else try {
457 OPC_CheckPredicate, 12, // 21: check predicate 12
458 OPC_Decode, 180, 122, 39, // 23: decode to QC_CM_JALT using decoder 39
459 // 23: }
460};
461static const uint8_t DecoderTableXqci16[234] = {
462 16, // 0: BitWidth 16
463 OPC_SwitchField, 13, 3, // 1: switch Inst[15:13] {
464 0, 119, // 4: case 0x0: {
465 OPC_CheckField, 0, 2, 2, // 6: check Inst[1:0] == 0x2
466 OPC_CheckField, 12, 1, 1, // 10: check Inst[12] == 0x1
467 OPC_Scope, 66, // 14: try {
468 OPC_SwitchField, 2, 10, // 16: switch Inst[11:2] {
469 132, 4, 6, // 19: case 0x204: {
470 OPC_CheckPredicate, 13, // 22: check predicate 13
471 OPC_Decode, 202, 122, 0, // 24: decode to QC_C_MIENTER using decoder 0
472 // 24: }
473 164, 4, 6, // 28: case 0x224: {
474 OPC_CheckPredicate, 13, // 31: check predicate 13
475 OPC_Decode, 203, 122, 0, // 33: decode to QC_C_MIENTER_NEST using decoder 0
476 // 33: }
477 196, 4, 6, // 37: case 0x244: {
478 OPC_CheckPredicate, 13, // 40: check predicate 13
479 OPC_Decode, 206, 122, 0, // 42: decode to QC_C_MRET using decoder 0
480 // 42: }
481 228, 4, 6, // 46: case 0x264: {
482 OPC_CheckPredicate, 13, // 49: check predicate 13
483 OPC_Decode, 205, 122, 0, // 51: decode to QC_C_MNRET using decoder 0
484 // 51: }
485 132, 5, 6, // 55: case 0x284: {
486 OPC_CheckPredicate, 13, // 58: check predicate 13
487 OPC_Decode, 204, 122, 0, // 60: decode to QC_C_MILEAVERET using decoder 0
488 // 60: }
489 196, 5, 6, // 64: case 0x2c4: {
490 OPC_CheckPredicate, 13, // 67: check predicate 13
491 OPC_Decode, 197, 122, 0, // 69: decode to QC_C_DI using decoder 0
492 // 69: }
493 228, 5, 0, // 73: case 0x2e4: {
494 OPC_CheckPredicate, 13, // 76: check predicate 13
495 OPC_Decode, 199, 122, 0, // 78: decode to QC_C_EI using decoder 0
496 // 78: }
497 // 78: } // switch Inst[11:2]
498 OPC_Scope, 35, // 82: } else try {
499 OPC_SwitchField, 2, 5, // 84: switch Inst[6:2] {
500 0, 6, // 87: case 0x0: {
501 OPC_CheckPredicate, 13, // 89: check predicate 13
502 OPC_Decode, 198, 122, 22, // 91: decode to QC_C_DIR using decoder 22
503 // 91: }
504 1, 6, // 95: case 0x1: {
505 OPC_CheckPredicate, 13, // 97: check predicate 13
506 OPC_Decode, 200, 122, 22, // 99: decode to QC_C_EIR using decoder 22
507 // 99: }
508 2, 6, // 103: case 0x2: {
509 OPC_CheckPredicate, 13, // 105: check predicate 13
510 OPC_Decode, 209, 122, 22, // 107: decode to QC_C_SETINT using decoder 22
511 // 107: }
512 3, 0, // 111: case 0x3: {
513 OPC_CheckPredicate, 13, // 113: check predicate 13
514 OPC_Decode, 196, 122, 22, // 115: decode to QC_C_CLRINT using decoder 22
515 // 115: }
516 // 115: } // switch Inst[6:2]
517 // 115: } else try {
518 OPC_CheckPredicate, 14, // 119: check predicate 14
519 OPC_Decode, 201, 122, 40, // 121: decode to QC_C_EXTU using decoder 40
520 // 121: }
521 // 121: }
522 1, 10, // 125: case 0x1: {
523 OPC_CheckPredicate, 15, // 127: check predicate 15
524 OPC_CheckField, 0, 2, 2, // 129: check Inst[1:0] == 0x2
525 OPC_Decode, 207, 122, 41, // 133: decode to QC_C_MULIADD using decoder 41
526 // 133: }
527 4, 75, // 137: case 0x4: {
528 OPC_SwitchField, 10, 3, // 139: switch Inst[12:10] {
529 0, 10, // 142: case 0x0: {
530 OPC_CheckPredicate, 16, // 144: check predicate 16
531 OPC_CheckField, 0, 7, 1, // 146: check Inst[6:0] == 0x1
532 OPC_Decode, 210, 122, 42, // 150: decode to QC_C_SYNC using decoder 42
533 // 150: }
534 1, 10, // 154: case 0x1: {
535 OPC_CheckPredicate, 16, // 156: check predicate 16
536 OPC_CheckField, 0, 7, 1, // 158: check Inst[6:0] == 0x1
537 OPC_Decode, 211, 122, 42, // 162: decode to QC_C_SYNCR using decoder 42
538 // 162: }
539 4, 22, // 166: case 0x4: {
540 OPC_CheckField, 0, 2, 1, // 168: check Inst[1:0] == 0x1
541 OPC_Scope, 10, // 172: try {
542 OPC_CheckField, 2, 5, 0, // 174: check Inst[6:2] == 0x0
543 OPC_CheckPredicate, 16, // 178: check predicate 16
544 OPC_Decode, 212, 122, 42, // 180: decode to QC_C_SYNCWF using decoder 42
545 // 180: } else try {
546 OPC_CheckPredicate, 14, // 184: check predicate 14
547 OPC_Decode, 194, 122, 43, // 186: decode to QC_C_BEXTI using decoder 43
548 // 186: }
549 // 186: }
550 5, 0, // 190: case 0x5: {
551 OPC_CheckField, 0, 2, 1, // 192: check Inst[1:0] == 0x1
552 OPC_Scope, 10, // 196: try {
553 OPC_CheckField, 2, 5, 0, // 198: check Inst[6:2] == 0x0
554 OPC_CheckPredicate, 16, // 202: check predicate 16
555 OPC_Decode, 213, 122, 42, // 204: decode to QC_C_SYNCWL using decoder 42
556 // 204: } else try {
557 OPC_CheckPredicate, 14, // 208: check predicate 14
558 OPC_Decode, 195, 122, 43, // 210: decode to QC_C_BSETI using decoder 43
559 // 210: }
560 // 210: }
561 // 210: } // switch Inst[12:10]
562 // 210: }
563 5, 0, // 214: case 0x5: {
564 OPC_CheckPredicate, 17, // 216: check predicate 17
565 OPC_CheckField, 10, 3, 3, // 218: check Inst[12:10] == 0x3
566 OPC_CheckField, 5, 2, 0, // 222: check Inst[6:5] == 0x0
567 OPC_CheckField, 0, 2, 2, // 226: check Inst[1:0] == 0x2
568 OPC_Decode, 208, 122, 44, // 230: decode to QC_C_MVEQZ using decoder 44
569 // 230: }
570 // 230: } // switch Inst[15:13]
571};
572static const uint8_t DecoderTableXwchc16[115] = {
573 16, // 0: BitWidth 16
574 OPC_SwitchField, 13, 3, // 1: switch Inst[15:13] {
575 1, 19, // 4: case 0x1: {
576 OPC_SwitchField, 0, 2, // 6: switch Inst[1:0] {
577 0, 6, // 9: case 0x0: {
578 OPC_CheckPredicate, 18, // 11: check predicate 18
579 OPC_Decode, 197, 123, 45, // 13: decode to QK_C_LBU using decoder 45
580 // 13: }
581 2, 0, // 17: case 0x2: {
582 OPC_CheckPredicate, 18, // 19: check predicate 18
583 OPC_Decode, 199, 123, 46, // 21: decode to QK_C_LHU using decoder 46
584 // 21: }
585 // 21: } // switch Inst[1:0]
586 // 21: }
587 4, 67, // 25: case 0x4: {
588 OPC_SwitchField, 5, 2, // 27: switch Inst[6:5] {
589 0, 14, // 30: case 0x0: {
590 OPC_CheckPredicate, 18, // 32: check predicate 18
591 OPC_CheckField, 11, 2, 0, // 34: check Inst[12:11] == 0x0
592 OPC_CheckField, 0, 2, 0, // 38: check Inst[1:0] == 0x0
593 OPC_Decode, 198, 123, 47, // 42: decode to QK_C_LBUSP using decoder 47
594 // 42: }
595 1, 14, // 46: case 0x1: {
596 OPC_CheckPredicate, 18, // 48: check predicate 18
597 OPC_CheckField, 11, 2, 0, // 50: check Inst[12:11] == 0x0
598 OPC_CheckField, 0, 2, 0, // 54: check Inst[1:0] == 0x0
599 OPC_Decode, 200, 123, 48, // 58: decode to QK_C_LHUSP using decoder 48
600 // 58: }
601 2, 14, // 62: case 0x2: {
602 OPC_CheckPredicate, 18, // 64: check predicate 18
603 OPC_CheckField, 11, 2, 0, // 66: check Inst[12:11] == 0x0
604 OPC_CheckField, 0, 2, 0, // 70: check Inst[1:0] == 0x0
605 OPC_Decode, 202, 123, 47, // 74: decode to QK_C_SBSP using decoder 47
606 // 74: }
607 3, 0, // 78: case 0x3: {
608 OPC_CheckPredicate, 18, // 80: check predicate 18
609 OPC_CheckField, 11, 2, 0, // 82: check Inst[12:11] == 0x0
610 OPC_CheckField, 0, 2, 0, // 86: check Inst[1:0] == 0x0
611 OPC_Decode, 204, 123, 48, // 90: decode to QK_C_SHSP using decoder 48
612 // 90: }
613 // 90: } // switch Inst[6:5]
614 // 90: }
615 5, 0, // 94: case 0x5: {
616 OPC_SwitchField, 0, 2, // 96: switch Inst[1:0] {
617 0, 6, // 99: case 0x0: {
618 OPC_CheckPredicate, 18, // 101: check predicate 18
619 OPC_Decode, 201, 123, 45, // 103: decode to QK_C_SB using decoder 45
620 // 103: }
621 2, 0, // 107: case 0x2: {
622 OPC_CheckPredicate, 18, // 109: check predicate 18
623 OPC_Decode, 203, 123, 46, // 111: decode to QK_C_SH using decoder 46
624 // 111: }
625 // 111: } // switch Inst[1:0]
626 // 111: }
627 // 111: } // switch Inst[15:13]
628};
629static const uint8_t DecoderTableZcOverlap16[162] = {
630 16, // 0: BitWidth 16
631 OPC_SwitchField, 13, 3, // 1: switch Inst[15:13] {
632 3, 19, // 4: case 0x3: {
633 OPC_SwitchField, 0, 2, // 6: switch Inst[1:0] {
634 0, 6, // 9: case 0x0: {
635 OPC_CheckPredicate, 19, // 11: check predicate 19
636 OPC_Decode, 230, 113, 49, // 13: decode to C_LD_RV32 using decoder 49
637 // 13: }
638 2, 0, // 17: case 0x2: {
639 OPC_CheckPredicate, 19, // 19: check predicate 19
640 OPC_Decode, 229, 113, 50, // 21: decode to C_LDSP_RV32 using decoder 50
641 // 21: }
642 // 21: } // switch Inst[1:0]
643 // 21: }
644 5, 114, // 25: case 0x5: {
645 OPC_SwitchField, 10, 3, // 27: switch Inst[12:10] {
646 0, 22, // 30: case 0x0: {
647 OPC_CheckField, 0, 2, 2, // 32: check Inst[1:0] == 0x2
648 OPC_Scope, 10, // 36: try {
649 OPC_CheckField, 7, 3, 0, // 38: check Inst[9:7] == 0x0
650 OPC_CheckPredicate, 20, // 42: check predicate 20
651 OPC_Decode, 128, 111, 38, // 44: decode to CM_JT using decoder 38
652 // 44: } else try {
653 OPC_CheckPredicate, 20, // 48: check predicate 20
654 OPC_Decode, 255, 110, 39, // 50: decode to CM_JALT using decoder 39
655 // 50: }
656 // 50: }
657 3, 27, // 54: case 0x3: {
658 OPC_SwitchField, 5, 2, // 56: switch Inst[6:5] {
659 1, 10, // 59: case 0x1: {
660 OPC_CheckPredicate, 21, // 61: check predicate 21
661 OPC_CheckField, 0, 2, 2, // 63: check Inst[1:0] == 0x2
662 OPC_Decode, 130, 111, 34, // 67: decode to CM_MVSA01 using decoder 34
663 // 67: }
664 3, 0, // 71: case 0x3: {
665 OPC_CheckPredicate, 21, // 73: check predicate 21
666 OPC_CheckField, 0, 2, 2, // 75: check Inst[1:0] == 0x2
667 OPC_Decode, 129, 111, 35, // 79: decode to CM_MVA01S using decoder 35
668 // 79: }
669 // 79: } // switch Inst[6:5]
670 // 79: }
671 6, 27, // 83: case 0x6: {
672 OPC_SwitchField, 8, 2, // 85: switch Inst[9:8] {
673 0, 10, // 88: case 0x0: {
674 OPC_CheckPredicate, 21, // 90: check predicate 21
675 OPC_CheckField, 0, 2, 2, // 92: check Inst[1:0] == 0x2
676 OPC_Decode, 134, 111, 36, // 96: decode to CM_PUSH using decoder 36
677 // 96: }
678 2, 0, // 100: case 0x2: {
679 OPC_CheckPredicate, 21, // 102: check predicate 21
680 OPC_CheckField, 0, 2, 2, // 104: check Inst[1:0] == 0x2
681 OPC_Decode, 131, 111, 36, // 108: decode to CM_POP using decoder 36
682 // 108: }
683 // 108: } // switch Inst[9:8]
684 // 108: }
685 7, 0, // 112: case 0x7: {
686 OPC_SwitchField, 8, 2, // 114: switch Inst[9:8] {
687 0, 10, // 117: case 0x0: {
688 OPC_CheckPredicate, 21, // 119: check predicate 21
689 OPC_CheckField, 0, 2, 2, // 121: check Inst[1:0] == 0x2
690 OPC_Decode, 133, 111, 36, // 125: decode to CM_POPRETZ using decoder 36
691 // 125: }
692 2, 0, // 129: case 0x2: {
693 OPC_CheckPredicate, 21, // 131: check predicate 21
694 OPC_CheckField, 0, 2, 2, // 133: check Inst[1:0] == 0x2
695 OPC_Decode, 132, 111, 36, // 137: decode to CM_POPRET using decoder 36
696 // 137: }
697 // 137: } // switch Inst[9:8]
698 // 137: }
699 // 137: } // switch Inst[12:10]
700 // 137: }
701 7, 0, // 141: case 0x7: {
702 OPC_SwitchField, 0, 2, // 143: switch Inst[1:0] {
703 0, 6, // 146: case 0x0: {
704 OPC_CheckPredicate, 19, // 148: check predicate 19
705 OPC_Decode, 128, 114, 49, // 150: decode to C_SD_RV32 using decoder 49
706 // 150: }
707 2, 0, // 154: case 0x2: {
708 OPC_CheckPredicate, 19, // 156: check predicate 19
709 OPC_Decode, 255, 113, 51, // 158: decode to C_SDSP_RV32 using decoder 51
710 // 158: }
711 // 158: } // switch Inst[1:0]
712 // 158: }
713 // 158: } // switch Inst[15:13]
714};
715// Handling 52 cases.
716template <typename InsnType>
717static std::enable_if_t<InsnBitWidth<InsnType> == 16, DecodeStatus>
718decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
719 DecodeComplete = true;
720 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
721 TmpType tmp;
722 switch (Idx) {
723 default: llvm_unreachable("Invalid decoder index!");
724 case 0:
725 return S;
726 case 1:
727 tmp = fieldFromInstruction(insn, 2, 3);
728 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
729 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
730 return MCDisassembler::Fail;
731 tmp = 0x0;
732 tmp |= fieldFromInstruction(insn, 5, 1) << 3;
733 tmp |= fieldFromInstruction(insn, 6, 1) << 2;
734 tmp |= fieldFromInstruction(insn, 7, 4) << 6;
735 tmp |= fieldFromInstruction(insn, 11, 2) << 4;
736 if (!Check(S, decodeUImmNonZeroOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
737 return S;
738 case 2:
739 tmp = 0x0;
740 tmp |= fieldFromInstruction(insn, 2, 5);
741 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
742 if (!Check(S, decodeSImmNonZeroOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
743 return S;
744 case 3:
745 tmp = fieldFromInstruction(insn, 7, 5);
746 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
747 tmp = fieldFromInstruction(insn, 7, 5);
748 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
749 tmp = 0x0;
750 tmp |= fieldFromInstruction(insn, 2, 5);
751 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
752 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
753 return S;
754 case 4:
755 tmp = fieldFromInstruction(insn, 7, 5);
756 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
757 tmp = fieldFromInstruction(insn, 7, 5);
758 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
759 tmp = 0x0;
760 tmp |= fieldFromInstruction(insn, 2, 5);
761 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
762 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
763 return S;
764 case 5:
765 tmp = fieldFromInstruction(insn, 2, 3);
766 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F8_D, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
767 tmp = fieldFromInstruction(insn, 7, 3);
768 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
769 tmp = 0x0;
770 tmp |= fieldFromInstruction(insn, 5, 2) << 6;
771 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
772 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
773 return S;
774 case 6:
775 tmp = fieldFromInstruction(insn, 7, 5);
776 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
777 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
778 return MCDisassembler::Fail;
779 tmp = 0x0;
780 tmp |= fieldFromInstruction(insn, 2, 3) << 6;
781 tmp |= fieldFromInstruction(insn, 5, 2) << 3;
782 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
783 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
784 return S;
785 case 7:
786 tmp = fieldFromInstruction(insn, 2, 3);
787 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
788 tmp = fieldFromInstruction(insn, 7, 3);
789 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
790 tmp = 0x0;
791 tmp |= fieldFromInstruction(insn, 5, 1) << 6;
792 tmp |= fieldFromInstruction(insn, 6, 1) << 2;
793 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
794 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
795 return S;
796 case 8:
797 tmp = fieldFromInstruction(insn, 7, 5);
798 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
799 tmp = 0x0;
800 tmp |= fieldFromInstruction(insn, 2, 5);
801 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
802 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
803 return S;
804 case 9:
805 tmp = fieldFromInstruction(insn, 7, 5);
806 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
807 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
808 return MCDisassembler::Fail;
809 tmp = 0x0;
810 tmp |= fieldFromInstruction(insn, 2, 2) << 6;
811 tmp |= fieldFromInstruction(insn, 4, 3) << 2;
812 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
813 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
814 return S;
815 case 10:
816 tmp = fieldFromInstruction(insn, 2, 3);
817 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
818 tmp = fieldFromInstruction(insn, 7, 3);
819 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
820 tmp = 0x0;
821 tmp |= fieldFromInstruction(insn, 5, 2) << 6;
822 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
823 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
824 return S;
825 case 11:
826 tmp = 0x1;
827 if (!Check(S, DecodeSingleRegister<RISCV::X1, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
828 return S;
829 case 12:
830 tmp = 0x5;
831 if (!Check(S, DecodeSingleRegister<RISCV::X5, 5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
832 return S;
833 case 13:
834 tmp = 0x2;
835 if (!Check(S, DecodeSingleRegister<RISCV::X2, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
836 tmp = 0x2;
837 if (!Check(S, DecodeSingleRegister<RISCV::X2, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
838 tmp = 0x0;
839 tmp |= fieldFromInstruction(insn, 2, 1) << 5;
840 tmp |= fieldFromInstruction(insn, 3, 2) << 7;
841 tmp |= fieldFromInstruction(insn, 5, 1) << 6;
842 tmp |= fieldFromInstruction(insn, 6, 1) << 4;
843 tmp |= fieldFromInstruction(insn, 12, 1) << 9;
844 if (!Check(S, decodeSImmNonZeroOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
845 return S;
846 case 14:
847 tmp = fieldFromInstruction(insn, 7, 5);
848 if (!Check(S, DecodeGPRNoX2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
849 tmp = 0x0;
850 tmp |= fieldFromInstruction(insn, 2, 5);
851 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
852 if (!Check(S, decodeCLUIImmOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
853 return S;
854 case 15:
855 tmp = fieldFromInstruction(insn, 7, 5);
856 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
857 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
858 return MCDisassembler::Fail;
859 tmp = 0x0;
860 tmp |= fieldFromInstruction(insn, 2, 3) << 6;
861 tmp |= fieldFromInstruction(insn, 5, 2) << 3;
862 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
863 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
864 return S;
865 case 16:
866 tmp = fieldFromInstruction(insn, 2, 3);
867 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
868 tmp = fieldFromInstruction(insn, 7, 3);
869 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
870 tmp = 0x0;
871 tmp |= fieldFromInstruction(insn, 5, 1) << 1;
872 tmp |= fieldFromInstruction(insn, 6, 1);
873 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
874 return S;
875 case 17:
876 tmp = fieldFromInstruction(insn, 2, 3);
877 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
878 tmp = fieldFromInstruction(insn, 7, 3);
879 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
880 tmp = fieldFromInstruction(insn, 5, 1) << 1;
881 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
882 return S;
883 case 18:
884 tmp = fieldFromInstruction(insn, 7, 3);
885 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
886 tmp = fieldFromInstruction(insn, 7, 3);
887 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
888 tmp = 0x0;
889 tmp |= fieldFromInstruction(insn, 2, 5);
890 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
891 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
892 return S;
893 case 19:
894 tmp = fieldFromInstruction(insn, 7, 3);
895 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
896 tmp = fieldFromInstruction(insn, 7, 3);
897 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
898 tmp = 0x0;
899 tmp |= fieldFromInstruction(insn, 2, 5);
900 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
901 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
902 return S;
903 case 20:
904 tmp = fieldFromInstruction(insn, 7, 3);
905 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
906 tmp = fieldFromInstruction(insn, 7, 3);
907 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
908 tmp = fieldFromInstruction(insn, 2, 3);
909 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
910 return S;
911 case 21:
912 tmp = fieldFromInstruction(insn, 7, 3);
913 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
914 tmp = fieldFromInstruction(insn, 7, 3);
915 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
916 return S;
917 case 22:
918 tmp = fieldFromInstruction(insn, 7, 5);
919 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
920 return S;
921 case 23:
922 tmp = fieldFromInstruction(insn, 7, 5);
923 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
924 tmp = fieldFromInstruction(insn, 2, 5);
925 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
926 return S;
927 case 24:
928 tmp = fieldFromInstruction(insn, 7, 5);
929 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
930 tmp = fieldFromInstruction(insn, 7, 5);
931 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
932 tmp = fieldFromInstruction(insn, 2, 5);
933 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
934 return S;
935 case 25:
936 tmp = 0x0;
937 tmp |= fieldFromInstruction(insn, 2, 1) << 4;
938 tmp |= fieldFromInstruction(insn, 3, 3);
939 tmp |= fieldFromInstruction(insn, 6, 1) << 6;
940 tmp |= fieldFromInstruction(insn, 7, 1) << 5;
941 tmp |= fieldFromInstruction(insn, 8, 1) << 9;
942 tmp |= fieldFromInstruction(insn, 9, 2) << 7;
943 tmp |= fieldFromInstruction(insn, 11, 1) << 3;
944 tmp |= fieldFromInstruction(insn, 12, 1) << 10;
945 if (!Check(S, decodeSImmOperandAndLslN<12, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
946 return S;
947 case 26:
948 tmp = fieldFromInstruction(insn, 2, 5);
949 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
950 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
951 return MCDisassembler::Fail;
952 tmp = 0x0;
953 tmp |= fieldFromInstruction(insn, 7, 3) << 6;
954 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
955 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
956 return S;
957 case 27:
958 tmp = fieldFromInstruction(insn, 7, 3);
959 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
960 tmp = 0x0;
961 tmp |= fieldFromInstruction(insn, 2, 1) << 4;
962 tmp |= fieldFromInstruction(insn, 3, 2);
963 tmp |= fieldFromInstruction(insn, 5, 2) << 5;
964 tmp |= fieldFromInstruction(insn, 10, 2) << 2;
965 tmp |= fieldFromInstruction(insn, 12, 1) << 7;
966 if (!Check(S, decodeSImmOperandAndLslN<9, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
967 return S;
968 case 28:
969 tmp = fieldFromInstruction(insn, 2, 5);
970 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
971 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
972 return MCDisassembler::Fail;
973 tmp = 0x0;
974 tmp |= fieldFromInstruction(insn, 7, 2) << 6;
975 tmp |= fieldFromInstruction(insn, 9, 4) << 2;
976 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
977 return S;
978 case 29:
979 tmp = fieldFromInstruction(insn, 2, 5);
980 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
981 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
982 return MCDisassembler::Fail;
983 tmp = 0x0;
984 tmp |= fieldFromInstruction(insn, 7, 3) << 6;
985 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
986 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
987 return S;
988 case 30:
989 tmp = fieldFromInstruction(insn, 2, 3);
990 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F8_F, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
991 tmp = fieldFromInstruction(insn, 7, 3);
992 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
993 tmp = 0x0;
994 tmp |= fieldFromInstruction(insn, 5, 1) << 6;
995 tmp |= fieldFromInstruction(insn, 6, 1) << 2;
996 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
997 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
998 return S;
999 case 31:
1000 tmp = fieldFromInstruction(insn, 7, 5);
1001 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1002 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
1003 return MCDisassembler::Fail;
1004 tmp = 0x0;
1005 tmp |= fieldFromInstruction(insn, 2, 2) << 6;
1006 tmp |= fieldFromInstruction(insn, 4, 3) << 2;
1007 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
1008 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1009 return S;
1010 case 32:
1011 tmp = fieldFromInstruction(insn, 2, 5);
1012 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1013 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
1014 return MCDisassembler::Fail;
1015 tmp = 0x0;
1016 tmp |= fieldFromInstruction(insn, 7, 2) << 6;
1017 tmp |= fieldFromInstruction(insn, 9, 4) << 2;
1018 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1019 return S;
1020 case 33:
1021 tmp = fieldFromInstruction(insn, 2, 11);
1022 if (!Check(S, decodeUImmOperand<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1023 return S;
1024 case 34:
1025 tmp = fieldFromInstruction(insn, 7, 3);
1026 if (!Check(S, DecodeGPRS07RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1027 tmp = fieldFromInstruction(insn, 2, 3);
1028 if (!Check(S, decodeMvsa01Rs2Operand(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; }
1029 return S;
1030 case 35:
1031 tmp = fieldFromInstruction(insn, 7, 3);
1032 if (!Check(S, DecodeGPRS07RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1033 tmp = fieldFromInstruction(insn, 2, 3);
1034 if (!Check(S, DecodeGPRS07RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1035 return S;
1036 case 36:
1037 tmp = fieldFromInstruction(insn, 4, 4);
1038 if (!Check(S, decodeZcmpRlist(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1039 tmp = fieldFromInstruction(insn, 2, 2) << 4;
1040 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
1041 return S;
1042 case 37:
1043 tmp = fieldFromInstruction(insn, 4, 4);
1044 if (!Check(S, decodeXqccmpRlistS0(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1045 tmp = fieldFromInstruction(insn, 2, 2) << 4;
1046 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
1047 return S;
1048 case 38:
1049 tmp = fieldFromInstruction(insn, 2, 5);
1050 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1051 return S;
1052 case 39:
1053 tmp = fieldFromInstruction(insn, 2, 8);
1054 if (!Check(S, decodeUImmOperand<8, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1055 return S;
1056 case 40:
1057 tmp = fieldFromInstruction(insn, 7, 5);
1058 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1059 tmp = fieldFromInstruction(insn, 7, 5);
1060 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1061 tmp = fieldFromInstruction(insn, 2, 5);
1062 if (!Check(S, decodeUImmPlus1Operand<5, 6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1063 return S;
1064 case 41:
1065 tmp = fieldFromInstruction(insn, 2, 3);
1066 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1067 tmp = fieldFromInstruction(insn, 2, 3);
1068 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1069 tmp = fieldFromInstruction(insn, 7, 3);
1070 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1071 tmp = 0x0;
1072 tmp |= fieldFromInstruction(insn, 5, 1) << 4;
1073 tmp |= fieldFromInstruction(insn, 6, 1);
1074 tmp |= fieldFromInstruction(insn, 10, 3) << 1;
1075 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1076 return S;
1077 case 42:
1078 tmp = fieldFromInstruction(insn, 7, 3);
1079 if (!Check(S, decodeUImmSlistOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1080 return S;
1081 case 43:
1082 tmp = fieldFromInstruction(insn, 7, 3);
1083 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1084 tmp = fieldFromInstruction(insn, 7, 3);
1085 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1086 tmp = fieldFromInstruction(insn, 2, 5);
1087 if (!Check(S, decodeUImmLog2XLenNonZeroOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1088 return S;
1089 case 44:
1090 tmp = fieldFromInstruction(insn, 2, 3);
1091 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1092 tmp = fieldFromInstruction(insn, 2, 3);
1093 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1094 tmp = fieldFromInstruction(insn, 7, 3);
1095 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1096 return S;
1097 case 45:
1098 tmp = fieldFromInstruction(insn, 2, 3);
1099 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1100 tmp = fieldFromInstruction(insn, 7, 3);
1101 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1102 tmp = 0x0;
1103 tmp |= fieldFromInstruction(insn, 5, 2) << 1;
1104 tmp |= fieldFromInstruction(insn, 10, 2) << 3;
1105 tmp |= fieldFromInstruction(insn, 12, 1);
1106 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1107 return S;
1108 case 46:
1109 tmp = fieldFromInstruction(insn, 2, 3);
1110 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1111 tmp = fieldFromInstruction(insn, 7, 3);
1112 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1113 tmp = 0x0;
1114 tmp |= fieldFromInstruction(insn, 5, 2) << 1;
1115 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
1116 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1117 return S;
1118 case 47:
1119 tmp = fieldFromInstruction(insn, 2, 3);
1120 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1121 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
1122 return MCDisassembler::Fail;
1123 tmp = fieldFromInstruction(insn, 7, 4);
1124 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1125 return S;
1126 case 48:
1127 tmp = fieldFromInstruction(insn, 2, 3);
1128 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1129 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
1130 return MCDisassembler::Fail;
1131 tmp = 0x0;
1132 tmp |= fieldFromInstruction(insn, 7, 1) << 4;
1133 tmp |= fieldFromInstruction(insn, 8, 3) << 1;
1134 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1135 return S;
1136 case 49:
1137 tmp = fieldFromInstruction(insn, 2, 3);
1138 if (!Check(S, DecodeGPRPairCRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1139 tmp = fieldFromInstruction(insn, 7, 3);
1140 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X8, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1141 tmp = 0x0;
1142 tmp |= fieldFromInstruction(insn, 5, 2) << 6;
1143 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
1144 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1145 return S;
1146 case 50:
1147 tmp = fieldFromInstruction(insn, 7, 5);
1148 if (!Check(S, DecodeGPRPairNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1149 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
1150 return MCDisassembler::Fail;
1151 tmp = 0x0;
1152 tmp |= fieldFromInstruction(insn, 2, 3) << 6;
1153 tmp |= fieldFromInstruction(insn, 5, 2) << 3;
1154 tmp |= fieldFromInstruction(insn, 12, 1) << 5;
1155 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1156 return S;
1157 case 51:
1158 tmp = fieldFromInstruction(insn, 2, 5);
1159 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1160 if (!Check(Out&: S, In: DecodeSingleRegister<RISCV::X2, 2>(Inst&: MI, Decoder)))
1161 return MCDisassembler::Fail;
1162 tmp = 0x0;
1163 tmp |= fieldFromInstruction(insn, 7, 3) << 6;
1164 tmp |= fieldFromInstruction(insn, 10, 3) << 3;
1165 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
1166 return S;
1167 }
1168}
1169static const uint8_t DecoderTable32[21023] = {
1170 32, // 0: BitWidth 32
1171 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
1172 3, 49, // 4: case 0x3: {
1173 OPC_SwitchField, 12, 3, // 6: switch Inst[14:12] {
1174 0, 4, // 9: case 0x0: {
1175 OPC_Decode, 225, 116, 0, // 11: decode to LB using decoder 0
1176 // 11: }
1177 1, 4, // 15: case 0x1: {
1178 OPC_Decode, 233, 116, 0, // 17: decode to LH using decoder 0
1179 // 17: }
1180 2, 4, // 21: case 0x2: {
1181 OPC_Decode, 247, 116, 0, // 23: decode to LW using decoder 0
1182 // 23: }
1183 3, 6, // 27: case 0x3: {
1184 OPC_CheckPredicate, 22, // 29: check predicate 22
1185 OPC_Decode, 229, 116, 0, // 31: decode to LD using decoder 0
1186 // 31: }
1187 4, 4, // 35: case 0x4: {
1188 OPC_Decode, 226, 116, 0, // 37: decode to LBU using decoder 0
1189 // 37: }
1190 5, 4, // 41: case 0x5: {
1191 OPC_Decode, 234, 116, 0, // 43: decode to LHU using decoder 0
1192 // 43: }
1193 6, 0, // 47: case 0x6: {
1194 OPC_CheckPredicate, 22, // 49: check predicate 22
1195 OPC_Decode, 248, 116, 0, // 51: decode to LWU using decoder 0
1196 // 51: }
1197 // 51: } // switch Inst[14:12]
1198 // 51: }
1199 7, 229, 14, // 55: case 0x7: {
1200 OPC_SwitchField, 12, 3, // 58: switch Inst[14:12] {
1201 0, 205, 3, // 61: case 0x0: {
1202 OPC_SwitchField, 26, 6, // 64: switch Inst[31:26] {
1203 0, 43, // 67: case 0x0: {
1204 OPC_SwitchField, 20, 5, // 69: switch Inst[24:20] {
1205 0, 6, // 72: case 0x0: {
1206 OPC_CheckPredicate, 23, // 74: check predicate 23
1207 OPC_Decode, 254, 127, 1, // 76: decode to VLE8_V using decoder 1
1208 // 76: }
1209 8, 10, // 80: case 0x8: {
1210 OPC_CheckPredicate, 23, // 82: check predicate 23
1211 OPC_CheckField, 25, 1, 1, // 84: check Inst[25] == 0x1
1212 OPC_Decode, 234, 127, 2, // 88: decode to VL1RE8_V using decoder 2
1213 // 88: }
1214 11, 10, // 92: case 0xb: {
1215 OPC_CheckPredicate, 23, // 94: check predicate 23
1216 OPC_CheckField, 25, 1, 1, // 96: check Inst[25] == 0x1
1217 OPC_Decode, 255, 127, 2, // 100: decode to VLM_V using decoder 2
1218 // 100: }
1219 16, 0, // 104: case 0x10: {
1220 OPC_CheckPredicate, 23, // 106: check predicate 23
1221 OPC_Decode, 253, 127, 1, // 108: decode to VLE8FF_V using decoder 1
1222 // 108: }
1223 // 108: } // switch Inst[24:20]
1224 // 108: }
1225 1, 7, // 112: case 0x1: {
1226 OPC_CheckPredicate, 23, // 114: check predicate 23
1227 OPC_Decode, 251, 128, 1, 3, // 116: decode to VLUXEI8_V using decoder 3
1228 // 116: }
1229 2, 7, // 121: case 0x2: {
1230 OPC_CheckPredicate, 23, // 123: check predicate 23
1231 OPC_Decode, 163, 128, 1, 4, // 125: decode to VLSE8_V using decoder 4
1232 // 125: }
1233 3, 7, // 130: case 0x3: {
1234 OPC_CheckPredicate, 23, // 132: check predicate 23
1235 OPC_Decode, 131, 128, 1, 3, // 134: decode to VLOXEI8_V using decoder 3
1236 // 134: }
1237 8, 33, // 139: case 0x8: {
1238 OPC_SwitchField, 20, 5, // 141: switch Inst[24:20] {
1239 0, 7, // 144: case 0x0: {
1240 OPC_CheckPredicate, 23, // 146: check predicate 23
1241 OPC_Decode, 171, 128, 1, 1, // 148: decode to VLSEG2E8_V using decoder 1
1242 // 148: }
1243 8, 10, // 153: case 0x8: {
1244 OPC_CheckPredicate, 23, // 155: check predicate 23
1245 OPC_CheckField, 25, 1, 1, // 157: check Inst[25] == 0x1
1246 OPC_Decode, 238, 127, 5, // 161: decode to VL2RE8_V using decoder 5
1247 // 161: }
1248 16, 0, // 165: case 0x10: {
1249 OPC_CheckPredicate, 23, // 167: check predicate 23
1250 OPC_Decode, 170, 128, 1, 1, // 169: decode to VLSEG2E8FF_V using decoder 1
1251 // 169: }
1252 // 169: } // switch Inst[24:20]
1253 // 169: }
1254 9, 7, // 174: case 0x9: {
1255 OPC_CheckPredicate, 23, // 176: check predicate 23
1256 OPC_Decode, 255, 128, 1, 3, // 178: decode to VLUXSEG2EI8_V using decoder 3
1257 // 178: }
1258 10, 7, // 183: case 0xa: {
1259 OPC_CheckPredicate, 23, // 185: check predicate 23
1260 OPC_Decode, 223, 128, 1, 4, // 187: decode to VLSSEG2E8_V using decoder 4
1261 // 187: }
1262 11, 7, // 192: case 0xb: {
1263 OPC_CheckPredicate, 23, // 194: check predicate 23
1264 OPC_Decode, 135, 128, 1, 3, // 196: decode to VLOXSEG2EI8_V using decoder 3
1265 // 196: }
1266 16, 21, // 201: case 0x10: {
1267 OPC_SwitchField, 20, 5, // 203: switch Inst[24:20] {
1268 0, 7, // 206: case 0x0: {
1269 OPC_CheckPredicate, 23, // 208: check predicate 23
1270 OPC_Decode, 179, 128, 1, 1, // 210: decode to VLSEG3E8_V using decoder 1
1271 // 210: }
1272 16, 0, // 215: case 0x10: {
1273 OPC_CheckPredicate, 23, // 217: check predicate 23
1274 OPC_Decode, 178, 128, 1, 1, // 219: decode to VLSEG3E8FF_V using decoder 1
1275 // 219: }
1276 // 219: } // switch Inst[24:20]
1277 // 219: }
1278 17, 7, // 224: case 0x11: {
1279 OPC_CheckPredicate, 23, // 226: check predicate 23
1280 OPC_Decode, 131, 129, 1, 3, // 228: decode to VLUXSEG3EI8_V using decoder 3
1281 // 228: }
1282 18, 7, // 233: case 0x12: {
1283 OPC_CheckPredicate, 23, // 235: check predicate 23
1284 OPC_Decode, 227, 128, 1, 4, // 237: decode to VLSSEG3E8_V using decoder 4
1285 // 237: }
1286 19, 7, // 242: case 0x13: {
1287 OPC_CheckPredicate, 23, // 244: check predicate 23
1288 OPC_Decode, 139, 128, 1, 3, // 246: decode to VLOXSEG3EI8_V using decoder 3
1289 // 246: }
1290 24, 33, // 251: case 0x18: {
1291 OPC_SwitchField, 20, 5, // 253: switch Inst[24:20] {
1292 0, 7, // 256: case 0x0: {
1293 OPC_CheckPredicate, 23, // 258: check predicate 23
1294 OPC_Decode, 187, 128, 1, 1, // 260: decode to VLSEG4E8_V using decoder 1
1295 // 260: }
1296 8, 10, // 265: case 0x8: {
1297 OPC_CheckPredicate, 23, // 267: check predicate 23
1298 OPC_CheckField, 25, 1, 1, // 269: check Inst[25] == 0x1
1299 OPC_Decode, 242, 127, 6, // 273: decode to VL4RE8_V using decoder 6
1300 // 273: }
1301 16, 0, // 277: case 0x10: {
1302 OPC_CheckPredicate, 23, // 279: check predicate 23
1303 OPC_Decode, 186, 128, 1, 1, // 281: decode to VLSEG4E8FF_V using decoder 1
1304 // 281: }
1305 // 281: } // switch Inst[24:20]
1306 // 281: }
1307 25, 7, // 286: case 0x19: {
1308 OPC_CheckPredicate, 23, // 288: check predicate 23
1309 OPC_Decode, 135, 129, 1, 3, // 290: decode to VLUXSEG4EI8_V using decoder 3
1310 // 290: }
1311 26, 7, // 295: case 0x1a: {
1312 OPC_CheckPredicate, 23, // 297: check predicate 23
1313 OPC_Decode, 231, 128, 1, 4, // 299: decode to VLSSEG4E8_V using decoder 4
1314 // 299: }
1315 27, 7, // 304: case 0x1b: {
1316 OPC_CheckPredicate, 23, // 306: check predicate 23
1317 OPC_Decode, 143, 128, 1, 3, // 308: decode to VLOXSEG4EI8_V using decoder 3
1318 // 308: }
1319 32, 21, // 313: case 0x20: {
1320 OPC_SwitchField, 20, 5, // 315: switch Inst[24:20] {
1321 0, 7, // 318: case 0x0: {
1322 OPC_CheckPredicate, 23, // 320: check predicate 23
1323 OPC_Decode, 195, 128, 1, 1, // 322: decode to VLSEG5E8_V using decoder 1
1324 // 322: }
1325 16, 0, // 327: case 0x10: {
1326 OPC_CheckPredicate, 23, // 329: check predicate 23
1327 OPC_Decode, 194, 128, 1, 1, // 331: decode to VLSEG5E8FF_V using decoder 1
1328 // 331: }
1329 // 331: } // switch Inst[24:20]
1330 // 331: }
1331 33, 7, // 336: case 0x21: {
1332 OPC_CheckPredicate, 23, // 338: check predicate 23
1333 OPC_Decode, 139, 129, 1, 3, // 340: decode to VLUXSEG5EI8_V using decoder 3
1334 // 340: }
1335 34, 7, // 345: case 0x22: {
1336 OPC_CheckPredicate, 23, // 347: check predicate 23
1337 OPC_Decode, 235, 128, 1, 4, // 349: decode to VLSSEG5E8_V using decoder 4
1338 // 349: }
1339 35, 7, // 354: case 0x23: {
1340 OPC_CheckPredicate, 23, // 356: check predicate 23
1341 OPC_Decode, 147, 128, 1, 3, // 358: decode to VLOXSEG5EI8_V using decoder 3
1342 // 358: }
1343 40, 21, // 363: case 0x28: {
1344 OPC_SwitchField, 20, 5, // 365: switch Inst[24:20] {
1345 0, 7, // 368: case 0x0: {
1346 OPC_CheckPredicate, 23, // 370: check predicate 23
1347 OPC_Decode, 203, 128, 1, 1, // 372: decode to VLSEG6E8_V using decoder 1
1348 // 372: }
1349 16, 0, // 377: case 0x10: {
1350 OPC_CheckPredicate, 23, // 379: check predicate 23
1351 OPC_Decode, 202, 128, 1, 1, // 381: decode to VLSEG6E8FF_V using decoder 1
1352 // 381: }
1353 // 381: } // switch Inst[24:20]
1354 // 381: }
1355 41, 7, // 386: case 0x29: {
1356 OPC_CheckPredicate, 23, // 388: check predicate 23
1357 OPC_Decode, 143, 129, 1, 3, // 390: decode to VLUXSEG6EI8_V using decoder 3
1358 // 390: }
1359 42, 7, // 395: case 0x2a: {
1360 OPC_CheckPredicate, 23, // 397: check predicate 23
1361 OPC_Decode, 239, 128, 1, 4, // 399: decode to VLSSEG6E8_V using decoder 4
1362 // 399: }
1363 43, 7, // 404: case 0x2b: {
1364 OPC_CheckPredicate, 23, // 406: check predicate 23
1365 OPC_Decode, 151, 128, 1, 3, // 408: decode to VLOXSEG6EI8_V using decoder 3
1366 // 408: }
1367 48, 21, // 413: case 0x30: {
1368 OPC_SwitchField, 20, 5, // 415: switch Inst[24:20] {
1369 0, 7, // 418: case 0x0: {
1370 OPC_CheckPredicate, 23, // 420: check predicate 23
1371 OPC_Decode, 211, 128, 1, 1, // 422: decode to VLSEG7E8_V using decoder 1
1372 // 422: }
1373 16, 0, // 427: case 0x10: {
1374 OPC_CheckPredicate, 23, // 429: check predicate 23
1375 OPC_Decode, 210, 128, 1, 1, // 431: decode to VLSEG7E8FF_V using decoder 1
1376 // 431: }
1377 // 431: } // switch Inst[24:20]
1378 // 431: }
1379 49, 7, // 436: case 0x31: {
1380 OPC_CheckPredicate, 23, // 438: check predicate 23
1381 OPC_Decode, 147, 129, 1, 3, // 440: decode to VLUXSEG7EI8_V using decoder 3
1382 // 440: }
1383 50, 7, // 445: case 0x32: {
1384 OPC_CheckPredicate, 23, // 447: check predicate 23
1385 OPC_Decode, 243, 128, 1, 4, // 449: decode to VLSSEG7E8_V using decoder 4
1386 // 449: }
1387 51, 7, // 454: case 0x33: {
1388 OPC_CheckPredicate, 23, // 456: check predicate 23
1389 OPC_Decode, 155, 128, 1, 3, // 458: decode to VLOXSEG7EI8_V using decoder 3
1390 // 458: }
1391 56, 33, // 463: case 0x38: {
1392 OPC_SwitchField, 20, 5, // 465: switch Inst[24:20] {
1393 0, 7, // 468: case 0x0: {
1394 OPC_CheckPredicate, 23, // 470: check predicate 23
1395 OPC_Decode, 219, 128, 1, 1, // 472: decode to VLSEG8E8_V using decoder 1
1396 // 472: }
1397 8, 10, // 477: case 0x8: {
1398 OPC_CheckPredicate, 23, // 479: check predicate 23
1399 OPC_CheckField, 25, 1, 1, // 481: check Inst[25] == 0x1
1400 OPC_Decode, 246, 127, 7, // 485: decode to VL8RE8_V using decoder 7
1401 // 485: }
1402 16, 0, // 489: case 0x10: {
1403 OPC_CheckPredicate, 23, // 491: check predicate 23
1404 OPC_Decode, 218, 128, 1, 1, // 493: decode to VLSEG8E8FF_V using decoder 1
1405 // 493: }
1406 // 493: } // switch Inst[24:20]
1407 // 493: }
1408 57, 7, // 498: case 0x39: {
1409 OPC_CheckPredicate, 23, // 500: check predicate 23
1410 OPC_Decode, 151, 129, 1, 3, // 502: decode to VLUXSEG8EI8_V using decoder 3
1411 // 502: }
1412 58, 7, // 507: case 0x3a: {
1413 OPC_CheckPredicate, 23, // 509: check predicate 23
1414 OPC_Decode, 247, 128, 1, 4, // 511: decode to VLSSEG8E8_V using decoder 4
1415 // 511: }
1416 59, 0, // 516: case 0x3b: {
1417 OPC_CheckPredicate, 23, // 518: check predicate 23
1418 OPC_Decode, 159, 128, 1, 3, // 520: decode to VLOXSEG8EI8_V using decoder 3
1419 // 520: }
1420 // 520: } // switch Inst[31:26]
1421 // 520: }
1422 1, 6, // 525: case 0x1: {
1423 OPC_CheckPredicate, 24, // 527: check predicate 24
1424 OPC_Decode, 161, 115, 8, // 529: decode to FLH using decoder 8
1425 // 529: }
1426 2, 6, // 533: case 0x2: {
1427 OPC_CheckPredicate, 25, // 535: check predicate 25
1428 OPC_Decode, 179, 115, 9, // 537: decode to FLW using decoder 9
1429 // 537: }
1430 3, 6, // 541: case 0x3: {
1431 OPC_CheckPredicate, 26, // 543: check predicate 26
1432 OPC_Decode, 148, 115, 10, // 545: decode to FLD using decoder 10
1433 // 545: }
1434 4, 6, // 549: case 0x4: {
1435 OPC_CheckPredicate, 27, // 551: check predicate 27
1436 OPC_Decode, 166, 115, 11, // 553: decode to FLQ using decoder 11
1437 // 553: }
1438 5, 193, 3, // 557: case 0x5: {
1439 OPC_SwitchField, 26, 6, // 560: switch Inst[31:26] {
1440 0, 31, // 563: case 0x0: {
1441 OPC_SwitchField, 20, 5, // 565: switch Inst[24:20] {
1442 0, 6, // 568: case 0x0: {
1443 OPC_CheckPredicate, 23, // 570: check predicate 23
1444 OPC_Decode, 248, 127, 1, // 572: decode to VLE16_V using decoder 1
1445 // 572: }
1446 8, 10, // 576: case 0x8: {
1447 OPC_CheckPredicate, 23, // 578: check predicate 23
1448 OPC_CheckField, 25, 1, 1, // 580: check Inst[25] == 0x1
1449 OPC_Decode, 231, 127, 2, // 584: decode to VL1RE16_V using decoder 2
1450 // 584: }
1451 16, 0, // 588: case 0x10: {
1452 OPC_CheckPredicate, 23, // 590: check predicate 23
1453 OPC_Decode, 247, 127, 1, // 592: decode to VLE16FF_V using decoder 1
1454 // 592: }
1455 // 592: } // switch Inst[24:20]
1456 // 592: }
1457 1, 7, // 596: case 0x1: {
1458 OPC_CheckPredicate, 23, // 598: check predicate 23
1459 OPC_Decode, 248, 128, 1, 3, // 600: decode to VLUXEI16_V using decoder 3
1460 // 600: }
1461 2, 7, // 605: case 0x2: {
1462 OPC_CheckPredicate, 23, // 607: check predicate 23
1463 OPC_Decode, 160, 128, 1, 4, // 609: decode to VLSE16_V using decoder 4
1464 // 609: }
1465 3, 7, // 614: case 0x3: {
1466 OPC_CheckPredicate, 23, // 616: check predicate 23
1467 OPC_Decode, 128, 128, 1, 3, // 618: decode to VLOXEI16_V using decoder 3
1468 // 618: }
1469 8, 33, // 623: case 0x8: {
1470 OPC_SwitchField, 20, 5, // 625: switch Inst[24:20] {
1471 0, 7, // 628: case 0x0: {
1472 OPC_CheckPredicate, 23, // 630: check predicate 23
1473 OPC_Decode, 165, 128, 1, 1, // 632: decode to VLSEG2E16_V using decoder 1
1474 // 632: }
1475 8, 10, // 637: case 0x8: {
1476 OPC_CheckPredicate, 23, // 639: check predicate 23
1477 OPC_CheckField, 25, 1, 1, // 641: check Inst[25] == 0x1
1478 OPC_Decode, 235, 127, 5, // 645: decode to VL2RE16_V using decoder 5
1479 // 645: }
1480 16, 0, // 649: case 0x10: {
1481 OPC_CheckPredicate, 23, // 651: check predicate 23
1482 OPC_Decode, 164, 128, 1, 1, // 653: decode to VLSEG2E16FF_V using decoder 1
1483 // 653: }
1484 // 653: } // switch Inst[24:20]
1485 // 653: }
1486 9, 7, // 658: case 0x9: {
1487 OPC_CheckPredicate, 23, // 660: check predicate 23
1488 OPC_Decode, 252, 128, 1, 3, // 662: decode to VLUXSEG2EI16_V using decoder 3
1489 // 662: }
1490 10, 7, // 667: case 0xa: {
1491 OPC_CheckPredicate, 23, // 669: check predicate 23
1492 OPC_Decode, 220, 128, 1, 4, // 671: decode to VLSSEG2E16_V using decoder 4
1493 // 671: }
1494 11, 7, // 676: case 0xb: {
1495 OPC_CheckPredicate, 23, // 678: check predicate 23
1496 OPC_Decode, 132, 128, 1, 3, // 680: decode to VLOXSEG2EI16_V using decoder 3
1497 // 680: }
1498 16, 21, // 685: case 0x10: {
1499 OPC_SwitchField, 20, 5, // 687: switch Inst[24:20] {
1500 0, 7, // 690: case 0x0: {
1501 OPC_CheckPredicate, 23, // 692: check predicate 23
1502 OPC_Decode, 173, 128, 1, 1, // 694: decode to VLSEG3E16_V using decoder 1
1503 // 694: }
1504 16, 0, // 699: case 0x10: {
1505 OPC_CheckPredicate, 23, // 701: check predicate 23
1506 OPC_Decode, 172, 128, 1, 1, // 703: decode to VLSEG3E16FF_V using decoder 1
1507 // 703: }
1508 // 703: } // switch Inst[24:20]
1509 // 703: }
1510 17, 7, // 708: case 0x11: {
1511 OPC_CheckPredicate, 23, // 710: check predicate 23
1512 OPC_Decode, 128, 129, 1, 3, // 712: decode to VLUXSEG3EI16_V using decoder 3
1513 // 712: }
1514 18, 7, // 717: case 0x12: {
1515 OPC_CheckPredicate, 23, // 719: check predicate 23
1516 OPC_Decode, 224, 128, 1, 4, // 721: decode to VLSSEG3E16_V using decoder 4
1517 // 721: }
1518 19, 7, // 726: case 0x13: {
1519 OPC_CheckPredicate, 23, // 728: check predicate 23
1520 OPC_Decode, 136, 128, 1, 3, // 730: decode to VLOXSEG3EI16_V using decoder 3
1521 // 730: }
1522 24, 33, // 735: case 0x18: {
1523 OPC_SwitchField, 20, 5, // 737: switch Inst[24:20] {
1524 0, 7, // 740: case 0x0: {
1525 OPC_CheckPredicate, 23, // 742: check predicate 23
1526 OPC_Decode, 181, 128, 1, 1, // 744: decode to VLSEG4E16_V using decoder 1
1527 // 744: }
1528 8, 10, // 749: case 0x8: {
1529 OPC_CheckPredicate, 23, // 751: check predicate 23
1530 OPC_CheckField, 25, 1, 1, // 753: check Inst[25] == 0x1
1531 OPC_Decode, 239, 127, 6, // 757: decode to VL4RE16_V using decoder 6
1532 // 757: }
1533 16, 0, // 761: case 0x10: {
1534 OPC_CheckPredicate, 23, // 763: check predicate 23
1535 OPC_Decode, 180, 128, 1, 1, // 765: decode to VLSEG4E16FF_V using decoder 1
1536 // 765: }
1537 // 765: } // switch Inst[24:20]
1538 // 765: }
1539 25, 7, // 770: case 0x19: {
1540 OPC_CheckPredicate, 23, // 772: check predicate 23
1541 OPC_Decode, 132, 129, 1, 3, // 774: decode to VLUXSEG4EI16_V using decoder 3
1542 // 774: }
1543 26, 7, // 779: case 0x1a: {
1544 OPC_CheckPredicate, 23, // 781: check predicate 23
1545 OPC_Decode, 228, 128, 1, 4, // 783: decode to VLSSEG4E16_V using decoder 4
1546 // 783: }
1547 27, 7, // 788: case 0x1b: {
1548 OPC_CheckPredicate, 23, // 790: check predicate 23
1549 OPC_Decode, 140, 128, 1, 3, // 792: decode to VLOXSEG4EI16_V using decoder 3
1550 // 792: }
1551 32, 21, // 797: case 0x20: {
1552 OPC_SwitchField, 20, 5, // 799: switch Inst[24:20] {
1553 0, 7, // 802: case 0x0: {
1554 OPC_CheckPredicate, 23, // 804: check predicate 23
1555 OPC_Decode, 189, 128, 1, 1, // 806: decode to VLSEG5E16_V using decoder 1
1556 // 806: }
1557 16, 0, // 811: case 0x10: {
1558 OPC_CheckPredicate, 23, // 813: check predicate 23
1559 OPC_Decode, 188, 128, 1, 1, // 815: decode to VLSEG5E16FF_V using decoder 1
1560 // 815: }
1561 // 815: } // switch Inst[24:20]
1562 // 815: }
1563 33, 7, // 820: case 0x21: {
1564 OPC_CheckPredicate, 23, // 822: check predicate 23
1565 OPC_Decode, 136, 129, 1, 3, // 824: decode to VLUXSEG5EI16_V using decoder 3
1566 // 824: }
1567 34, 7, // 829: case 0x22: {
1568 OPC_CheckPredicate, 23, // 831: check predicate 23
1569 OPC_Decode, 232, 128, 1, 4, // 833: decode to VLSSEG5E16_V using decoder 4
1570 // 833: }
1571 35, 7, // 838: case 0x23: {
1572 OPC_CheckPredicate, 23, // 840: check predicate 23
1573 OPC_Decode, 144, 128, 1, 3, // 842: decode to VLOXSEG5EI16_V using decoder 3
1574 // 842: }
1575 40, 21, // 847: case 0x28: {
1576 OPC_SwitchField, 20, 5, // 849: switch Inst[24:20] {
1577 0, 7, // 852: case 0x0: {
1578 OPC_CheckPredicate, 23, // 854: check predicate 23
1579 OPC_Decode, 197, 128, 1, 1, // 856: decode to VLSEG6E16_V using decoder 1
1580 // 856: }
1581 16, 0, // 861: case 0x10: {
1582 OPC_CheckPredicate, 23, // 863: check predicate 23
1583 OPC_Decode, 196, 128, 1, 1, // 865: decode to VLSEG6E16FF_V using decoder 1
1584 // 865: }
1585 // 865: } // switch Inst[24:20]
1586 // 865: }
1587 41, 7, // 870: case 0x29: {
1588 OPC_CheckPredicate, 23, // 872: check predicate 23
1589 OPC_Decode, 140, 129, 1, 3, // 874: decode to VLUXSEG6EI16_V using decoder 3
1590 // 874: }
1591 42, 7, // 879: case 0x2a: {
1592 OPC_CheckPredicate, 23, // 881: check predicate 23
1593 OPC_Decode, 236, 128, 1, 4, // 883: decode to VLSSEG6E16_V using decoder 4
1594 // 883: }
1595 43, 7, // 888: case 0x2b: {
1596 OPC_CheckPredicate, 23, // 890: check predicate 23
1597 OPC_Decode, 148, 128, 1, 3, // 892: decode to VLOXSEG6EI16_V using decoder 3
1598 // 892: }
1599 48, 21, // 897: case 0x30: {
1600 OPC_SwitchField, 20, 5, // 899: switch Inst[24:20] {
1601 0, 7, // 902: case 0x0: {
1602 OPC_CheckPredicate, 23, // 904: check predicate 23
1603 OPC_Decode, 205, 128, 1, 1, // 906: decode to VLSEG7E16_V using decoder 1
1604 // 906: }
1605 16, 0, // 911: case 0x10: {
1606 OPC_CheckPredicate, 23, // 913: check predicate 23
1607 OPC_Decode, 204, 128, 1, 1, // 915: decode to VLSEG7E16FF_V using decoder 1
1608 // 915: }
1609 // 915: } // switch Inst[24:20]
1610 // 915: }
1611 49, 7, // 920: case 0x31: {
1612 OPC_CheckPredicate, 23, // 922: check predicate 23
1613 OPC_Decode, 144, 129, 1, 3, // 924: decode to VLUXSEG7EI16_V using decoder 3
1614 // 924: }
1615 50, 7, // 929: case 0x32: {
1616 OPC_CheckPredicate, 23, // 931: check predicate 23
1617 OPC_Decode, 240, 128, 1, 4, // 933: decode to VLSSEG7E16_V using decoder 4
1618 // 933: }
1619 51, 7, // 938: case 0x33: {
1620 OPC_CheckPredicate, 23, // 940: check predicate 23
1621 OPC_Decode, 152, 128, 1, 3, // 942: decode to VLOXSEG7EI16_V using decoder 3
1622 // 942: }
1623 56, 33, // 947: case 0x38: {
1624 OPC_SwitchField, 20, 5, // 949: switch Inst[24:20] {
1625 0, 7, // 952: case 0x0: {
1626 OPC_CheckPredicate, 23, // 954: check predicate 23
1627 OPC_Decode, 213, 128, 1, 1, // 956: decode to VLSEG8E16_V using decoder 1
1628 // 956: }
1629 8, 10, // 961: case 0x8: {
1630 OPC_CheckPredicate, 23, // 963: check predicate 23
1631 OPC_CheckField, 25, 1, 1, // 965: check Inst[25] == 0x1
1632 OPC_Decode, 243, 127, 7, // 969: decode to VL8RE16_V using decoder 7
1633 // 969: }
1634 16, 0, // 973: case 0x10: {
1635 OPC_CheckPredicate, 23, // 975: check predicate 23
1636 OPC_Decode, 212, 128, 1, 1, // 977: decode to VLSEG8E16FF_V using decoder 1
1637 // 977: }
1638 // 977: } // switch Inst[24:20]
1639 // 977: }
1640 57, 7, // 982: case 0x39: {
1641 OPC_CheckPredicate, 23, // 984: check predicate 23
1642 OPC_Decode, 148, 129, 1, 3, // 986: decode to VLUXSEG8EI16_V using decoder 3
1643 // 986: }
1644 58, 7, // 991: case 0x3a: {
1645 OPC_CheckPredicate, 23, // 993: check predicate 23
1646 OPC_Decode, 244, 128, 1, 4, // 995: decode to VLSSEG8E16_V using decoder 4
1647 // 995: }
1648 59, 0, // 1000: case 0x3b: {
1649 OPC_CheckPredicate, 23, // 1002: check predicate 23
1650 OPC_Decode, 156, 128, 1, 3, // 1004: decode to VLOXSEG8EI16_V using decoder 3
1651 // 1004: }
1652 // 1004: } // switch Inst[31:26]
1653 // 1004: }
1654 6, 193, 3, // 1009: case 0x6: {
1655 OPC_SwitchField, 26, 6, // 1012: switch Inst[31:26] {
1656 0, 31, // 1015: case 0x0: {
1657 OPC_SwitchField, 20, 5, // 1017: switch Inst[24:20] {
1658 0, 6, // 1020: case 0x0: {
1659 OPC_CheckPredicate, 23, // 1022: check predicate 23
1660 OPC_Decode, 250, 127, 1, // 1024: decode to VLE32_V using decoder 1
1661 // 1024: }
1662 8, 10, // 1028: case 0x8: {
1663 OPC_CheckPredicate, 23, // 1030: check predicate 23
1664 OPC_CheckField, 25, 1, 1, // 1032: check Inst[25] == 0x1
1665 OPC_Decode, 232, 127, 2, // 1036: decode to VL1RE32_V using decoder 2
1666 // 1036: }
1667 16, 0, // 1040: case 0x10: {
1668 OPC_CheckPredicate, 23, // 1042: check predicate 23
1669 OPC_Decode, 249, 127, 1, // 1044: decode to VLE32FF_V using decoder 1
1670 // 1044: }
1671 // 1044: } // switch Inst[24:20]
1672 // 1044: }
1673 1, 7, // 1048: case 0x1: {
1674 OPC_CheckPredicate, 23, // 1050: check predicate 23
1675 OPC_Decode, 249, 128, 1, 3, // 1052: decode to VLUXEI32_V using decoder 3
1676 // 1052: }
1677 2, 7, // 1057: case 0x2: {
1678 OPC_CheckPredicate, 23, // 1059: check predicate 23
1679 OPC_Decode, 161, 128, 1, 4, // 1061: decode to VLSE32_V using decoder 4
1680 // 1061: }
1681 3, 7, // 1066: case 0x3: {
1682 OPC_CheckPredicate, 23, // 1068: check predicate 23
1683 OPC_Decode, 129, 128, 1, 3, // 1070: decode to VLOXEI32_V using decoder 3
1684 // 1070: }
1685 8, 33, // 1075: case 0x8: {
1686 OPC_SwitchField, 20, 5, // 1077: switch Inst[24:20] {
1687 0, 7, // 1080: case 0x0: {
1688 OPC_CheckPredicate, 23, // 1082: check predicate 23
1689 OPC_Decode, 167, 128, 1, 1, // 1084: decode to VLSEG2E32_V using decoder 1
1690 // 1084: }
1691 8, 10, // 1089: case 0x8: {
1692 OPC_CheckPredicate, 23, // 1091: check predicate 23
1693 OPC_CheckField, 25, 1, 1, // 1093: check Inst[25] == 0x1
1694 OPC_Decode, 236, 127, 5, // 1097: decode to VL2RE32_V using decoder 5
1695 // 1097: }
1696 16, 0, // 1101: case 0x10: {
1697 OPC_CheckPredicate, 23, // 1103: check predicate 23
1698 OPC_Decode, 166, 128, 1, 1, // 1105: decode to VLSEG2E32FF_V using decoder 1
1699 // 1105: }
1700 // 1105: } // switch Inst[24:20]
1701 // 1105: }
1702 9, 7, // 1110: case 0x9: {
1703 OPC_CheckPredicate, 23, // 1112: check predicate 23
1704 OPC_Decode, 253, 128, 1, 3, // 1114: decode to VLUXSEG2EI32_V using decoder 3
1705 // 1114: }
1706 10, 7, // 1119: case 0xa: {
1707 OPC_CheckPredicate, 23, // 1121: check predicate 23
1708 OPC_Decode, 221, 128, 1, 4, // 1123: decode to VLSSEG2E32_V using decoder 4
1709 // 1123: }
1710 11, 7, // 1128: case 0xb: {
1711 OPC_CheckPredicate, 23, // 1130: check predicate 23
1712 OPC_Decode, 133, 128, 1, 3, // 1132: decode to VLOXSEG2EI32_V using decoder 3
1713 // 1132: }
1714 16, 21, // 1137: case 0x10: {
1715 OPC_SwitchField, 20, 5, // 1139: switch Inst[24:20] {
1716 0, 7, // 1142: case 0x0: {
1717 OPC_CheckPredicate, 23, // 1144: check predicate 23
1718 OPC_Decode, 175, 128, 1, 1, // 1146: decode to VLSEG3E32_V using decoder 1
1719 // 1146: }
1720 16, 0, // 1151: case 0x10: {
1721 OPC_CheckPredicate, 23, // 1153: check predicate 23
1722 OPC_Decode, 174, 128, 1, 1, // 1155: decode to VLSEG3E32FF_V using decoder 1
1723 // 1155: }
1724 // 1155: } // switch Inst[24:20]
1725 // 1155: }
1726 17, 7, // 1160: case 0x11: {
1727 OPC_CheckPredicate, 23, // 1162: check predicate 23
1728 OPC_Decode, 129, 129, 1, 3, // 1164: decode to VLUXSEG3EI32_V using decoder 3
1729 // 1164: }
1730 18, 7, // 1169: case 0x12: {
1731 OPC_CheckPredicate, 23, // 1171: check predicate 23
1732 OPC_Decode, 225, 128, 1, 4, // 1173: decode to VLSSEG3E32_V using decoder 4
1733 // 1173: }
1734 19, 7, // 1178: case 0x13: {
1735 OPC_CheckPredicate, 23, // 1180: check predicate 23
1736 OPC_Decode, 137, 128, 1, 3, // 1182: decode to VLOXSEG3EI32_V using decoder 3
1737 // 1182: }
1738 24, 33, // 1187: case 0x18: {
1739 OPC_SwitchField, 20, 5, // 1189: switch Inst[24:20] {
1740 0, 7, // 1192: case 0x0: {
1741 OPC_CheckPredicate, 23, // 1194: check predicate 23
1742 OPC_Decode, 183, 128, 1, 1, // 1196: decode to VLSEG4E32_V using decoder 1
1743 // 1196: }
1744 8, 10, // 1201: case 0x8: {
1745 OPC_CheckPredicate, 23, // 1203: check predicate 23
1746 OPC_CheckField, 25, 1, 1, // 1205: check Inst[25] == 0x1
1747 OPC_Decode, 240, 127, 6, // 1209: decode to VL4RE32_V using decoder 6
1748 // 1209: }
1749 16, 0, // 1213: case 0x10: {
1750 OPC_CheckPredicate, 23, // 1215: check predicate 23
1751 OPC_Decode, 182, 128, 1, 1, // 1217: decode to VLSEG4E32FF_V using decoder 1
1752 // 1217: }
1753 // 1217: } // switch Inst[24:20]
1754 // 1217: }
1755 25, 7, // 1222: case 0x19: {
1756 OPC_CheckPredicate, 23, // 1224: check predicate 23
1757 OPC_Decode, 133, 129, 1, 3, // 1226: decode to VLUXSEG4EI32_V using decoder 3
1758 // 1226: }
1759 26, 7, // 1231: case 0x1a: {
1760 OPC_CheckPredicate, 23, // 1233: check predicate 23
1761 OPC_Decode, 229, 128, 1, 4, // 1235: decode to VLSSEG4E32_V using decoder 4
1762 // 1235: }
1763 27, 7, // 1240: case 0x1b: {
1764 OPC_CheckPredicate, 23, // 1242: check predicate 23
1765 OPC_Decode, 141, 128, 1, 3, // 1244: decode to VLOXSEG4EI32_V using decoder 3
1766 // 1244: }
1767 32, 21, // 1249: case 0x20: {
1768 OPC_SwitchField, 20, 5, // 1251: switch Inst[24:20] {
1769 0, 7, // 1254: case 0x0: {
1770 OPC_CheckPredicate, 23, // 1256: check predicate 23
1771 OPC_Decode, 191, 128, 1, 1, // 1258: decode to VLSEG5E32_V using decoder 1
1772 // 1258: }
1773 16, 0, // 1263: case 0x10: {
1774 OPC_CheckPredicate, 23, // 1265: check predicate 23
1775 OPC_Decode, 190, 128, 1, 1, // 1267: decode to VLSEG5E32FF_V using decoder 1
1776 // 1267: }
1777 // 1267: } // switch Inst[24:20]
1778 // 1267: }
1779 33, 7, // 1272: case 0x21: {
1780 OPC_CheckPredicate, 23, // 1274: check predicate 23
1781 OPC_Decode, 137, 129, 1, 3, // 1276: decode to VLUXSEG5EI32_V using decoder 3
1782 // 1276: }
1783 34, 7, // 1281: case 0x22: {
1784 OPC_CheckPredicate, 23, // 1283: check predicate 23
1785 OPC_Decode, 233, 128, 1, 4, // 1285: decode to VLSSEG5E32_V using decoder 4
1786 // 1285: }
1787 35, 7, // 1290: case 0x23: {
1788 OPC_CheckPredicate, 23, // 1292: check predicate 23
1789 OPC_Decode, 145, 128, 1, 3, // 1294: decode to VLOXSEG5EI32_V using decoder 3
1790 // 1294: }
1791 40, 21, // 1299: case 0x28: {
1792 OPC_SwitchField, 20, 5, // 1301: switch Inst[24:20] {
1793 0, 7, // 1304: case 0x0: {
1794 OPC_CheckPredicate, 23, // 1306: check predicate 23
1795 OPC_Decode, 199, 128, 1, 1, // 1308: decode to VLSEG6E32_V using decoder 1
1796 // 1308: }
1797 16, 0, // 1313: case 0x10: {
1798 OPC_CheckPredicate, 23, // 1315: check predicate 23
1799 OPC_Decode, 198, 128, 1, 1, // 1317: decode to VLSEG6E32FF_V using decoder 1
1800 // 1317: }
1801 // 1317: } // switch Inst[24:20]
1802 // 1317: }
1803 41, 7, // 1322: case 0x29: {
1804 OPC_CheckPredicate, 23, // 1324: check predicate 23
1805 OPC_Decode, 141, 129, 1, 3, // 1326: decode to VLUXSEG6EI32_V using decoder 3
1806 // 1326: }
1807 42, 7, // 1331: case 0x2a: {
1808 OPC_CheckPredicate, 23, // 1333: check predicate 23
1809 OPC_Decode, 237, 128, 1, 4, // 1335: decode to VLSSEG6E32_V using decoder 4
1810 // 1335: }
1811 43, 7, // 1340: case 0x2b: {
1812 OPC_CheckPredicate, 23, // 1342: check predicate 23
1813 OPC_Decode, 149, 128, 1, 3, // 1344: decode to VLOXSEG6EI32_V using decoder 3
1814 // 1344: }
1815 48, 21, // 1349: case 0x30: {
1816 OPC_SwitchField, 20, 5, // 1351: switch Inst[24:20] {
1817 0, 7, // 1354: case 0x0: {
1818 OPC_CheckPredicate, 23, // 1356: check predicate 23
1819 OPC_Decode, 207, 128, 1, 1, // 1358: decode to VLSEG7E32_V using decoder 1
1820 // 1358: }
1821 16, 0, // 1363: case 0x10: {
1822 OPC_CheckPredicate, 23, // 1365: check predicate 23
1823 OPC_Decode, 206, 128, 1, 1, // 1367: decode to VLSEG7E32FF_V using decoder 1
1824 // 1367: }
1825 // 1367: } // switch Inst[24:20]
1826 // 1367: }
1827 49, 7, // 1372: case 0x31: {
1828 OPC_CheckPredicate, 23, // 1374: check predicate 23
1829 OPC_Decode, 145, 129, 1, 3, // 1376: decode to VLUXSEG7EI32_V using decoder 3
1830 // 1376: }
1831 50, 7, // 1381: case 0x32: {
1832 OPC_CheckPredicate, 23, // 1383: check predicate 23
1833 OPC_Decode, 241, 128, 1, 4, // 1385: decode to VLSSEG7E32_V using decoder 4
1834 // 1385: }
1835 51, 7, // 1390: case 0x33: {
1836 OPC_CheckPredicate, 23, // 1392: check predicate 23
1837 OPC_Decode, 153, 128, 1, 3, // 1394: decode to VLOXSEG7EI32_V using decoder 3
1838 // 1394: }
1839 56, 33, // 1399: case 0x38: {
1840 OPC_SwitchField, 20, 5, // 1401: switch Inst[24:20] {
1841 0, 7, // 1404: case 0x0: {
1842 OPC_CheckPredicate, 23, // 1406: check predicate 23
1843 OPC_Decode, 215, 128, 1, 1, // 1408: decode to VLSEG8E32_V using decoder 1
1844 // 1408: }
1845 8, 10, // 1413: case 0x8: {
1846 OPC_CheckPredicate, 23, // 1415: check predicate 23
1847 OPC_CheckField, 25, 1, 1, // 1417: check Inst[25] == 0x1
1848 OPC_Decode, 244, 127, 7, // 1421: decode to VL8RE32_V using decoder 7
1849 // 1421: }
1850 16, 0, // 1425: case 0x10: {
1851 OPC_CheckPredicate, 23, // 1427: check predicate 23
1852 OPC_Decode, 214, 128, 1, 1, // 1429: decode to VLSEG8E32FF_V using decoder 1
1853 // 1429: }
1854 // 1429: } // switch Inst[24:20]
1855 // 1429: }
1856 57, 7, // 1434: case 0x39: {
1857 OPC_CheckPredicate, 23, // 1436: check predicate 23
1858 OPC_Decode, 149, 129, 1, 3, // 1438: decode to VLUXSEG8EI32_V using decoder 3
1859 // 1438: }
1860 58, 7, // 1443: case 0x3a: {
1861 OPC_CheckPredicate, 23, // 1445: check predicate 23
1862 OPC_Decode, 245, 128, 1, 4, // 1447: decode to VLSSEG8E32_V using decoder 4
1863 // 1447: }
1864 59, 0, // 1452: case 0x3b: {
1865 OPC_CheckPredicate, 23, // 1454: check predicate 23
1866 OPC_Decode, 157, 128, 1, 3, // 1456: decode to VLOXSEG8EI32_V using decoder 3
1867 // 1456: }
1868 // 1456: } // switch Inst[31:26]
1869 // 1456: }
1870 7, 0, // 1461: case 0x7: {
1871 OPC_SwitchField, 26, 3, // 1463: switch Inst[28:26] {
1872 0, 233, 1, // 1466: case 0x0: {
1873 OPC_SwitchField, 29, 3, // 1469: switch Inst[31:29] {
1874 0, 31, // 1472: case 0x0: {
1875 OPC_SwitchField, 20, 5, // 1474: switch Inst[24:20] {
1876 0, 6, // 1477: case 0x0: {
1877 OPC_CheckPredicate, 28, // 1479: check predicate 28
1878 OPC_Decode, 252, 127, 1, // 1481: decode to VLE64_V using decoder 1
1879 // 1481: }
1880 8, 10, // 1485: case 0x8: {
1881 OPC_CheckPredicate, 28, // 1487: check predicate 28
1882 OPC_CheckField, 25, 1, 1, // 1489: check Inst[25] == 0x1
1883 OPC_Decode, 233, 127, 2, // 1493: decode to VL1RE64_V using decoder 2
1884 // 1493: }
1885 16, 0, // 1497: case 0x10: {
1886 OPC_CheckPredicate, 28, // 1499: check predicate 28
1887 OPC_Decode, 251, 127, 1, // 1501: decode to VLE64FF_V using decoder 1
1888 // 1501: }
1889 // 1501: } // switch Inst[24:20]
1890 // 1501: }
1891 1, 33, // 1505: case 0x1: {
1892 OPC_SwitchField, 20, 5, // 1507: switch Inst[24:20] {
1893 0, 7, // 1510: case 0x0: {
1894 OPC_CheckPredicate, 28, // 1512: check predicate 28
1895 OPC_Decode, 169, 128, 1, 1, // 1514: decode to VLSEG2E64_V using decoder 1
1896 // 1514: }
1897 8, 10, // 1519: case 0x8: {
1898 OPC_CheckPredicate, 28, // 1521: check predicate 28
1899 OPC_CheckField, 25, 1, 1, // 1523: check Inst[25] == 0x1
1900 OPC_Decode, 237, 127, 5, // 1527: decode to VL2RE64_V using decoder 5
1901 // 1527: }
1902 16, 0, // 1531: case 0x10: {
1903 OPC_CheckPredicate, 28, // 1533: check predicate 28
1904 OPC_Decode, 168, 128, 1, 1, // 1535: decode to VLSEG2E64FF_V using decoder 1
1905 // 1535: }
1906 // 1535: } // switch Inst[24:20]
1907 // 1535: }
1908 2, 21, // 1540: case 0x2: {
1909 OPC_SwitchField, 20, 5, // 1542: switch Inst[24:20] {
1910 0, 7, // 1545: case 0x0: {
1911 OPC_CheckPredicate, 28, // 1547: check predicate 28
1912 OPC_Decode, 177, 128, 1, 1, // 1549: decode to VLSEG3E64_V using decoder 1
1913 // 1549: }
1914 16, 0, // 1554: case 0x10: {
1915 OPC_CheckPredicate, 28, // 1556: check predicate 28
1916 OPC_Decode, 176, 128, 1, 1, // 1558: decode to VLSEG3E64FF_V using decoder 1
1917 // 1558: }
1918 // 1558: } // switch Inst[24:20]
1919 // 1558: }
1920 3, 33, // 1563: case 0x3: {
1921 OPC_SwitchField, 20, 5, // 1565: switch Inst[24:20] {
1922 0, 7, // 1568: case 0x0: {
1923 OPC_CheckPredicate, 28, // 1570: check predicate 28
1924 OPC_Decode, 185, 128, 1, 1, // 1572: decode to VLSEG4E64_V using decoder 1
1925 // 1572: }
1926 8, 10, // 1577: case 0x8: {
1927 OPC_CheckPredicate, 28, // 1579: check predicate 28
1928 OPC_CheckField, 25, 1, 1, // 1581: check Inst[25] == 0x1
1929 OPC_Decode, 241, 127, 6, // 1585: decode to VL4RE64_V using decoder 6
1930 // 1585: }
1931 16, 0, // 1589: case 0x10: {
1932 OPC_CheckPredicate, 28, // 1591: check predicate 28
1933 OPC_Decode, 184, 128, 1, 1, // 1593: decode to VLSEG4E64FF_V using decoder 1
1934 // 1593: }
1935 // 1593: } // switch Inst[24:20]
1936 // 1593: }
1937 4, 21, // 1598: case 0x4: {
1938 OPC_SwitchField, 20, 5, // 1600: switch Inst[24:20] {
1939 0, 7, // 1603: case 0x0: {
1940 OPC_CheckPredicate, 28, // 1605: check predicate 28
1941 OPC_Decode, 193, 128, 1, 1, // 1607: decode to VLSEG5E64_V using decoder 1
1942 // 1607: }
1943 16, 0, // 1612: case 0x10: {
1944 OPC_CheckPredicate, 28, // 1614: check predicate 28
1945 OPC_Decode, 192, 128, 1, 1, // 1616: decode to VLSEG5E64FF_V using decoder 1
1946 // 1616: }
1947 // 1616: } // switch Inst[24:20]
1948 // 1616: }
1949 5, 21, // 1621: case 0x5: {
1950 OPC_SwitchField, 20, 5, // 1623: switch Inst[24:20] {
1951 0, 7, // 1626: case 0x0: {
1952 OPC_CheckPredicate, 28, // 1628: check predicate 28
1953 OPC_Decode, 201, 128, 1, 1, // 1630: decode to VLSEG6E64_V using decoder 1
1954 // 1630: }
1955 16, 0, // 1635: case 0x10: {
1956 OPC_CheckPredicate, 28, // 1637: check predicate 28
1957 OPC_Decode, 200, 128, 1, 1, // 1639: decode to VLSEG6E64FF_V using decoder 1
1958 // 1639: }
1959 // 1639: } // switch Inst[24:20]
1960 // 1639: }
1961 6, 21, // 1644: case 0x6: {
1962 OPC_SwitchField, 20, 5, // 1646: switch Inst[24:20] {
1963 0, 7, // 1649: case 0x0: {
1964 OPC_CheckPredicate, 28, // 1651: check predicate 28
1965 OPC_Decode, 209, 128, 1, 1, // 1653: decode to VLSEG7E64_V using decoder 1
1966 // 1653: }
1967 16, 0, // 1658: case 0x10: {
1968 OPC_CheckPredicate, 28, // 1660: check predicate 28
1969 OPC_Decode, 208, 128, 1, 1, // 1662: decode to VLSEG7E64FF_V using decoder 1
1970 // 1662: }
1971 // 1662: } // switch Inst[24:20]
1972 // 1662: }
1973 7, 0, // 1667: case 0x7: {
1974 OPC_SwitchField, 20, 5, // 1669: switch Inst[24:20] {
1975 0, 7, // 1672: case 0x0: {
1976 OPC_CheckPredicate, 28, // 1674: check predicate 28
1977 OPC_Decode, 217, 128, 1, 1, // 1676: decode to VLSEG8E64_V using decoder 1
1978 // 1676: }
1979 8, 10, // 1681: case 0x8: {
1980 OPC_CheckPredicate, 28, // 1683: check predicate 28
1981 OPC_CheckField, 25, 1, 1, // 1685: check Inst[25] == 0x1
1982 OPC_Decode, 245, 127, 7, // 1689: decode to VL8RE64_V using decoder 7
1983 // 1689: }
1984 16, 0, // 1693: case 0x10: {
1985 OPC_CheckPredicate, 28, // 1695: check predicate 28
1986 OPC_Decode, 216, 128, 1, 1, // 1697: decode to VLSEG8E64FF_V using decoder 1
1987 // 1697: }
1988 // 1697: } // switch Inst[24:20]
1989 // 1697: }
1990 // 1697: } // switch Inst[31:29]
1991 // 1697: }
1992 1, 75, // 1702: case 0x1: {
1993 OPC_SwitchField, 29, 3, // 1704: switch Inst[31:29] {
1994 0, 7, // 1707: case 0x0: {
1995 OPC_CheckPredicate, 29, // 1709: check predicate 29
1996 OPC_Decode, 250, 128, 1, 3, // 1711: decode to VLUXEI64_V using decoder 3
1997 // 1711: }
1998 1, 7, // 1716: case 0x1: {
1999 OPC_CheckPredicate, 30, // 1718: check predicate 30
2000 OPC_Decode, 254, 128, 1, 3, // 1720: decode to VLUXSEG2EI64_V using decoder 3
2001 // 1720: }
2002 2, 7, // 1725: case 0x2: {
2003 OPC_CheckPredicate, 30, // 1727: check predicate 30
2004 OPC_Decode, 130, 129, 1, 3, // 1729: decode to VLUXSEG3EI64_V using decoder 3
2005 // 1729: }
2006 3, 7, // 1734: case 0x3: {
2007 OPC_CheckPredicate, 30, // 1736: check predicate 30
2008 OPC_Decode, 134, 129, 1, 3, // 1738: decode to VLUXSEG4EI64_V using decoder 3
2009 // 1738: }
2010 4, 7, // 1743: case 0x4: {
2011 OPC_CheckPredicate, 30, // 1745: check predicate 30
2012 OPC_Decode, 138, 129, 1, 3, // 1747: decode to VLUXSEG5EI64_V using decoder 3
2013 // 1747: }
2014 5, 7, // 1752: case 0x5: {
2015 OPC_CheckPredicate, 30, // 1754: check predicate 30
2016 OPC_Decode, 142, 129, 1, 3, // 1756: decode to VLUXSEG6EI64_V using decoder 3
2017 // 1756: }
2018 6, 7, // 1761: case 0x6: {
2019 OPC_CheckPredicate, 30, // 1763: check predicate 30
2020 OPC_Decode, 146, 129, 1, 3, // 1765: decode to VLUXSEG7EI64_V using decoder 3
2021 // 1765: }
2022 7, 0, // 1770: case 0x7: {
2023 OPC_CheckPredicate, 30, // 1772: check predicate 30
2024 OPC_Decode, 150, 129, 1, 3, // 1774: decode to VLUXSEG8EI64_V using decoder 3
2025 // 1774: }
2026 // 1774: } // switch Inst[31:29]
2027 // 1774: }
2028 2, 75, // 1779: case 0x2: {
2029 OPC_SwitchField, 29, 3, // 1781: switch Inst[31:29] {
2030 0, 7, // 1784: case 0x0: {
2031 OPC_CheckPredicate, 28, // 1786: check predicate 28
2032 OPC_Decode, 162, 128, 1, 4, // 1788: decode to VLSE64_V using decoder 4
2033 // 1788: }
2034 1, 7, // 1793: case 0x1: {
2035 OPC_CheckPredicate, 28, // 1795: check predicate 28
2036 OPC_Decode, 222, 128, 1, 4, // 1797: decode to VLSSEG2E64_V using decoder 4
2037 // 1797: }
2038 2, 7, // 1802: case 0x2: {
2039 OPC_CheckPredicate, 28, // 1804: check predicate 28
2040 OPC_Decode, 226, 128, 1, 4, // 1806: decode to VLSSEG3E64_V using decoder 4
2041 // 1806: }
2042 3, 7, // 1811: case 0x3: {
2043 OPC_CheckPredicate, 28, // 1813: check predicate 28
2044 OPC_Decode, 230, 128, 1, 4, // 1815: decode to VLSSEG4E64_V using decoder 4
2045 // 1815: }
2046 4, 7, // 1820: case 0x4: {
2047 OPC_CheckPredicate, 28, // 1822: check predicate 28
2048 OPC_Decode, 234, 128, 1, 4, // 1824: decode to VLSSEG5E64_V using decoder 4
2049 // 1824: }
2050 5, 7, // 1829: case 0x5: {
2051 OPC_CheckPredicate, 28, // 1831: check predicate 28
2052 OPC_Decode, 238, 128, 1, 4, // 1833: decode to VLSSEG6E64_V using decoder 4
2053 // 1833: }
2054 6, 7, // 1838: case 0x6: {
2055 OPC_CheckPredicate, 28, // 1840: check predicate 28
2056 OPC_Decode, 242, 128, 1, 4, // 1842: decode to VLSSEG7E64_V using decoder 4
2057 // 1842: }
2058 7, 0, // 1847: case 0x7: {
2059 OPC_CheckPredicate, 28, // 1849: check predicate 28
2060 OPC_Decode, 246, 128, 1, 4, // 1851: decode to VLSSEG8E64_V using decoder 4
2061 // 1851: }
2062 // 1851: } // switch Inst[31:29]
2063 // 1851: }
2064 3, 75, // 1856: case 0x3: {
2065 OPC_SwitchField, 29, 3, // 1858: switch Inst[31:29] {
2066 0, 7, // 1861: case 0x0: {
2067 OPC_CheckPredicate, 29, // 1863: check predicate 29
2068 OPC_Decode, 130, 128, 1, 3, // 1865: decode to VLOXEI64_V using decoder 3
2069 // 1865: }
2070 1, 7, // 1870: case 0x1: {
2071 OPC_CheckPredicate, 30, // 1872: check predicate 30
2072 OPC_Decode, 134, 128, 1, 3, // 1874: decode to VLOXSEG2EI64_V using decoder 3
2073 // 1874: }
2074 2, 7, // 1879: case 0x2: {
2075 OPC_CheckPredicate, 30, // 1881: check predicate 30
2076 OPC_Decode, 138, 128, 1, 3, // 1883: decode to VLOXSEG3EI64_V using decoder 3
2077 // 1883: }
2078 3, 7, // 1888: case 0x3: {
2079 OPC_CheckPredicate, 30, // 1890: check predicate 30
2080 OPC_Decode, 142, 128, 1, 3, // 1892: decode to VLOXSEG4EI64_V using decoder 3
2081 // 1892: }
2082 4, 7, // 1897: case 0x4: {
2083 OPC_CheckPredicate, 30, // 1899: check predicate 30
2084 OPC_Decode, 146, 128, 1, 3, // 1901: decode to VLOXSEG5EI64_V using decoder 3
2085 // 1901: }
2086 5, 7, // 1906: case 0x5: {
2087 OPC_CheckPredicate, 30, // 1908: check predicate 30
2088 OPC_Decode, 150, 128, 1, 3, // 1910: decode to VLOXSEG6EI64_V using decoder 3
2089 // 1910: }
2090 6, 7, // 1915: case 0x6: {
2091 OPC_CheckPredicate, 30, // 1917: check predicate 30
2092 OPC_Decode, 154, 128, 1, 3, // 1919: decode to VLOXSEG7EI64_V using decoder 3
2093 // 1919: }
2094 7, 0, // 1924: case 0x7: {
2095 OPC_CheckPredicate, 30, // 1926: check predicate 30
2096 OPC_Decode, 158, 128, 1, 3, // 1928: decode to VLOXSEG8EI64_V using decoder 3
2097 // 1928: }
2098 // 1928: } // switch Inst[31:29]
2099 // 1928: }
2100 4, 7, // 1933: case 0x4: {
2101 OPC_CheckPredicate, 31, // 1935: check predicate 31
2102 OPC_Decode, 217, 129, 1, 12, // 1937: decode to VMTL_V using decoder 12
2103 // 1937: }
2104 5, 0, // 1942: case 0x5: {
2105 OPC_CheckPredicate, 32, // 1944: check predicate 32
2106 OPC_Decode, 219, 129, 1, 12, // 1946: decode to VMTTL_V using decoder 12
2107 // 1946: }
2108 // 1946: } // switch Inst[28:26]
2109 // 1946: }
2110 // 1946: } // switch Inst[14:12]
2111 // 1946: }
2112 15, 76, // 1951: case 0xf: {
2113 OPC_SwitchField, 7, 8, // 1953: switch Inst[14:7] {
2114 0, 24, // 1956: case 0x0: {
2115 OPC_SwitchField, 28, 4, // 1958: switch Inst[31:28] {
2116 0, 8, // 1961: case 0x0: {
2117 OPC_CheckField, 15, 5, 0, // 1963: check Inst[19:15] == 0x0
2118 OPC_Decode, 137, 115, 13, // 1967: decode to FENCE using decoder 13
2119 // 1967: }
2120 8, 0, // 1971: case 0x8: {
2121 OPC_CheckField, 15, 13, 224, 12, // 1973: check Inst[27:15] == 0x660
2122 OPC_Decode, 139, 115, 14, // 1978: decode to FENCE_TSO using decoder 14
2123 // 1978: }
2124 // 1978: } // switch Inst[31:28]
2125 // 1978: }
2126 32, 8, // 1982: case 0x20: {
2127 OPC_CheckField, 15, 17, 0, // 1984: check Inst[31:15] == 0x0
2128 OPC_Decode, 138, 115, 14, // 1988: decode to FENCE_I using decoder 14
2129 // 1988: }
2130 64, 0, // 1992: case 0x40: {
2131 OPC_SwitchField, 20, 12, // 1994: switch Inst[31:20] {
2132 0, 6, // 1997: case 0x0: {
2133 OPC_CheckPredicate, 33, // 1999: check predicate 33
2134 OPC_Decode, 246, 110, 15, // 2001: decode to CBO_INVAL using decoder 15
2135 // 2001: }
2136 1, 6, // 2005: case 0x1: {
2137 OPC_CheckPredicate, 33, // 2007: check predicate 33
2138 OPC_Decode, 244, 110, 15, // 2009: decode to CBO_CLEAN using decoder 15
2139 // 2009: }
2140 2, 6, // 2013: case 0x2: {
2141 OPC_CheckPredicate, 33, // 2015: check predicate 33
2142 OPC_Decode, 245, 110, 15, // 2017: decode to CBO_FLUSH using decoder 15
2143 // 2017: }
2144 4, 0, // 2021: case 0x4: {
2145 OPC_CheckPredicate, 34, // 2023: check predicate 34
2146 OPC_Decode, 247, 110, 15, // 2025: decode to CBO_ZERO using decoder 15
2147 // 2025: }
2148 // 2025: } // switch Inst[31:20]
2149 // 2025: }
2150 // 2025: } // switch Inst[14:7]
2151 // 2025: }
2152 19, 149, 3, // 2029: case 0x13: {
2153 OPC_SwitchField, 12, 3, // 2032: switch Inst[14:12] {
2154 0, 4, // 2035: case 0x0: {
2155 OPC_Decode, 209, 107, 0, // 2037: decode to ADDI using decoder 0
2156 // 2037: }
2157 1, 217, 1, // 2041: case 0x1: {
2158 OPC_SwitchField, 26, 6, // 2044: switch Inst[31:26] {
2159 0, 4, // 2047: case 0x0: {
2160 OPC_Decode, 218, 124, 16, // 2049: decode to SLLI using decoder 16
2161 // 2049: }
2162 2, 11, // 2053: case 0x2: {
2163 OPC_CheckPredicate, 35, // 2055: check predicate 35
2164 OPC_CheckField, 20, 6, 15, // 2057: check Inst[25:20] == 0xf
2165 OPC_Decode, 198, 132, 1, 17, // 2061: decode to ZIP_RV32 using decoder 17
2166 // 2061: }
2167 4, 83, // 2066: case 0x4: {
2168 OPC_SwitchField, 20, 6, // 2068: switch Inst[25:20] {
2169 0, 6, // 2071: case 0x0: {
2170 OPC_CheckPredicate, 36, // 2073: check predicate 36
2171 OPC_Decode, 197, 124, 17, // 2075: decode to SHA256SUM0 using decoder 17
2172 // 2075: }
2173 1, 6, // 2079: case 0x1: {
2174 OPC_CheckPredicate, 36, // 2081: check predicate 36
2175 OPC_Decode, 198, 124, 17, // 2083: decode to SHA256SUM1 using decoder 17
2176 // 2083: }
2177 2, 6, // 2087: case 0x2: {
2178 OPC_CheckPredicate, 36, // 2089: check predicate 36
2179 OPC_Decode, 195, 124, 17, // 2091: decode to SHA256SIG0 using decoder 17
2180 // 2091: }
2181 3, 6, // 2095: case 0x3: {
2182 OPC_CheckPredicate, 36, // 2097: check predicate 36
2183 OPC_Decode, 196, 124, 17, // 2099: decode to SHA256SIG1 using decoder 17
2184 // 2099: }
2185 4, 6, // 2103: case 0x4: {
2186 OPC_CheckPredicate, 37, // 2105: check predicate 37
2187 OPC_Decode, 205, 124, 17, // 2107: decode to SHA512SUM0 using decoder 17
2188 // 2107: }
2189 5, 6, // 2111: case 0x5: {
2190 OPC_CheckPredicate, 37, // 2113: check predicate 37
2191 OPC_Decode, 207, 124, 17, // 2115: decode to SHA512SUM1 using decoder 17
2192 // 2115: }
2193 6, 6, // 2119: case 0x6: {
2194 OPC_CheckPredicate, 37, // 2121: check predicate 37
2195 OPC_Decode, 199, 124, 17, // 2123: decode to SHA512SIG0 using decoder 17
2196 // 2123: }
2197 7, 6, // 2127: case 0x7: {
2198 OPC_CheckPredicate, 37, // 2129: check predicate 37
2199 OPC_Decode, 202, 124, 17, // 2131: decode to SHA512SIG1 using decoder 17
2200 // 2131: }
2201 8, 6, // 2135: case 0x8: {
2202 OPC_CheckPredicate, 38, // 2137: check predicate 38
2203 OPC_Decode, 227, 124, 17, // 2139: decode to SM3P0 using decoder 17
2204 // 2139: }
2205 9, 0, // 2143: case 0x9: {
2206 OPC_CheckPredicate, 38, // 2145: check predicate 38
2207 OPC_Decode, 228, 124, 17, // 2147: decode to SM3P1 using decoder 17
2208 // 2147: }
2209 // 2147: } // switch Inst[25:20]
2210 // 2147: }
2211 10, 6, // 2151: case 0xa: {
2212 OPC_CheckPredicate, 39, // 2153: check predicate 39
2213 OPC_Decode, 243, 110, 16, // 2155: decode to BSETI using decoder 16
2214 // 2155: }
2215 12, 23, // 2159: case 0xc: {
2216 OPC_SwitchField, 24, 2, // 2161: switch Inst[25:24] {
2217 0, 10, // 2164: case 0x0: {
2218 OPC_CheckPredicate, 40, // 2166: check predicate 40
2219 OPC_CheckField, 20, 4, 0, // 2168: check Inst[23:20] == 0x0
2220 OPC_Decode, 221, 107, 17, // 2172: decode to AES64IM using decoder 17
2221 // 2172: }
2222 1, 0, // 2176: case 0x1: {
2223 OPC_CheckPredicate, 41, // 2178: check predicate 41
2224 OPC_Decode, 222, 107, 18, // 2180: decode to AES64KS1I using decoder 18
2225 // 2180: }
2226 // 2180: } // switch Inst[25:24]
2227 // 2180: }
2228 18, 6, // 2184: case 0x12: {
2229 OPC_CheckPredicate, 39, // 2186: check predicate 39
2230 OPC_Decode, 228, 110, 16, // 2188: decode to BCLRI using decoder 16
2231 // 2188: }
2232 24, 59, // 2192: case 0x18: {
2233 OPC_SwitchField, 20, 6, // 2194: switch Inst[25:20] {
2234 0, 6, // 2197: case 0x0: {
2235 OPC_CheckPredicate, 42, // 2199: check predicate 42
2236 OPC_Decode, 253, 110, 17, // 2201: decode to CLZ using decoder 17
2237 // 2201: }
2238 1, 6, // 2205: case 0x1: {
2239 OPC_CheckPredicate, 42, // 2207: check predicate 42
2240 OPC_Decode, 143, 111, 17, // 2209: decode to CTZ using decoder 17
2241 // 2209: }
2242 2, 6, // 2213: case 0x2: {
2243 OPC_CheckPredicate, 42, // 2215: check predicate 42
2244 OPC_Decode, 135, 111, 17, // 2217: decode to CPOP using decoder 17
2245 // 2217: }
2246 3, 6, // 2221: case 0x3: {
2247 OPC_CheckPredicate, 43, // 2223: check predicate 43
2248 OPC_Decode, 251, 110, 17, // 2225: decode to CLS using decoder 17
2249 // 2225: }
2250 4, 6, // 2229: case 0x4: {
2251 OPC_CheckPredicate, 42, // 2231: check predicate 42
2252 OPC_Decode, 242, 123, 17, // 2233: decode to SEXT_B using decoder 17
2253 // 2233: }
2254 5, 6, // 2237: case 0x5: {
2255 OPC_CheckPredicate, 42, // 2239: check predicate 42
2256 OPC_Decode, 243, 123, 17, // 2241: decode to SEXT_H using decoder 17
2257 // 2241: }
2258 7, 0, // 2245: case 0x7: {
2259 OPC_CheckPredicate, 43, // 2247: check predicate 43
2260 OPC_Decode, 205, 107, 17, // 2249: decode to ABS using decoder 17
2261 // 2249: }
2262 // 2249: } // switch Inst[25:20]
2263 // 2249: }
2264 26, 0, // 2253: case 0x1a: {
2265 OPC_CheckPredicate, 39, // 2255: check predicate 39
2266 OPC_Decode, 236, 110, 16, // 2257: decode to BINVI using decoder 16
2267 // 2257: }
2268 // 2257: } // switch Inst[31:26]
2269 // 2257: }
2270 2, 4, // 2261: case 0x2: {
2271 OPC_Decode, 223, 124, 0, // 2263: decode to SLTI using decoder 0
2272 // 2263: }
2273 3, 4, // 2267: case 0x3: {
2274 OPC_Decode, 224, 124, 0, // 2269: decode to SLTIU using decoder 0
2275 // 2269: }
2276 4, 5, // 2273: case 0x4: {
2277 OPC_Decode, 163, 132, 1, 0, // 2275: decode to XORI using decoder 0
2278 // 2275: }
2279 5, 108, // 2280: case 0x5: {
2280 OPC_SwitchField, 26, 6, // 2282: switch Inst[31:26] {
2281 0, 4, // 2285: case 0x0: {
2282 OPC_Decode, 161, 125, 16, // 2287: decode to SRLI using decoder 16
2283 // 2287: }
2284 2, 10, // 2291: case 0x2: {
2285 OPC_CheckPredicate, 35, // 2293: check predicate 35
2286 OPC_CheckField, 20, 6, 15, // 2295: check Inst[25:20] == 0xf
2287 OPC_Decode, 177, 126, 17, // 2299: decode to UNZIP_RV32 using decoder 17
2288 // 2299: }
2289 10, 10, // 2303: case 0xa: {
2290 OPC_CheckPredicate, 42, // 2305: check predicate 42
2291 OPC_CheckField, 20, 6, 7, // 2307: check Inst[25:20] == 0x7
2292 OPC_Decode, 211, 118, 17, // 2311: decode to ORC_B using decoder 17
2293 // 2311: }
2294 16, 4, // 2315: case 0x10: {
2295 OPC_Decode, 154, 125, 16, // 2317: decode to SRAI using decoder 16
2296 // 2317: }
2297 18, 6, // 2321: case 0x12: {
2298 OPC_CheckPredicate, 39, // 2323: check predicate 39
2299 OPC_Decode, 232, 110, 16, // 2325: decode to BEXTI using decoder 16
2300 // 2325: }
2301 24, 6, // 2329: case 0x18: {
2302 OPC_CheckPredicate, 44, // 2331: check predicate 44
2303 OPC_Decode, 217, 123, 16, // 2333: decode to RORI using decoder 16
2304 // 2333: }
2305 26, 0, // 2337: case 0x1a: {
2306 OPC_SwitchField, 20, 6, // 2339: switch Inst[25:20] {
2307 7, 6, // 2342: case 0x7: {
2308 OPC_CheckPredicate, 45, // 2344: check predicate 45
2309 OPC_Decode, 241, 110, 17, // 2346: decode to BREV8 using decoder 17
2310 // 2346: }
2311 24, 6, // 2350: case 0x18: {
2312 OPC_CheckPredicate, 46, // 2352: check predicate 46
2313 OPC_Decode, 210, 123, 17, // 2354: decode to REV8_RV32 using decoder 17
2314 // 2354: }
2315 31, 6, // 2358: case 0x1f: {
2316 OPC_CheckPredicate, 47, // 2360: check predicate 47
2317 OPC_Decode, 212, 123, 17, // 2362: decode to REV_RV32 using decoder 17
2318 // 2362: }
2319 48, 6, // 2366: case 0x30: {
2320 OPC_CheckPredicate, 48, // 2368: check predicate 48
2321 OPC_Decode, 209, 123, 17, // 2370: decode to REV16_RV64 using decoder 17
2322 // 2370: }
2323 56, 6, // 2374: case 0x38: {
2324 OPC_CheckPredicate, 49, // 2376: check predicate 49
2325 OPC_Decode, 211, 123, 17, // 2378: decode to REV8_RV64 using decoder 17
2326 // 2378: }
2327 63, 0, // 2382: case 0x3f: {
2328 OPC_CheckPredicate, 48, // 2384: check predicate 48
2329 OPC_Decode, 213, 123, 17, // 2386: decode to REV_RV64 using decoder 17
2330 // 2386: }
2331 // 2386: } // switch Inst[25:20]
2332 // 2386: }
2333 // 2386: } // switch Inst[31:26]
2334 // 2386: }
2335 6, 39, // 2390: case 0x6: {
2336 OPC_Scope, 33, // 2392: try {
2337 OPC_SwitchField, 20, 5, // 2394: switch Inst[24:20] {
2338 0, 8, // 2397: case 0x0: {
2339 OPC_CheckField, 7, 5, 0, // 2399: check Inst[11:7] == 0x0
2340 OPC_Decode, 135, 121, 19, // 2403: decode to PREFETCH_I using decoder 19
2341 // 2403: }
2342 1, 8, // 2407: case 0x1: {
2343 OPC_CheckField, 7, 5, 0, // 2409: check Inst[11:7] == 0x0
2344 OPC_Decode, 136, 121, 19, // 2413: decode to PREFETCH_R using decoder 19
2345 // 2413: }
2346 3, 0, // 2417: case 0x3: {
2347 OPC_CheckField, 7, 5, 0, // 2419: check Inst[11:7] == 0x0
2348 OPC_Decode, 137, 121, 19, // 2423: decode to PREFETCH_W using decoder 19
2349 // 2423: }
2350 // 2423: } // switch Inst[24:20]
2351 // 2423: } else try {
2352 OPC_Decode, 212, 118, 0, // 2427: decode to ORI using decoder 0
2353 // 2427: }
2354 // 2427: }
2355 7, 0, // 2431: case 0x7: {
2356 OPC_Decode, 222, 110, 0, // 2433: decode to ANDI using decoder 0
2357 // 2433: }
2358 // 2433: } // switch Inst[14:12]
2359 // 2433: }
2360 23, 4, // 2437: case 0x17: {
2361 OPC_Decode, 226, 110, 20, // 2439: decode to AUIPC using decoder 20
2362 // 2439: }
2363 27, 195, 35, // 2443: case 0x1b: {
2364 OPC_SwitchField, 12, 3, // 2446: switch Inst[14:12] {
2365 0, 6, // 2449: case 0x0: {
2366 OPC_CheckPredicate, 22, // 2451: check predicate 22
2367 OPC_Decode, 210, 107, 0, // 2453: decode to ADDIW using decoder 0
2368 // 2453: }
2369 1, 68, // 2457: case 0x1: {
2370 OPC_SwitchField, 26, 6, // 2459: switch Inst[31:26] {
2371 0, 10, // 2462: case 0x0: {
2372 OPC_CheckPredicate, 22, // 2464: check predicate 22
2373 OPC_CheckField, 25, 1, 0, // 2466: check Inst[25] == 0x0
2374 OPC_Decode, 219, 124, 21, // 2470: decode to SLLIW using decoder 21
2375 // 2470: }
2376 2, 6, // 2474: case 0x2: {
2377 OPC_CheckPredicate, 50, // 2476: check predicate 50
2378 OPC_Decode, 220, 124, 16, // 2478: decode to SLLI_UW using decoder 16
2379 // 2478: }
2380 24, 0, // 2482: case 0x18: {
2381 OPC_SwitchField, 20, 6, // 2484: switch Inst[25:20] {
2382 0, 6, // 2487: case 0x0: {
2383 OPC_CheckPredicate, 51, // 2489: check predicate 51
2384 OPC_Decode, 254, 110, 17, // 2491: decode to CLZW using decoder 17
2385 // 2491: }
2386 1, 6, // 2495: case 0x1: {
2387 OPC_CheckPredicate, 51, // 2497: check predicate 51
2388 OPC_Decode, 144, 111, 17, // 2499: decode to CTZW using decoder 17
2389 // 2499: }
2390 2, 6, // 2503: case 0x2: {
2391 OPC_CheckPredicate, 51, // 2505: check predicate 51
2392 OPC_Decode, 136, 111, 17, // 2507: decode to CPOPW using decoder 17
2393 // 2507: }
2394 3, 6, // 2511: case 0x3: {
2395 OPC_CheckPredicate, 48, // 2513: check predicate 48
2396 OPC_Decode, 252, 110, 17, // 2515: decode to CLSW using decoder 17
2397 // 2515: }
2398 7, 0, // 2519: case 0x7: {
2399 OPC_CheckPredicate, 48, // 2521: check predicate 48
2400 OPC_Decode, 206, 107, 17, // 2523: decode to ABSW using decoder 17
2401 // 2523: }
2402 // 2523: } // switch Inst[25:20]
2403 // 2523: }
2404 // 2523: } // switch Inst[31:26]
2405 // 2523: }
2406 2, 209, 10, // 2527: case 0x2: {
2407 OPC_SwitchField, 26, 6, // 2530: switch Inst[31:26] {
2408 0, 50, // 2533: case 0x0: {
2409 OPC_SwitchField, 7, 1, // 2535: switch Inst[7] {
2410 0, 23, // 2538: case 0x0: {
2411 OPC_SwitchField, 25, 1, // 2540: switch Inst[25] {
2412 0, 10, // 2543: case 0x0: {
2413 OPC_CheckPredicate, 47, // 2545: check predicate 47
2414 OPC_CheckField, 24, 1, 1, // 2547: check Inst[24] == 0x1
2415 OPC_Decode, 156, 122, 22, // 2551: decode to PWSLLI_B using decoder 22
2416 // 2551: }
2417 1, 0, // 2555: case 0x1: {
2418 OPC_CheckPredicate, 47, // 2557: check predicate 47
2419 OPC_Decode, 157, 122, 23, // 2559: decode to PWSLLI_H using decoder 23
2420 // 2559: }
2421 // 2559: } // switch Inst[25]
2422 // 2559: }
2423 1, 0, // 2563: case 0x1: {
2424 OPC_SwitchField, 25, 1, // 2565: switch Inst[25] {
2425 0, 6, // 2568: case 0x0: {
2426 OPC_CheckPredicate, 47, // 2570: check predicate 47
2427 OPC_Decode, 142, 122, 24, // 2572: decode to PWADD_H using decoder 24
2428 // 2572: }
2429 1, 0, // 2576: case 0x1: {
2430 OPC_CheckPredicate, 47, // 2578: check predicate 47
2431 OPC_Decode, 138, 132, 1, 24, // 2580: decode to WADD using decoder 24
2432 // 2580: }
2433 // 2580: } // switch Inst[25]
2434 // 2580: }
2435 // 2580: } // switch Inst[7]
2436 // 2580: }
2437 1, 33, // 2585: case 0x1: {
2438 OPC_SwitchField, 7, 1, // 2587: switch Inst[7] {
2439 0, 7, // 2590: case 0x0: {
2440 OPC_CheckPredicate, 47, // 2592: check predicate 47
2441 OPC_Decode, 154, 132, 1, 25, // 2594: decode to WSLLI using decoder 25
2442 // 2594: }
2443 1, 0, // 2599: case 0x1: {
2444 OPC_SwitchField, 25, 1, // 2601: switch Inst[25] {
2445 0, 6, // 2604: case 0x0: {
2446 OPC_CheckPredicate, 47, // 2606: check predicate 47
2447 OPC_Decode, 141, 122, 24, // 2608: decode to PWADD_B using decoder 24
2448 // 2608: }
2449 1, 0, // 2612: case 0x1: {
2450 OPC_CheckPredicate, 47, // 2614: check predicate 47
2451 OPC_Decode, 184, 119, 24, // 2616: decode to PM2WADD_H using decoder 24
2452 // 2616: }
2453 // 2616: } // switch Inst[25]
2454 // 2616: }
2455 // 2616: } // switch Inst[7]
2456 // 2616: }
2457 2, 46, // 2620: case 0x2: {
2458 OPC_SwitchField, 7, 1, // 2622: switch Inst[7] {
2459 0, 19, // 2625: case 0x0: {
2460 OPC_SwitchField, 25, 1, // 2627: switch Inst[25] {
2461 0, 6, // 2630: case 0x0: {
2462 OPC_CheckPredicate, 47, // 2632: check predicate 47
2463 OPC_Decode, 158, 122, 24, // 2634: decode to PWSLL_BS using decoder 24
2464 // 2634: }
2465 1, 0, // 2638: case 0x1: {
2466 OPC_CheckPredicate, 47, // 2640: check predicate 47
2467 OPC_Decode, 159, 122, 24, // 2642: decode to PWSLL_HS using decoder 24
2468 // 2642: }
2469 // 2642: } // switch Inst[25]
2470 // 2642: }
2471 1, 0, // 2646: case 0x1: {
2472 OPC_SwitchField, 25, 1, // 2648: switch Inst[25] {
2473 0, 6, // 2651: case 0x0: {
2474 OPC_CheckPredicate, 47, // 2653: check predicate 47
2475 OPC_Decode, 138, 122, 26, // 2655: decode to PWADDA_H using decoder 26
2476 // 2655: }
2477 1, 0, // 2659: case 0x1: {
2478 OPC_CheckPredicate, 47, // 2661: check predicate 47
2479 OPC_Decode, 139, 132, 1, 26, // 2663: decode to WADDA using decoder 26
2480 // 2663: }
2481 // 2663: } // switch Inst[25]
2482 // 2663: }
2483 // 2663: } // switch Inst[7]
2484 // 2663: }
2485 3, 37, // 2668: case 0x3: {
2486 OPC_SwitchField, 7, 1, // 2670: switch Inst[7] {
2487 0, 11, // 2673: case 0x0: {
2488 OPC_CheckPredicate, 47, // 2675: check predicate 47
2489 OPC_CheckField, 25, 1, 1, // 2677: check Inst[25] == 0x1
2490 OPC_Decode, 153, 132, 1, 24, // 2681: decode to WSLL using decoder 24
2491 // 2681: }
2492 1, 0, // 2686: case 0x1: {
2493 OPC_SwitchField, 25, 1, // 2688: switch Inst[25] {
2494 0, 6, // 2691: case 0x0: {
2495 OPC_CheckPredicate, 47, // 2693: check predicate 47
2496 OPC_Decode, 137, 122, 26, // 2695: decode to PWADDA_B using decoder 26
2497 // 2695: }
2498 1, 0, // 2699: case 0x1: {
2499 OPC_CheckPredicate, 47, // 2701: check predicate 47
2500 OPC_Decode, 180, 119, 26, // 2703: decode to PM2WADDA_H using decoder 26
2501 // 2703: }
2502 // 2703: } // switch Inst[25]
2503 // 2703: }
2504 // 2703: } // switch Inst[7]
2505 // 2703: }
2506 4, 28, // 2707: case 0x4: {
2507 OPC_SwitchField, 25, 1, // 2709: switch Inst[25] {
2508 0, 10, // 2712: case 0x0: {
2509 OPC_CheckPredicate, 47, // 2714: check predicate 47
2510 OPC_CheckField, 7, 1, 1, // 2716: check Inst[7] == 0x1
2511 OPC_Decode, 140, 122, 24, // 2720: decode to PWADDU_H using decoder 24
2512 // 2720: }
2513 1, 0, // 2724: case 0x1: {
2514 OPC_CheckPredicate, 47, // 2726: check predicate 47
2515 OPC_CheckField, 7, 1, 1, // 2728: check Inst[7] == 0x1
2516 OPC_Decode, 141, 132, 1, 24, // 2732: decode to WADDU using decoder 24
2517 // 2732: }
2518 // 2732: } // switch Inst[25]
2519 // 2732: }
2520 5, 27, // 2737: case 0x5: {
2521 OPC_SwitchField, 25, 1, // 2739: switch Inst[25] {
2522 0, 10, // 2742: case 0x0: {
2523 OPC_CheckPredicate, 47, // 2744: check predicate 47
2524 OPC_CheckField, 7, 1, 1, // 2746: check Inst[7] == 0x1
2525 OPC_Decode, 139, 122, 24, // 2750: decode to PWADDU_B using decoder 24
2526 // 2750: }
2527 1, 0, // 2754: case 0x1: {
2528 OPC_CheckPredicate, 47, // 2756: check predicate 47
2529 OPC_CheckField, 7, 1, 1, // 2758: check Inst[7] == 0x1
2530 OPC_Decode, 185, 119, 24, // 2762: decode to PM2WADD_HX using decoder 24
2531 // 2762: }
2532 // 2762: } // switch Inst[25]
2533 // 2762: }
2534 6, 28, // 2766: case 0x6: {
2535 OPC_SwitchField, 25, 1, // 2768: switch Inst[25] {
2536 0, 10, // 2771: case 0x0: {
2537 OPC_CheckPredicate, 47, // 2773: check predicate 47
2538 OPC_CheckField, 7, 1, 1, // 2775: check Inst[7] == 0x1
2539 OPC_Decode, 136, 122, 26, // 2779: decode to PWADDAU_H using decoder 26
2540 // 2779: }
2541 1, 0, // 2783: case 0x1: {
2542 OPC_CheckPredicate, 47, // 2785: check predicate 47
2543 OPC_CheckField, 7, 1, 1, // 2787: check Inst[7] == 0x1
2544 OPC_Decode, 140, 132, 1, 26, // 2791: decode to WADDAU using decoder 26
2545 // 2791: }
2546 // 2791: } // switch Inst[25]
2547 // 2791: }
2548 7, 27, // 2796: case 0x7: {
2549 OPC_SwitchField, 25, 1, // 2798: switch Inst[25] {
2550 0, 10, // 2801: case 0x0: {
2551 OPC_CheckPredicate, 47, // 2803: check predicate 47
2552 OPC_CheckField, 7, 1, 1, // 2805: check Inst[7] == 0x1
2553 OPC_Decode, 135, 122, 26, // 2809: decode to PWADDAU_B using decoder 26
2554 // 2809: }
2555 1, 0, // 2813: case 0x1: {
2556 OPC_CheckPredicate, 47, // 2815: check predicate 47
2557 OPC_CheckField, 7, 1, 1, // 2817: check Inst[7] == 0x1
2558 OPC_Decode, 181, 119, 26, // 2821: decode to PM2WADDA_HX using decoder 26
2559 // 2821: }
2560 // 2821: } // switch Inst[25]
2561 // 2821: }
2562 8, 28, // 2825: case 0x8: {
2563 OPC_SwitchField, 25, 1, // 2827: switch Inst[25] {
2564 0, 10, // 2830: case 0x0: {
2565 OPC_CheckPredicate, 47, // 2832: check predicate 47
2566 OPC_CheckField, 7, 1, 1, // 2834: check Inst[7] == 0x1
2567 OPC_Decode, 151, 122, 24, // 2838: decode to PWMUL_H using decoder 24
2568 // 2838: }
2569 1, 0, // 2842: case 0x1: {
2570 OPC_CheckPredicate, 47, // 2844: check predicate 47
2571 OPC_CheckField, 7, 1, 1, // 2846: check Inst[7] == 0x1
2572 OPC_Decode, 146, 132, 1, 24, // 2850: decode to WMUL using decoder 24
2573 // 2850: }
2574 // 2850: } // switch Inst[25]
2575 // 2850: }
2576 9, 27, // 2855: case 0x9: {
2577 OPC_SwitchField, 25, 1, // 2857: switch Inst[25] {
2578 0, 10, // 2860: case 0x0: {
2579 OPC_CheckPredicate, 47, // 2862: check predicate 47
2580 OPC_CheckField, 7, 1, 1, // 2864: check Inst[7] == 0x1
2581 OPC_Decode, 150, 122, 24, // 2868: decode to PWMUL_B using decoder 24
2582 // 2868: }
2583 1, 0, // 2872: case 0x1: {
2584 OPC_CheckPredicate, 47, // 2874: check predicate 47
2585 OPC_CheckField, 7, 1, 1, // 2876: check Inst[7] == 0x1
2586 OPC_Decode, 183, 119, 24, // 2880: decode to PM2WADDU_H using decoder 24
2587 // 2880: }
2588 // 2880: } // switch Inst[25]
2589 // 2880: }
2590 10, 28, // 2884: case 0xa: {
2591 OPC_SwitchField, 25, 1, // 2886: switch Inst[25] {
2592 0, 10, // 2889: case 0x0: {
2593 OPC_CheckPredicate, 47, // 2891: check predicate 47
2594 OPC_CheckField, 7, 1, 1, // 2893: check Inst[7] == 0x1
2595 OPC_Decode, 145, 122, 26, // 2897: decode to PWMACC_H using decoder 26
2596 // 2897: }
2597 1, 0, // 2901: case 0x1: {
2598 OPC_CheckPredicate, 47, // 2903: check predicate 47
2599 OPC_CheckField, 7, 1, 1, // 2905: check Inst[7] == 0x1
2600 OPC_Decode, 143, 132, 1, 26, // 2909: decode to WMACC using decoder 26
2601 // 2909: }
2602 // 2909: } // switch Inst[25]
2603 // 2909: }
2604 11, 14, // 2914: case 0xb: {
2605 OPC_CheckPredicate, 47, // 2916: check predicate 47
2606 OPC_CheckField, 25, 1, 1, // 2918: check Inst[25] == 0x1
2607 OPC_CheckField, 7, 1, 1, // 2922: check Inst[7] == 0x1
2608 OPC_Decode, 179, 119, 26, // 2926: decode to PM2WADDAU_H using decoder 26
2609 // 2926: }
2610 12, 37, // 2930: case 0xc: {
2611 OPC_SwitchField, 7, 1, // 2932: switch Inst[7] {
2612 0, 10, // 2935: case 0x0: {
2613 OPC_CheckPredicate, 47, // 2937: check predicate 47
2614 OPC_CheckField, 25, 1, 0, // 2939: check Inst[25] == 0x0
2615 OPC_Decode, 146, 119, 27, // 2943: decode to PLI_DH using decoder 27
2616 // 2943: }
2617 1, 0, // 2947: case 0x1: {
2618 OPC_SwitchField, 25, 1, // 2949: switch Inst[25] {
2619 0, 6, // 2952: case 0x0: {
2620 OPC_CheckPredicate, 47, // 2954: check predicate 47
2621 OPC_Decode, 149, 122, 24, // 2956: decode to PWMULU_H using decoder 24
2622 // 2956: }
2623 1, 0, // 2960: case 0x1: {
2624 OPC_CheckPredicate, 47, // 2962: check predicate 47
2625 OPC_Decode, 148, 132, 1, 24, // 2964: decode to WMULU using decoder 24
2626 // 2964: }
2627 // 2964: } // switch Inst[25]
2628 // 2964: }
2629 // 2964: } // switch Inst[7]
2630 // 2964: }
2631 13, 31, // 2969: case 0xd: {
2632 OPC_SwitchField, 7, 1, // 2971: switch Inst[7] {
2633 0, 14, // 2974: case 0x0: {
2634 OPC_CheckPredicate, 47, // 2976: check predicate 47
2635 OPC_CheckField, 24, 2, 0, // 2978: check Inst[25:24] == 0x0
2636 OPC_CheckField, 15, 1, 0, // 2982: check Inst[15] == 0x0
2637 OPC_Decode, 145, 119, 28, // 2986: decode to PLI_DB using decoder 28
2638 // 2986: }
2639 1, 0, // 2990: case 0x1: {
2640 OPC_CheckPredicate, 47, // 2992: check predicate 47
2641 OPC_CheckField, 25, 1, 0, // 2994: check Inst[25] == 0x0
2642 OPC_Decode, 148, 122, 24, // 2998: decode to PWMULU_B using decoder 24
2643 // 2998: }
2644 // 2998: } // switch Inst[7]
2645 // 2998: }
2646 14, 28, // 3002: case 0xe: {
2647 OPC_SwitchField, 25, 1, // 3004: switch Inst[25] {
2648 0, 10, // 3007: case 0x0: {
2649 OPC_CheckPredicate, 47, // 3009: check predicate 47
2650 OPC_CheckField, 7, 1, 1, // 3011: check Inst[7] == 0x1
2651 OPC_Decode, 144, 122, 26, // 3015: decode to PWMACCU_H using decoder 26
2652 // 3015: }
2653 1, 0, // 3019: case 0x1: {
2654 OPC_CheckPredicate, 47, // 3021: check predicate 47
2655 OPC_CheckField, 7, 1, 1, // 3023: check Inst[7] == 0x1
2656 OPC_Decode, 145, 132, 1, 26, // 3027: decode to WMACCU using decoder 26
2657 // 3027: }
2658 // 3027: } // switch Inst[25]
2659 // 3027: }
2660 16, 50, // 3032: case 0x10: {
2661 OPC_SwitchField, 7, 1, // 3034: switch Inst[7] {
2662 0, 23, // 3037: case 0x0: {
2663 OPC_SwitchField, 25, 1, // 3039: switch Inst[25] {
2664 0, 10, // 3042: case 0x0: {
2665 OPC_CheckPredicate, 47, // 3044: check predicate 47
2666 OPC_CheckField, 24, 1, 1, // 3046: check Inst[24] == 0x1
2667 OPC_Decode, 152, 122, 22, // 3050: decode to PWSLAI_B using decoder 22
2668 // 3050: }
2669 1, 0, // 3054: case 0x1: {
2670 OPC_CheckPredicate, 47, // 3056: check predicate 47
2671 OPC_Decode, 153, 122, 23, // 3058: decode to PWSLAI_H using decoder 23
2672 // 3058: }
2673 // 3058: } // switch Inst[25]
2674 // 3058: }
2675 1, 0, // 3062: case 0x1: {
2676 OPC_SwitchField, 25, 1, // 3064: switch Inst[25] {
2677 0, 6, // 3067: case 0x0: {
2678 OPC_CheckPredicate, 47, // 3069: check predicate 47
2679 OPC_Decode, 167, 122, 24, // 3071: decode to PWSUB_H using decoder 24
2680 // 3071: }
2681 1, 0, // 3075: case 0x1: {
2682 OPC_CheckPredicate, 47, // 3077: check predicate 47
2683 OPC_Decode, 155, 132, 1, 24, // 3079: decode to WSUB using decoder 24
2684 // 3079: }
2685 // 3079: } // switch Inst[25]
2686 // 3079: }
2687 // 3079: } // switch Inst[7]
2688 // 3079: }
2689 17, 33, // 3084: case 0x11: {
2690 OPC_SwitchField, 7, 1, // 3086: switch Inst[7] {
2691 0, 7, // 3089: case 0x0: {
2692 OPC_CheckPredicate, 47, // 3091: check predicate 47
2693 OPC_Decode, 152, 132, 1, 25, // 3093: decode to WSLAI using decoder 25
2694 // 3093: }
2695 1, 0, // 3098: case 0x1: {
2696 OPC_SwitchField, 25, 1, // 3100: switch Inst[25] {
2697 0, 6, // 3103: case 0x0: {
2698 OPC_CheckPredicate, 47, // 3105: check predicate 47
2699 OPC_Decode, 166, 122, 24, // 3107: decode to PWSUB_B using decoder 24
2700 // 3107: }
2701 1, 0, // 3111: case 0x1: {
2702 OPC_CheckPredicate, 47, // 3113: check predicate 47
2703 OPC_Decode, 188, 119, 24, // 3115: decode to PM2WSUB_H using decoder 24
2704 // 3115: }
2705 // 3115: } // switch Inst[25]
2706 // 3115: }
2707 // 3115: } // switch Inst[7]
2708 // 3115: }
2709 18, 46, // 3119: case 0x12: {
2710 OPC_SwitchField, 7, 1, // 3121: switch Inst[7] {
2711 0, 19, // 3124: case 0x0: {
2712 OPC_SwitchField, 25, 1, // 3126: switch Inst[25] {
2713 0, 6, // 3129: case 0x0: {
2714 OPC_CheckPredicate, 47, // 3131: check predicate 47
2715 OPC_Decode, 154, 122, 24, // 3133: decode to PWSLA_BS using decoder 24
2716 // 3133: }
2717 1, 0, // 3137: case 0x1: {
2718 OPC_CheckPredicate, 47, // 3139: check predicate 47
2719 OPC_Decode, 155, 122, 24, // 3141: decode to PWSLA_HS using decoder 24
2720 // 3141: }
2721 // 3141: } // switch Inst[25]
2722 // 3141: }
2723 1, 0, // 3145: case 0x1: {
2724 OPC_SwitchField, 25, 1, // 3147: switch Inst[25] {
2725 0, 6, // 3150: case 0x0: {
2726 OPC_CheckPredicate, 47, // 3152: check predicate 47
2727 OPC_Decode, 163, 122, 26, // 3154: decode to PWSUBA_H using decoder 26
2728 // 3154: }
2729 1, 0, // 3158: case 0x1: {
2730 OPC_CheckPredicate, 47, // 3160: check predicate 47
2731 OPC_Decode, 156, 132, 1, 26, // 3162: decode to WSUBA using decoder 26
2732 // 3162: }
2733 // 3162: } // switch Inst[25]
2734 // 3162: }
2735 // 3162: } // switch Inst[7]
2736 // 3162: }
2737 19, 37, // 3167: case 0x13: {
2738 OPC_SwitchField, 7, 1, // 3169: switch Inst[7] {
2739 0, 11, // 3172: case 0x0: {
2740 OPC_CheckPredicate, 47, // 3174: check predicate 47
2741 OPC_CheckField, 25, 1, 1, // 3176: check Inst[25] == 0x1
2742 OPC_Decode, 151, 132, 1, 24, // 3180: decode to WSLA using decoder 24
2743 // 3180: }
2744 1, 0, // 3185: case 0x1: {
2745 OPC_SwitchField, 25, 1, // 3187: switch Inst[25] {
2746 0, 6, // 3190: case 0x0: {
2747 OPC_CheckPredicate, 47, // 3192: check predicate 47
2748 OPC_Decode, 162, 122, 26, // 3194: decode to PWSUBA_B using decoder 26
2749 // 3194: }
2750 1, 0, // 3198: case 0x1: {
2751 OPC_CheckPredicate, 47, // 3200: check predicate 47
2752 OPC_Decode, 186, 119, 26, // 3202: decode to PM2WSUBA_H using decoder 26
2753 // 3202: }
2754 // 3202: } // switch Inst[25]
2755 // 3202: }
2756 // 3202: } // switch Inst[7]
2757 // 3202: }
2758 20, 28, // 3206: case 0x14: {
2759 OPC_SwitchField, 25, 1, // 3208: switch Inst[25] {
2760 0, 10, // 3211: case 0x0: {
2761 OPC_CheckPredicate, 47, // 3213: check predicate 47
2762 OPC_CheckField, 7, 1, 1, // 3215: check Inst[7] == 0x1
2763 OPC_Decode, 165, 122, 24, // 3219: decode to PWSUBU_H using decoder 24
2764 // 3219: }
2765 1, 0, // 3223: case 0x1: {
2766 OPC_CheckPredicate, 47, // 3225: check predicate 47
2767 OPC_CheckField, 7, 1, 1, // 3227: check Inst[7] == 0x1
2768 OPC_Decode, 158, 132, 1, 24, // 3231: decode to WSUBU using decoder 24
2769 // 3231: }
2770 // 3231: } // switch Inst[25]
2771 // 3231: }
2772 21, 27, // 3236: case 0x15: {
2773 OPC_SwitchField, 25, 1, // 3238: switch Inst[25] {
2774 0, 10, // 3241: case 0x0: {
2775 OPC_CheckPredicate, 47, // 3243: check predicate 47
2776 OPC_CheckField, 7, 1, 1, // 3245: check Inst[7] == 0x1
2777 OPC_Decode, 164, 122, 24, // 3249: decode to PWSUBU_B using decoder 24
2778 // 3249: }
2779 1, 0, // 3253: case 0x1: {
2780 OPC_CheckPredicate, 47, // 3255: check predicate 47
2781 OPC_CheckField, 7, 1, 1, // 3257: check Inst[7] == 0x1
2782 OPC_Decode, 189, 119, 24, // 3261: decode to PM2WSUB_HX using decoder 24
2783 // 3261: }
2784 // 3261: } // switch Inst[25]
2785 // 3261: }
2786 22, 28, // 3265: case 0x16: {
2787 OPC_SwitchField, 25, 1, // 3267: switch Inst[25] {
2788 0, 10, // 3270: case 0x0: {
2789 OPC_CheckPredicate, 47, // 3272: check predicate 47
2790 OPC_CheckField, 7, 1, 1, // 3274: check Inst[7] == 0x1
2791 OPC_Decode, 161, 122, 26, // 3278: decode to PWSUBAU_H using decoder 26
2792 // 3278: }
2793 1, 0, // 3282: case 0x1: {
2794 OPC_CheckPredicate, 47, // 3284: check predicate 47
2795 OPC_CheckField, 7, 1, 1, // 3286: check Inst[7] == 0x1
2796 OPC_Decode, 157, 132, 1, 26, // 3290: decode to WSUBAU using decoder 26
2797 // 3290: }
2798 // 3290: } // switch Inst[25]
2799 // 3290: }
2800 23, 27, // 3295: case 0x17: {
2801 OPC_SwitchField, 25, 1, // 3297: switch Inst[25] {
2802 0, 10, // 3300: case 0x0: {
2803 OPC_CheckPredicate, 47, // 3302: check predicate 47
2804 OPC_CheckField, 7, 1, 1, // 3304: check Inst[7] == 0x1
2805 OPC_Decode, 160, 122, 26, // 3308: decode to PWSUBAU_B using decoder 26
2806 // 3308: }
2807 1, 0, // 3312: case 0x1: {
2808 OPC_CheckPredicate, 47, // 3314: check predicate 47
2809 OPC_CheckField, 7, 1, 1, // 3316: check Inst[7] == 0x1
2810 OPC_Decode, 187, 119, 26, // 3320: decode to PM2WSUBA_HX using decoder 26
2811 // 3320: }
2812 // 3320: } // switch Inst[25]
2813 // 3320: }
2814 24, 28, // 3324: case 0x18: {
2815 OPC_SwitchField, 25, 1, // 3326: switch Inst[25] {
2816 0, 10, // 3329: case 0x0: {
2817 OPC_CheckPredicate, 47, // 3331: check predicate 47
2818 OPC_CheckField, 7, 1, 1, // 3333: check Inst[7] == 0x1
2819 OPC_Decode, 147, 122, 24, // 3337: decode to PWMULSU_H using decoder 24
2820 // 3337: }
2821 1, 0, // 3341: case 0x1: {
2822 OPC_CheckPredicate, 47, // 3343: check predicate 47
2823 OPC_CheckField, 7, 1, 1, // 3345: check Inst[7] == 0x1
2824 OPC_Decode, 147, 132, 1, 24, // 3349: decode to WMULSU using decoder 24
2825 // 3349: }
2826 // 3349: } // switch Inst[25]
2827 // 3349: }
2828 25, 27, // 3354: case 0x19: {
2829 OPC_SwitchField, 25, 1, // 3356: switch Inst[25] {
2830 0, 10, // 3359: case 0x0: {
2831 OPC_CheckPredicate, 47, // 3361: check predicate 47
2832 OPC_CheckField, 7, 1, 1, // 3363: check Inst[7] == 0x1
2833 OPC_Decode, 146, 122, 24, // 3367: decode to PWMULSU_B using decoder 24
2834 // 3367: }
2835 1, 0, // 3371: case 0x1: {
2836 OPC_CheckPredicate, 47, // 3373: check predicate 47
2837 OPC_CheckField, 7, 1, 1, // 3375: check Inst[7] == 0x1
2838 OPC_Decode, 182, 119, 24, // 3379: decode to PM2WADDSU_H using decoder 24
2839 // 3379: }
2840 // 3379: } // switch Inst[25]
2841 // 3379: }
2842 26, 28, // 3383: case 0x1a: {
2843 OPC_SwitchField, 25, 1, // 3385: switch Inst[25] {
2844 0, 10, // 3388: case 0x0: {
2845 OPC_CheckPredicate, 47, // 3390: check predicate 47
2846 OPC_CheckField, 7, 1, 1, // 3392: check Inst[7] == 0x1
2847 OPC_Decode, 143, 122, 26, // 3396: decode to PWMACCSU_H using decoder 26
2848 // 3396: }
2849 1, 0, // 3400: case 0x1: {
2850 OPC_CheckPredicate, 47, // 3402: check predicate 47
2851 OPC_CheckField, 7, 1, 1, // 3404: check Inst[7] == 0x1
2852 OPC_Decode, 144, 132, 1, 26, // 3408: decode to WMACCSU using decoder 26
2853 // 3408: }
2854 // 3408: } // switch Inst[25]
2855 // 3408: }
2856 27, 14, // 3413: case 0x1b: {
2857 OPC_CheckPredicate, 47, // 3415: check predicate 47
2858 OPC_CheckField, 25, 1, 1, // 3417: check Inst[25] == 0x1
2859 OPC_CheckField, 7, 1, 1, // 3421: check Inst[7] == 0x1
2860 OPC_Decode, 178, 119, 26, // 3425: decode to PM2WADDASU_H using decoder 26
2861 // 3425: }
2862 28, 14, // 3429: case 0x1c: {
2863 OPC_CheckPredicate, 47, // 3431: check predicate 47
2864 OPC_CheckField, 25, 1, 0, // 3433: check Inst[25] == 0x0
2865 OPC_CheckField, 7, 1, 0, // 3437: check Inst[7] == 0x0
2866 OPC_Decode, 149, 119, 29, // 3441: decode to PLUI_DH using decoder 29
2867 // 3441: }
2868 30, 47, // 3445: case 0x1e: {
2869 OPC_SwitchField, 7, 1, // 3447: switch Inst[7] {
2870 0, 21, // 3450: case 0x0: {
2871 OPC_SwitchField, 25, 1, // 3452: switch Inst[25] {
2872 0, 7, // 3455: case 0x0: {
2873 OPC_CheckPredicate, 47, // 3457: check predicate 47
2874 OPC_Decode, 160, 132, 1, 24, // 3459: decode to WZIP8P using decoder 24
2875 // 3459: }
2876 1, 0, // 3464: case 0x1: {
2877 OPC_CheckPredicate, 47, // 3466: check predicate 47
2878 OPC_Decode, 159, 132, 1, 24, // 3468: decode to WZIP16P using decoder 24
2879 // 3468: }
2880 // 3468: } // switch Inst[25]
2881 // 3468: }
2882 1, 0, // 3473: case 0x1: {
2883 OPC_SwitchField, 25, 1, // 3475: switch Inst[25] {
2884 0, 6, // 3478: case 0x0: {
2885 OPC_CheckPredicate, 47, // 3480: check predicate 47
2886 OPC_Decode, 141, 120, 26, // 3482: decode to PMQWACC_H using decoder 26
2887 // 3482: }
2888 1, 0, // 3486: case 0x1: {
2889 OPC_CheckPredicate, 47, // 3488: check predicate 47
2890 OPC_Decode, 240, 117, 26, // 3490: decode to MQWACC using decoder 26
2891 // 3490: }
2892 // 3490: } // switch Inst[25]
2893 // 3490: }
2894 // 3490: } // switch Inst[7]
2895 // 3490: }
2896 31, 27, // 3494: case 0x1f: {
2897 OPC_SwitchField, 25, 1, // 3496: switch Inst[25] {
2898 0, 10, // 3499: case 0x0: {
2899 OPC_CheckPredicate, 47, // 3501: check predicate 47
2900 OPC_CheckField, 7, 1, 1, // 3503: check Inst[7] == 0x1
2901 OPC_Decode, 140, 120, 26, // 3507: decode to PMQRWACC_H using decoder 26
2902 // 3507: }
2903 1, 0, // 3511: case 0x1: {
2904 OPC_CheckPredicate, 47, // 3513: check predicate 47
2905 OPC_CheckField, 7, 1, 1, // 3515: check Inst[7] == 0x1
2906 OPC_Decode, 239, 117, 26, // 3519: decode to MQRWACC using decoder 26
2907 // 3519: }
2908 // 3519: } // switch Inst[25]
2909 // 3519: }
2910 32, 36, // 3523: case 0x20: {
2911 OPC_SwitchField, 25, 1, // 3525: switch Inst[25] {
2912 0, 23, // 3528: case 0x0: {
2913 OPC_SwitchField, 24, 1, // 3530: switch Inst[24] {
2914 0, 10, // 3533: case 0x0: {
2915 OPC_CheckPredicate, 43, // 3535: check predicate 43
2916 OPC_CheckField, 23, 1, 1, // 3537: check Inst[23] == 0x1
2917 OPC_Decode, 174, 121, 30, // 3541: decode to PSLLI_B using decoder 30
2918 // 3541: }
2919 1, 0, // 3545: case 0x1: {
2920 OPC_CheckPredicate, 43, // 3547: check predicate 43
2921 OPC_Decode, 178, 121, 18, // 3549: decode to PSLLI_H using decoder 18
2922 // 3549: }
2923 // 3549: } // switch Inst[24]
2924 // 3549: }
2925 1, 0, // 3553: case 0x1: {
2926 OPC_CheckPredicate, 48, // 3555: check predicate 48
2927 OPC_Decode, 179, 121, 21, // 3557: decode to PSLLI_W using decoder 21
2928 // 3557: }
2929 // 3557: } // switch Inst[25]
2930 // 3557: }
2931 34, 19, // 3561: case 0x22: {
2932 OPC_SwitchField, 25, 1, // 3563: switch Inst[25] {
2933 0, 6, // 3566: case 0x0: {
2934 OPC_CheckPredicate, 43, // 3568: check predicate 43
2935 OPC_Decode, 184, 121, 31, // 3570: decode to PSLL_HS using decoder 31
2936 // 3570: }
2937 1, 0, // 3574: case 0x1: {
2938 OPC_CheckPredicate, 48, // 3576: check predicate 48
2939 OPC_Decode, 185, 121, 31, // 3578: decode to PSLL_WS using decoder 31
2940 // 3578: }
2941 // 3578: } // switch Inst[25]
2942 // 3578: }
2943 35, 10, // 3582: case 0x23: {
2944 OPC_CheckPredicate, 43, // 3584: check predicate 43
2945 OPC_CheckField, 25, 1, 0, // 3586: check Inst[25] == 0x0
2946 OPC_Decode, 180, 121, 31, // 3590: decode to PSLL_BS using decoder 31
2947 // 3590: }
2948 38, 19, // 3594: case 0x26: {
2949 OPC_SwitchField, 25, 1, // 3596: switch Inst[25] {
2950 0, 6, // 3599: case 0x0: {
2951 OPC_CheckPredicate, 43, // 3601: check predicate 43
2952 OPC_Decode, 251, 118, 31, // 3603: decode to PADD_HS using decoder 31
2953 // 3603: }
2954 1, 0, // 3607: case 0x1: {
2955 OPC_CheckPredicate, 48, // 3609: check predicate 48
2956 OPC_Decode, 253, 118, 31, // 3611: decode to PADD_WS using decoder 31
2957 // 3611: }
2958 // 3611: } // switch Inst[25]
2959 // 3611: }
2960 39, 10, // 3615: case 0x27: {
2961 OPC_CheckPredicate, 43, // 3617: check predicate 43
2962 OPC_CheckField, 25, 1, 0, // 3619: check Inst[25] == 0x0
2963 OPC_Decode, 243, 118, 31, // 3623: decode to PADD_BS using decoder 31
2964 // 3623: }
2965 42, 19, // 3627: case 0x2a: {
2966 OPC_SwitchField, 25, 1, // 3629: switch Inst[25] {
2967 0, 6, // 3632: case 0x0: {
2968 OPC_CheckPredicate, 43, // 3634: check predicate 43
2969 OPC_Decode, 235, 121, 31, // 3636: decode to PSSHL_HS using decoder 31
2970 // 3636: }
2971 1, 0, // 3640: case 0x1: {
2972 OPC_CheckPredicate, 48, // 3642: check predicate 48
2973 OPC_Decode, 236, 121, 31, // 3644: decode to PSSHL_WS using decoder 31
2974 // 3644: }
2975 // 3644: } // switch Inst[25]
2976 // 3644: }
2977 43, 10, // 3648: case 0x2b: {
2978 OPC_CheckPredicate, 48, // 3650: check predicate 48
2979 OPC_CheckField, 25, 1, 1, // 3652: check Inst[25] == 0x1
2980 OPC_Decode, 210, 124, 31, // 3656: decode to SHL using decoder 31
2981 // 3656: }
2982 44, 19, // 3660: case 0x2c: {
2983 OPC_SwitchField, 25, 1, // 3662: switch Inst[25] {
2984 0, 6, // 3665: case 0x0: {
2985 OPC_CheckPredicate, 43, // 3667: check predicate 43
2986 OPC_Decode, 147, 119, 32, // 3669: decode to PLI_H using decoder 32
2987 // 3669: }
2988 1, 0, // 3673: case 0x1: {
2989 OPC_CheckPredicate, 48, // 3675: check predicate 48
2990 OPC_Decode, 148, 119, 32, // 3677: decode to PLI_W using decoder 32
2991 // 3677: }
2992 // 3677: } // switch Inst[25]
2993 // 3677: }
2994 45, 14, // 3681: case 0x2d: {
2995 OPC_CheckPredicate, 43, // 3683: check predicate 43
2996 OPC_CheckField, 24, 2, 0, // 3685: check Inst[25:24] == 0x0
2997 OPC_CheckField, 15, 1, 0, // 3689: check Inst[15] == 0x0
2998 OPC_Decode, 144, 119, 33, // 3693: decode to PLI_B using decoder 33
2999 // 3693: }
3000 46, 19, // 3697: case 0x2e: {
3001 OPC_SwitchField, 25, 1, // 3699: switch Inst[25] {
3002 0, 6, // 3702: case 0x0: {
3003 OPC_CheckPredicate, 43, // 3704: check predicate 43
3004 OPC_Decode, 231, 121, 31, // 3706: decode to PSSHLR_HS using decoder 31
3005 // 3706: }
3006 1, 0, // 3710: case 0x1: {
3007 OPC_CheckPredicate, 48, // 3712: check predicate 48
3008 OPC_Decode, 232, 121, 31, // 3714: decode to PSSHLR_WS using decoder 31
3009 // 3714: }
3010 // 3714: } // switch Inst[25]
3011 // 3714: }
3012 47, 10, // 3718: case 0x2f: {
3013 OPC_CheckPredicate, 48, // 3720: check predicate 48
3014 OPC_CheckField, 25, 1, 1, // 3722: check Inst[25] == 0x1
3015 OPC_Decode, 211, 124, 31, // 3726: decode to SHLR using decoder 31
3016 // 3726: }
3017 52, 23, // 3730: case 0x34: {
3018 OPC_SwitchField, 25, 1, // 3732: switch Inst[25] {
3019 0, 10, // 3735: case 0x0: {
3020 OPC_CheckPredicate, 43, // 3737: check predicate 43
3021 OPC_CheckField, 24, 1, 1, // 3739: check Inst[24] == 0x1
3022 OPC_Decode, 239, 121, 18, // 3743: decode to PSSLAI_H using decoder 18
3023 // 3743: }
3024 1, 0, // 3747: case 0x1: {
3025 OPC_CheckPredicate, 48, // 3749: check predicate 48
3026 OPC_Decode, 240, 121, 21, // 3751: decode to PSSLAI_W using decoder 21
3027 // 3751: }
3028 // 3751: } // switch Inst[25]
3029 // 3751: }
3030 56, 35, // 3755: case 0x38: {
3031 OPC_SwitchField, 20, 6, // 3757: switch Inst[25:20] {
3032 4, 6, // 3760: case 0x4: {
3033 OPC_CheckPredicate, 43, // 3762: check predicate 43
3034 OPC_Decode, 167, 121, 17, // 3764: decode to PSEXT_H_B using decoder 17
3035 // 3764: }
3036 7, 6, // 3768: case 0x7: {
3037 OPC_CheckPredicate, 43, // 3770: check predicate 43
3038 OPC_Decode, 141, 121, 17, // 3772: decode to PSABS_H using decoder 17
3039 // 3772: }
3040 36, 6, // 3776: case 0x24: {
3041 OPC_CheckPredicate, 48, // 3778: check predicate 48
3042 OPC_Decode, 168, 121, 17, // 3780: decode to PSEXT_W_B using decoder 17
3043 // 3780: }
3044 37, 0, // 3784: case 0x25: {
3045 OPC_CheckPredicate, 48, // 3786: check predicate 48
3046 OPC_Decode, 169, 121, 17, // 3788: decode to PSEXT_W_H using decoder 17
3047 // 3788: }
3048 // 3788: } // switch Inst[25:20]
3049 // 3788: }
3050 57, 10, // 3792: case 0x39: {
3051 OPC_CheckPredicate, 43, // 3794: check predicate 43
3052 OPC_CheckField, 20, 6, 7, // 3796: check Inst[25:20] == 0x7
3053 OPC_Decode, 138, 121, 17, // 3800: decode to PSABS_B using decoder 17
3054 // 3800: }
3055 58, 19, // 3804: case 0x3a: {
3056 OPC_SwitchField, 25, 1, // 3806: switch Inst[25] {
3057 0, 6, // 3809: case 0x0: {
3058 OPC_CheckPredicate, 43, // 3811: check predicate 43
3059 OPC_Decode, 227, 121, 31, // 3813: decode to PSSHA_HS using decoder 31
3060 // 3813: }
3061 1, 0, // 3817: case 0x1: {
3062 OPC_CheckPredicate, 48, // 3819: check predicate 48
3063 OPC_Decode, 228, 121, 31, // 3821: decode to PSSHA_WS using decoder 31
3064 // 3821: }
3065 // 3821: } // switch Inst[25]
3066 // 3821: }
3067 59, 10, // 3825: case 0x3b: {
3068 OPC_CheckPredicate, 48, // 3827: check predicate 48
3069 OPC_CheckField, 25, 1, 1, // 3829: check Inst[25] == 0x1
3070 OPC_Decode, 194, 124, 31, // 3833: decode to SHA using decoder 31
3071 // 3833: }
3072 60, 19, // 3837: case 0x3c: {
3073 OPC_SwitchField, 25, 1, // 3839: switch Inst[25] {
3074 0, 6, // 3842: case 0x0: {
3075 OPC_CheckPredicate, 43, // 3844: check predicate 43
3076 OPC_Decode, 150, 119, 34, // 3846: decode to PLUI_H using decoder 34
3077 // 3846: }
3078 1, 0, // 3850: case 0x1: {
3079 OPC_CheckPredicate, 48, // 3852: check predicate 48
3080 OPC_Decode, 151, 119, 34, // 3854: decode to PLUI_W using decoder 34
3081 // 3854: }
3082 // 3854: } // switch Inst[25]
3083 // 3854: }
3084 62, 19, // 3858: case 0x3e: {
3085 OPC_SwitchField, 25, 1, // 3860: switch Inst[25] {
3086 0, 6, // 3863: case 0x0: {
3087 OPC_CheckPredicate, 43, // 3865: check predicate 43
3088 OPC_Decode, 223, 121, 31, // 3867: decode to PSSHAR_HS using decoder 31
3089 // 3867: }
3090 1, 0, // 3871: case 0x1: {
3091 OPC_CheckPredicate, 48, // 3873: check predicate 48
3092 OPC_Decode, 224, 121, 31, // 3875: decode to PSSHAR_WS using decoder 31
3093 // 3875: }
3094 // 3875: } // switch Inst[25]
3095 // 3875: }
3096 63, 0, // 3879: case 0x3f: {
3097 OPC_CheckPredicate, 48, // 3881: check predicate 48
3098 OPC_CheckField, 25, 1, 1, // 3883: check Inst[25] == 0x1
3099 OPC_Decode, 209, 124, 31, // 3887: decode to SHAR using decoder 31
3100 // 3887: }
3101 // 3887: } // switch Inst[31:26]
3102 // 3887: }
3103 4, 226, 7, // 3891: case 0x4: {
3104 OPC_SwitchField, 26, 6, // 3894: switch Inst[31:26] {
3105 0, 31, // 3897: case 0x0: {
3106 OPC_SwitchField, 25, 1, // 3899: switch Inst[25] {
3107 0, 14, // 3902: case 0x0: {
3108 OPC_CheckPredicate, 47, // 3904: check predicate 47
3109 OPC_CheckField, 24, 1, 1, // 3906: check Inst[24] == 0x1
3110 OPC_CheckField, 15, 1, 1, // 3910: check Inst[15] == 0x1
3111 OPC_Decode, 230, 120, 35, // 3914: decode to PNSRLI_B using decoder 35
3112 // 3914: }
3113 1, 0, // 3918: case 0x1: {
3114 OPC_CheckPredicate, 47, // 3920: check predicate 47
3115 OPC_CheckField, 15, 1, 1, // 3922: check Inst[15] == 0x1
3116 OPC_Decode, 231, 120, 36, // 3926: decode to PNSRLI_H using decoder 36
3117 // 3926: }
3118 // 3926: } // switch Inst[25]
3119 // 3926: }
3120 1, 10, // 3930: case 0x1: {
3121 OPC_CheckPredicate, 47, // 3932: check predicate 47
3122 OPC_CheckField, 15, 1, 1, // 3934: check Inst[15] == 0x1
3123 OPC_Decode, 209, 118, 37, // 3938: decode to NSRLI using decoder 37
3124 // 3938: }
3125 2, 27, // 3942: case 0x2: {
3126 OPC_SwitchField, 25, 1, // 3944: switch Inst[25] {
3127 0, 10, // 3947: case 0x0: {
3128 OPC_CheckPredicate, 47, // 3949: check predicate 47
3129 OPC_CheckField, 15, 1, 1, // 3951: check Inst[15] == 0x1
3130 OPC_Decode, 232, 120, 38, // 3955: decode to PNSRL_BS using decoder 38
3131 // 3955: }
3132 1, 0, // 3959: case 0x1: {
3133 OPC_CheckPredicate, 47, // 3961: check predicate 47
3134 OPC_CheckField, 15, 1, 1, // 3963: check Inst[15] == 0x1
3135 OPC_Decode, 233, 120, 38, // 3967: decode to PNSRL_HS using decoder 38
3136 // 3967: }
3137 // 3967: } // switch Inst[25]
3138 // 3967: }
3139 3, 14, // 3971: case 0x3: {
3140 OPC_CheckPredicate, 47, // 3973: check predicate 47
3141 OPC_CheckField, 25, 1, 1, // 3975: check Inst[25] == 0x1
3142 OPC_CheckField, 15, 1, 1, // 3979: check Inst[15] == 0x1
3143 OPC_Decode, 208, 118, 38, // 3983: decode to NSRL using decoder 38
3144 // 3983: }
3145 6, 14, // 3987: case 0x6: {
3146 OPC_CheckPredicate, 47, // 3989: check predicate 47
3147 OPC_CheckField, 25, 1, 0, // 3991: check Inst[25] == 0x0
3148 OPC_CheckField, 15, 1, 0, // 3995: check Inst[15] == 0x0
3149 OPC_Decode, 132, 121, 38, // 3999: decode to PREDSUM_DHS using decoder 38
3150 // 3999: }
3151 7, 14, // 4003: case 0x7: {
3152 OPC_CheckPredicate, 47, // 4005: check predicate 47
3153 OPC_CheckField, 25, 1, 0, // 4007: check Inst[25] == 0x0
3154 OPC_CheckField, 15, 1, 0, // 4011: check Inst[15] == 0x0
3155 OPC_Decode, 131, 121, 38, // 4015: decode to PREDSUM_DBS using decoder 38
3156 // 4015: }
3157 8, 31, // 4019: case 0x8: {
3158 OPC_SwitchField, 25, 1, // 4021: switch Inst[25] {
3159 0, 14, // 4024: case 0x0: {
3160 OPC_CheckPredicate, 47, // 4026: check predicate 47
3161 OPC_CheckField, 24, 1, 1, // 4028: check Inst[24] == 0x1
3162 OPC_CheckField, 15, 1, 1, // 4032: check Inst[15] == 0x1
3163 OPC_Decode, 200, 120, 35, // 4036: decode to PNCLIPIU_B using decoder 35
3164 // 4036: }
3165 1, 0, // 4040: case 0x1: {
3166 OPC_CheckPredicate, 47, // 4042: check predicate 47
3167 OPC_CheckField, 15, 1, 1, // 4044: check Inst[15] == 0x1
3168 OPC_Decode, 201, 120, 36, // 4048: decode to PNCLIPIU_H using decoder 36
3169 // 4048: }
3170 // 4048: } // switch Inst[25]
3171 // 4048: }
3172 9, 10, // 4052: case 0x9: {
3173 OPC_CheckPredicate, 47, // 4054: check predicate 47
3174 OPC_CheckField, 15, 1, 1, // 4056: check Inst[15] == 0x1
3175 OPC_Decode, 151, 118, 37, // 4060: decode to NCLIPIU using decoder 37
3176 // 4060: }
3177 10, 27, // 4064: case 0xa: {
3178 OPC_SwitchField, 25, 1, // 4066: switch Inst[25] {
3179 0, 10, // 4069: case 0x0: {
3180 OPC_CheckPredicate, 47, // 4071: check predicate 47
3181 OPC_CheckField, 15, 1, 1, // 4073: check Inst[15] == 0x1
3182 OPC_Decode, 218, 120, 38, // 4077: decode to PNCLIPU_BS using decoder 38
3183 // 4077: }
3184 1, 0, // 4081: case 0x1: {
3185 OPC_CheckPredicate, 47, // 4083: check predicate 47
3186 OPC_CheckField, 15, 1, 1, // 4085: check Inst[15] == 0x1
3187 OPC_Decode, 219, 120, 38, // 4089: decode to PNCLIPU_HS using decoder 38
3188 // 4089: }
3189 // 4089: } // switch Inst[25]
3190 // 4089: }
3191 11, 14, // 4093: case 0xb: {
3192 OPC_CheckPredicate, 47, // 4095: check predicate 47
3193 OPC_CheckField, 25, 1, 1, // 4097: check Inst[25] == 0x1
3194 OPC_CheckField, 15, 1, 1, // 4101: check Inst[15] == 0x1
3195 OPC_Decode, 156, 118, 38, // 4105: decode to NCLIPU using decoder 38
3196 // 4105: }
3197 12, 31, // 4109: case 0xc: {
3198 OPC_SwitchField, 25, 1, // 4111: switch Inst[25] {
3199 0, 14, // 4114: case 0x0: {
3200 OPC_CheckPredicate, 47, // 4116: check predicate 47
3201 OPC_CheckField, 24, 1, 1, // 4118: check Inst[24] == 0x1
3202 OPC_CheckField, 15, 1, 1, // 4122: check Inst[15] == 0x1
3203 OPC_Decode, 207, 120, 35, // 4126: decode to PNCLIPRIU_B using decoder 35
3204 // 4126: }
3205 1, 0, // 4130: case 0x1: {
3206 OPC_CheckPredicate, 47, // 4132: check predicate 47
3207 OPC_CheckField, 15, 1, 1, // 4134: check Inst[15] == 0x1
3208 OPC_Decode, 208, 120, 36, // 4138: decode to PNCLIPRIU_H using decoder 36
3209 // 4138: }
3210 // 4138: } // switch Inst[25]
3211 // 4138: }
3212 13, 10, // 4142: case 0xd: {
3213 OPC_CheckPredicate, 47, // 4144: check predicate 47
3214 OPC_CheckField, 15, 1, 1, // 4146: check Inst[15] == 0x1
3215 OPC_Decode, 154, 118, 37, // 4150: decode to NCLIPRIU using decoder 37
3216 // 4150: }
3217 14, 36, // 4154: case 0xe: {
3218 OPC_SwitchField, 15, 1, // 4156: switch Inst[15] {
3219 0, 10, // 4159: case 0x0: {
3220 OPC_CheckPredicate, 47, // 4161: check predicate 47
3221 OPC_CheckField, 25, 1, 0, // 4163: check Inst[25] == 0x0
3222 OPC_Decode, 255, 120, 38, // 4167: decode to PREDSUMU_DHS using decoder 38
3223 // 4167: }
3224 1, 0, // 4171: case 0x1: {
3225 OPC_SwitchField, 25, 1, // 4173: switch Inst[25] {
3226 0, 6, // 4176: case 0x0: {
3227 OPC_CheckPredicate, 47, // 4178: check predicate 47
3228 OPC_Decode, 211, 120, 38, // 4180: decode to PNCLIPRU_BS using decoder 38
3229 // 4180: }
3230 1, 0, // 4184: case 0x1: {
3231 OPC_CheckPredicate, 47, // 4186: check predicate 47
3232 OPC_Decode, 212, 120, 38, // 4188: decode to PNCLIPRU_HS using decoder 38
3233 // 4188: }
3234 // 4188: } // switch Inst[25]
3235 // 4188: }
3236 // 4188: } // switch Inst[15]
3237 // 4188: }
3238 15, 27, // 4192: case 0xf: {
3239 OPC_SwitchField, 15, 1, // 4194: switch Inst[15] {
3240 0, 10, // 4197: case 0x0: {
3241 OPC_CheckPredicate, 47, // 4199: check predicate 47
3242 OPC_CheckField, 25, 1, 0, // 4201: check Inst[25] == 0x0
3243 OPC_Decode, 254, 120, 38, // 4205: decode to PREDSUMU_DBS using decoder 38
3244 // 4205: }
3245 1, 0, // 4209: case 0x1: {
3246 OPC_CheckPredicate, 47, // 4211: check predicate 47
3247 OPC_CheckField, 25, 1, 1, // 4213: check Inst[25] == 0x1
3248 OPC_Decode, 155, 118, 38, // 4217: decode to NCLIPRU using decoder 38
3249 // 4217: }
3250 // 4217: } // switch Inst[15]
3251 // 4217: }
3252 16, 31, // 4221: case 0x10: {
3253 OPC_SwitchField, 25, 1, // 4223: switch Inst[25] {
3254 0, 14, // 4226: case 0x0: {
3255 OPC_CheckPredicate, 47, // 4228: check predicate 47
3256 OPC_CheckField, 24, 1, 1, // 4230: check Inst[24] == 0x1
3257 OPC_CheckField, 15, 1, 1, // 4234: check Inst[15] == 0x1
3258 OPC_Decode, 222, 120, 35, // 4238: decode to PNSRAI_B using decoder 35
3259 // 4238: }
3260 1, 0, // 4242: case 0x1: {
3261 OPC_CheckPredicate, 47, // 4244: check predicate 47
3262 OPC_CheckField, 15, 1, 1, // 4246: check Inst[15] == 0x1
3263 OPC_Decode, 223, 120, 36, // 4250: decode to PNSRAI_H using decoder 36
3264 // 4250: }
3265 // 4250: } // switch Inst[25]
3266 // 4250: }
3267 17, 10, // 4254: case 0x11: {
3268 OPC_CheckPredicate, 47, // 4256: check predicate 47
3269 OPC_CheckField, 15, 1, 1, // 4258: check Inst[15] == 0x1
3270 OPC_Decode, 205, 118, 37, // 4262: decode to NSRAI using decoder 37
3271 // 4262: }
3272 18, 27, // 4266: case 0x12: {
3273 OPC_SwitchField, 25, 1, // 4268: switch Inst[25] {
3274 0, 10, // 4271: case 0x0: {
3275 OPC_CheckPredicate, 47, // 4273: check predicate 47
3276 OPC_CheckField, 15, 1, 1, // 4275: check Inst[15] == 0x1
3277 OPC_Decode, 228, 120, 38, // 4279: decode to PNSRA_BS using decoder 38
3278 // 4279: }
3279 1, 0, // 4283: case 0x1: {
3280 OPC_CheckPredicate, 47, // 4285: check predicate 47
3281 OPC_CheckField, 15, 1, 1, // 4287: check Inst[15] == 0x1
3282 OPC_Decode, 229, 120, 38, // 4291: decode to PNSRA_HS using decoder 38
3283 // 4291: }
3284 // 4291: } // switch Inst[25]
3285 // 4291: }
3286 19, 14, // 4295: case 0x13: {
3287 OPC_CheckPredicate, 47, // 4297: check predicate 47
3288 OPC_CheckField, 25, 1, 1, // 4299: check Inst[25] == 0x1
3289 OPC_CheckField, 15, 1, 1, // 4303: check Inst[15] == 0x1
3290 OPC_Decode, 204, 118, 38, // 4307: decode to NSRA using decoder 38
3291 // 4307: }
3292 20, 31, // 4311: case 0x14: {
3293 OPC_SwitchField, 25, 1, // 4313: switch Inst[25] {
3294 0, 14, // 4316: case 0x0: {
3295 OPC_CheckPredicate, 47, // 4318: check predicate 47
3296 OPC_CheckField, 24, 1, 1, // 4320: check Inst[24] == 0x1
3297 OPC_CheckField, 15, 1, 1, // 4324: check Inst[15] == 0x1
3298 OPC_Decode, 224, 120, 35, // 4328: decode to PNSRARI_B using decoder 35
3299 // 4328: }
3300 1, 0, // 4332: case 0x1: {
3301 OPC_CheckPredicate, 47, // 4334: check predicate 47
3302 OPC_CheckField, 15, 1, 1, // 4336: check Inst[15] == 0x1
3303 OPC_Decode, 225, 120, 36, // 4340: decode to PNSRARI_H using decoder 36
3304 // 4340: }
3305 // 4340: } // switch Inst[25]
3306 // 4340: }
3307 21, 10, // 4344: case 0x15: {
3308 OPC_CheckPredicate, 47, // 4346: check predicate 47
3309 OPC_CheckField, 15, 1, 1, // 4348: check Inst[15] == 0x1
3310 OPC_Decode, 207, 118, 37, // 4352: decode to NSRARI using decoder 37
3311 // 4352: }
3312 22, 27, // 4356: case 0x16: {
3313 OPC_SwitchField, 25, 1, // 4358: switch Inst[25] {
3314 0, 10, // 4361: case 0x0: {
3315 OPC_CheckPredicate, 47, // 4363: check predicate 47
3316 OPC_CheckField, 15, 1, 1, // 4365: check Inst[15] == 0x1
3317 OPC_Decode, 226, 120, 38, // 4369: decode to PNSRAR_BS using decoder 38
3318 // 4369: }
3319 1, 0, // 4373: case 0x1: {
3320 OPC_CheckPredicate, 47, // 4375: check predicate 47
3321 OPC_CheckField, 15, 1, 1, // 4377: check Inst[15] == 0x1
3322 OPC_Decode, 227, 120, 38, // 4381: decode to PNSRAR_HS using decoder 38
3323 // 4381: }
3324 // 4381: } // switch Inst[25]
3325 // 4381: }
3326 23, 14, // 4385: case 0x17: {
3327 OPC_CheckPredicate, 47, // 4387: check predicate 47
3328 OPC_CheckField, 25, 1, 1, // 4389: check Inst[25] == 0x1
3329 OPC_CheckField, 15, 1, 1, // 4393: check Inst[15] == 0x1
3330 OPC_Decode, 206, 118, 38, // 4397: decode to NSRAR using decoder 38
3331 // 4397: }
3332 24, 31, // 4401: case 0x18: {
3333 OPC_SwitchField, 25, 1, // 4403: switch Inst[25] {
3334 0, 14, // 4406: case 0x0: {
3335 OPC_CheckPredicate, 47, // 4408: check predicate 47
3336 OPC_CheckField, 24, 1, 1, // 4410: check Inst[24] == 0x1
3337 OPC_CheckField, 15, 1, 1, // 4414: check Inst[15] == 0x1
3338 OPC_Decode, 202, 120, 35, // 4418: decode to PNCLIPI_B using decoder 35
3339 // 4418: }
3340 1, 0, // 4422: case 0x1: {
3341 OPC_CheckPredicate, 47, // 4424: check predicate 47
3342 OPC_CheckField, 15, 1, 1, // 4426: check Inst[15] == 0x1
3343 OPC_Decode, 203, 120, 36, // 4430: decode to PNCLIPI_H using decoder 36
3344 // 4430: }
3345 // 4430: } // switch Inst[25]
3346 // 4430: }
3347 25, 10, // 4434: case 0x19: {
3348 OPC_CheckPredicate, 47, // 4436: check predicate 47
3349 OPC_CheckField, 15, 1, 1, // 4438: check Inst[15] == 0x1
3350 OPC_Decode, 150, 118, 37, // 4442: decode to NCLIPI using decoder 37
3351 // 4442: }
3352 26, 27, // 4446: case 0x1a: {
3353 OPC_SwitchField, 25, 1, // 4448: switch Inst[25] {
3354 0, 10, // 4451: case 0x0: {
3355 OPC_CheckPredicate, 47, // 4453: check predicate 47
3356 OPC_CheckField, 15, 1, 1, // 4455: check Inst[15] == 0x1
3357 OPC_Decode, 220, 120, 38, // 4459: decode to PNCLIP_BS using decoder 38
3358 // 4459: }
3359 1, 0, // 4463: case 0x1: {
3360 OPC_CheckPredicate, 47, // 4465: check predicate 47
3361 OPC_CheckField, 15, 1, 1, // 4467: check Inst[15] == 0x1
3362 OPC_Decode, 221, 120, 38, // 4471: decode to PNCLIP_HS using decoder 38
3363 // 4471: }
3364 // 4471: } // switch Inst[25]
3365 // 4471: }
3366 27, 14, // 4475: case 0x1b: {
3367 OPC_CheckPredicate, 47, // 4477: check predicate 47
3368 OPC_CheckField, 25, 1, 1, // 4479: check Inst[25] == 0x1
3369 OPC_CheckField, 15, 1, 1, // 4483: check Inst[15] == 0x1
3370 OPC_Decode, 149, 118, 38, // 4487: decode to NCLIP using decoder 38
3371 // 4487: }
3372 28, 31, // 4491: case 0x1c: {
3373 OPC_SwitchField, 25, 1, // 4493: switch Inst[25] {
3374 0, 14, // 4496: case 0x0: {
3375 OPC_CheckPredicate, 47, // 4498: check predicate 47
3376 OPC_CheckField, 24, 1, 1, // 4500: check Inst[24] == 0x1
3377 OPC_CheckField, 15, 1, 1, // 4504: check Inst[15] == 0x1
3378 OPC_Decode, 209, 120, 35, // 4508: decode to PNCLIPRI_B using decoder 35
3379 // 4508: }
3380 1, 0, // 4512: case 0x1: {
3381 OPC_CheckPredicate, 47, // 4514: check predicate 47
3382 OPC_CheckField, 15, 1, 1, // 4516: check Inst[15] == 0x1
3383 OPC_Decode, 210, 120, 36, // 4520: decode to PNCLIPRI_H using decoder 36
3384 // 4520: }
3385 // 4520: } // switch Inst[25]
3386 // 4520: }
3387 29, 10, // 4524: case 0x1d: {
3388 OPC_CheckPredicate, 47, // 4526: check predicate 47
3389 OPC_CheckField, 15, 1, 1, // 4528: check Inst[15] == 0x1
3390 OPC_Decode, 153, 118, 37, // 4532: decode to NCLIPRI using decoder 37
3391 // 4532: }
3392 30, 27, // 4536: case 0x1e: {
3393 OPC_SwitchField, 25, 1, // 4538: switch Inst[25] {
3394 0, 10, // 4541: case 0x0: {
3395 OPC_CheckPredicate, 47, // 4543: check predicate 47
3396 OPC_CheckField, 15, 1, 1, // 4545: check Inst[15] == 0x1
3397 OPC_Decode, 213, 120, 38, // 4549: decode to PNCLIPR_BS using decoder 38
3398 // 4549: }
3399 1, 0, // 4553: case 0x1: {
3400 OPC_CheckPredicate, 47, // 4555: check predicate 47
3401 OPC_CheckField, 15, 1, 1, // 4557: check Inst[15] == 0x1
3402 OPC_Decode, 214, 120, 38, // 4561: decode to PNCLIPR_HS using decoder 38
3403 // 4561: }
3404 // 4561: } // switch Inst[25]
3405 // 4561: }
3406 31, 14, // 4565: case 0x1f: {
3407 OPC_CheckPredicate, 47, // 4567: check predicate 47
3408 OPC_CheckField, 25, 1, 1, // 4569: check Inst[25] == 0x1
3409 OPC_CheckField, 15, 1, 1, // 4573: check Inst[15] == 0x1
3410 OPC_Decode, 152, 118, 38, // 4577: decode to NCLIPR using decoder 38
3411 // 4577: }
3412 32, 36, // 4581: case 0x20: {
3413 OPC_SwitchField, 25, 1, // 4583: switch Inst[25] {
3414 0, 23, // 4586: case 0x0: {
3415 OPC_SwitchField, 24, 1, // 4588: switch Inst[24] {
3416 0, 10, // 4591: case 0x0: {
3417 OPC_CheckPredicate, 43, // 4593: check predicate 43
3418 OPC_CheckField, 23, 1, 1, // 4595: check Inst[23] == 0x1
3419 OPC_Decode, 202, 121, 30, // 4599: decode to PSRLI_B using decoder 30
3420 // 4599: }
3421 1, 0, // 4603: case 0x1: {
3422 OPC_CheckPredicate, 43, // 4605: check predicate 43
3423 OPC_Decode, 206, 121, 18, // 4607: decode to PSRLI_H using decoder 18
3424 // 4607: }
3425 // 4607: } // switch Inst[24]
3426 // 4607: }
3427 1, 0, // 4611: case 0x1: {
3428 OPC_CheckPredicate, 48, // 4613: check predicate 48
3429 OPC_Decode, 207, 121, 21, // 4615: decode to PSRLI_W using decoder 21
3430 // 4615: }
3431 // 4615: } // switch Inst[25]
3432 // 4615: }
3433 34, 19, // 4619: case 0x22: {
3434 OPC_SwitchField, 25, 1, // 4621: switch Inst[25] {
3435 0, 6, // 4624: case 0x0: {
3436 OPC_CheckPredicate, 43, // 4626: check predicate 43
3437 OPC_Decode, 212, 121, 31, // 4628: decode to PSRL_HS using decoder 31
3438 // 4628: }
3439 1, 0, // 4632: case 0x1: {
3440 OPC_CheckPredicate, 48, // 4634: check predicate 48
3441 OPC_Decode, 213, 121, 31, // 4636: decode to PSRL_WS using decoder 31
3442 // 4636: }
3443 // 4636: } // switch Inst[25]
3444 // 4636: }
3445 35, 10, // 4640: case 0x23: {
3446 OPC_CheckPredicate, 43, // 4642: check predicate 43
3447 OPC_CheckField, 25, 1, 0, // 4644: check Inst[25] == 0x0
3448 OPC_Decode, 208, 121, 31, // 4648: decode to PSRL_BS using decoder 31
3449 // 4648: }
3450 38, 19, // 4652: case 0x26: {
3451 OPC_SwitchField, 25, 1, // 4654: switch Inst[25] {
3452 0, 6, // 4657: case 0x0: {
3453 OPC_CheckPredicate, 43, // 4659: check predicate 43
3454 OPC_Decode, 133, 121, 31, // 4661: decode to PREDSUM_HS using decoder 31
3455 // 4661: }
3456 1, 0, // 4665: case 0x1: {
3457 OPC_CheckPredicate, 48, // 4667: check predicate 48
3458 OPC_Decode, 134, 121, 31, // 4669: decode to PREDSUM_WS using decoder 31
3459 // 4669: }
3460 // 4669: } // switch Inst[25]
3461 // 4669: }
3462 39, 10, // 4673: case 0x27: {
3463 OPC_CheckPredicate, 43, // 4675: check predicate 43
3464 OPC_CheckField, 25, 1, 0, // 4677: check Inst[25] == 0x0
3465 OPC_Decode, 130, 121, 31, // 4681: decode to PREDSUM_BS using decoder 31
3466 // 4681: }
3467 40, 23, // 4685: case 0x28: {
3468 OPC_SwitchField, 25, 1, // 4687: switch Inst[25] {
3469 0, 10, // 4690: case 0x0: {
3470 OPC_CheckPredicate, 43, // 4692: check predicate 43
3471 OPC_CheckField, 24, 1, 1, // 4694: check Inst[24] == 0x1
3472 OPC_Decode, 133, 122, 18, // 4698: decode to PUSATI_H using decoder 18
3473 // 4698: }
3474 1, 0, // 4702: case 0x1: {
3475 OPC_CheckPredicate, 48, // 4704: check predicate 48
3476 OPC_Decode, 134, 122, 21, // 4706: decode to PUSATI_W using decoder 21
3477 // 4706: }
3478 // 4706: } // switch Inst[25]
3479 // 4706: }
3480 41, 6, // 4710: case 0x29: {
3481 OPC_CheckPredicate, 48, // 4712: check predicate 48
3482 OPC_Decode, 179, 126, 39, // 4714: decode to USATI_RV64 using decoder 39
3483 // 4714: }
3484 46, 19, // 4718: case 0x2e: {
3485 OPC_SwitchField, 25, 1, // 4720: switch Inst[25] {
3486 0, 6, // 4723: case 0x0: {
3487 OPC_CheckPredicate, 43, // 4725: check predicate 43
3488 OPC_Decode, 128, 121, 31, // 4727: decode to PREDSUMU_HS using decoder 31
3489 // 4727: }
3490 1, 0, // 4731: case 0x1: {
3491 OPC_CheckPredicate, 48, // 4733: check predicate 48
3492 OPC_Decode, 129, 121, 31, // 4735: decode to PREDSUMU_WS using decoder 31
3493 // 4735: }
3494 // 4735: } // switch Inst[25]
3495 // 4735: }
3496 47, 10, // 4739: case 0x2f: {
3497 OPC_CheckPredicate, 43, // 4741: check predicate 43
3498 OPC_CheckField, 25, 1, 0, // 4743: check Inst[25] == 0x0
3499 OPC_Decode, 253, 120, 31, // 4747: decode to PREDSUMU_BS using decoder 31
3500 // 4747: }
3501 48, 36, // 4751: case 0x30: {
3502 OPC_SwitchField, 25, 1, // 4753: switch Inst[25] {
3503 0, 23, // 4756: case 0x0: {
3504 OPC_SwitchField, 24, 1, // 4758: switch Inst[24] {
3505 0, 10, // 4761: case 0x0: {
3506 OPC_CheckPredicate, 43, // 4763: check predicate 43
3507 OPC_CheckField, 23, 1, 1, // 4765: check Inst[23] == 0x1
3508 OPC_Decode, 186, 121, 30, // 4769: decode to PSRAI_B using decoder 30
3509 // 4769: }
3510 1, 0, // 4773: case 0x1: {
3511 OPC_CheckPredicate, 43, // 4775: check predicate 43
3512 OPC_Decode, 190, 121, 18, // 4777: decode to PSRAI_H using decoder 18
3513 // 4777: }
3514 // 4777: } // switch Inst[24]
3515 // 4777: }
3516 1, 0, // 4781: case 0x1: {
3517 OPC_CheckPredicate, 48, // 4783: check predicate 48
3518 OPC_Decode, 191, 121, 21, // 4785: decode to PSRAI_W using decoder 21
3519 // 4785: }
3520 // 4785: } // switch Inst[25]
3521 // 4785: }
3522 50, 19, // 4789: case 0x32: {
3523 OPC_SwitchField, 25, 1, // 4791: switch Inst[25] {
3524 0, 6, // 4794: case 0x0: {
3525 OPC_CheckPredicate, 43, // 4796: check predicate 43
3526 OPC_Decode, 200, 121, 31, // 4798: decode to PSRA_HS using decoder 31
3527 // 4798: }
3528 1, 0, // 4802: case 0x1: {
3529 OPC_CheckPredicate, 48, // 4804: check predicate 48
3530 OPC_Decode, 201, 121, 31, // 4806: decode to PSRA_WS using decoder 31
3531 // 4806: }
3532 // 4806: } // switch Inst[25]
3533 // 4806: }
3534 51, 10, // 4810: case 0x33: {
3535 OPC_CheckPredicate, 43, // 4812: check predicate 43
3536 OPC_CheckField, 25, 1, 0, // 4814: check Inst[25] == 0x0
3537 OPC_Decode, 196, 121, 31, // 4818: decode to PSRA_BS using decoder 31
3538 // 4818: }
3539 52, 23, // 4822: case 0x34: {
3540 OPC_SwitchField, 25, 1, // 4824: switch Inst[25] {
3541 0, 10, // 4827: case 0x0: {
3542 OPC_CheckPredicate, 43, // 4829: check predicate 43
3543 OPC_CheckField, 24, 1, 1, // 4831: check Inst[24] == 0x1
3544 OPC_Decode, 194, 121, 18, // 4835: decode to PSRARI_H using decoder 18
3545 // 4835: }
3546 1, 0, // 4839: case 0x1: {
3547 OPC_CheckPredicate, 48, // 4841: check predicate 48
3548 OPC_Decode, 195, 121, 21, // 4843: decode to PSRARI_W using decoder 21
3549 // 4843: }
3550 // 4843: } // switch Inst[25]
3551 // 4843: }
3552 53, 6, // 4847: case 0x35: {
3553 OPC_CheckPredicate, 48, // 4849: check predicate 48
3554 OPC_Decode, 157, 125, 39, // 4851: decode to SRARI_RV64 using decoder 39
3555 // 4851: }
3556 56, 23, // 4855: case 0x38: {
3557 OPC_SwitchField, 25, 1, // 4857: switch Inst[25] {
3558 0, 10, // 4860: case 0x0: {
3559 OPC_CheckPredicate, 43, // 4862: check predicate 43
3560 OPC_CheckField, 24, 1, 1, // 4864: check Inst[24] == 0x1
3561 OPC_Decode, 159, 121, 40, // 4868: decode to PSATI_H using decoder 40
3562 // 4868: }
3563 1, 0, // 4872: case 0x1: {
3564 OPC_CheckPredicate, 48, // 4874: check predicate 48
3565 OPC_Decode, 160, 121, 41, // 4876: decode to PSATI_W using decoder 41
3566 // 4876: }
3567 // 4876: } // switch Inst[25]
3568 // 4876: }
3569 57, 0, // 4880: case 0x39: {
3570 OPC_CheckPredicate, 48, // 4882: check predicate 48
3571 OPC_Decode, 223, 123, 42, // 4884: decode to SATI_RV64 using decoder 42
3572 // 4884: }
3573 // 4884: } // switch Inst[31:26]
3574 // 4884: }
3575 5, 27, // 4888: case 0x5: {
3576 OPC_SwitchField, 25, 7, // 4890: switch Inst[31:25] {
3577 0, 6, // 4893: case 0x0: {
3578 OPC_CheckPredicate, 22, // 4895: check predicate 22
3579 OPC_Decode, 162, 125, 21, // 4897: decode to SRLIW using decoder 21
3580 // 4897: }
3581 32, 6, // 4901: case 0x20: {
3582 OPC_CheckPredicate, 22, // 4903: check predicate 22
3583 OPC_Decode, 155, 125, 21, // 4905: decode to SRAIW using decoder 21
3584 // 4905: }
3585 48, 0, // 4909: case 0x30: {
3586 OPC_CheckPredicate, 49, // 4911: check predicate 49
3587 OPC_Decode, 218, 123, 21, // 4913: decode to RORIW using decoder 21
3588 // 4913: }
3589 // 4913: } // switch Inst[31:25]
3590 // 4913: }
3591 6, 0, // 4917: case 0x6: {
3592 OPC_SwitchField, 25, 7, // 4919: switch Inst[31:25] {
3593 0, 69, // 4922: case 0x0: {
3594 OPC_SwitchField, 15, 1, // 4924: switch Inst[15] {
3595 0, 31, // 4927: case 0x0: {
3596 OPC_SwitchField, 24, 1, // 4929: switch Inst[24] {
3597 0, 14, // 4932: case 0x0: {
3598 OPC_CheckPredicate, 47, // 4934: check predicate 47
3599 OPC_CheckField, 23, 1, 1, // 4936: check Inst[23] == 0x1
3600 OPC_CheckField, 7, 1, 0, // 4940: check Inst[7] == 0x0
3601 OPC_Decode, 175, 121, 43, // 4944: decode to PSLLI_DB using decoder 43
3602 // 4944: }
3603 1, 0, // 4948: case 0x1: {
3604 OPC_CheckPredicate, 47, // 4950: check predicate 47
3605 OPC_CheckField, 7, 1, 0, // 4952: check Inst[7] == 0x0
3606 OPC_Decode, 176, 121, 44, // 4956: decode to PSLLI_DH using decoder 44
3607 // 4956: }
3608 // 4956: } // switch Inst[24]
3609 // 4956: }
3610 1, 0, // 4960: case 0x1: {
3611 OPC_SwitchField, 24, 1, // 4962: switch Inst[24] {
3612 0, 14, // 4965: case 0x0: {
3613 OPC_CheckPredicate, 47, // 4967: check predicate 47
3614 OPC_CheckField, 23, 1, 1, // 4969: check Inst[23] == 0x1
3615 OPC_CheckField, 7, 1, 0, // 4973: check Inst[7] == 0x0
3616 OPC_Decode, 203, 121, 43, // 4977: decode to PSRLI_DB using decoder 43
3617 // 4977: }
3618 1, 0, // 4981: case 0x1: {
3619 OPC_CheckPredicate, 47, // 4983: check predicate 47
3620 OPC_CheckField, 7, 1, 0, // 4985: check Inst[7] == 0x0
3621 OPC_Decode, 204, 121, 44, // 4989: decode to PSRLI_DH using decoder 44
3622 // 4989: }
3623 // 4989: } // switch Inst[24]
3624 // 4989: }
3625 // 4989: } // switch Inst[15]
3626 // 4989: }
3627 1, 27, // 4993: case 0x1: {
3628 OPC_SwitchField, 15, 1, // 4995: switch Inst[15] {
3629 0, 10, // 4998: case 0x0: {
3630 OPC_CheckPredicate, 47, // 5000: check predicate 47
3631 OPC_CheckField, 7, 1, 0, // 5002: check Inst[7] == 0x0
3632 OPC_Decode, 177, 121, 45, // 5006: decode to PSLLI_DW using decoder 45
3633 // 5006: }
3634 1, 0, // 5010: case 0x1: {
3635 OPC_CheckPredicate, 47, // 5012: check predicate 47
3636 OPC_CheckField, 7, 1, 0, // 5014: check Inst[7] == 0x0
3637 OPC_Decode, 205, 121, 45, // 5018: decode to PSRLI_DW using decoder 45
3638 // 5018: }
3639 // 5018: } // switch Inst[15]
3640 // 5018: }
3641 4, 27, // 5022: case 0x4: {
3642 OPC_SwitchField, 15, 1, // 5024: switch Inst[15] {
3643 0, 10, // 5027: case 0x0: {
3644 OPC_CheckPredicate, 47, // 5029: check predicate 47
3645 OPC_CheckField, 7, 1, 0, // 5031: check Inst[7] == 0x0
3646 OPC_Decode, 182, 121, 46, // 5035: decode to PSLL_DHS using decoder 46
3647 // 5035: }
3648 1, 0, // 5039: case 0x1: {
3649 OPC_CheckPredicate, 47, // 5041: check predicate 47
3650 OPC_CheckField, 7, 1, 0, // 5043: check Inst[7] == 0x0
3651 OPC_Decode, 210, 121, 46, // 5047: decode to PSRL_DHS using decoder 46
3652 // 5047: }
3653 // 5047: } // switch Inst[15]
3654 // 5047: }
3655 5, 27, // 5051: case 0x5: {
3656 OPC_SwitchField, 15, 1, // 5053: switch Inst[15] {
3657 0, 10, // 5056: case 0x0: {
3658 OPC_CheckPredicate, 47, // 5058: check predicate 47
3659 OPC_CheckField, 7, 1, 0, // 5060: check Inst[7] == 0x0
3660 OPC_Decode, 183, 121, 46, // 5064: decode to PSLL_DWS using decoder 46
3661 // 5064: }
3662 1, 0, // 5068: case 0x1: {
3663 OPC_CheckPredicate, 47, // 5070: check predicate 47
3664 OPC_CheckField, 7, 1, 0, // 5072: check Inst[7] == 0x0
3665 OPC_Decode, 211, 121, 46, // 5076: decode to PSRL_DWS using decoder 46
3666 // 5076: }
3667 // 5076: } // switch Inst[15]
3668 // 5076: }
3669 6, 27, // 5080: case 0x6: {
3670 OPC_SwitchField, 15, 1, // 5082: switch Inst[15] {
3671 0, 10, // 5085: case 0x0: {
3672 OPC_CheckPredicate, 47, // 5087: check predicate 47
3673 OPC_CheckField, 7, 1, 0, // 5089: check Inst[7] == 0x0
3674 OPC_Decode, 181, 121, 46, // 5093: decode to PSLL_DBS using decoder 46
3675 // 5093: }
3676 1, 0, // 5097: case 0x1: {
3677 OPC_CheckPredicate, 47, // 5099: check predicate 47
3678 OPC_CheckField, 7, 1, 0, // 5101: check Inst[7] == 0x0
3679 OPC_Decode, 209, 121, 46, // 5105: decode to PSRL_DBS using decoder 46
3680 // 5105: }
3681 // 5105: } // switch Inst[15]
3682 // 5105: }
3683 12, 14, // 5109: case 0xc: {
3684 OPC_CheckPredicate, 47, // 5111: check predicate 47
3685 OPC_CheckField, 15, 1, 0, // 5113: check Inst[15] == 0x0
3686 OPC_CheckField, 7, 1, 0, // 5117: check Inst[7] == 0x0
3687 OPC_Decode, 247, 118, 46, // 5121: decode to PADD_DHS using decoder 46
3688 // 5121: }
3689 13, 14, // 5125: case 0xd: {
3690 OPC_CheckPredicate, 47, // 5127: check predicate 47
3691 OPC_CheckField, 15, 1, 0, // 5129: check Inst[15] == 0x0
3692 OPC_CheckField, 7, 1, 0, // 5133: check Inst[7] == 0x0
3693 OPC_Decode, 249, 118, 46, // 5137: decode to PADD_DWS using decoder 46
3694 // 5137: }
3695 14, 14, // 5141: case 0xe: {
3696 OPC_CheckPredicate, 47, // 5143: check predicate 47
3697 OPC_CheckField, 15, 1, 0, // 5145: check Inst[15] == 0x0
3698 OPC_CheckField, 7, 1, 0, // 5149: check Inst[7] == 0x0
3699 OPC_Decode, 245, 118, 46, // 5153: decode to PADD_DBS using decoder 46
3700 // 5153: }
3701 16, 18, // 5157: case 0x10: {
3702 OPC_CheckPredicate, 47, // 5159: check predicate 47
3703 OPC_CheckField, 24, 1, 1, // 5161: check Inst[24] == 0x1
3704 OPC_CheckField, 15, 1, 1, // 5165: check Inst[15] == 0x1
3705 OPC_CheckField, 7, 1, 0, // 5169: check Inst[7] == 0x0
3706 OPC_Decode, 131, 122, 44, // 5173: decode to PUSATI_DH using decoder 44
3707 // 5173: }
3708 17, 14, // 5177: case 0x11: {
3709 OPC_CheckPredicate, 47, // 5179: check predicate 47
3710 OPC_CheckField, 15, 1, 1, // 5181: check Inst[15] == 0x1
3711 OPC_CheckField, 7, 1, 0, // 5185: check Inst[7] == 0x0
3712 OPC_Decode, 132, 122, 45, // 5189: decode to PUSATI_DW using decoder 45
3713 // 5189: }
3714 20, 14, // 5193: case 0x14: {
3715 OPC_CheckPredicate, 47, // 5195: check predicate 47
3716 OPC_CheckField, 15, 1, 0, // 5197: check Inst[15] == 0x0
3717 OPC_CheckField, 7, 1, 0, // 5201: check Inst[7] == 0x0
3718 OPC_Decode, 233, 121, 46, // 5205: decode to PSSHL_DHS using decoder 46
3719 // 5205: }
3720 21, 14, // 5209: case 0x15: {
3721 OPC_CheckPredicate, 47, // 5211: check predicate 47
3722 OPC_CheckField, 15, 1, 0, // 5213: check Inst[15] == 0x0
3723 OPC_CheckField, 7, 1, 0, // 5217: check Inst[7] == 0x0
3724 OPC_Decode, 234, 121, 46, // 5221: decode to PSSHL_DWS using decoder 46
3725 // 5221: }
3726 28, 14, // 5225: case 0x1c: {
3727 OPC_CheckPredicate, 47, // 5227: check predicate 47
3728 OPC_CheckField, 15, 1, 0, // 5229: check Inst[15] == 0x0
3729 OPC_CheckField, 7, 1, 0, // 5233: check Inst[7] == 0x0
3730 OPC_Decode, 229, 121, 46, // 5237: decode to PSSHLR_DHS using decoder 46
3731 // 5237: }
3732 29, 14, // 5241: case 0x1d: {
3733 OPC_CheckPredicate, 47, // 5243: check predicate 47
3734 OPC_CheckField, 15, 1, 0, // 5245: check Inst[15] == 0x0
3735 OPC_CheckField, 7, 1, 0, // 5249: check Inst[7] == 0x0
3736 OPC_Decode, 230, 121, 46, // 5253: decode to PSSHLR_DWS using decoder 46
3737 // 5253: }
3738 32, 39, // 5257: case 0x20: {
3739 OPC_SwitchField, 24, 1, // 5259: switch Inst[24] {
3740 0, 18, // 5262: case 0x0: {
3741 OPC_CheckPredicate, 47, // 5264: check predicate 47
3742 OPC_CheckField, 23, 1, 1, // 5266: check Inst[23] == 0x1
3743 OPC_CheckField, 15, 1, 1, // 5270: check Inst[15] == 0x1
3744 OPC_CheckField, 7, 1, 0, // 5274: check Inst[7] == 0x0
3745 OPC_Decode, 187, 121, 43, // 5278: decode to PSRAI_DB using decoder 43
3746 // 5278: }
3747 1, 0, // 5282: case 0x1: {
3748 OPC_CheckPredicate, 47, // 5284: check predicate 47
3749 OPC_CheckField, 15, 1, 1, // 5286: check Inst[15] == 0x1
3750 OPC_CheckField, 7, 1, 0, // 5290: check Inst[7] == 0x0
3751 OPC_Decode, 188, 121, 44, // 5294: decode to PSRAI_DH using decoder 44
3752 // 5294: }
3753 // 5294: } // switch Inst[24]
3754 // 5294: }
3755 33, 14, // 5298: case 0x21: {
3756 OPC_CheckPredicate, 47, // 5300: check predicate 47
3757 OPC_CheckField, 15, 1, 1, // 5302: check Inst[15] == 0x1
3758 OPC_CheckField, 7, 1, 0, // 5306: check Inst[7] == 0x0
3759 OPC_Decode, 189, 121, 45, // 5310: decode to PSRAI_DW using decoder 45
3760 // 5310: }
3761 36, 14, // 5314: case 0x24: {
3762 OPC_CheckPredicate, 47, // 5316: check predicate 47
3763 OPC_CheckField, 15, 1, 1, // 5318: check Inst[15] == 0x1
3764 OPC_CheckField, 7, 1, 0, // 5322: check Inst[7] == 0x0
3765 OPC_Decode, 198, 121, 46, // 5326: decode to PSRA_DHS using decoder 46
3766 // 5326: }
3767 37, 14, // 5330: case 0x25: {
3768 OPC_CheckPredicate, 47, // 5332: check predicate 47
3769 OPC_CheckField, 15, 1, 1, // 5334: check Inst[15] == 0x1
3770 OPC_CheckField, 7, 1, 0, // 5338: check Inst[7] == 0x0
3771 OPC_Decode, 199, 121, 46, // 5342: decode to PSRA_DWS using decoder 46
3772 // 5342: }
3773 38, 14, // 5346: case 0x26: {
3774 OPC_CheckPredicate, 47, // 5348: check predicate 47
3775 OPC_CheckField, 15, 1, 1, // 5350: check Inst[15] == 0x1
3776 OPC_CheckField, 7, 1, 0, // 5354: check Inst[7] == 0x0
3777 OPC_Decode, 197, 121, 46, // 5358: decode to PSRA_DBS using decoder 46
3778 // 5358: }
3779 40, 35, // 5362: case 0x28: {
3780 OPC_SwitchField, 15, 1, // 5364: switch Inst[15] {
3781 0, 14, // 5367: case 0x0: {
3782 OPC_CheckPredicate, 47, // 5369: check predicate 47
3783 OPC_CheckField, 24, 1, 1, // 5371: check Inst[24] == 0x1
3784 OPC_CheckField, 7, 1, 0, // 5375: check Inst[7] == 0x0
3785 OPC_Decode, 237, 121, 44, // 5379: decode to PSSLAI_DH using decoder 44
3786 // 5379: }
3787 1, 0, // 5383: case 0x1: {
3788 OPC_CheckPredicate, 47, // 5385: check predicate 47
3789 OPC_CheckField, 24, 1, 1, // 5387: check Inst[24] == 0x1
3790 OPC_CheckField, 7, 1, 0, // 5391: check Inst[7] == 0x0
3791 OPC_Decode, 192, 121, 44, // 5395: decode to PSRARI_DH using decoder 44
3792 // 5395: }
3793 // 5395: } // switch Inst[15]
3794 // 5395: }
3795 41, 27, // 5399: case 0x29: {
3796 OPC_SwitchField, 15, 1, // 5401: switch Inst[15] {
3797 0, 10, // 5404: case 0x0: {
3798 OPC_CheckPredicate, 47, // 5406: check predicate 47
3799 OPC_CheckField, 7, 1, 0, // 5408: check Inst[7] == 0x0
3800 OPC_Decode, 238, 121, 45, // 5412: decode to PSSLAI_DW using decoder 45
3801 // 5412: }
3802 1, 0, // 5416: case 0x1: {
3803 OPC_CheckPredicate, 47, // 5418: check predicate 47
3804 OPC_CheckField, 7, 1, 0, // 5420: check Inst[7] == 0x0
3805 OPC_Decode, 193, 121, 45, // 5424: decode to PSRARI_DW using decoder 45
3806 // 5424: }
3807 // 5424: } // switch Inst[15]
3808 // 5424: }
3809 48, 48, // 5428: case 0x30: {
3810 OPC_SwitchField, 15, 1, // 5430: switch Inst[15] {
3811 0, 27, // 5433: case 0x0: {
3812 OPC_SwitchField, 20, 5, // 5435: switch Inst[24:20] {
3813 4, 10, // 5438: case 0x4: {
3814 OPC_CheckPredicate, 47, // 5440: check predicate 47
3815 OPC_CheckField, 7, 1, 0, // 5442: check Inst[7] == 0x0
3816 OPC_Decode, 164, 121, 47, // 5446: decode to PSEXT_DH_B using decoder 47
3817 // 5446: }
3818 7, 0, // 5450: case 0x7: {
3819 OPC_CheckPredicate, 47, // 5452: check predicate 47
3820 OPC_CheckField, 7, 1, 0, // 5454: check Inst[7] == 0x0
3821 OPC_Decode, 140, 121, 47, // 5458: decode to PSABS_DH using decoder 47
3822 // 5458: }
3823 // 5458: } // switch Inst[24:20]
3824 // 5458: }
3825 1, 0, // 5462: case 0x1: {
3826 OPC_CheckPredicate, 47, // 5464: check predicate 47
3827 OPC_CheckField, 24, 1, 1, // 5466: check Inst[24] == 0x1
3828 OPC_CheckField, 7, 1, 0, // 5470: check Inst[7] == 0x0
3829 OPC_Decode, 157, 121, 48, // 5474: decode to PSATI_DH using decoder 48
3830 // 5474: }
3831 // 5474: } // switch Inst[15]
3832 // 5474: }
3833 49, 44, // 5478: case 0x31: {
3834 OPC_SwitchField, 15, 1, // 5480: switch Inst[15] {
3835 0, 27, // 5483: case 0x0: {
3836 OPC_SwitchField, 20, 5, // 5485: switch Inst[24:20] {
3837 4, 10, // 5488: case 0x4: {
3838 OPC_CheckPredicate, 47, // 5490: check predicate 47
3839 OPC_CheckField, 7, 1, 0, // 5492: check Inst[7] == 0x0
3840 OPC_Decode, 165, 121, 47, // 5496: decode to PSEXT_DW_B using decoder 47
3841 // 5496: }
3842 5, 0, // 5500: case 0x5: {
3843 OPC_CheckPredicate, 47, // 5502: check predicate 47
3844 OPC_CheckField, 7, 1, 0, // 5504: check Inst[7] == 0x0
3845 OPC_Decode, 166, 121, 47, // 5508: decode to PSEXT_DW_H using decoder 47
3846 // 5508: }
3847 // 5508: } // switch Inst[24:20]
3848 // 5508: }
3849 1, 0, // 5512: case 0x1: {
3850 OPC_CheckPredicate, 47, // 5514: check predicate 47
3851 OPC_CheckField, 7, 1, 0, // 5516: check Inst[7] == 0x0
3852 OPC_Decode, 158, 121, 49, // 5520: decode to PSATI_DW using decoder 49
3853 // 5520: }
3854 // 5520: } // switch Inst[15]
3855 // 5520: }
3856 50, 18, // 5524: case 0x32: {
3857 OPC_CheckPredicate, 47, // 5526: check predicate 47
3858 OPC_CheckField, 20, 5, 7, // 5528: check Inst[24:20] == 0x7
3859 OPC_CheckField, 15, 1, 0, // 5532: check Inst[15] == 0x0
3860 OPC_CheckField, 7, 1, 0, // 5536: check Inst[7] == 0x0
3861 OPC_Decode, 139, 121, 47, // 5540: decode to PSABS_DB using decoder 47
3862 // 5540: }
3863 52, 14, // 5544: case 0x34: {
3864 OPC_CheckPredicate, 47, // 5546: check predicate 47
3865 OPC_CheckField, 15, 1, 0, // 5548: check Inst[15] == 0x0
3866 OPC_CheckField, 7, 1, 0, // 5552: check Inst[7] == 0x0
3867 OPC_Decode, 225, 121, 46, // 5556: decode to PSSHA_DHS using decoder 46
3868 // 5556: }
3869 53, 14, // 5560: case 0x35: {
3870 OPC_CheckPredicate, 47, // 5562: check predicate 47
3871 OPC_CheckField, 15, 1, 0, // 5564: check Inst[15] == 0x0
3872 OPC_CheckField, 7, 1, 0, // 5568: check Inst[7] == 0x0
3873 OPC_Decode, 226, 121, 46, // 5572: decode to PSSHA_DWS using decoder 46
3874 // 5572: }
3875 60, 14, // 5576: case 0x3c: {
3876 OPC_CheckPredicate, 47, // 5578: check predicate 47
3877 OPC_CheckField, 15, 1, 0, // 5580: check Inst[15] == 0x0
3878 OPC_CheckField, 7, 1, 0, // 5584: check Inst[7] == 0x0
3879 OPC_Decode, 221, 121, 46, // 5588: decode to PSSHAR_DHS using decoder 46
3880 // 5588: }
3881 61, 14, // 5592: case 0x3d: {
3882 OPC_CheckPredicate, 47, // 5594: check predicate 47
3883 OPC_CheckField, 15, 1, 0, // 5596: check Inst[15] == 0x0
3884 OPC_CheckField, 7, 1, 0, // 5600: check Inst[7] == 0x0
3885 OPC_Decode, 222, 121, 46, // 5604: decode to PSSHAR_DWS using decoder 46
3886 // 5604: }
3887 64, 48, // 5608: case 0x40: {
3888 OPC_SwitchField, 15, 1, // 5610: switch Inst[15] {
3889 0, 14, // 5613: case 0x0: {
3890 OPC_CheckPredicate, 47, // 5615: check predicate 47
3891 OPC_CheckField, 20, 1, 0, // 5617: check Inst[20] == 0x0
3892 OPC_CheckField, 7, 1, 0, // 5621: check Inst[7] == 0x0
3893 OPC_Decode, 246, 118, 50, // 5625: decode to PADD_DH using decoder 50
3894 // 5625: }
3895 1, 0, // 5629: case 0x1: {
3896 OPC_SwitchField, 20, 1, // 5631: switch Inst[20] {
3897 0, 10, // 5634: case 0x0: {
3898 OPC_CheckPredicate, 47, // 5636: check predicate 47
3899 OPC_CheckField, 7, 1, 0, // 5638: check Inst[7] == 0x0
3900 OPC_Decode, 240, 120, 50, // 5642: decode to PPAIRE_DB using decoder 50
3901 // 5642: }
3902 1, 0, // 5646: case 0x1: {
3903 OPC_CheckPredicate, 47, // 5648: check predicate 47
3904 OPC_CheckField, 7, 1, 0, // 5650: check Inst[7] == 0x0
3905 OPC_Decode, 141, 119, 50, // 5654: decode to PAS_DHX using decoder 50
3906 // 5654: }
3907 // 5654: } // switch Inst[20]
3908 // 5654: }
3909 // 5654: } // switch Inst[15]
3910 // 5654: }
3911 65, 35, // 5658: case 0x41: {
3912 OPC_SwitchField, 15, 1, // 5660: switch Inst[15] {
3913 0, 14, // 5663: case 0x0: {
3914 OPC_CheckPredicate, 47, // 5665: check predicate 47
3915 OPC_CheckField, 20, 1, 0, // 5667: check Inst[20] == 0x0
3916 OPC_CheckField, 7, 1, 0, // 5671: check Inst[7] == 0x0
3917 OPC_Decode, 248, 118, 50, // 5675: decode to PADD_DW using decoder 50
3918 // 5675: }
3919 1, 0, // 5679: case 0x1: {
3920 OPC_CheckPredicate, 47, // 5681: check predicate 47
3921 OPC_CheckField, 20, 1, 0, // 5683: check Inst[20] == 0x0
3922 OPC_CheckField, 7, 1, 0, // 5687: check Inst[7] == 0x0
3923 OPC_Decode, 241, 120, 50, // 5691: decode to PPAIRE_DH using decoder 50
3924 // 5691: }
3925 // 5691: } // switch Inst[15]
3926 // 5691: }
3927 66, 35, // 5695: case 0x42: {
3928 OPC_SwitchField, 15, 1, // 5697: switch Inst[15] {
3929 0, 14, // 5700: case 0x0: {
3930 OPC_CheckPredicate, 47, // 5702: check predicate 47
3931 OPC_CheckField, 20, 1, 0, // 5704: check Inst[20] == 0x0
3932 OPC_CheckField, 7, 1, 0, // 5708: check Inst[7] == 0x0
3933 OPC_Decode, 244, 118, 50, // 5712: decode to PADD_DB using decoder 50
3934 // 5712: }
3935 1, 0, // 5716: case 0x1: {
3936 OPC_CheckPredicate, 47, // 5718: check predicate 47
3937 OPC_CheckField, 20, 1, 1, // 5720: check Inst[20] == 0x1
3938 OPC_CheckField, 7, 1, 0, // 5724: check Inst[7] == 0x0
3939 OPC_Decode, 161, 121, 50, // 5728: decode to PSA_DHX using decoder 50
3940 // 5728: }
3941 // 5728: } // switch Inst[15]
3942 // 5728: }
3943 67, 18, // 5732: case 0x43: {
3944 OPC_CheckPredicate, 47, // 5734: check predicate 47
3945 OPC_CheckField, 20, 1, 0, // 5736: check Inst[20] == 0x0
3946 OPC_CheckField, 15, 1, 0, // 5740: check Inst[15] == 0x0
3947 OPC_CheckField, 7, 1, 0, // 5744: check Inst[7] == 0x0
3948 OPC_Decode, 208, 107, 50, // 5748: decode to ADDD using decoder 50
3949 // 5748: }
3950 72, 48, // 5752: case 0x48: {
3951 OPC_SwitchField, 15, 1, // 5754: switch Inst[15] {
3952 0, 14, // 5757: case 0x0: {
3953 OPC_CheckPredicate, 47, // 5759: check predicate 47
3954 OPC_CheckField, 20, 1, 0, // 5761: check Inst[20] == 0x0
3955 OPC_CheckField, 7, 1, 0, // 5765: check Inst[7] == 0x0
3956 OPC_Decode, 150, 121, 50, // 5769: decode to PSADD_DH using decoder 50
3957 // 5769: }
3958 1, 0, // 5773: case 0x1: {
3959 OPC_SwitchField, 20, 1, // 5775: switch Inst[20] {
3960 0, 10, // 5778: case 0x0: {
3961 OPC_CheckPredicate, 47, // 5780: check predicate 47
3962 OPC_CheckField, 7, 1, 0, // 5782: check Inst[7] == 0x0
3963 OPC_Decode, 235, 120, 50, // 5786: decode to PPAIREO_DB using decoder 50
3964 // 5786: }
3965 1, 0, // 5790: case 0x1: {
3966 OPC_CheckPredicate, 47, // 5792: check predicate 47
3967 OPC_CheckField, 7, 1, 0, // 5794: check Inst[7] == 0x0
3968 OPC_Decode, 154, 121, 50, // 5798: decode to PSAS_DHX using decoder 50
3969 // 5798: }
3970 // 5798: } // switch Inst[20]
3971 // 5798: }
3972 // 5798: } // switch Inst[15]
3973 // 5798: }
3974 73, 35, // 5802: case 0x49: {
3975 OPC_SwitchField, 15, 1, // 5804: switch Inst[15] {
3976 0, 14, // 5807: case 0x0: {
3977 OPC_CheckPredicate, 47, // 5809: check predicate 47
3978 OPC_CheckField, 20, 1, 0, // 5811: check Inst[20] == 0x0
3979 OPC_CheckField, 7, 1, 0, // 5815: check Inst[7] == 0x0
3980 OPC_Decode, 151, 121, 50, // 5819: decode to PSADD_DW using decoder 50
3981 // 5819: }
3982 1, 0, // 5823: case 0x1: {
3983 OPC_CheckPredicate, 47, // 5825: check predicate 47
3984 OPC_CheckField, 20, 1, 0, // 5827: check Inst[20] == 0x0
3985 OPC_CheckField, 7, 1, 0, // 5831: check Inst[7] == 0x0
3986 OPC_Decode, 236, 120, 50, // 5835: decode to PPAIREO_DH using decoder 50
3987 // 5835: }
3988 // 5835: } // switch Inst[15]
3989 // 5835: }
3990 74, 35, // 5839: case 0x4a: {
3991 OPC_SwitchField, 15, 1, // 5841: switch Inst[15] {
3992 0, 14, // 5844: case 0x0: {
3993 OPC_CheckPredicate, 47, // 5846: check predicate 47
3994 OPC_CheckField, 20, 1, 0, // 5848: check Inst[20] == 0x0
3995 OPC_CheckField, 7, 1, 0, // 5852: check Inst[7] == 0x0
3996 OPC_Decode, 149, 121, 50, // 5856: decode to PSADD_DB using decoder 50
3997 // 5856: }
3998 1, 0, // 5860: case 0x1: {
3999 OPC_CheckPredicate, 47, // 5862: check predicate 47
4000 OPC_CheckField, 20, 1, 1, // 5864: check Inst[20] == 0x1
4001 OPC_CheckField, 7, 1, 0, // 5868: check Inst[7] == 0x0
4002 OPC_Decode, 214, 121, 50, // 5872: decode to PSSA_DHX using decoder 50
4003 // 5872: }
4004 // 5872: } // switch Inst[15]
4005 // 5872: }
4006 76, 35, // 5876: case 0x4c: {
4007 OPC_SwitchField, 15, 1, // 5878: switch Inst[15] {
4008 0, 14, // 5881: case 0x0: {
4009 OPC_CheckPredicate, 47, // 5883: check predicate 47
4010 OPC_CheckField, 20, 1, 0, // 5885: check Inst[20] == 0x0
4011 OPC_CheckField, 7, 1, 0, // 5889: check Inst[7] == 0x0
4012 OPC_Decode, 222, 118, 50, // 5893: decode to PAADD_DH using decoder 50
4013 // 5893: }
4014 1, 0, // 5897: case 0x1: {
4015 OPC_CheckPredicate, 47, // 5899: check predicate 47
4016 OPC_CheckField, 20, 1, 1, // 5901: check Inst[20] == 0x1
4017 OPC_CheckField, 7, 1, 0, // 5905: check Inst[7] == 0x0
4018 OPC_Decode, 226, 118, 50, // 5909: decode to PAAS_DHX using decoder 50
4019 // 5909: }
4020 // 5909: } // switch Inst[15]
4021 // 5909: }
4022 77, 18, // 5913: case 0x4d: {
4023 OPC_CheckPredicate, 47, // 5915: check predicate 47
4024 OPC_CheckField, 20, 1, 0, // 5917: check Inst[20] == 0x0
4025 OPC_CheckField, 15, 1, 0, // 5921: check Inst[15] == 0x0
4026 OPC_CheckField, 7, 1, 0, // 5925: check Inst[7] == 0x0
4027 OPC_Decode, 223, 118, 50, // 5929: decode to PAADD_DW using decoder 50
4028 // 5929: }
4029 78, 35, // 5933: case 0x4e: {
4030 OPC_SwitchField, 15, 1, // 5935: switch Inst[15] {
4031 0, 14, // 5938: case 0x0: {
4032 OPC_CheckPredicate, 47, // 5940: check predicate 47
4033 OPC_CheckField, 20, 1, 0, // 5942: check Inst[20] == 0x0
4034 OPC_CheckField, 7, 1, 0, // 5946: check Inst[7] == 0x0
4035 OPC_Decode, 221, 118, 50, // 5950: decode to PAADD_DB using decoder 50
4036 // 5950: }
4037 1, 0, // 5954: case 0x1: {
4038 OPC_CheckPredicate, 47, // 5956: check predicate 47
4039 OPC_CheckField, 20, 1, 1, // 5958: check Inst[20] == 0x1
4040 OPC_CheckField, 7, 1, 0, // 5962: check Inst[7] == 0x0
4041 OPC_Decode, 254, 118, 50, // 5966: decode to PASA_DHX using decoder 50
4042 // 5966: }
4043 // 5966: } // switch Inst[15]
4044 // 5966: }
4045 80, 35, // 5970: case 0x50: {
4046 OPC_SwitchField, 15, 1, // 5972: switch Inst[15] {
4047 0, 14, // 5975: case 0x0: {
4048 OPC_CheckPredicate, 47, // 5977: check predicate 47
4049 OPC_CheckField, 20, 1, 1, // 5979: check Inst[20] == 0x1
4050 OPC_CheckField, 7, 1, 0, // 5983: check Inst[7] == 0x0
4051 OPC_Decode, 170, 121, 50, // 5987: decode to PSH1ADD_DH using decoder 50
4052 // 5987: }
4053 1, 0, // 5991: case 0x1: {
4054 OPC_CheckPredicate, 47, // 5993: check predicate 47
4055 OPC_CheckField, 20, 1, 0, // 5995: check Inst[20] == 0x0
4056 OPC_CheckField, 7, 1, 0, // 5999: check Inst[7] == 0x0
4057 OPC_Decode, 244, 120, 50, // 6003: decode to PPAIROE_DB using decoder 50
4058 // 6003: }
4059 // 6003: } // switch Inst[15]
4060 // 6003: }
4061 81, 35, // 6007: case 0x51: {
4062 OPC_SwitchField, 15, 1, // 6009: switch Inst[15] {
4063 0, 14, // 6012: case 0x0: {
4064 OPC_CheckPredicate, 47, // 6014: check predicate 47
4065 OPC_CheckField, 20, 1, 1, // 6016: check Inst[20] == 0x1
4066 OPC_CheckField, 7, 1, 0, // 6020: check Inst[7] == 0x0
4067 OPC_Decode, 171, 121, 50, // 6024: decode to PSH1ADD_DW using decoder 50
4068 // 6024: }
4069 1, 0, // 6028: case 0x1: {
4070 OPC_CheckPredicate, 47, // 6030: check predicate 47
4071 OPC_CheckField, 20, 1, 0, // 6032: check Inst[20] == 0x0
4072 OPC_CheckField, 7, 1, 0, // 6036: check Inst[7] == 0x0
4073 OPC_Decode, 245, 120, 50, // 6040: decode to PPAIROE_DH using decoder 50
4074 // 6040: }
4075 // 6040: } // switch Inst[15]
4076 // 6040: }
4077 88, 48, // 6044: case 0x58: {
4078 OPC_SwitchField, 15, 1, // 6046: switch Inst[15] {
4079 0, 27, // 6049: case 0x0: {
4080 OPC_SwitchField, 20, 1, // 6051: switch Inst[20] {
4081 0, 10, // 6054: case 0x0: {
4082 OPC_CheckPredicate, 47, // 6056: check predicate 47
4083 OPC_CheckField, 7, 1, 0, // 6058: check Inst[7] == 0x0
4084 OPC_Decode, 144, 121, 50, // 6062: decode to PSADDU_DH using decoder 50
4085 // 6062: }
4086 1, 0, // 6066: case 0x1: {
4087 OPC_CheckPredicate, 47, // 6068: check predicate 47
4088 OPC_CheckField, 7, 1, 0, // 6070: check Inst[7] == 0x0
4089 OPC_Decode, 217, 121, 50, // 6074: decode to PSSH1SADD_DH using decoder 50
4090 // 6074: }
4091 // 6074: } // switch Inst[20]
4092 // 6074: }
4093 1, 0, // 6078: case 0x1: {
4094 OPC_CheckPredicate, 47, // 6080: check predicate 47
4095 OPC_CheckField, 20, 1, 0, // 6082: check Inst[20] == 0x0
4096 OPC_CheckField, 7, 1, 0, // 6086: check Inst[7] == 0x0
4097 OPC_Decode, 249, 120, 50, // 6090: decode to PPAIRO_DB using decoder 50
4098 // 6090: }
4099 // 6090: } // switch Inst[15]
4100 // 6090: }
4101 89, 48, // 6094: case 0x59: {
4102 OPC_SwitchField, 15, 1, // 6096: switch Inst[15] {
4103 0, 27, // 6099: case 0x0: {
4104 OPC_SwitchField, 20, 1, // 6101: switch Inst[20] {
4105 0, 10, // 6104: case 0x0: {
4106 OPC_CheckPredicate, 47, // 6106: check predicate 47
4107 OPC_CheckField, 7, 1, 0, // 6108: check Inst[7] == 0x0
4108 OPC_Decode, 145, 121, 50, // 6112: decode to PSADDU_DW using decoder 50
4109 // 6112: }
4110 1, 0, // 6116: case 0x1: {
4111 OPC_CheckPredicate, 47, // 6118: check predicate 47
4112 OPC_CheckField, 7, 1, 0, // 6120: check Inst[7] == 0x0
4113 OPC_Decode, 218, 121, 50, // 6124: decode to PSSH1SADD_DW using decoder 50
4114 // 6124: }
4115 // 6124: } // switch Inst[20]
4116 // 6124: }
4117 1, 0, // 6128: case 0x1: {
4118 OPC_CheckPredicate, 47, // 6130: check predicate 47
4119 OPC_CheckField, 20, 1, 0, // 6132: check Inst[20] == 0x0
4120 OPC_CheckField, 7, 1, 0, // 6136: check Inst[7] == 0x0
4121 OPC_Decode, 250, 120, 50, // 6140: decode to PPAIRO_DH using decoder 50
4122 // 6140: }
4123 // 6140: } // switch Inst[15]
4124 // 6140: }
4125 90, 18, // 6144: case 0x5a: {
4126 OPC_CheckPredicate, 47, // 6146: check predicate 47
4127 OPC_CheckField, 20, 1, 0, // 6148: check Inst[20] == 0x0
4128 OPC_CheckField, 15, 1, 0, // 6152: check Inst[15] == 0x0
4129 OPC_CheckField, 7, 1, 0, // 6156: check Inst[7] == 0x0
4130 OPC_Decode, 143, 121, 50, // 6160: decode to PSADDU_DB using decoder 50
4131 // 6160: }
4132 92, 18, // 6164: case 0x5c: {
4133 OPC_CheckPredicate, 47, // 6166: check predicate 47
4134 OPC_CheckField, 20, 1, 0, // 6168: check Inst[20] == 0x0
4135 OPC_CheckField, 15, 1, 0, // 6172: check Inst[15] == 0x0
4136 OPC_CheckField, 7, 1, 0, // 6176: check Inst[7] == 0x0
4137 OPC_Decode, 216, 118, 50, // 6180: decode to PAADDU_DH using decoder 50
4138 // 6180: }
4139 93, 18, // 6184: case 0x5d: {
4140 OPC_CheckPredicate, 47, // 6186: check predicate 47
4141 OPC_CheckField, 20, 1, 0, // 6188: check Inst[20] == 0x0
4142 OPC_CheckField, 15, 1, 0, // 6192: check Inst[15] == 0x0
4143 OPC_CheckField, 7, 1, 0, // 6196: check Inst[7] == 0x0
4144 OPC_Decode, 217, 118, 50, // 6200: decode to PAADDU_DW using decoder 50
4145 // 6200: }
4146 94, 18, // 6204: case 0x5e: {
4147 OPC_CheckPredicate, 47, // 6206: check predicate 47
4148 OPC_CheckField, 20, 1, 0, // 6208: check Inst[20] == 0x0
4149 OPC_CheckField, 15, 1, 0, // 6212: check Inst[15] == 0x0
4150 OPC_CheckField, 7, 1, 0, // 6216: check Inst[7] == 0x0
4151 OPC_Decode, 215, 118, 50, // 6220: decode to PAADDU_DB using decoder 50
4152 // 6220: }
4153 96, 35, // 6224: case 0x60: {
4154 OPC_SwitchField, 15, 1, // 6226: switch Inst[15] {
4155 0, 14, // 6229: case 0x0: {
4156 OPC_CheckPredicate, 47, // 6231: check predicate 47
4157 OPC_CheckField, 20, 1, 0, // 6233: check Inst[20] == 0x0
4158 OPC_CheckField, 7, 1, 0, // 6237: check Inst[7] == 0x0
4159 OPC_Decode, 255, 121, 50, // 6241: decode to PSUB_DH using decoder 50
4160 // 6241: }
4161 1, 0, // 6245: case 0x1: {
4162 OPC_CheckPredicate, 47, // 6247: check predicate 47
4163 OPC_CheckField, 20, 1, 1, // 6249: check Inst[20] == 0x1
4164 OPC_CheckField, 7, 1, 0, // 6253: check Inst[7] == 0x0
4165 OPC_Decode, 144, 120, 50, // 6257: decode to PMSEQ_DH using decoder 50
4166 // 6257: }
4167 // 6257: } // switch Inst[15]
4168 // 6257: }
4169 97, 35, // 6261: case 0x61: {
4170 OPC_SwitchField, 15, 1, // 6263: switch Inst[15] {
4171 0, 14, // 6266: case 0x0: {
4172 OPC_CheckPredicate, 47, // 6268: check predicate 47
4173 OPC_CheckField, 20, 1, 0, // 6270: check Inst[20] == 0x0
4174 OPC_CheckField, 7, 1, 0, // 6274: check Inst[7] == 0x0
4175 OPC_Decode, 128, 122, 50, // 6278: decode to PSUB_DW using decoder 50
4176 // 6278: }
4177 1, 0, // 6282: case 0x1: {
4178 OPC_CheckPredicate, 47, // 6284: check predicate 47
4179 OPC_CheckField, 20, 1, 1, // 6286: check Inst[20] == 0x1
4180 OPC_CheckField, 7, 1, 0, // 6290: check Inst[7] == 0x0
4181 OPC_Decode, 145, 120, 50, // 6294: decode to PMSEQ_DW using decoder 50
4182 // 6294: }
4183 // 6294: } // switch Inst[15]
4184 // 6294: }
4185 98, 35, // 6298: case 0x62: {
4186 OPC_SwitchField, 15, 1, // 6300: switch Inst[15] {
4187 0, 14, // 6303: case 0x0: {
4188 OPC_CheckPredicate, 47, // 6305: check predicate 47
4189 OPC_CheckField, 20, 1, 0, // 6307: check Inst[20] == 0x0
4190 OPC_CheckField, 7, 1, 0, // 6311: check Inst[7] == 0x0
4191 OPC_Decode, 254, 121, 50, // 6315: decode to PSUB_DB using decoder 50
4192 // 6315: }
4193 1, 0, // 6319: case 0x1: {
4194 OPC_CheckPredicate, 47, // 6321: check predicate 47
4195 OPC_CheckField, 20, 1, 1, // 6323: check Inst[20] == 0x1
4196 OPC_CheckField, 7, 1, 0, // 6327: check Inst[7] == 0x0
4197 OPC_Decode, 143, 120, 50, // 6331: decode to PMSEQ_DB using decoder 50
4198 // 6331: }
4199 // 6331: } // switch Inst[15]
4200 // 6331: }
4201 99, 18, // 6335: case 0x63: {
4202 OPC_CheckPredicate, 47, // 6337: check predicate 47
4203 OPC_CheckField, 20, 1, 0, // 6339: check Inst[20] == 0x0
4204 OPC_CheckField, 15, 1, 0, // 6343: check Inst[15] == 0x0
4205 OPC_CheckField, 7, 1, 0, // 6347: check Inst[7] == 0x0
4206 OPC_Decode, 185, 125, 50, // 6351: decode to SUBD using decoder 50
4207 // 6351: }
4208 100, 18, // 6355: case 0x64: {
4209 OPC_CheckPredicate, 47, // 6357: check predicate 47
4210 OPC_CheckField, 20, 1, 0, // 6359: check Inst[20] == 0x0
4211 OPC_CheckField, 15, 1, 0, // 6363: check Inst[15] == 0x0
4212 OPC_CheckField, 7, 1, 0, // 6367: check Inst[7] == 0x0
4213 OPC_Decode, 237, 118, 50, // 6371: decode to PABD_DH using decoder 50
4214 // 6371: }
4215 102, 18, // 6375: case 0x66: {
4216 OPC_CheckPredicate, 47, // 6377: check predicate 47
4217 OPC_CheckField, 20, 1, 0, // 6379: check Inst[20] == 0x0
4218 OPC_CheckField, 15, 1, 0, // 6383: check Inst[15] == 0x0
4219 OPC_CheckField, 7, 1, 0, // 6387: check Inst[7] == 0x0
4220 OPC_Decode, 236, 118, 50, // 6391: decode to PABD_DB using decoder 50
4221 // 6391: }
4222 104, 35, // 6395: case 0x68: {
4223 OPC_SwitchField, 15, 1, // 6397: switch Inst[15] {
4224 0, 14, // 6400: case 0x0: {
4225 OPC_CheckPredicate, 47, // 6402: check predicate 47
4226 OPC_CheckField, 20, 1, 0, // 6404: check Inst[20] == 0x0
4227 OPC_CheckField, 7, 1, 0, // 6408: check Inst[7] == 0x0
4228 OPC_Decode, 249, 121, 50, // 6412: decode to PSSUB_DH using decoder 50
4229 // 6412: }
4230 1, 0, // 6416: case 0x1: {
4231 OPC_CheckPredicate, 47, // 6418: check predicate 47
4232 OPC_CheckField, 20, 1, 1, // 6420: check Inst[20] == 0x1
4233 OPC_CheckField, 7, 1, 0, // 6424: check Inst[7] == 0x0
4234 OPC_Decode, 156, 120, 50, // 6428: decode to PMSLT_DH using decoder 50
4235 // 6428: }
4236 // 6428: } // switch Inst[15]
4237 // 6428: }
4238 105, 35, // 6432: case 0x69: {
4239 OPC_SwitchField, 15, 1, // 6434: switch Inst[15] {
4240 0, 14, // 6437: case 0x0: {
4241 OPC_CheckPredicate, 47, // 6439: check predicate 47
4242 OPC_CheckField, 20, 1, 0, // 6441: check Inst[20] == 0x0
4243 OPC_CheckField, 7, 1, 0, // 6445: check Inst[7] == 0x0
4244 OPC_Decode, 250, 121, 50, // 6449: decode to PSSUB_DW using decoder 50
4245 // 6449: }
4246 1, 0, // 6453: case 0x1: {
4247 OPC_CheckPredicate, 47, // 6455: check predicate 47
4248 OPC_CheckField, 20, 1, 1, // 6457: check Inst[20] == 0x1
4249 OPC_CheckField, 7, 1, 0, // 6461: check Inst[7] == 0x0
4250 OPC_Decode, 157, 120, 50, // 6465: decode to PMSLT_DW using decoder 50
4251 // 6465: }
4252 // 6465: } // switch Inst[15]
4253 // 6465: }
4254 106, 35, // 6469: case 0x6a: {
4255 OPC_SwitchField, 15, 1, // 6471: switch Inst[15] {
4256 0, 14, // 6474: case 0x0: {
4257 OPC_CheckPredicate, 47, // 6476: check predicate 47
4258 OPC_CheckField, 20, 1, 0, // 6478: check Inst[20] == 0x0
4259 OPC_CheckField, 7, 1, 0, // 6482: check Inst[7] == 0x0
4260 OPC_Decode, 248, 121, 50, // 6486: decode to PSSUB_DB using decoder 50
4261 // 6486: }
4262 1, 0, // 6490: case 0x1: {
4263 OPC_CheckPredicate, 47, // 6492: check predicate 47
4264 OPC_CheckField, 20, 1, 1, // 6494: check Inst[20] == 0x1
4265 OPC_CheckField, 7, 1, 0, // 6498: check Inst[7] == 0x0
4266 OPC_Decode, 155, 120, 50, // 6502: decode to PMSLT_DB using decoder 50
4267 // 6502: }
4268 // 6502: } // switch Inst[15]
4269 // 6502: }
4270 108, 35, // 6506: case 0x6c: {
4271 OPC_SwitchField, 15, 1, // 6508: switch Inst[15] {
4272 0, 14, // 6511: case 0x0: {
4273 OPC_CheckPredicate, 47, // 6513: check predicate 47
4274 OPC_CheckField, 20, 1, 0, // 6515: check Inst[20] == 0x0
4275 OPC_CheckField, 7, 1, 0, // 6519: check Inst[7] == 0x0
4276 OPC_Decode, 137, 119, 50, // 6523: decode to PASUB_DH using decoder 50
4277 // 6523: }
4278 1, 0, // 6527: case 0x1: {
4279 OPC_CheckPredicate, 47, // 6529: check predicate 47
4280 OPC_CheckField, 20, 1, 1, // 6531: check Inst[20] == 0x1
4281 OPC_CheckField, 7, 1, 0, // 6535: check Inst[7] == 0x0
4282 OPC_Decode, 150, 120, 50, // 6539: decode to PMSLTU_DH using decoder 50
4283 // 6539: }
4284 // 6539: } // switch Inst[15]
4285 // 6539: }
4286 109, 35, // 6543: case 0x6d: {
4287 OPC_SwitchField, 15, 1, // 6545: switch Inst[15] {
4288 0, 14, // 6548: case 0x0: {
4289 OPC_CheckPredicate, 47, // 6550: check predicate 47
4290 OPC_CheckField, 20, 1, 0, // 6552: check Inst[20] == 0x0
4291 OPC_CheckField, 7, 1, 0, // 6556: check Inst[7] == 0x0
4292 OPC_Decode, 138, 119, 50, // 6560: decode to PASUB_DW using decoder 50
4293 // 6560: }
4294 1, 0, // 6564: case 0x1: {
4295 OPC_CheckPredicate, 47, // 6566: check predicate 47
4296 OPC_CheckField, 20, 1, 1, // 6568: check Inst[20] == 0x1
4297 OPC_CheckField, 7, 1, 0, // 6572: check Inst[7] == 0x0
4298 OPC_Decode, 151, 120, 50, // 6576: decode to PMSLTU_DW using decoder 50
4299 // 6576: }
4300 // 6576: } // switch Inst[15]
4301 // 6576: }
4302 110, 35, // 6580: case 0x6e: {
4303 OPC_SwitchField, 15, 1, // 6582: switch Inst[15] {
4304 0, 14, // 6585: case 0x0: {
4305 OPC_CheckPredicate, 47, // 6587: check predicate 47
4306 OPC_CheckField, 20, 1, 0, // 6589: check Inst[20] == 0x0
4307 OPC_CheckField, 7, 1, 0, // 6593: check Inst[7] == 0x0
4308 OPC_Decode, 136, 119, 50, // 6597: decode to PASUB_DB using decoder 50
4309 // 6597: }
4310 1, 0, // 6601: case 0x1: {
4311 OPC_CheckPredicate, 47, // 6603: check predicate 47
4312 OPC_CheckField, 20, 1, 1, // 6605: check Inst[20] == 0x1
4313 OPC_CheckField, 7, 1, 0, // 6609: check Inst[7] == 0x0
4314 OPC_Decode, 149, 120, 50, // 6613: decode to PMSLTU_DB using decoder 50
4315 // 6613: }
4316 // 6613: } // switch Inst[15]
4317 // 6613: }
4318 112, 18, // 6617: case 0x70: {
4319 OPC_CheckPredicate, 47, // 6619: check predicate 47
4320 OPC_CheckField, 20, 1, 1, // 6621: check Inst[20] == 0x1
4321 OPC_CheckField, 15, 1, 1, // 6625: check Inst[15] == 0x1
4322 OPC_CheckField, 7, 1, 0, // 6629: check Inst[7] == 0x0
4323 OPC_Decode, 250, 119, 50, // 6633: decode to PMIN_DH using decoder 50
4324 // 6633: }
4325 113, 18, // 6637: case 0x71: {
4326 OPC_CheckPredicate, 47, // 6639: check predicate 47
4327 OPC_CheckField, 20, 1, 1, // 6641: check Inst[20] == 0x1
4328 OPC_CheckField, 15, 1, 1, // 6645: check Inst[15] == 0x1
4329 OPC_CheckField, 7, 1, 0, // 6649: check Inst[7] == 0x0
4330 OPC_Decode, 251, 119, 50, // 6653: decode to PMIN_DW using decoder 50
4331 // 6653: }
4332 114, 18, // 6657: case 0x72: {
4333 OPC_CheckPredicate, 47, // 6659: check predicate 47
4334 OPC_CheckField, 20, 1, 1, // 6661: check Inst[20] == 0x1
4335 OPC_CheckField, 15, 1, 1, // 6665: check Inst[15] == 0x1
4336 OPC_CheckField, 7, 1, 0, // 6669: check Inst[7] == 0x0
4337 OPC_Decode, 249, 119, 50, // 6673: decode to PMIN_DB using decoder 50
4338 // 6673: }
4339 116, 35, // 6677: case 0x74: {
4340 OPC_SwitchField, 15, 1, // 6679: switch Inst[15] {
4341 0, 14, // 6682: case 0x0: {
4342 OPC_CheckPredicate, 47, // 6684: check predicate 47
4343 OPC_CheckField, 20, 1, 0, // 6686: check Inst[20] == 0x0
4344 OPC_CheckField, 7, 1, 0, // 6690: check Inst[7] == 0x0
4345 OPC_Decode, 233, 118, 50, // 6694: decode to PABDU_DH using decoder 50
4346 // 6694: }
4347 1, 0, // 6698: case 0x1: {
4348 OPC_CheckPredicate, 47, // 6700: check predicate 47
4349 OPC_CheckField, 20, 1, 1, // 6702: check Inst[20] == 0x1
4350 OPC_CheckField, 7, 1, 0, // 6706: check Inst[7] == 0x0
4351 OPC_Decode, 244, 119, 50, // 6710: decode to PMINU_DH using decoder 50
4352 // 6710: }
4353 // 6710: } // switch Inst[15]
4354 // 6710: }
4355 117, 18, // 6714: case 0x75: {
4356 OPC_CheckPredicate, 47, // 6716: check predicate 47
4357 OPC_CheckField, 20, 1, 1, // 6718: check Inst[20] == 0x1
4358 OPC_CheckField, 15, 1, 1, // 6722: check Inst[15] == 0x1
4359 OPC_CheckField, 7, 1, 0, // 6726: check Inst[7] == 0x0
4360 OPC_Decode, 245, 119, 50, // 6730: decode to PMINU_DW using decoder 50
4361 // 6730: }
4362 118, 35, // 6734: case 0x76: {
4363 OPC_SwitchField, 15, 1, // 6736: switch Inst[15] {
4364 0, 14, // 6739: case 0x0: {
4365 OPC_CheckPredicate, 47, // 6741: check predicate 47
4366 OPC_CheckField, 20, 1, 0, // 6743: check Inst[20] == 0x0
4367 OPC_CheckField, 7, 1, 0, // 6747: check Inst[7] == 0x0
4368 OPC_Decode, 232, 118, 50, // 6751: decode to PABDU_DB using decoder 50
4369 // 6751: }
4370 1, 0, // 6755: case 0x1: {
4371 OPC_CheckPredicate, 47, // 6757: check predicate 47
4372 OPC_CheckField, 20, 1, 1, // 6759: check Inst[20] == 0x1
4373 OPC_CheckField, 7, 1, 0, // 6763: check Inst[7] == 0x0
4374 OPC_Decode, 243, 119, 50, // 6767: decode to PMINU_DB using decoder 50
4375 // 6767: }
4376 // 6767: } // switch Inst[15]
4377 // 6767: }
4378 120, 35, // 6771: case 0x78: {
4379 OPC_SwitchField, 15, 1, // 6773: switch Inst[15] {
4380 0, 14, // 6776: case 0x0: {
4381 OPC_CheckPredicate, 47, // 6778: check predicate 47
4382 OPC_CheckField, 20, 1, 0, // 6780: check Inst[20] == 0x0
4383 OPC_CheckField, 7, 1, 0, // 6784: check Inst[7] == 0x0
4384 OPC_Decode, 243, 121, 50, // 6788: decode to PSSUBU_DH using decoder 50
4385 // 6788: }
4386 1, 0, // 6792: case 0x1: {
4387 OPC_CheckPredicate, 47, // 6794: check predicate 47
4388 OPC_CheckField, 20, 1, 1, // 6796: check Inst[20] == 0x1
4389 OPC_CheckField, 7, 1, 0, // 6800: check Inst[7] == 0x0
4390 OPC_Decode, 218, 119, 50, // 6804: decode to PMAX_DH using decoder 50
4391 // 6804: }
4392 // 6804: } // switch Inst[15]
4393 // 6804: }
4394 121, 35, // 6808: case 0x79: {
4395 OPC_SwitchField, 15, 1, // 6810: switch Inst[15] {
4396 0, 14, // 6813: case 0x0: {
4397 OPC_CheckPredicate, 47, // 6815: check predicate 47
4398 OPC_CheckField, 20, 1, 0, // 6817: check Inst[20] == 0x0
4399 OPC_CheckField, 7, 1, 0, // 6821: check Inst[7] == 0x0
4400 OPC_Decode, 244, 121, 50, // 6825: decode to PSSUBU_DW using decoder 50
4401 // 6825: }
4402 1, 0, // 6829: case 0x1: {
4403 OPC_CheckPredicate, 47, // 6831: check predicate 47
4404 OPC_CheckField, 20, 1, 1, // 6833: check Inst[20] == 0x1
4405 OPC_CheckField, 7, 1, 0, // 6837: check Inst[7] == 0x0
4406 OPC_Decode, 219, 119, 50, // 6841: decode to PMAX_DW using decoder 50
4407 // 6841: }
4408 // 6841: } // switch Inst[15]
4409 // 6841: }
4410 122, 35, // 6845: case 0x7a: {
4411 OPC_SwitchField, 15, 1, // 6847: switch Inst[15] {
4412 0, 14, // 6850: case 0x0: {
4413 OPC_CheckPredicate, 47, // 6852: check predicate 47
4414 OPC_CheckField, 20, 1, 0, // 6854: check Inst[20] == 0x0
4415 OPC_CheckField, 7, 1, 0, // 6858: check Inst[7] == 0x0
4416 OPC_Decode, 242, 121, 50, // 6862: decode to PSSUBU_DB using decoder 50
4417 // 6862: }
4418 1, 0, // 6866: case 0x1: {
4419 OPC_CheckPredicate, 47, // 6868: check predicate 47
4420 OPC_CheckField, 20, 1, 1, // 6870: check Inst[20] == 0x1
4421 OPC_CheckField, 7, 1, 0, // 6874: check Inst[7] == 0x0
4422 OPC_Decode, 217, 119, 50, // 6878: decode to PMAX_DB using decoder 50
4423 // 6878: }
4424 // 6878: } // switch Inst[15]
4425 // 6878: }
4426 124, 35, // 6882: case 0x7c: {
4427 OPC_SwitchField, 15, 1, // 6884: switch Inst[15] {
4428 0, 14, // 6887: case 0x0: {
4429 OPC_CheckPredicate, 47, // 6889: check predicate 47
4430 OPC_CheckField, 20, 1, 0, // 6891: check Inst[20] == 0x0
4431 OPC_CheckField, 7, 1, 0, // 6895: check Inst[7] == 0x0
4432 OPC_Decode, 131, 119, 50, // 6899: decode to PASUBU_DH using decoder 50
4433 // 6899: }
4434 1, 0, // 6903: case 0x1: {
4435 OPC_CheckPredicate, 47, // 6905: check predicate 47
4436 OPC_CheckField, 20, 1, 1, // 6907: check Inst[20] == 0x1
4437 OPC_CheckField, 7, 1, 0, // 6911: check Inst[7] == 0x0
4438 OPC_Decode, 212, 119, 50, // 6915: decode to PMAXU_DH using decoder 50
4439 // 6915: }
4440 // 6915: } // switch Inst[15]
4441 // 6915: }
4442 125, 35, // 6919: case 0x7d: {
4443 OPC_SwitchField, 15, 1, // 6921: switch Inst[15] {
4444 0, 14, // 6924: case 0x0: {
4445 OPC_CheckPredicate, 47, // 6926: check predicate 47
4446 OPC_CheckField, 20, 1, 0, // 6928: check Inst[20] == 0x0
4447 OPC_CheckField, 7, 1, 0, // 6932: check Inst[7] == 0x0
4448 OPC_Decode, 132, 119, 50, // 6936: decode to PASUBU_DW using decoder 50
4449 // 6936: }
4450 1, 0, // 6940: case 0x1: {
4451 OPC_CheckPredicate, 47, // 6942: check predicate 47
4452 OPC_CheckField, 20, 1, 1, // 6944: check Inst[20] == 0x1
4453 OPC_CheckField, 7, 1, 0, // 6948: check Inst[7] == 0x0
4454 OPC_Decode, 213, 119, 50, // 6952: decode to PMAXU_DW using decoder 50
4455 // 6952: }
4456 // 6952: } // switch Inst[15]
4457 // 6952: }
4458 126, 0, // 6956: case 0x7e: {
4459 OPC_SwitchField, 15, 1, // 6958: switch Inst[15] {
4460 0, 14, // 6961: case 0x0: {
4461 OPC_CheckPredicate, 47, // 6963: check predicate 47
4462 OPC_CheckField, 20, 1, 0, // 6965: check Inst[20] == 0x0
4463 OPC_CheckField, 7, 1, 0, // 6969: check Inst[7] == 0x0
4464 OPC_Decode, 130, 119, 50, // 6973: decode to PASUBU_DB using decoder 50
4465 // 6973: }
4466 1, 0, // 6977: case 0x1: {
4467 OPC_CheckPredicate, 47, // 6979: check predicate 47
4468 OPC_CheckField, 20, 1, 1, // 6981: check Inst[20] == 0x1
4469 OPC_CheckField, 7, 1, 0, // 6985: check Inst[7] == 0x0
4470 OPC_Decode, 211, 119, 50, // 6989: decode to PMAXU_DB using decoder 50
4471 // 6989: }
4472 // 6989: } // switch Inst[15]
4473 // 6989: }
4474 // 6989: } // switch Inst[31:25]
4475 // 6989: }
4476 // 6989: } // switch Inst[14:12]
4477 // 6989: }
4478 35, 29, // 6993: case 0x23: {
4479 OPC_SwitchField, 12, 3, // 6995: switch Inst[14:12] {
4480 0, 4, // 6998: case 0x0: {
4481 OPC_Decode, 224, 123, 51, // 7000: decode to SB using decoder 51
4482 // 7000: }
4483 1, 4, // 7004: case 0x1: {
4484 OPC_Decode, 187, 124, 51, // 7006: decode to SH using decoder 51
4485 // 7006: }
4486 2, 4, // 7010: case 0x2: {
4487 OPC_Decode, 187, 125, 51, // 7012: decode to SW using decoder 51
4488 // 7012: }
4489 3, 0, // 7016: case 0x3: {
4490 OPC_CheckPredicate, 22, // 7018: check predicate 22
4491 OPC_Decode, 238, 123, 51, // 7020: decode to SD using decoder 51
4492 // 7020: }
4493 // 7020: } // switch Inst[14:12]
4494 // 7020: }
4495 39, 165, 11, // 7024: case 0x27: {
4496 OPC_SwitchField, 12, 3, // 7027: switch Inst[14:12] {
4497 0, 136, 3, // 7030: case 0x0: {
4498 OPC_SwitchField, 26, 6, // 7033: switch Inst[31:26] {
4499 0, 38, // 7036: case 0x0: {
4500 OPC_SwitchField, 20, 5, // 7038: switch Inst[24:20] {
4501 0, 7, // 7041: case 0x0: {
4502 OPC_CheckPredicate, 23, // 7043: check predicate 23
4503 OPC_Decode, 177, 130, 1, 1, // 7045: decode to VSE8_V using decoder 1
4504 // 7045: }
4505 8, 11, // 7050: case 0x8: {
4506 OPC_CheckPredicate, 23, // 7052: check predicate 23
4507 OPC_CheckField, 25, 1, 1, // 7054: check Inst[25] == 0x1
4508 OPC_Decode, 162, 130, 1, 2, // 7058: decode to VS1R_V using decoder 2
4509 // 7058: }
4510 11, 0, // 7063: case 0xb: {
4511 OPC_CheckPredicate, 23, // 7065: check predicate 23
4512 OPC_CheckField, 25, 1, 1, // 7067: check Inst[25] == 0x1
4513 OPC_Decode, 203, 130, 1, 2, // 7071: decode to VSM_V using decoder 2
4514 // 7071: }
4515 // 7071: } // switch Inst[24:20]
4516 // 7071: }
4517 1, 7, // 7076: case 0x1: {
4518 OPC_CheckPredicate, 23, // 7078: check predicate 23
4519 OPC_Decode, 189, 131, 1, 3, // 7080: decode to VSUXEI8_V using decoder 3
4520 // 7080: }
4521 2, 7, // 7085: case 0x2: {
4522 OPC_CheckPredicate, 23, // 7087: check predicate 23
4523 OPC_Decode, 245, 130, 1, 4, // 7089: decode to VSSE8_V using decoder 4
4524 // 7089: }
4525 3, 7, // 7094: case 0x3: {
4526 OPC_CheckPredicate, 23, // 7096: check predicate 23
4527 OPC_Decode, 207, 130, 1, 3, // 7098: decode to VSOXEI8_V using decoder 3
4528 // 7098: }
4529 8, 25, // 7103: case 0x8: {
4530 OPC_SwitchField, 20, 5, // 7105: switch Inst[24:20] {
4531 0, 7, // 7108: case 0x0: {
4532 OPC_CheckPredicate, 23, // 7110: check predicate 23
4533 OPC_Decode, 249, 130, 1, 1, // 7112: decode to VSSEG2E8_V using decoder 1
4534 // 7112: }
4535 8, 0, // 7117: case 0x8: {
4536 OPC_CheckPredicate, 23, // 7119: check predicate 23
4537 OPC_CheckField, 25, 1, 1, // 7121: check Inst[25] == 0x1
4538 OPC_Decode, 163, 130, 1, 5, // 7125: decode to VS2R_V using decoder 5
4539 // 7125: }
4540 // 7125: } // switch Inst[24:20]
4541 // 7125: }
4542 9, 7, // 7130: case 0x9: {
4543 OPC_CheckPredicate, 23, // 7132: check predicate 23
4544 OPC_Decode, 193, 131, 1, 3, // 7134: decode to VSUXSEG2EI8_V using decoder 3
4545 // 7134: }
4546 10, 7, // 7139: case 0xa: {
4547 OPC_CheckPredicate, 23, // 7141: check predicate 23
4548 OPC_Decode, 155, 131, 1, 4, // 7143: decode to VSSSEG2E8_V using decoder 4
4549 // 7143: }
4550 11, 7, // 7148: case 0xb: {
4551 OPC_CheckPredicate, 23, // 7150: check predicate 23
4552 OPC_Decode, 211, 130, 1, 3, // 7152: decode to VSOXSEG2EI8_V using decoder 3
4553 // 7152: }
4554 16, 11, // 7157: case 0x10: {
4555 OPC_CheckPredicate, 23, // 7159: check predicate 23
4556 OPC_CheckField, 20, 5, 0, // 7161: check Inst[24:20] == 0x0
4557 OPC_Decode, 253, 130, 1, 1, // 7165: decode to VSSEG3E8_V using decoder 1
4558 // 7165: }
4559 17, 7, // 7170: case 0x11: {
4560 OPC_CheckPredicate, 23, // 7172: check predicate 23
4561 OPC_Decode, 197, 131, 1, 3, // 7174: decode to VSUXSEG3EI8_V using decoder 3
4562 // 7174: }
4563 18, 7, // 7179: case 0x12: {
4564 OPC_CheckPredicate, 23, // 7181: check predicate 23
4565 OPC_Decode, 159, 131, 1, 4, // 7183: decode to VSSSEG3E8_V using decoder 4
4566 // 7183: }
4567 19, 7, // 7188: case 0x13: {
4568 OPC_CheckPredicate, 23, // 7190: check predicate 23
4569 OPC_Decode, 215, 130, 1, 3, // 7192: decode to VSOXSEG3EI8_V using decoder 3
4570 // 7192: }
4571 24, 25, // 7197: case 0x18: {
4572 OPC_SwitchField, 20, 5, // 7199: switch Inst[24:20] {
4573 0, 7, // 7202: case 0x0: {
4574 OPC_CheckPredicate, 23, // 7204: check predicate 23
4575 OPC_Decode, 129, 131, 1, 1, // 7206: decode to VSSEG4E8_V using decoder 1
4576 // 7206: }
4577 8, 0, // 7211: case 0x8: {
4578 OPC_CheckPredicate, 23, // 7213: check predicate 23
4579 OPC_CheckField, 25, 1, 1, // 7215: check Inst[25] == 0x1
4580 OPC_Decode, 164, 130, 1, 6, // 7219: decode to VS4R_V using decoder 6
4581 // 7219: }
4582 // 7219: } // switch Inst[24:20]
4583 // 7219: }
4584 25, 7, // 7224: case 0x19: {
4585 OPC_CheckPredicate, 23, // 7226: check predicate 23
4586 OPC_Decode, 201, 131, 1, 3, // 7228: decode to VSUXSEG4EI8_V using decoder 3
4587 // 7228: }
4588 26, 7, // 7233: case 0x1a: {
4589 OPC_CheckPredicate, 23, // 7235: check predicate 23
4590 OPC_Decode, 163, 131, 1, 4, // 7237: decode to VSSSEG4E8_V using decoder 4
4591 // 7237: }
4592 27, 7, // 7242: case 0x1b: {
4593 OPC_CheckPredicate, 23, // 7244: check predicate 23
4594 OPC_Decode, 219, 130, 1, 3, // 7246: decode to VSOXSEG4EI8_V using decoder 3
4595 // 7246: }
4596 32, 11, // 7251: case 0x20: {
4597 OPC_CheckPredicate, 23, // 7253: check predicate 23
4598 OPC_CheckField, 20, 5, 0, // 7255: check Inst[24:20] == 0x0
4599 OPC_Decode, 133, 131, 1, 1, // 7259: decode to VSSEG5E8_V using decoder 1
4600 // 7259: }
4601 33, 7, // 7264: case 0x21: {
4602 OPC_CheckPredicate, 23, // 7266: check predicate 23
4603 OPC_Decode, 205, 131, 1, 3, // 7268: decode to VSUXSEG5EI8_V using decoder 3
4604 // 7268: }
4605 34, 7, // 7273: case 0x22: {
4606 OPC_CheckPredicate, 23, // 7275: check predicate 23
4607 OPC_Decode, 167, 131, 1, 4, // 7277: decode to VSSSEG5E8_V using decoder 4
4608 // 7277: }
4609 35, 7, // 7282: case 0x23: {
4610 OPC_CheckPredicate, 23, // 7284: check predicate 23
4611 OPC_Decode, 223, 130, 1, 3, // 7286: decode to VSOXSEG5EI8_V using decoder 3
4612 // 7286: }
4613 40, 11, // 7291: case 0x28: {
4614 OPC_CheckPredicate, 23, // 7293: check predicate 23
4615 OPC_CheckField, 20, 5, 0, // 7295: check Inst[24:20] == 0x0
4616 OPC_Decode, 137, 131, 1, 1, // 7299: decode to VSSEG6E8_V using decoder 1
4617 // 7299: }
4618 41, 7, // 7304: case 0x29: {
4619 OPC_CheckPredicate, 23, // 7306: check predicate 23
4620 OPC_Decode, 209, 131, 1, 3, // 7308: decode to VSUXSEG6EI8_V using decoder 3
4621 // 7308: }
4622 42, 7, // 7313: case 0x2a: {
4623 OPC_CheckPredicate, 23, // 7315: check predicate 23
4624 OPC_Decode, 171, 131, 1, 4, // 7317: decode to VSSSEG6E8_V using decoder 4
4625 // 7317: }
4626 43, 7, // 7322: case 0x2b: {
4627 OPC_CheckPredicate, 23, // 7324: check predicate 23
4628 OPC_Decode, 227, 130, 1, 3, // 7326: decode to VSOXSEG6EI8_V using decoder 3
4629 // 7326: }
4630 48, 11, // 7331: case 0x30: {
4631 OPC_CheckPredicate, 23, // 7333: check predicate 23
4632 OPC_CheckField, 20, 5, 0, // 7335: check Inst[24:20] == 0x0
4633 OPC_Decode, 141, 131, 1, 1, // 7339: decode to VSSEG7E8_V using decoder 1
4634 // 7339: }
4635 49, 7, // 7344: case 0x31: {
4636 OPC_CheckPredicate, 23, // 7346: check predicate 23
4637 OPC_Decode, 213, 131, 1, 3, // 7348: decode to VSUXSEG7EI8_V using decoder 3
4638 // 7348: }
4639 50, 7, // 7353: case 0x32: {
4640 OPC_CheckPredicate, 23, // 7355: check predicate 23
4641 OPC_Decode, 175, 131, 1, 4, // 7357: decode to VSSSEG7E8_V using decoder 4
4642 // 7357: }
4643 51, 7, // 7362: case 0x33: {
4644 OPC_CheckPredicate, 23, // 7364: check predicate 23
4645 OPC_Decode, 231, 130, 1, 3, // 7366: decode to VSOXSEG7EI8_V using decoder 3
4646 // 7366: }
4647 56, 25, // 7371: case 0x38: {
4648 OPC_SwitchField, 20, 5, // 7373: switch Inst[24:20] {
4649 0, 7, // 7376: case 0x0: {
4650 OPC_CheckPredicate, 23, // 7378: check predicate 23
4651 OPC_Decode, 145, 131, 1, 1, // 7380: decode to VSSEG8E8_V using decoder 1
4652 // 7380: }
4653 8, 0, // 7385: case 0x8: {
4654 OPC_CheckPredicate, 23, // 7387: check predicate 23
4655 OPC_CheckField, 25, 1, 1, // 7389: check Inst[25] == 0x1
4656 OPC_Decode, 165, 130, 1, 7, // 7393: decode to VS8R_V using decoder 7
4657 // 7393: }
4658 // 7393: } // switch Inst[24:20]
4659 // 7393: }
4660 57, 7, // 7398: case 0x39: {
4661 OPC_CheckPredicate, 23, // 7400: check predicate 23
4662 OPC_Decode, 217, 131, 1, 3, // 7402: decode to VSUXSEG8EI8_V using decoder 3
4663 // 7402: }
4664 58, 7, // 7407: case 0x3a: {
4665 OPC_CheckPredicate, 23, // 7409: check predicate 23
4666 OPC_Decode, 179, 131, 1, 4, // 7411: decode to VSSSEG8E8_V using decoder 4
4667 // 7411: }
4668 59, 0, // 7416: case 0x3b: {
4669 OPC_CheckPredicate, 23, // 7418: check predicate 23
4670 OPC_Decode, 235, 130, 1, 3, // 7420: decode to VSOXSEG8EI8_V using decoder 3
4671 // 7420: }
4672 // 7420: } // switch Inst[31:26]
4673 // 7420: }
4674 1, 6, // 7425: case 0x1: {
4675 OPC_CheckPredicate, 24, // 7427: check predicate 24
4676 OPC_Decode, 160, 116, 52, // 7429: decode to FSH using decoder 52
4677 // 7429: }
4678 2, 6, // 7433: case 0x2: {
4679 OPC_CheckPredicate, 25, // 7435: check predicate 25
4680 OPC_Decode, 178, 116, 53, // 7437: decode to FSW using decoder 53
4681 // 7437: }
4682 3, 6, // 7441: case 0x3: {
4683 OPC_CheckPredicate, 26, // 7443: check predicate 26
4684 OPC_Decode, 135, 116, 54, // 7445: decode to FSD using decoder 54
4685 // 7445: }
4686 4, 6, // 7449: case 0x4: {
4687 OPC_CheckPredicate, 27, // 7451: check predicate 27
4688 OPC_Decode, 161, 116, 55, // 7453: decode to FSQ using decoder 55
4689 // 7453: }
4690 5, 195, 2, // 7457: case 0x5: {
4691 OPC_SwitchField, 26, 6, // 7460: switch Inst[31:26] {
4692 0, 11, // 7463: case 0x0: {
4693 OPC_CheckPredicate, 23, // 7465: check predicate 23
4694 OPC_CheckField, 20, 5, 0, // 7467: check Inst[24:20] == 0x0
4695 OPC_Decode, 174, 130, 1, 1, // 7471: decode to VSE16_V using decoder 1
4696 // 7471: }
4697 1, 7, // 7476: case 0x1: {
4698 OPC_CheckPredicate, 23, // 7478: check predicate 23
4699 OPC_Decode, 186, 131, 1, 3, // 7480: decode to VSUXEI16_V using decoder 3
4700 // 7480: }
4701 2, 7, // 7485: case 0x2: {
4702 OPC_CheckPredicate, 23, // 7487: check predicate 23
4703 OPC_Decode, 242, 130, 1, 4, // 7489: decode to VSSE16_V using decoder 4
4704 // 7489: }
4705 3, 7, // 7494: case 0x3: {
4706 OPC_CheckPredicate, 23, // 7496: check predicate 23
4707 OPC_Decode, 204, 130, 1, 3, // 7498: decode to VSOXEI16_V using decoder 3
4708 // 7498: }
4709 8, 11, // 7503: case 0x8: {
4710 OPC_CheckPredicate, 23, // 7505: check predicate 23
4711 OPC_CheckField, 20, 5, 0, // 7507: check Inst[24:20] == 0x0
4712 OPC_Decode, 246, 130, 1, 1, // 7511: decode to VSSEG2E16_V using decoder 1
4713 // 7511: }
4714 9, 7, // 7516: case 0x9: {
4715 OPC_CheckPredicate, 23, // 7518: check predicate 23
4716 OPC_Decode, 190, 131, 1, 3, // 7520: decode to VSUXSEG2EI16_V using decoder 3
4717 // 7520: }
4718 10, 7, // 7525: case 0xa: {
4719 OPC_CheckPredicate, 23, // 7527: check predicate 23
4720 OPC_Decode, 152, 131, 1, 4, // 7529: decode to VSSSEG2E16_V using decoder 4
4721 // 7529: }
4722 11, 7, // 7534: case 0xb: {
4723 OPC_CheckPredicate, 23, // 7536: check predicate 23
4724 OPC_Decode, 208, 130, 1, 3, // 7538: decode to VSOXSEG2EI16_V using decoder 3
4725 // 7538: }
4726 16, 11, // 7543: case 0x10: {
4727 OPC_CheckPredicate, 23, // 7545: check predicate 23
4728 OPC_CheckField, 20, 5, 0, // 7547: check Inst[24:20] == 0x0
4729 OPC_Decode, 250, 130, 1, 1, // 7551: decode to VSSEG3E16_V using decoder 1
4730 // 7551: }
4731 17, 7, // 7556: case 0x11: {
4732 OPC_CheckPredicate, 23, // 7558: check predicate 23
4733 OPC_Decode, 194, 131, 1, 3, // 7560: decode to VSUXSEG3EI16_V using decoder 3
4734 // 7560: }
4735 18, 7, // 7565: case 0x12: {
4736 OPC_CheckPredicate, 23, // 7567: check predicate 23
4737 OPC_Decode, 156, 131, 1, 4, // 7569: decode to VSSSEG3E16_V using decoder 4
4738 // 7569: }
4739 19, 7, // 7574: case 0x13: {
4740 OPC_CheckPredicate, 23, // 7576: check predicate 23
4741 OPC_Decode, 212, 130, 1, 3, // 7578: decode to VSOXSEG3EI16_V using decoder 3
4742 // 7578: }
4743 24, 11, // 7583: case 0x18: {
4744 OPC_CheckPredicate, 23, // 7585: check predicate 23
4745 OPC_CheckField, 20, 5, 0, // 7587: check Inst[24:20] == 0x0
4746 OPC_Decode, 254, 130, 1, 1, // 7591: decode to VSSEG4E16_V using decoder 1
4747 // 7591: }
4748 25, 7, // 7596: case 0x19: {
4749 OPC_CheckPredicate, 23, // 7598: check predicate 23
4750 OPC_Decode, 198, 131, 1, 3, // 7600: decode to VSUXSEG4EI16_V using decoder 3
4751 // 7600: }
4752 26, 7, // 7605: case 0x1a: {
4753 OPC_CheckPredicate, 23, // 7607: check predicate 23
4754 OPC_Decode, 160, 131, 1, 4, // 7609: decode to VSSSEG4E16_V using decoder 4
4755 // 7609: }
4756 27, 7, // 7614: case 0x1b: {
4757 OPC_CheckPredicate, 23, // 7616: check predicate 23
4758 OPC_Decode, 216, 130, 1, 3, // 7618: decode to VSOXSEG4EI16_V using decoder 3
4759 // 7618: }
4760 32, 11, // 7623: case 0x20: {
4761 OPC_CheckPredicate, 23, // 7625: check predicate 23
4762 OPC_CheckField, 20, 5, 0, // 7627: check Inst[24:20] == 0x0
4763 OPC_Decode, 130, 131, 1, 1, // 7631: decode to VSSEG5E16_V using decoder 1
4764 // 7631: }
4765 33, 7, // 7636: case 0x21: {
4766 OPC_CheckPredicate, 23, // 7638: check predicate 23
4767 OPC_Decode, 202, 131, 1, 3, // 7640: decode to VSUXSEG5EI16_V using decoder 3
4768 // 7640: }
4769 34, 7, // 7645: case 0x22: {
4770 OPC_CheckPredicate, 23, // 7647: check predicate 23
4771 OPC_Decode, 164, 131, 1, 4, // 7649: decode to VSSSEG5E16_V using decoder 4
4772 // 7649: }
4773 35, 7, // 7654: case 0x23: {
4774 OPC_CheckPredicate, 23, // 7656: check predicate 23
4775 OPC_Decode, 220, 130, 1, 3, // 7658: decode to VSOXSEG5EI16_V using decoder 3
4776 // 7658: }
4777 40, 11, // 7663: case 0x28: {
4778 OPC_CheckPredicate, 23, // 7665: check predicate 23
4779 OPC_CheckField, 20, 5, 0, // 7667: check Inst[24:20] == 0x0
4780 OPC_Decode, 134, 131, 1, 1, // 7671: decode to VSSEG6E16_V using decoder 1
4781 // 7671: }
4782 41, 7, // 7676: case 0x29: {
4783 OPC_CheckPredicate, 23, // 7678: check predicate 23
4784 OPC_Decode, 206, 131, 1, 3, // 7680: decode to VSUXSEG6EI16_V using decoder 3
4785 // 7680: }
4786 42, 7, // 7685: case 0x2a: {
4787 OPC_CheckPredicate, 23, // 7687: check predicate 23
4788 OPC_Decode, 168, 131, 1, 4, // 7689: decode to VSSSEG6E16_V using decoder 4
4789 // 7689: }
4790 43, 7, // 7694: case 0x2b: {
4791 OPC_CheckPredicate, 23, // 7696: check predicate 23
4792 OPC_Decode, 224, 130, 1, 3, // 7698: decode to VSOXSEG6EI16_V using decoder 3
4793 // 7698: }
4794 48, 11, // 7703: case 0x30: {
4795 OPC_CheckPredicate, 23, // 7705: check predicate 23
4796 OPC_CheckField, 20, 5, 0, // 7707: check Inst[24:20] == 0x0
4797 OPC_Decode, 138, 131, 1, 1, // 7711: decode to VSSEG7E16_V using decoder 1
4798 // 7711: }
4799 49, 7, // 7716: case 0x31: {
4800 OPC_CheckPredicate, 23, // 7718: check predicate 23
4801 OPC_Decode, 210, 131, 1, 3, // 7720: decode to VSUXSEG7EI16_V using decoder 3
4802 // 7720: }
4803 50, 7, // 7725: case 0x32: {
4804 OPC_CheckPredicate, 23, // 7727: check predicate 23
4805 OPC_Decode, 172, 131, 1, 4, // 7729: decode to VSSSEG7E16_V using decoder 4
4806 // 7729: }
4807 51, 7, // 7734: case 0x33: {
4808 OPC_CheckPredicate, 23, // 7736: check predicate 23
4809 OPC_Decode, 228, 130, 1, 3, // 7738: decode to VSOXSEG7EI16_V using decoder 3
4810 // 7738: }
4811 56, 11, // 7743: case 0x38: {
4812 OPC_CheckPredicate, 23, // 7745: check predicate 23
4813 OPC_CheckField, 20, 5, 0, // 7747: check Inst[24:20] == 0x0
4814 OPC_Decode, 142, 131, 1, 1, // 7751: decode to VSSEG8E16_V using decoder 1
4815 // 7751: }
4816 57, 7, // 7756: case 0x39: {
4817 OPC_CheckPredicate, 23, // 7758: check predicate 23
4818 OPC_Decode, 214, 131, 1, 3, // 7760: decode to VSUXSEG8EI16_V using decoder 3
4819 // 7760: }
4820 58, 7, // 7765: case 0x3a: {
4821 OPC_CheckPredicate, 23, // 7767: check predicate 23
4822 OPC_Decode, 176, 131, 1, 4, // 7769: decode to VSSSEG8E16_V using decoder 4
4823 // 7769: }
4824 59, 0, // 7774: case 0x3b: {
4825 OPC_CheckPredicate, 23, // 7776: check predicate 23
4826 OPC_Decode, 232, 130, 1, 3, // 7778: decode to VSOXSEG8EI16_V using decoder 3
4827 // 7778: }
4828 // 7778: } // switch Inst[31:26]
4829 // 7778: }
4830 6, 195, 2, // 7783: case 0x6: {
4831 OPC_SwitchField, 26, 6, // 7786: switch Inst[31:26] {
4832 0, 11, // 7789: case 0x0: {
4833 OPC_CheckPredicate, 23, // 7791: check predicate 23
4834 OPC_CheckField, 20, 5, 0, // 7793: check Inst[24:20] == 0x0
4835 OPC_Decode, 175, 130, 1, 1, // 7797: decode to VSE32_V using decoder 1
4836 // 7797: }
4837 1, 7, // 7802: case 0x1: {
4838 OPC_CheckPredicate, 23, // 7804: check predicate 23
4839 OPC_Decode, 187, 131, 1, 3, // 7806: decode to VSUXEI32_V using decoder 3
4840 // 7806: }
4841 2, 7, // 7811: case 0x2: {
4842 OPC_CheckPredicate, 23, // 7813: check predicate 23
4843 OPC_Decode, 243, 130, 1, 4, // 7815: decode to VSSE32_V using decoder 4
4844 // 7815: }
4845 3, 7, // 7820: case 0x3: {
4846 OPC_CheckPredicate, 23, // 7822: check predicate 23
4847 OPC_Decode, 205, 130, 1, 3, // 7824: decode to VSOXEI32_V using decoder 3
4848 // 7824: }
4849 8, 11, // 7829: case 0x8: {
4850 OPC_CheckPredicate, 23, // 7831: check predicate 23
4851 OPC_CheckField, 20, 5, 0, // 7833: check Inst[24:20] == 0x0
4852 OPC_Decode, 247, 130, 1, 1, // 7837: decode to VSSEG2E32_V using decoder 1
4853 // 7837: }
4854 9, 7, // 7842: case 0x9: {
4855 OPC_CheckPredicate, 23, // 7844: check predicate 23
4856 OPC_Decode, 191, 131, 1, 3, // 7846: decode to VSUXSEG2EI32_V using decoder 3
4857 // 7846: }
4858 10, 7, // 7851: case 0xa: {
4859 OPC_CheckPredicate, 23, // 7853: check predicate 23
4860 OPC_Decode, 153, 131, 1, 4, // 7855: decode to VSSSEG2E32_V using decoder 4
4861 // 7855: }
4862 11, 7, // 7860: case 0xb: {
4863 OPC_CheckPredicate, 23, // 7862: check predicate 23
4864 OPC_Decode, 209, 130, 1, 3, // 7864: decode to VSOXSEG2EI32_V using decoder 3
4865 // 7864: }
4866 16, 11, // 7869: case 0x10: {
4867 OPC_CheckPredicate, 23, // 7871: check predicate 23
4868 OPC_CheckField, 20, 5, 0, // 7873: check Inst[24:20] == 0x0
4869 OPC_Decode, 251, 130, 1, 1, // 7877: decode to VSSEG3E32_V using decoder 1
4870 // 7877: }
4871 17, 7, // 7882: case 0x11: {
4872 OPC_CheckPredicate, 23, // 7884: check predicate 23
4873 OPC_Decode, 195, 131, 1, 3, // 7886: decode to VSUXSEG3EI32_V using decoder 3
4874 // 7886: }
4875 18, 7, // 7891: case 0x12: {
4876 OPC_CheckPredicate, 23, // 7893: check predicate 23
4877 OPC_Decode, 157, 131, 1, 4, // 7895: decode to VSSSEG3E32_V using decoder 4
4878 // 7895: }
4879 19, 7, // 7900: case 0x13: {
4880 OPC_CheckPredicate, 23, // 7902: check predicate 23
4881 OPC_Decode, 213, 130, 1, 3, // 7904: decode to VSOXSEG3EI32_V using decoder 3
4882 // 7904: }
4883 24, 11, // 7909: case 0x18: {
4884 OPC_CheckPredicate, 23, // 7911: check predicate 23
4885 OPC_CheckField, 20, 5, 0, // 7913: check Inst[24:20] == 0x0
4886 OPC_Decode, 255, 130, 1, 1, // 7917: decode to VSSEG4E32_V using decoder 1
4887 // 7917: }
4888 25, 7, // 7922: case 0x19: {
4889 OPC_CheckPredicate, 23, // 7924: check predicate 23
4890 OPC_Decode, 199, 131, 1, 3, // 7926: decode to VSUXSEG4EI32_V using decoder 3
4891 // 7926: }
4892 26, 7, // 7931: case 0x1a: {
4893 OPC_CheckPredicate, 23, // 7933: check predicate 23
4894 OPC_Decode, 161, 131, 1, 4, // 7935: decode to VSSSEG4E32_V using decoder 4
4895 // 7935: }
4896 27, 7, // 7940: case 0x1b: {
4897 OPC_CheckPredicate, 23, // 7942: check predicate 23
4898 OPC_Decode, 217, 130, 1, 3, // 7944: decode to VSOXSEG4EI32_V using decoder 3
4899 // 7944: }
4900 32, 11, // 7949: case 0x20: {
4901 OPC_CheckPredicate, 23, // 7951: check predicate 23
4902 OPC_CheckField, 20, 5, 0, // 7953: check Inst[24:20] == 0x0
4903 OPC_Decode, 131, 131, 1, 1, // 7957: decode to VSSEG5E32_V using decoder 1
4904 // 7957: }
4905 33, 7, // 7962: case 0x21: {
4906 OPC_CheckPredicate, 23, // 7964: check predicate 23
4907 OPC_Decode, 203, 131, 1, 3, // 7966: decode to VSUXSEG5EI32_V using decoder 3
4908 // 7966: }
4909 34, 7, // 7971: case 0x22: {
4910 OPC_CheckPredicate, 23, // 7973: check predicate 23
4911 OPC_Decode, 165, 131, 1, 4, // 7975: decode to VSSSEG5E32_V using decoder 4
4912 // 7975: }
4913 35, 7, // 7980: case 0x23: {
4914 OPC_CheckPredicate, 23, // 7982: check predicate 23
4915 OPC_Decode, 221, 130, 1, 3, // 7984: decode to VSOXSEG5EI32_V using decoder 3
4916 // 7984: }
4917 40, 11, // 7989: case 0x28: {
4918 OPC_CheckPredicate, 23, // 7991: check predicate 23
4919 OPC_CheckField, 20, 5, 0, // 7993: check Inst[24:20] == 0x0
4920 OPC_Decode, 135, 131, 1, 1, // 7997: decode to VSSEG6E32_V using decoder 1
4921 // 7997: }
4922 41, 7, // 8002: case 0x29: {
4923 OPC_CheckPredicate, 23, // 8004: check predicate 23
4924 OPC_Decode, 207, 131, 1, 3, // 8006: decode to VSUXSEG6EI32_V using decoder 3
4925 // 8006: }
4926 42, 7, // 8011: case 0x2a: {
4927 OPC_CheckPredicate, 23, // 8013: check predicate 23
4928 OPC_Decode, 169, 131, 1, 4, // 8015: decode to VSSSEG6E32_V using decoder 4
4929 // 8015: }
4930 43, 7, // 8020: case 0x2b: {
4931 OPC_CheckPredicate, 23, // 8022: check predicate 23
4932 OPC_Decode, 225, 130, 1, 3, // 8024: decode to VSOXSEG6EI32_V using decoder 3
4933 // 8024: }
4934 48, 11, // 8029: case 0x30: {
4935 OPC_CheckPredicate, 23, // 8031: check predicate 23
4936 OPC_CheckField, 20, 5, 0, // 8033: check Inst[24:20] == 0x0
4937 OPC_Decode, 139, 131, 1, 1, // 8037: decode to VSSEG7E32_V using decoder 1
4938 // 8037: }
4939 49, 7, // 8042: case 0x31: {
4940 OPC_CheckPredicate, 23, // 8044: check predicate 23
4941 OPC_Decode, 211, 131, 1, 3, // 8046: decode to VSUXSEG7EI32_V using decoder 3
4942 // 8046: }
4943 50, 7, // 8051: case 0x32: {
4944 OPC_CheckPredicate, 23, // 8053: check predicate 23
4945 OPC_Decode, 173, 131, 1, 4, // 8055: decode to VSSSEG7E32_V using decoder 4
4946 // 8055: }
4947 51, 7, // 8060: case 0x33: {
4948 OPC_CheckPredicate, 23, // 8062: check predicate 23
4949 OPC_Decode, 229, 130, 1, 3, // 8064: decode to VSOXSEG7EI32_V using decoder 3
4950 // 8064: }
4951 56, 11, // 8069: case 0x38: {
4952 OPC_CheckPredicate, 23, // 8071: check predicate 23
4953 OPC_CheckField, 20, 5, 0, // 8073: check Inst[24:20] == 0x0
4954 OPC_Decode, 143, 131, 1, 1, // 8077: decode to VSSEG8E32_V using decoder 1
4955 // 8077: }
4956 57, 7, // 8082: case 0x39: {
4957 OPC_CheckPredicate, 23, // 8084: check predicate 23
4958 OPC_Decode, 215, 131, 1, 3, // 8086: decode to VSUXSEG8EI32_V using decoder 3
4959 // 8086: }
4960 58, 7, // 8091: case 0x3a: {
4961 OPC_CheckPredicate, 23, // 8093: check predicate 23
4962 OPC_Decode, 177, 131, 1, 4, // 8095: decode to VSSSEG8E32_V using decoder 4
4963 // 8095: }
4964 59, 0, // 8100: case 0x3b: {
4965 OPC_CheckPredicate, 23, // 8102: check predicate 23
4966 OPC_Decode, 233, 130, 1, 3, // 8104: decode to VSOXSEG8EI32_V using decoder 3
4967 // 8104: }
4968 // 8104: } // switch Inst[31:26]
4969 // 8104: }
4970 7, 0, // 8109: case 0x7: {
4971 OPC_SwitchField, 26, 3, // 8111: switch Inst[28:26] {
4972 0, 107, // 8114: case 0x0: {
4973 OPC_SwitchField, 29, 3, // 8116: switch Inst[31:29] {
4974 0, 11, // 8119: case 0x0: {
4975 OPC_CheckPredicate, 28, // 8121: check predicate 28
4976 OPC_CheckField, 20, 5, 0, // 8123: check Inst[24:20] == 0x0
4977 OPC_Decode, 176, 130, 1, 1, // 8127: decode to VSE64_V using decoder 1
4978 // 8127: }
4979 1, 11, // 8132: case 0x1: {
4980 OPC_CheckPredicate, 28, // 8134: check predicate 28
4981 OPC_CheckField, 20, 5, 0, // 8136: check Inst[24:20] == 0x0
4982 OPC_Decode, 248, 130, 1, 1, // 8140: decode to VSSEG2E64_V using decoder 1
4983 // 8140: }
4984 2, 11, // 8145: case 0x2: {
4985 OPC_CheckPredicate, 28, // 8147: check predicate 28
4986 OPC_CheckField, 20, 5, 0, // 8149: check Inst[24:20] == 0x0
4987 OPC_Decode, 252, 130, 1, 1, // 8153: decode to VSSEG3E64_V using decoder 1
4988 // 8153: }
4989 3, 11, // 8158: case 0x3: {
4990 OPC_CheckPredicate, 28, // 8160: check predicate 28
4991 OPC_CheckField, 20, 5, 0, // 8162: check Inst[24:20] == 0x0
4992 OPC_Decode, 128, 131, 1, 1, // 8166: decode to VSSEG4E64_V using decoder 1
4993 // 8166: }
4994 4, 11, // 8171: case 0x4: {
4995 OPC_CheckPredicate, 28, // 8173: check predicate 28
4996 OPC_CheckField, 20, 5, 0, // 8175: check Inst[24:20] == 0x0
4997 OPC_Decode, 132, 131, 1, 1, // 8179: decode to VSSEG5E64_V using decoder 1
4998 // 8179: }
4999 5, 11, // 8184: case 0x5: {
5000 OPC_CheckPredicate, 28, // 8186: check predicate 28
5001 OPC_CheckField, 20, 5, 0, // 8188: check Inst[24:20] == 0x0
5002 OPC_Decode, 136, 131, 1, 1, // 8192: decode to VSSEG6E64_V using decoder 1
5003 // 8192: }
5004 6, 11, // 8197: case 0x6: {
5005 OPC_CheckPredicate, 28, // 8199: check predicate 28
5006 OPC_CheckField, 20, 5, 0, // 8201: check Inst[24:20] == 0x0
5007 OPC_Decode, 140, 131, 1, 1, // 8205: decode to VSSEG7E64_V using decoder 1
5008 // 8205: }
5009 7, 0, // 8210: case 0x7: {
5010 OPC_CheckPredicate, 28, // 8212: check predicate 28
5011 OPC_CheckField, 20, 5, 0, // 8214: check Inst[24:20] == 0x0
5012 OPC_Decode, 144, 131, 1, 1, // 8218: decode to VSSEG8E64_V using decoder 1
5013 // 8218: }
5014 // 8218: } // switch Inst[31:29]
5015 // 8218: }
5016 1, 75, // 8223: case 0x1: {
5017 OPC_SwitchField, 29, 3, // 8225: switch Inst[31:29] {
5018 0, 7, // 8228: case 0x0: {
5019 OPC_CheckPredicate, 29, // 8230: check predicate 29
5020 OPC_Decode, 188, 131, 1, 3, // 8232: decode to VSUXEI64_V using decoder 3
5021 // 8232: }
5022 1, 7, // 8237: case 0x1: {
5023 OPC_CheckPredicate, 30, // 8239: check predicate 30
5024 OPC_Decode, 192, 131, 1, 3, // 8241: decode to VSUXSEG2EI64_V using decoder 3
5025 // 8241: }
5026 2, 7, // 8246: case 0x2: {
5027 OPC_CheckPredicate, 30, // 8248: check predicate 30
5028 OPC_Decode, 196, 131, 1, 3, // 8250: decode to VSUXSEG3EI64_V using decoder 3
5029 // 8250: }
5030 3, 7, // 8255: case 0x3: {
5031 OPC_CheckPredicate, 30, // 8257: check predicate 30
5032 OPC_Decode, 200, 131, 1, 3, // 8259: decode to VSUXSEG4EI64_V using decoder 3
5033 // 8259: }
5034 4, 7, // 8264: case 0x4: {
5035 OPC_CheckPredicate, 30, // 8266: check predicate 30
5036 OPC_Decode, 204, 131, 1, 3, // 8268: decode to VSUXSEG5EI64_V using decoder 3
5037 // 8268: }
5038 5, 7, // 8273: case 0x5: {
5039 OPC_CheckPredicate, 30, // 8275: check predicate 30
5040 OPC_Decode, 208, 131, 1, 3, // 8277: decode to VSUXSEG6EI64_V using decoder 3
5041 // 8277: }
5042 6, 7, // 8282: case 0x6: {
5043 OPC_CheckPredicate, 30, // 8284: check predicate 30
5044 OPC_Decode, 212, 131, 1, 3, // 8286: decode to VSUXSEG7EI64_V using decoder 3
5045 // 8286: }
5046 7, 0, // 8291: case 0x7: {
5047 OPC_CheckPredicate, 30, // 8293: check predicate 30
5048 OPC_Decode, 216, 131, 1, 3, // 8295: decode to VSUXSEG8EI64_V using decoder 3
5049 // 8295: }
5050 // 8295: } // switch Inst[31:29]
5051 // 8295: }
5052 2, 75, // 8300: case 0x2: {
5053 OPC_SwitchField, 29, 3, // 8302: switch Inst[31:29] {
5054 0, 7, // 8305: case 0x0: {
5055 OPC_CheckPredicate, 28, // 8307: check predicate 28
5056 OPC_Decode, 244, 130, 1, 4, // 8309: decode to VSSE64_V using decoder 4
5057 // 8309: }
5058 1, 7, // 8314: case 0x1: {
5059 OPC_CheckPredicate, 28, // 8316: check predicate 28
5060 OPC_Decode, 154, 131, 1, 4, // 8318: decode to VSSSEG2E64_V using decoder 4
5061 // 8318: }
5062 2, 7, // 8323: case 0x2: {
5063 OPC_CheckPredicate, 28, // 8325: check predicate 28
5064 OPC_Decode, 158, 131, 1, 4, // 8327: decode to VSSSEG3E64_V using decoder 4
5065 // 8327: }
5066 3, 7, // 8332: case 0x3: {
5067 OPC_CheckPredicate, 28, // 8334: check predicate 28
5068 OPC_Decode, 162, 131, 1, 4, // 8336: decode to VSSSEG4E64_V using decoder 4
5069 // 8336: }
5070 4, 7, // 8341: case 0x4: {
5071 OPC_CheckPredicate, 28, // 8343: check predicate 28
5072 OPC_Decode, 166, 131, 1, 4, // 8345: decode to VSSSEG5E64_V using decoder 4
5073 // 8345: }
5074 5, 7, // 8350: case 0x5: {
5075 OPC_CheckPredicate, 28, // 8352: check predicate 28
5076 OPC_Decode, 170, 131, 1, 4, // 8354: decode to VSSSEG6E64_V using decoder 4
5077 // 8354: }
5078 6, 7, // 8359: case 0x6: {
5079 OPC_CheckPredicate, 28, // 8361: check predicate 28
5080 OPC_Decode, 174, 131, 1, 4, // 8363: decode to VSSSEG7E64_V using decoder 4
5081 // 8363: }
5082 7, 0, // 8368: case 0x7: {
5083 OPC_CheckPredicate, 28, // 8370: check predicate 28
5084 OPC_Decode, 178, 131, 1, 4, // 8372: decode to VSSSEG8E64_V using decoder 4
5085 // 8372: }
5086 // 8372: } // switch Inst[31:29]
5087 // 8372: }
5088 3, 75, // 8377: case 0x3: {
5089 OPC_SwitchField, 29, 3, // 8379: switch Inst[31:29] {
5090 0, 7, // 8382: case 0x0: {
5091 OPC_CheckPredicate, 29, // 8384: check predicate 29
5092 OPC_Decode, 206, 130, 1, 3, // 8386: decode to VSOXEI64_V using decoder 3
5093 // 8386: }
5094 1, 7, // 8391: case 0x1: {
5095 OPC_CheckPredicate, 30, // 8393: check predicate 30
5096 OPC_Decode, 210, 130, 1, 3, // 8395: decode to VSOXSEG2EI64_V using decoder 3
5097 // 8395: }
5098 2, 7, // 8400: case 0x2: {
5099 OPC_CheckPredicate, 30, // 8402: check predicate 30
5100 OPC_Decode, 214, 130, 1, 3, // 8404: decode to VSOXSEG3EI64_V using decoder 3
5101 // 8404: }
5102 3, 7, // 8409: case 0x3: {
5103 OPC_CheckPredicate, 30, // 8411: check predicate 30
5104 OPC_Decode, 218, 130, 1, 3, // 8413: decode to VSOXSEG4EI64_V using decoder 3
5105 // 8413: }
5106 4, 7, // 8418: case 0x4: {
5107 OPC_CheckPredicate, 30, // 8420: check predicate 30
5108 OPC_Decode, 222, 130, 1, 3, // 8422: decode to VSOXSEG5EI64_V using decoder 3
5109 // 8422: }
5110 5, 7, // 8427: case 0x5: {
5111 OPC_CheckPredicate, 30, // 8429: check predicate 30
5112 OPC_Decode, 226, 130, 1, 3, // 8431: decode to VSOXSEG6EI64_V using decoder 3
5113 // 8431: }
5114 6, 7, // 8436: case 0x6: {
5115 OPC_CheckPredicate, 30, // 8438: check predicate 30
5116 OPC_Decode, 230, 130, 1, 3, // 8440: decode to VSOXSEG7EI64_V using decoder 3
5117 // 8440: }
5118 7, 0, // 8445: case 0x7: {
5119 OPC_CheckPredicate, 30, // 8447: check predicate 30
5120 OPC_Decode, 234, 130, 1, 3, // 8449: decode to VSOXSEG8EI64_V using decoder 3
5121 // 8449: }
5122 // 8449: } // switch Inst[31:29]
5123 // 8449: }
5124 4, 7, // 8454: case 0x4: {
5125 OPC_CheckPredicate, 31, // 8456: check predicate 31
5126 OPC_Decode, 218, 129, 1, 12, // 8458: decode to VMTS_V using decoder 12
5127 // 8458: }
5128 5, 0, // 8463: case 0x5: {
5129 OPC_CheckPredicate, 32, // 8465: check predicate 32
5130 OPC_Decode, 220, 129, 1, 12, // 8467: decode to VMTTS_V using decoder 12
5131 // 8467: }
5132 // 8467: } // switch Inst[28:26]
5133 // 8467: }
5134 // 8467: } // switch Inst[14:12]
5135 // 8467: }
5136 47, 226, 16, // 8472: case 0x2f: {
5137 OPC_SwitchField, 25, 7, // 8475: switch Inst[31:25] {
5138 0, 35, // 8478: case 0x0: {
5139 OPC_SwitchField, 12, 3, // 8480: switch Inst[14:12] {
5140 0, 6, // 8483: case 0x0: {
5141 OPC_CheckPredicate, 52, // 8485: check predicate 52
5142 OPC_Decode, 181, 109, 56, // 8487: decode to AMOADD_B using decoder 56
5143 // 8487: }
5144 1, 6, // 8491: case 0x1: {
5145 OPC_CheckPredicate, 52, // 8493: check predicate 52
5146 OPC_Decode, 189, 109, 56, // 8495: decode to AMOADD_H using decoder 56
5147 // 8495: }
5148 2, 6, // 8499: case 0x2: {
5149 OPC_CheckPredicate, 53, // 8501: check predicate 53
5150 OPC_Decode, 193, 109, 56, // 8503: decode to AMOADD_W using decoder 56
5151 // 8503: }
5152 3, 0, // 8507: case 0x3: {
5153 OPC_CheckPredicate, 54, // 8509: check predicate 54
5154 OPC_Decode, 185, 109, 56, // 8511: decode to AMOADD_D using decoder 56
5155 // 8511: }
5156 // 8511: } // switch Inst[14:12]
5157 // 8511: }
5158 1, 35, // 8515: case 0x1: {
5159 OPC_SwitchField, 12, 3, // 8517: switch Inst[14:12] {
5160 0, 6, // 8520: case 0x0: {
5161 OPC_CheckPredicate, 52, // 8522: check predicate 52
5162 OPC_Decode, 184, 109, 56, // 8524: decode to AMOADD_B_RL using decoder 56
5163 // 8524: }
5164 1, 6, // 8528: case 0x1: {
5165 OPC_CheckPredicate, 52, // 8530: check predicate 52
5166 OPC_Decode, 192, 109, 56, // 8532: decode to AMOADD_H_RL using decoder 56
5167 // 8532: }
5168 2, 6, // 8536: case 0x2: {
5169 OPC_CheckPredicate, 53, // 8538: check predicate 53
5170 OPC_Decode, 196, 109, 56, // 8540: decode to AMOADD_W_RL using decoder 56
5171 // 8540: }
5172 3, 0, // 8544: case 0x3: {
5173 OPC_CheckPredicate, 54, // 8546: check predicate 54
5174 OPC_Decode, 188, 109, 56, // 8548: decode to AMOADD_D_RL using decoder 56
5175 // 8548: }
5176 // 8548: } // switch Inst[14:12]
5177 // 8548: }
5178 2, 35, // 8552: case 0x2: {
5179 OPC_SwitchField, 12, 3, // 8554: switch Inst[14:12] {
5180 0, 6, // 8557: case 0x0: {
5181 OPC_CheckPredicate, 52, // 8559: check predicate 52
5182 OPC_Decode, 182, 109, 56, // 8561: decode to AMOADD_B_AQ using decoder 56
5183 // 8561: }
5184 1, 6, // 8565: case 0x1: {
5185 OPC_CheckPredicate, 52, // 8567: check predicate 52
5186 OPC_Decode, 190, 109, 56, // 8569: decode to AMOADD_H_AQ using decoder 56
5187 // 8569: }
5188 2, 6, // 8573: case 0x2: {
5189 OPC_CheckPredicate, 53, // 8575: check predicate 53
5190 OPC_Decode, 194, 109, 56, // 8577: decode to AMOADD_W_AQ using decoder 56
5191 // 8577: }
5192 3, 0, // 8581: case 0x3: {
5193 OPC_CheckPredicate, 54, // 8583: check predicate 54
5194 OPC_Decode, 186, 109, 56, // 8585: decode to AMOADD_D_AQ using decoder 56
5195 // 8585: }
5196 // 8585: } // switch Inst[14:12]
5197 // 8585: }
5198 3, 35, // 8589: case 0x3: {
5199 OPC_SwitchField, 12, 3, // 8591: switch Inst[14:12] {
5200 0, 6, // 8594: case 0x0: {
5201 OPC_CheckPredicate, 52, // 8596: check predicate 52
5202 OPC_Decode, 183, 109, 56, // 8598: decode to AMOADD_B_AQRL using decoder 56
5203 // 8598: }
5204 1, 6, // 8602: case 0x1: {
5205 OPC_CheckPredicate, 52, // 8604: check predicate 52
5206 OPC_Decode, 191, 109, 56, // 8606: decode to AMOADD_H_AQRL using decoder 56
5207 // 8606: }
5208 2, 6, // 8610: case 0x2: {
5209 OPC_CheckPredicate, 53, // 8612: check predicate 53
5210 OPC_Decode, 195, 109, 56, // 8614: decode to AMOADD_W_AQRL using decoder 56
5211 // 8614: }
5212 3, 0, // 8618: case 0x3: {
5213 OPC_CheckPredicate, 54, // 8620: check predicate 54
5214 OPC_Decode, 187, 109, 56, // 8622: decode to AMOADD_D_AQRL using decoder 56
5215 // 8622: }
5216 // 8622: } // switch Inst[14:12]
5217 // 8622: }
5218 4, 35, // 8626: case 0x4: {
5219 OPC_SwitchField, 12, 3, // 8628: switch Inst[14:12] {
5220 0, 6, // 8631: case 0x0: {
5221 OPC_CheckPredicate, 52, // 8633: check predicate 52
5222 OPC_Decode, 189, 110, 56, // 8635: decode to AMOSWAP_B using decoder 56
5223 // 8635: }
5224 1, 6, // 8639: case 0x1: {
5225 OPC_CheckPredicate, 52, // 8641: check predicate 52
5226 OPC_Decode, 197, 110, 56, // 8643: decode to AMOSWAP_H using decoder 56
5227 // 8643: }
5228 2, 6, // 8647: case 0x2: {
5229 OPC_CheckPredicate, 53, // 8649: check predicate 53
5230 OPC_Decode, 201, 110, 56, // 8651: decode to AMOSWAP_W using decoder 56
5231 // 8651: }
5232 3, 0, // 8655: case 0x3: {
5233 OPC_CheckPredicate, 54, // 8657: check predicate 54
5234 OPC_Decode, 193, 110, 56, // 8659: decode to AMOSWAP_D using decoder 56
5235 // 8659: }
5236 // 8659: } // switch Inst[14:12]
5237 // 8659: }
5238 5, 35, // 8663: case 0x5: {
5239 OPC_SwitchField, 12, 3, // 8665: switch Inst[14:12] {
5240 0, 6, // 8668: case 0x0: {
5241 OPC_CheckPredicate, 52, // 8670: check predicate 52
5242 OPC_Decode, 192, 110, 56, // 8672: decode to AMOSWAP_B_RL using decoder 56
5243 // 8672: }
5244 1, 6, // 8676: case 0x1: {
5245 OPC_CheckPredicate, 52, // 8678: check predicate 52
5246 OPC_Decode, 200, 110, 56, // 8680: decode to AMOSWAP_H_RL using decoder 56
5247 // 8680: }
5248 2, 6, // 8684: case 0x2: {
5249 OPC_CheckPredicate, 53, // 8686: check predicate 53
5250 OPC_Decode, 204, 110, 56, // 8688: decode to AMOSWAP_W_RL using decoder 56
5251 // 8688: }
5252 3, 0, // 8692: case 0x3: {
5253 OPC_CheckPredicate, 54, // 8694: check predicate 54
5254 OPC_Decode, 196, 110, 56, // 8696: decode to AMOSWAP_D_RL using decoder 56
5255 // 8696: }
5256 // 8696: } // switch Inst[14:12]
5257 // 8696: }
5258 6, 35, // 8700: case 0x6: {
5259 OPC_SwitchField, 12, 3, // 8702: switch Inst[14:12] {
5260 0, 6, // 8705: case 0x0: {
5261 OPC_CheckPredicate, 52, // 8707: check predicate 52
5262 OPC_Decode, 190, 110, 56, // 8709: decode to AMOSWAP_B_AQ using decoder 56
5263 // 8709: }
5264 1, 6, // 8713: case 0x1: {
5265 OPC_CheckPredicate, 52, // 8715: check predicate 52
5266 OPC_Decode, 198, 110, 56, // 8717: decode to AMOSWAP_H_AQ using decoder 56
5267 // 8717: }
5268 2, 6, // 8721: case 0x2: {
5269 OPC_CheckPredicate, 53, // 8723: check predicate 53
5270 OPC_Decode, 202, 110, 56, // 8725: decode to AMOSWAP_W_AQ using decoder 56
5271 // 8725: }
5272 3, 0, // 8729: case 0x3: {
5273 OPC_CheckPredicate, 54, // 8731: check predicate 54
5274 OPC_Decode, 194, 110, 56, // 8733: decode to AMOSWAP_D_AQ using decoder 56
5275 // 8733: }
5276 // 8733: } // switch Inst[14:12]
5277 // 8733: }
5278 7, 35, // 8737: case 0x7: {
5279 OPC_SwitchField, 12, 3, // 8739: switch Inst[14:12] {
5280 0, 6, // 8742: case 0x0: {
5281 OPC_CheckPredicate, 52, // 8744: check predicate 52
5282 OPC_Decode, 191, 110, 56, // 8746: decode to AMOSWAP_B_AQRL using decoder 56
5283 // 8746: }
5284 1, 6, // 8750: case 0x1: {
5285 OPC_CheckPredicate, 52, // 8752: check predicate 52
5286 OPC_Decode, 199, 110, 56, // 8754: decode to AMOSWAP_H_AQRL using decoder 56
5287 // 8754: }
5288 2, 6, // 8758: case 0x2: {
5289 OPC_CheckPredicate, 53, // 8760: check predicate 53
5290 OPC_Decode, 203, 110, 56, // 8762: decode to AMOSWAP_W_AQRL using decoder 56
5291 // 8762: }
5292 3, 0, // 8766: case 0x3: {
5293 OPC_CheckPredicate, 54, // 8768: check predicate 54
5294 OPC_Decode, 195, 110, 56, // 8770: decode to AMOSWAP_D_AQRL using decoder 56
5295 // 8770: }
5296 // 8770: } // switch Inst[14:12]
5297 // 8770: }
5298 8, 27, // 8774: case 0x8: {
5299 OPC_SwitchField, 12, 3, // 8776: switch Inst[14:12] {
5300 2, 10, // 8779: case 0x2: {
5301 OPC_CheckPredicate, 55, // 8781: check predicate 55
5302 OPC_CheckField, 20, 5, 0, // 8783: check Inst[24:20] == 0x0
5303 OPC_Decode, 242, 116, 17, // 8787: decode to LR_W using decoder 17
5304 // 8787: }
5305 3, 0, // 8791: case 0x3: {
5306 OPC_CheckPredicate, 56, // 8793: check predicate 56
5307 OPC_CheckField, 20, 5, 0, // 8795: check Inst[24:20] == 0x0
5308 OPC_Decode, 238, 116, 17, // 8799: decode to LR_D using decoder 17
5309 // 8799: }
5310 // 8799: } // switch Inst[14:12]
5311 // 8799: }
5312 9, 27, // 8803: case 0x9: {
5313 OPC_SwitchField, 12, 3, // 8805: switch Inst[14:12] {
5314 2, 10, // 8808: case 0x2: {
5315 OPC_CheckPredicate, 55, // 8810: check predicate 55
5316 OPC_CheckField, 20, 5, 0, // 8812: check Inst[24:20] == 0x0
5317 OPC_Decode, 245, 116, 17, // 8816: decode to LR_W_RL using decoder 17
5318 // 8816: }
5319 3, 0, // 8820: case 0x3: {
5320 OPC_CheckPredicate, 56, // 8822: check predicate 56
5321 OPC_CheckField, 20, 5, 0, // 8824: check Inst[24:20] == 0x0
5322 OPC_Decode, 241, 116, 17, // 8828: decode to LR_D_RL using decoder 17
5323 // 8828: }
5324 // 8828: } // switch Inst[14:12]
5325 // 8828: }
5326 10, 27, // 8832: case 0xa: {
5327 OPC_SwitchField, 12, 3, // 8834: switch Inst[14:12] {
5328 2, 10, // 8837: case 0x2: {
5329 OPC_CheckPredicate, 55, // 8839: check predicate 55
5330 OPC_CheckField, 20, 5, 0, // 8841: check Inst[24:20] == 0x0
5331 OPC_Decode, 243, 116, 17, // 8845: decode to LR_W_AQ using decoder 17
5332 // 8845: }
5333 3, 0, // 8849: case 0x3: {
5334 OPC_CheckPredicate, 56, // 8851: check predicate 56
5335 OPC_CheckField, 20, 5, 0, // 8853: check Inst[24:20] == 0x0
5336 OPC_Decode, 239, 116, 17, // 8857: decode to LR_D_AQ using decoder 17
5337 // 8857: }
5338 // 8857: } // switch Inst[14:12]
5339 // 8857: }
5340 11, 27, // 8861: case 0xb: {
5341 OPC_SwitchField, 12, 3, // 8863: switch Inst[14:12] {
5342 2, 10, // 8866: case 0x2: {
5343 OPC_CheckPredicate, 55, // 8868: check predicate 55
5344 OPC_CheckField, 20, 5, 0, // 8870: check Inst[24:20] == 0x0
5345 OPC_Decode, 244, 116, 17, // 8874: decode to LR_W_AQRL using decoder 17
5346 // 8874: }
5347 3, 0, // 8878: case 0x3: {
5348 OPC_CheckPredicate, 56, // 8880: check predicate 56
5349 OPC_CheckField, 20, 5, 0, // 8882: check Inst[24:20] == 0x0
5350 OPC_Decode, 240, 116, 17, // 8886: decode to LR_D_AQRL using decoder 17
5351 // 8886: }
5352 // 8886: } // switch Inst[14:12]
5353 // 8886: }
5354 12, 19, // 8890: case 0xc: {
5355 OPC_SwitchField, 12, 3, // 8892: switch Inst[14:12] {
5356 2, 6, // 8895: case 0x2: {
5357 OPC_CheckPredicate, 55, // 8897: check predicate 55
5358 OPC_Decode, 234, 123, 56, // 8899: decode to SC_W using decoder 56
5359 // 8899: }
5360 3, 0, // 8903: case 0x3: {
5361 OPC_CheckPredicate, 56, // 8905: check predicate 56
5362 OPC_Decode, 230, 123, 56, // 8907: decode to SC_D using decoder 56
5363 // 8907: }
5364 // 8907: } // switch Inst[14:12]
5365 // 8907: }
5366 13, 19, // 8911: case 0xd: {
5367 OPC_SwitchField, 12, 3, // 8913: switch Inst[14:12] {
5368 2, 6, // 8916: case 0x2: {
5369 OPC_CheckPredicate, 55, // 8918: check predicate 55
5370 OPC_Decode, 237, 123, 56, // 8920: decode to SC_W_RL using decoder 56
5371 // 8920: }
5372 3, 0, // 8924: case 0x3: {
5373 OPC_CheckPredicate, 56, // 8926: check predicate 56
5374 OPC_Decode, 233, 123, 56, // 8928: decode to SC_D_RL using decoder 56
5375 // 8928: }
5376 // 8928: } // switch Inst[14:12]
5377 // 8928: }
5378 14, 19, // 8932: case 0xe: {
5379 OPC_SwitchField, 12, 3, // 8934: switch Inst[14:12] {
5380 2, 6, // 8937: case 0x2: {
5381 OPC_CheckPredicate, 55, // 8939: check predicate 55
5382 OPC_Decode, 235, 123, 56, // 8941: decode to SC_W_AQ using decoder 56
5383 // 8941: }
5384 3, 0, // 8945: case 0x3: {
5385 OPC_CheckPredicate, 56, // 8947: check predicate 56
5386 OPC_Decode, 231, 123, 56, // 8949: decode to SC_D_AQ using decoder 56
5387 // 8949: }
5388 // 8949: } // switch Inst[14:12]
5389 // 8949: }
5390 15, 19, // 8953: case 0xf: {
5391 OPC_SwitchField, 12, 3, // 8955: switch Inst[14:12] {
5392 2, 6, // 8958: case 0x2: {
5393 OPC_CheckPredicate, 55, // 8960: check predicate 55
5394 OPC_Decode, 236, 123, 56, // 8962: decode to SC_W_AQRL using decoder 56
5395 // 8962: }
5396 3, 0, // 8966: case 0x3: {
5397 OPC_CheckPredicate, 56, // 8968: check predicate 56
5398 OPC_Decode, 232, 123, 56, // 8970: decode to SC_D_AQRL using decoder 56
5399 // 8970: }
5400 // 8970: } // switch Inst[14:12]
5401 // 8970: }
5402 16, 35, // 8974: case 0x10: {
5403 OPC_SwitchField, 12, 3, // 8976: switch Inst[14:12] {
5404 0, 6, // 8979: case 0x0: {
5405 OPC_CheckPredicate, 52, // 8981: check predicate 52
5406 OPC_Decode, 205, 110, 56, // 8983: decode to AMOXOR_B using decoder 56
5407 // 8983: }
5408 1, 6, // 8987: case 0x1: {
5409 OPC_CheckPredicate, 52, // 8989: check predicate 52
5410 OPC_Decode, 213, 110, 56, // 8991: decode to AMOXOR_H using decoder 56
5411 // 8991: }
5412 2, 6, // 8995: case 0x2: {
5413 OPC_CheckPredicate, 53, // 8997: check predicate 53
5414 OPC_Decode, 217, 110, 56, // 8999: decode to AMOXOR_W using decoder 56
5415 // 8999: }
5416 3, 0, // 9003: case 0x3: {
5417 OPC_CheckPredicate, 54, // 9005: check predicate 54
5418 OPC_Decode, 209, 110, 56, // 9007: decode to AMOXOR_D using decoder 56
5419 // 9007: }
5420 // 9007: } // switch Inst[14:12]
5421 // 9007: }
5422 17, 35, // 9011: case 0x11: {
5423 OPC_SwitchField, 12, 3, // 9013: switch Inst[14:12] {
5424 0, 6, // 9016: case 0x0: {
5425 OPC_CheckPredicate, 52, // 9018: check predicate 52
5426 OPC_Decode, 208, 110, 56, // 9020: decode to AMOXOR_B_RL using decoder 56
5427 // 9020: }
5428 1, 6, // 9024: case 0x1: {
5429 OPC_CheckPredicate, 52, // 9026: check predicate 52
5430 OPC_Decode, 216, 110, 56, // 9028: decode to AMOXOR_H_RL using decoder 56
5431 // 9028: }
5432 2, 6, // 9032: case 0x2: {
5433 OPC_CheckPredicate, 53, // 9034: check predicate 53
5434 OPC_Decode, 220, 110, 56, // 9036: decode to AMOXOR_W_RL using decoder 56
5435 // 9036: }
5436 3, 0, // 9040: case 0x3: {
5437 OPC_CheckPredicate, 54, // 9042: check predicate 54
5438 OPC_Decode, 212, 110, 56, // 9044: decode to AMOXOR_D_RL using decoder 56
5439 // 9044: }
5440 // 9044: } // switch Inst[14:12]
5441 // 9044: }
5442 18, 35, // 9048: case 0x12: {
5443 OPC_SwitchField, 12, 3, // 9050: switch Inst[14:12] {
5444 0, 6, // 9053: case 0x0: {
5445 OPC_CheckPredicate, 52, // 9055: check predicate 52
5446 OPC_Decode, 206, 110, 56, // 9057: decode to AMOXOR_B_AQ using decoder 56
5447 // 9057: }
5448 1, 6, // 9061: case 0x1: {
5449 OPC_CheckPredicate, 52, // 9063: check predicate 52
5450 OPC_Decode, 214, 110, 56, // 9065: decode to AMOXOR_H_AQ using decoder 56
5451 // 9065: }
5452 2, 6, // 9069: case 0x2: {
5453 OPC_CheckPredicate, 53, // 9071: check predicate 53
5454 OPC_Decode, 218, 110, 56, // 9073: decode to AMOXOR_W_AQ using decoder 56
5455 // 9073: }
5456 3, 0, // 9077: case 0x3: {
5457 OPC_CheckPredicate, 54, // 9079: check predicate 54
5458 OPC_Decode, 210, 110, 56, // 9081: decode to AMOXOR_D_AQ using decoder 56
5459 // 9081: }
5460 // 9081: } // switch Inst[14:12]
5461 // 9081: }
5462 19, 35, // 9085: case 0x13: {
5463 OPC_SwitchField, 12, 3, // 9087: switch Inst[14:12] {
5464 0, 6, // 9090: case 0x0: {
5465 OPC_CheckPredicate, 52, // 9092: check predicate 52
5466 OPC_Decode, 207, 110, 56, // 9094: decode to AMOXOR_B_AQRL using decoder 56
5467 // 9094: }
5468 1, 6, // 9098: case 0x1: {
5469 OPC_CheckPredicate, 52, // 9100: check predicate 52
5470 OPC_Decode, 215, 110, 56, // 9102: decode to AMOXOR_H_AQRL using decoder 56
5471 // 9102: }
5472 2, 6, // 9106: case 0x2: {
5473 OPC_CheckPredicate, 53, // 9108: check predicate 53
5474 OPC_Decode, 219, 110, 56, // 9110: decode to AMOXOR_W_AQRL using decoder 56
5475 // 9110: }
5476 3, 0, // 9114: case 0x3: {
5477 OPC_CheckPredicate, 54, // 9116: check predicate 54
5478 OPC_Decode, 211, 110, 56, // 9118: decode to AMOXOR_D_AQRL using decoder 56
5479 // 9118: }
5480 // 9118: } // switch Inst[14:12]
5481 // 9118: }
5482 20, 43, // 9122: case 0x14: {
5483 OPC_SwitchField, 12, 3, // 9124: switch Inst[14:12] {
5484 0, 6, // 9127: case 0x0: {
5485 OPC_CheckPredicate, 57, // 9129: check predicate 57
5486 OPC_Decode, 213, 109, 57, // 9131: decode to AMOCAS_B using decoder 57
5487 // 9131: }
5488 1, 6, // 9135: case 0x1: {
5489 OPC_CheckPredicate, 57, // 9137: check predicate 57
5490 OPC_Decode, 225, 109, 57, // 9139: decode to AMOCAS_H using decoder 57
5491 // 9139: }
5492 2, 6, // 9143: case 0x2: {
5493 OPC_CheckPredicate, 58, // 9145: check predicate 58
5494 OPC_Decode, 233, 109, 57, // 9147: decode to AMOCAS_W using decoder 57
5495 // 9147: }
5496 3, 6, // 9151: case 0x3: {
5497 OPC_CheckPredicate, 59, // 9153: check predicate 59
5498 OPC_Decode, 221, 109, 57, // 9155: decode to AMOCAS_D_RV64 using decoder 57
5499 // 9155: }
5500 4, 0, // 9159: case 0x4: {
5501 OPC_CheckPredicate, 59, // 9161: check predicate 59
5502 OPC_Decode, 229, 109, 58, // 9163: decode to AMOCAS_Q using decoder 58
5503 // 9163: }
5504 // 9163: } // switch Inst[14:12]
5505 // 9163: }
5506 21, 43, // 9167: case 0x15: {
5507 OPC_SwitchField, 12, 3, // 9169: switch Inst[14:12] {
5508 0, 6, // 9172: case 0x0: {
5509 OPC_CheckPredicate, 57, // 9174: check predicate 57
5510 OPC_Decode, 216, 109, 57, // 9176: decode to AMOCAS_B_RL using decoder 57
5511 // 9176: }
5512 1, 6, // 9180: case 0x1: {
5513 OPC_CheckPredicate, 57, // 9182: check predicate 57
5514 OPC_Decode, 228, 109, 57, // 9184: decode to AMOCAS_H_RL using decoder 57
5515 // 9184: }
5516 2, 6, // 9188: case 0x2: {
5517 OPC_CheckPredicate, 58, // 9190: check predicate 58
5518 OPC_Decode, 236, 109, 57, // 9192: decode to AMOCAS_W_RL using decoder 57
5519 // 9192: }
5520 3, 6, // 9196: case 0x3: {
5521 OPC_CheckPredicate, 59, // 9198: check predicate 59
5522 OPC_Decode, 224, 109, 57, // 9200: decode to AMOCAS_D_RV64_RL using decoder 57
5523 // 9200: }
5524 4, 0, // 9204: case 0x4: {
5525 OPC_CheckPredicate, 59, // 9206: check predicate 59
5526 OPC_Decode, 232, 109, 58, // 9208: decode to AMOCAS_Q_RL using decoder 58
5527 // 9208: }
5528 // 9208: } // switch Inst[14:12]
5529 // 9208: }
5530 22, 43, // 9212: case 0x16: {
5531 OPC_SwitchField, 12, 3, // 9214: switch Inst[14:12] {
5532 0, 6, // 9217: case 0x0: {
5533 OPC_CheckPredicate, 57, // 9219: check predicate 57
5534 OPC_Decode, 214, 109, 57, // 9221: decode to AMOCAS_B_AQ using decoder 57
5535 // 9221: }
5536 1, 6, // 9225: case 0x1: {
5537 OPC_CheckPredicate, 57, // 9227: check predicate 57
5538 OPC_Decode, 226, 109, 57, // 9229: decode to AMOCAS_H_AQ using decoder 57
5539 // 9229: }
5540 2, 6, // 9233: case 0x2: {
5541 OPC_CheckPredicate, 58, // 9235: check predicate 58
5542 OPC_Decode, 234, 109, 57, // 9237: decode to AMOCAS_W_AQ using decoder 57
5543 // 9237: }
5544 3, 6, // 9241: case 0x3: {
5545 OPC_CheckPredicate, 59, // 9243: check predicate 59
5546 OPC_Decode, 222, 109, 57, // 9245: decode to AMOCAS_D_RV64_AQ using decoder 57
5547 // 9245: }
5548 4, 0, // 9249: case 0x4: {
5549 OPC_CheckPredicate, 59, // 9251: check predicate 59
5550 OPC_Decode, 230, 109, 58, // 9253: decode to AMOCAS_Q_AQ using decoder 58
5551 // 9253: }
5552 // 9253: } // switch Inst[14:12]
5553 // 9253: }
5554 23, 43, // 9257: case 0x17: {
5555 OPC_SwitchField, 12, 3, // 9259: switch Inst[14:12] {
5556 0, 6, // 9262: case 0x0: {
5557 OPC_CheckPredicate, 57, // 9264: check predicate 57
5558 OPC_Decode, 215, 109, 57, // 9266: decode to AMOCAS_B_AQRL using decoder 57
5559 // 9266: }
5560 1, 6, // 9270: case 0x1: {
5561 OPC_CheckPredicate, 57, // 9272: check predicate 57
5562 OPC_Decode, 227, 109, 57, // 9274: decode to AMOCAS_H_AQRL using decoder 57
5563 // 9274: }
5564 2, 6, // 9278: case 0x2: {
5565 OPC_CheckPredicate, 58, // 9280: check predicate 58
5566 OPC_Decode, 235, 109, 57, // 9282: decode to AMOCAS_W_AQRL using decoder 57
5567 // 9282: }
5568 3, 6, // 9286: case 0x3: {
5569 OPC_CheckPredicate, 59, // 9288: check predicate 59
5570 OPC_Decode, 223, 109, 57, // 9290: decode to AMOCAS_D_RV64_AQRL using decoder 57
5571 // 9290: }
5572 4, 0, // 9294: case 0x4: {
5573 OPC_CheckPredicate, 59, // 9296: check predicate 59
5574 OPC_Decode, 231, 109, 58, // 9298: decode to AMOCAS_Q_AQRL using decoder 58
5575 // 9298: }
5576 // 9298: } // switch Inst[14:12]
5577 // 9298: }
5578 26, 51, // 9302: case 0x1a: {
5579 OPC_SwitchField, 12, 3, // 9304: switch Inst[14:12] {
5580 0, 10, // 9307: case 0x0: {
5581 OPC_CheckPredicate, 60, // 9309: check predicate 60
5582 OPC_CheckField, 20, 5, 0, // 9311: check Inst[24:20] == 0x0
5583 OPC_Decode, 227, 116, 17, // 9315: decode to LB_AQ using decoder 17
5584 // 9315: }
5585 1, 10, // 9319: case 0x1: {
5586 OPC_CheckPredicate, 60, // 9321: check predicate 60
5587 OPC_CheckField, 20, 5, 0, // 9323: check Inst[24:20] == 0x0
5588 OPC_Decode, 235, 116, 17, // 9327: decode to LH_AQ using decoder 17
5589 // 9327: }
5590 2, 10, // 9331: case 0x2: {
5591 OPC_CheckPredicate, 60, // 9333: check predicate 60
5592 OPC_CheckField, 20, 5, 0, // 9335: check Inst[24:20] == 0x0
5593 OPC_Decode, 249, 116, 17, // 9339: decode to LW_AQ using decoder 17
5594 // 9339: }
5595 3, 0, // 9343: case 0x3: {
5596 OPC_CheckPredicate, 61, // 9345: check predicate 61
5597 OPC_CheckField, 20, 5, 0, // 9347: check Inst[24:20] == 0x0
5598 OPC_Decode, 230, 116, 17, // 9351: decode to LD_AQ using decoder 17
5599 // 9351: }
5600 // 9351: } // switch Inst[14:12]
5601 // 9351: }
5602 27, 51, // 9355: case 0x1b: {
5603 OPC_SwitchField, 12, 3, // 9357: switch Inst[14:12] {
5604 0, 10, // 9360: case 0x0: {
5605 OPC_CheckPredicate, 60, // 9362: check predicate 60
5606 OPC_CheckField, 20, 5, 0, // 9364: check Inst[24:20] == 0x0
5607 OPC_Decode, 228, 116, 17, // 9368: decode to LB_AQRL using decoder 17
5608 // 9368: }
5609 1, 10, // 9372: case 0x1: {
5610 OPC_CheckPredicate, 60, // 9374: check predicate 60
5611 OPC_CheckField, 20, 5, 0, // 9376: check Inst[24:20] == 0x0
5612 OPC_Decode, 236, 116, 17, // 9380: decode to LH_AQRL using decoder 17
5613 // 9380: }
5614 2, 10, // 9384: case 0x2: {
5615 OPC_CheckPredicate, 60, // 9386: check predicate 60
5616 OPC_CheckField, 20, 5, 0, // 9388: check Inst[24:20] == 0x0
5617 OPC_Decode, 250, 116, 17, // 9392: decode to LW_AQRL using decoder 17
5618 // 9392: }
5619 3, 0, // 9396: case 0x3: {
5620 OPC_CheckPredicate, 61, // 9398: check predicate 61
5621 OPC_CheckField, 20, 5, 0, // 9400: check Inst[24:20] == 0x0
5622 OPC_Decode, 231, 116, 17, // 9404: decode to LD_AQRL using decoder 17
5623 // 9404: }
5624 // 9404: } // switch Inst[14:12]
5625 // 9404: }
5626 29, 35, // 9408: case 0x1d: {
5627 OPC_SwitchField, 7, 8, // 9410: switch Inst[14:7] {
5628 0, 6, // 9413: case 0x0: {
5629 OPC_CheckPredicate, 60, // 9415: check predicate 60
5630 OPC_Decode, 226, 123, 59, // 9417: decode to SB_RL using decoder 59
5631 // 9417: }
5632 32, 6, // 9421: case 0x20: {
5633 OPC_CheckPredicate, 60, // 9423: check predicate 60
5634 OPC_Decode, 214, 124, 59, // 9425: decode to SH_RL using decoder 59
5635 // 9425: }
5636 64, 6, // 9429: case 0x40: {
5637 OPC_CheckPredicate, 60, // 9431: check predicate 60
5638 OPC_Decode, 190, 125, 59, // 9433: decode to SW_RL using decoder 59
5639 // 9433: }
5640 96, 0, // 9437: case 0x60: {
5641 OPC_CheckPredicate, 61, // 9439: check predicate 61
5642 OPC_Decode, 240, 123, 59, // 9441: decode to SD_RL using decoder 59
5643 // 9441: }
5644 // 9441: } // switch Inst[14:7]
5645 // 9441: }
5646 31, 35, // 9445: case 0x1f: {
5647 OPC_SwitchField, 7, 8, // 9447: switch Inst[14:7] {
5648 0, 6, // 9450: case 0x0: {
5649 OPC_CheckPredicate, 60, // 9452: check predicate 60
5650 OPC_Decode, 225, 123, 59, // 9454: decode to SB_AQRL using decoder 59
5651 // 9454: }
5652 32, 6, // 9458: case 0x20: {
5653 OPC_CheckPredicate, 60, // 9460: check predicate 60
5654 OPC_Decode, 212, 124, 59, // 9462: decode to SH_AQRL using decoder 59
5655 // 9462: }
5656 64, 6, // 9466: case 0x40: {
5657 OPC_CheckPredicate, 60, // 9468: check predicate 60
5658 OPC_Decode, 188, 125, 59, // 9470: decode to SW_AQRL using decoder 59
5659 // 9470: }
5660 96, 0, // 9474: case 0x60: {
5661 OPC_CheckPredicate, 61, // 9476: check predicate 61
5662 OPC_Decode, 239, 123, 59, // 9478: decode to SD_AQRL using decoder 59
5663 // 9478: }
5664 // 9478: } // switch Inst[14:7]
5665 // 9478: }
5666 32, 35, // 9482: case 0x20: {
5667 OPC_SwitchField, 12, 3, // 9484: switch Inst[14:12] {
5668 0, 6, // 9487: case 0x0: {
5669 OPC_CheckPredicate, 52, // 9489: check predicate 52
5670 OPC_Decode, 173, 110, 56, // 9491: decode to AMOOR_B using decoder 56
5671 // 9491: }
5672 1, 6, // 9495: case 0x1: {
5673 OPC_CheckPredicate, 52, // 9497: check predicate 52
5674 OPC_Decode, 181, 110, 56, // 9499: decode to AMOOR_H using decoder 56
5675 // 9499: }
5676 2, 6, // 9503: case 0x2: {
5677 OPC_CheckPredicate, 53, // 9505: check predicate 53
5678 OPC_Decode, 185, 110, 56, // 9507: decode to AMOOR_W using decoder 56
5679 // 9507: }
5680 3, 0, // 9511: case 0x3: {
5681 OPC_CheckPredicate, 54, // 9513: check predicate 54
5682 OPC_Decode, 177, 110, 56, // 9515: decode to AMOOR_D using decoder 56
5683 // 9515: }
5684 // 9515: } // switch Inst[14:12]
5685 // 9515: }
5686 33, 35, // 9519: case 0x21: {
5687 OPC_SwitchField, 12, 3, // 9521: switch Inst[14:12] {
5688 0, 6, // 9524: case 0x0: {
5689 OPC_CheckPredicate, 52, // 9526: check predicate 52
5690 OPC_Decode, 176, 110, 56, // 9528: decode to AMOOR_B_RL using decoder 56
5691 // 9528: }
5692 1, 6, // 9532: case 0x1: {
5693 OPC_CheckPredicate, 52, // 9534: check predicate 52
5694 OPC_Decode, 184, 110, 56, // 9536: decode to AMOOR_H_RL using decoder 56
5695 // 9536: }
5696 2, 6, // 9540: case 0x2: {
5697 OPC_CheckPredicate, 53, // 9542: check predicate 53
5698 OPC_Decode, 188, 110, 56, // 9544: decode to AMOOR_W_RL using decoder 56
5699 // 9544: }
5700 3, 0, // 9548: case 0x3: {
5701 OPC_CheckPredicate, 54, // 9550: check predicate 54
5702 OPC_Decode, 180, 110, 56, // 9552: decode to AMOOR_D_RL using decoder 56
5703 // 9552: }
5704 // 9552: } // switch Inst[14:12]
5705 // 9552: }
5706 34, 35, // 9556: case 0x22: {
5707 OPC_SwitchField, 12, 3, // 9558: switch Inst[14:12] {
5708 0, 6, // 9561: case 0x0: {
5709 OPC_CheckPredicate, 52, // 9563: check predicate 52
5710 OPC_Decode, 174, 110, 56, // 9565: decode to AMOOR_B_AQ using decoder 56
5711 // 9565: }
5712 1, 6, // 9569: case 0x1: {
5713 OPC_CheckPredicate, 52, // 9571: check predicate 52
5714 OPC_Decode, 182, 110, 56, // 9573: decode to AMOOR_H_AQ using decoder 56
5715 // 9573: }
5716 2, 6, // 9577: case 0x2: {
5717 OPC_CheckPredicate, 53, // 9579: check predicate 53
5718 OPC_Decode, 186, 110, 56, // 9581: decode to AMOOR_W_AQ using decoder 56
5719 // 9581: }
5720 3, 0, // 9585: case 0x3: {
5721 OPC_CheckPredicate, 54, // 9587: check predicate 54
5722 OPC_Decode, 178, 110, 56, // 9589: decode to AMOOR_D_AQ using decoder 56
5723 // 9589: }
5724 // 9589: } // switch Inst[14:12]
5725 // 9589: }
5726 35, 35, // 9593: case 0x23: {
5727 OPC_SwitchField, 12, 3, // 9595: switch Inst[14:12] {
5728 0, 6, // 9598: case 0x0: {
5729 OPC_CheckPredicate, 52, // 9600: check predicate 52
5730 OPC_Decode, 175, 110, 56, // 9602: decode to AMOOR_B_AQRL using decoder 56
5731 // 9602: }
5732 1, 6, // 9606: case 0x1: {
5733 OPC_CheckPredicate, 52, // 9608: check predicate 52
5734 OPC_Decode, 183, 110, 56, // 9610: decode to AMOOR_H_AQRL using decoder 56
5735 // 9610: }
5736 2, 6, // 9614: case 0x2: {
5737 OPC_CheckPredicate, 53, // 9616: check predicate 53
5738 OPC_Decode, 187, 110, 56, // 9618: decode to AMOOR_W_AQRL using decoder 56
5739 // 9618: }
5740 3, 0, // 9622: case 0x3: {
5741 OPC_CheckPredicate, 54, // 9624: check predicate 54
5742 OPC_Decode, 179, 110, 56, // 9626: decode to AMOOR_D_AQRL using decoder 56
5743 // 9626: }
5744 // 9626: } // switch Inst[14:12]
5745 // 9626: }
5746 36, 19, // 9630: case 0x24: {
5747 OPC_SwitchField, 12, 3, // 9632: switch Inst[14:12] {
5748 2, 6, // 9635: case 0x2: {
5749 OPC_CheckPredicate, 62, // 9637: check predicate 62
5750 OPC_Decode, 169, 125, 56, // 9639: decode to SSAMOSWAP_W using decoder 56
5751 // 9639: }
5752 3, 0, // 9643: case 0x3: {
5753 OPC_CheckPredicate, 63, // 9645: check predicate 63
5754 OPC_Decode, 165, 125, 56, // 9647: decode to SSAMOSWAP_D using decoder 56
5755 // 9647: }
5756 // 9647: } // switch Inst[14:12]
5757 // 9647: }
5758 37, 19, // 9651: case 0x25: {
5759 OPC_SwitchField, 12, 3, // 9653: switch Inst[14:12] {
5760 2, 6, // 9656: case 0x2: {
5761 OPC_CheckPredicate, 62, // 9658: check predicate 62
5762 OPC_Decode, 172, 125, 56, // 9660: decode to SSAMOSWAP_W_RL using decoder 56
5763 // 9660: }
5764 3, 0, // 9664: case 0x3: {
5765 OPC_CheckPredicate, 63, // 9666: check predicate 63
5766 OPC_Decode, 168, 125, 56, // 9668: decode to SSAMOSWAP_D_RL using decoder 56
5767 // 9668: }
5768 // 9668: } // switch Inst[14:12]
5769 // 9668: }
5770 38, 19, // 9672: case 0x26: {
5771 OPC_SwitchField, 12, 3, // 9674: switch Inst[14:12] {
5772 2, 6, // 9677: case 0x2: {
5773 OPC_CheckPredicate, 62, // 9679: check predicate 62
5774 OPC_Decode, 170, 125, 56, // 9681: decode to SSAMOSWAP_W_AQ using decoder 56
5775 // 9681: }
5776 3, 0, // 9685: case 0x3: {
5777 OPC_CheckPredicate, 63, // 9687: check predicate 63
5778 OPC_Decode, 166, 125, 56, // 9689: decode to SSAMOSWAP_D_AQ using decoder 56
5779 // 9689: }
5780 // 9689: } // switch Inst[14:12]
5781 // 9689: }
5782 39, 19, // 9693: case 0x27: {
5783 OPC_SwitchField, 12, 3, // 9695: switch Inst[14:12] {
5784 2, 6, // 9698: case 0x2: {
5785 OPC_CheckPredicate, 62, // 9700: check predicate 62
5786 OPC_Decode, 171, 125, 56, // 9702: decode to SSAMOSWAP_W_AQRL using decoder 56
5787 // 9702: }
5788 3, 0, // 9706: case 0x3: {
5789 OPC_CheckPredicate, 63, // 9708: check predicate 63
5790 OPC_Decode, 167, 125, 56, // 9710: decode to SSAMOSWAP_D_AQRL using decoder 56
5791 // 9710: }
5792 // 9710: } // switch Inst[14:12]
5793 // 9710: }
5794 48, 35, // 9714: case 0x30: {
5795 OPC_SwitchField, 12, 3, // 9716: switch Inst[14:12] {
5796 0, 6, // 9719: case 0x0: {
5797 OPC_CheckPredicate, 52, // 9721: check predicate 52
5798 OPC_Decode, 197, 109, 56, // 9723: decode to AMOAND_B using decoder 56
5799 // 9723: }
5800 1, 6, // 9727: case 0x1: {
5801 OPC_CheckPredicate, 52, // 9729: check predicate 52
5802 OPC_Decode, 205, 109, 56, // 9731: decode to AMOAND_H using decoder 56
5803 // 9731: }
5804 2, 6, // 9735: case 0x2: {
5805 OPC_CheckPredicate, 53, // 9737: check predicate 53
5806 OPC_Decode, 209, 109, 56, // 9739: decode to AMOAND_W using decoder 56
5807 // 9739: }
5808 3, 0, // 9743: case 0x3: {
5809 OPC_CheckPredicate, 54, // 9745: check predicate 54
5810 OPC_Decode, 201, 109, 56, // 9747: decode to AMOAND_D using decoder 56
5811 // 9747: }
5812 // 9747: } // switch Inst[14:12]
5813 // 9747: }
5814 49, 35, // 9751: case 0x31: {
5815 OPC_SwitchField, 12, 3, // 9753: switch Inst[14:12] {
5816 0, 6, // 9756: case 0x0: {
5817 OPC_CheckPredicate, 52, // 9758: check predicate 52
5818 OPC_Decode, 200, 109, 56, // 9760: decode to AMOAND_B_RL using decoder 56
5819 // 9760: }
5820 1, 6, // 9764: case 0x1: {
5821 OPC_CheckPredicate, 52, // 9766: check predicate 52
5822 OPC_Decode, 208, 109, 56, // 9768: decode to AMOAND_H_RL using decoder 56
5823 // 9768: }
5824 2, 6, // 9772: case 0x2: {
5825 OPC_CheckPredicate, 53, // 9774: check predicate 53
5826 OPC_Decode, 212, 109, 56, // 9776: decode to AMOAND_W_RL using decoder 56
5827 // 9776: }
5828 3, 0, // 9780: case 0x3: {
5829 OPC_CheckPredicate, 54, // 9782: check predicate 54
5830 OPC_Decode, 204, 109, 56, // 9784: decode to AMOAND_D_RL using decoder 56
5831 // 9784: }
5832 // 9784: } // switch Inst[14:12]
5833 // 9784: }
5834 50, 35, // 9788: case 0x32: {
5835 OPC_SwitchField, 12, 3, // 9790: switch Inst[14:12] {
5836 0, 6, // 9793: case 0x0: {
5837 OPC_CheckPredicate, 52, // 9795: check predicate 52
5838 OPC_Decode, 198, 109, 56, // 9797: decode to AMOAND_B_AQ using decoder 56
5839 // 9797: }
5840 1, 6, // 9801: case 0x1: {
5841 OPC_CheckPredicate, 52, // 9803: check predicate 52
5842 OPC_Decode, 206, 109, 56, // 9805: decode to AMOAND_H_AQ using decoder 56
5843 // 9805: }
5844 2, 6, // 9809: case 0x2: {
5845 OPC_CheckPredicate, 53, // 9811: check predicate 53
5846 OPC_Decode, 210, 109, 56, // 9813: decode to AMOAND_W_AQ using decoder 56
5847 // 9813: }
5848 3, 0, // 9817: case 0x3: {
5849 OPC_CheckPredicate, 54, // 9819: check predicate 54
5850 OPC_Decode, 202, 109, 56, // 9821: decode to AMOAND_D_AQ using decoder 56
5851 // 9821: }
5852 // 9821: } // switch Inst[14:12]
5853 // 9821: }
5854 51, 35, // 9825: case 0x33: {
5855 OPC_SwitchField, 12, 3, // 9827: switch Inst[14:12] {
5856 0, 6, // 9830: case 0x0: {
5857 OPC_CheckPredicate, 52, // 9832: check predicate 52
5858 OPC_Decode, 199, 109, 56, // 9834: decode to AMOAND_B_AQRL using decoder 56
5859 // 9834: }
5860 1, 6, // 9838: case 0x1: {
5861 OPC_CheckPredicate, 52, // 9840: check predicate 52
5862 OPC_Decode, 207, 109, 56, // 9842: decode to AMOAND_H_AQRL using decoder 56
5863 // 9842: }
5864 2, 6, // 9846: case 0x2: {
5865 OPC_CheckPredicate, 53, // 9848: check predicate 53
5866 OPC_Decode, 211, 109, 56, // 9850: decode to AMOAND_W_AQRL using decoder 56
5867 // 9850: }
5868 3, 0, // 9854: case 0x3: {
5869 OPC_CheckPredicate, 54, // 9856: check predicate 54
5870 OPC_Decode, 203, 109, 56, // 9858: decode to AMOAND_D_AQRL using decoder 56
5871 // 9858: }
5872 // 9858: } // switch Inst[14:12]
5873 // 9858: }
5874 64, 35, // 9862: case 0x40: {
5875 OPC_SwitchField, 12, 3, // 9864: switch Inst[14:12] {
5876 0, 6, // 9867: case 0x0: {
5877 OPC_CheckPredicate, 52, // 9869: check predicate 52
5878 OPC_Decode, 157, 110, 56, // 9871: decode to AMOMIN_B using decoder 56
5879 // 9871: }
5880 1, 6, // 9875: case 0x1: {
5881 OPC_CheckPredicate, 52, // 9877: check predicate 52
5882 OPC_Decode, 165, 110, 56, // 9879: decode to AMOMIN_H using decoder 56
5883 // 9879: }
5884 2, 6, // 9883: case 0x2: {
5885 OPC_CheckPredicate, 53, // 9885: check predicate 53
5886 OPC_Decode, 169, 110, 56, // 9887: decode to AMOMIN_W using decoder 56
5887 // 9887: }
5888 3, 0, // 9891: case 0x3: {
5889 OPC_CheckPredicate, 54, // 9893: check predicate 54
5890 OPC_Decode, 161, 110, 56, // 9895: decode to AMOMIN_D using decoder 56
5891 // 9895: }
5892 // 9895: } // switch Inst[14:12]
5893 // 9895: }
5894 65, 35, // 9899: case 0x41: {
5895 OPC_SwitchField, 12, 3, // 9901: switch Inst[14:12] {
5896 0, 6, // 9904: case 0x0: {
5897 OPC_CheckPredicate, 52, // 9906: check predicate 52
5898 OPC_Decode, 160, 110, 56, // 9908: decode to AMOMIN_B_RL using decoder 56
5899 // 9908: }
5900 1, 6, // 9912: case 0x1: {
5901 OPC_CheckPredicate, 52, // 9914: check predicate 52
5902 OPC_Decode, 168, 110, 56, // 9916: decode to AMOMIN_H_RL using decoder 56
5903 // 9916: }
5904 2, 6, // 9920: case 0x2: {
5905 OPC_CheckPredicate, 53, // 9922: check predicate 53
5906 OPC_Decode, 172, 110, 56, // 9924: decode to AMOMIN_W_RL using decoder 56
5907 // 9924: }
5908 3, 0, // 9928: case 0x3: {
5909 OPC_CheckPredicate, 54, // 9930: check predicate 54
5910 OPC_Decode, 164, 110, 56, // 9932: decode to AMOMIN_D_RL using decoder 56
5911 // 9932: }
5912 // 9932: } // switch Inst[14:12]
5913 // 9932: }
5914 66, 35, // 9936: case 0x42: {
5915 OPC_SwitchField, 12, 3, // 9938: switch Inst[14:12] {
5916 0, 6, // 9941: case 0x0: {
5917 OPC_CheckPredicate, 52, // 9943: check predicate 52
5918 OPC_Decode, 158, 110, 56, // 9945: decode to AMOMIN_B_AQ using decoder 56
5919 // 9945: }
5920 1, 6, // 9949: case 0x1: {
5921 OPC_CheckPredicate, 52, // 9951: check predicate 52
5922 OPC_Decode, 166, 110, 56, // 9953: decode to AMOMIN_H_AQ using decoder 56
5923 // 9953: }
5924 2, 6, // 9957: case 0x2: {
5925 OPC_CheckPredicate, 53, // 9959: check predicate 53
5926 OPC_Decode, 170, 110, 56, // 9961: decode to AMOMIN_W_AQ using decoder 56
5927 // 9961: }
5928 3, 0, // 9965: case 0x3: {
5929 OPC_CheckPredicate, 54, // 9967: check predicate 54
5930 OPC_Decode, 162, 110, 56, // 9969: decode to AMOMIN_D_AQ using decoder 56
5931 // 9969: }
5932 // 9969: } // switch Inst[14:12]
5933 // 9969: }
5934 67, 35, // 9973: case 0x43: {
5935 OPC_SwitchField, 12, 3, // 9975: switch Inst[14:12] {
5936 0, 6, // 9978: case 0x0: {
5937 OPC_CheckPredicate, 52, // 9980: check predicate 52
5938 OPC_Decode, 159, 110, 56, // 9982: decode to AMOMIN_B_AQRL using decoder 56
5939 // 9982: }
5940 1, 6, // 9986: case 0x1: {
5941 OPC_CheckPredicate, 52, // 9988: check predicate 52
5942 OPC_Decode, 167, 110, 56, // 9990: decode to AMOMIN_H_AQRL using decoder 56
5943 // 9990: }
5944 2, 6, // 9994: case 0x2: {
5945 OPC_CheckPredicate, 53, // 9996: check predicate 53
5946 OPC_Decode, 171, 110, 56, // 9998: decode to AMOMIN_W_AQRL using decoder 56
5947 // 9998: }
5948 3, 0, // 10002: case 0x3: {
5949 OPC_CheckPredicate, 54, // 10004: check predicate 54
5950 OPC_Decode, 163, 110, 56, // 10006: decode to AMOMIN_D_AQRL using decoder 56
5951 // 10006: }
5952 // 10006: } // switch Inst[14:12]
5953 // 10006: }
5954 72, 43, // 10010: case 0x48: {
5955 OPC_SwitchField, 12, 3, // 10012: switch Inst[14:12] {
5956 1, 6, // 10015: case 0x1: {
5957 OPC_CheckPredicate, 64, // 10017: check predicate 64
5958 OPC_Decode, 253, 116, 56, // 10019: decode to LXH using decoder 56
5959 // 10019: }
5960 2, 6, // 10023: case 0x2: {
5961 OPC_CheckPredicate, 64, // 10025: check predicate 64
5962 OPC_Decode, 141, 117, 56, // 10027: decode to LXW using decoder 56
5963 // 10027: }
5964 3, 6, // 10031: case 0x3: {
5965 OPC_CheckPredicate, 65, // 10033: check predicate 65
5966 OPC_Decode, 252, 116, 56, // 10035: decode to LXD using decoder 56
5967 // 10035: }
5968 5, 6, // 10039: case 0x5: {
5969 OPC_CheckPredicate, 64, // 10041: check predicate 64
5970 OPC_Decode, 254, 116, 56, // 10043: decode to LXHU using decoder 56
5971 // 10043: }
5972 6, 0, // 10047: case 0x6: {
5973 OPC_CheckPredicate, 65, // 10049: check predicate 65
5974 OPC_Decode, 142, 117, 56, // 10051: decode to LXWU using decoder 56
5975 // 10051: }
5976 // 10051: } // switch Inst[14:12]
5977 // 10051: }
5978 80, 35, // 10055: case 0x50: {
5979 OPC_SwitchField, 12, 3, // 10057: switch Inst[14:12] {
5980 0, 6, // 10060: case 0x0: {
5981 OPC_CheckPredicate, 52, // 10062: check predicate 52
5982 OPC_Decode, 253, 109, 56, // 10064: decode to AMOMAX_B using decoder 56
5983 // 10064: }
5984 1, 6, // 10068: case 0x1: {
5985 OPC_CheckPredicate, 52, // 10070: check predicate 52
5986 OPC_Decode, 133, 110, 56, // 10072: decode to AMOMAX_H using decoder 56
5987 // 10072: }
5988 2, 6, // 10076: case 0x2: {
5989 OPC_CheckPredicate, 53, // 10078: check predicate 53
5990 OPC_Decode, 137, 110, 56, // 10080: decode to AMOMAX_W using decoder 56
5991 // 10080: }
5992 3, 0, // 10084: case 0x3: {
5993 OPC_CheckPredicate, 54, // 10086: check predicate 54
5994 OPC_Decode, 129, 110, 56, // 10088: decode to AMOMAX_D using decoder 56
5995 // 10088: }
5996 // 10088: } // switch Inst[14:12]
5997 // 10088: }
5998 81, 35, // 10092: case 0x51: {
5999 OPC_SwitchField, 12, 3, // 10094: switch Inst[14:12] {
6000 0, 6, // 10097: case 0x0: {
6001 OPC_CheckPredicate, 52, // 10099: check predicate 52
6002 OPC_Decode, 128, 110, 56, // 10101: decode to AMOMAX_B_RL using decoder 56
6003 // 10101: }
6004 1, 6, // 10105: case 0x1: {
6005 OPC_CheckPredicate, 52, // 10107: check predicate 52
6006 OPC_Decode, 136, 110, 56, // 10109: decode to AMOMAX_H_RL using decoder 56
6007 // 10109: }
6008 2, 6, // 10113: case 0x2: {
6009 OPC_CheckPredicate, 53, // 10115: check predicate 53
6010 OPC_Decode, 140, 110, 56, // 10117: decode to AMOMAX_W_RL using decoder 56
6011 // 10117: }
6012 3, 0, // 10121: case 0x3: {
6013 OPC_CheckPredicate, 54, // 10123: check predicate 54
6014 OPC_Decode, 132, 110, 56, // 10125: decode to AMOMAX_D_RL using decoder 56
6015 // 10125: }
6016 // 10125: } // switch Inst[14:12]
6017 // 10125: }
6018 82, 35, // 10129: case 0x52: {
6019 OPC_SwitchField, 12, 3, // 10131: switch Inst[14:12] {
6020 0, 6, // 10134: case 0x0: {
6021 OPC_CheckPredicate, 52, // 10136: check predicate 52
6022 OPC_Decode, 254, 109, 56, // 10138: decode to AMOMAX_B_AQ using decoder 56
6023 // 10138: }
6024 1, 6, // 10142: case 0x1: {
6025 OPC_CheckPredicate, 52, // 10144: check predicate 52
6026 OPC_Decode, 134, 110, 56, // 10146: decode to AMOMAX_H_AQ using decoder 56
6027 // 10146: }
6028 2, 6, // 10150: case 0x2: {
6029 OPC_CheckPredicate, 53, // 10152: check predicate 53
6030 OPC_Decode, 138, 110, 56, // 10154: decode to AMOMAX_W_AQ using decoder 56
6031 // 10154: }
6032 3, 0, // 10158: case 0x3: {
6033 OPC_CheckPredicate, 54, // 10160: check predicate 54
6034 OPC_Decode, 130, 110, 56, // 10162: decode to AMOMAX_D_AQ using decoder 56
6035 // 10162: }
6036 // 10162: } // switch Inst[14:12]
6037 // 10162: }
6038 83, 35, // 10166: case 0x53: {
6039 OPC_SwitchField, 12, 3, // 10168: switch Inst[14:12] {
6040 0, 6, // 10171: case 0x0: {
6041 OPC_CheckPredicate, 52, // 10173: check predicate 52
6042 OPC_Decode, 255, 109, 56, // 10175: decode to AMOMAX_B_AQRL using decoder 56
6043 // 10175: }
6044 1, 6, // 10179: case 0x1: {
6045 OPC_CheckPredicate, 52, // 10181: check predicate 52
6046 OPC_Decode, 135, 110, 56, // 10183: decode to AMOMAX_H_AQRL using decoder 56
6047 // 10183: }
6048 2, 6, // 10187: case 0x2: {
6049 OPC_CheckPredicate, 53, // 10189: check predicate 53
6050 OPC_Decode, 139, 110, 56, // 10191: decode to AMOMAX_W_AQRL using decoder 56
6051 // 10191: }
6052 3, 0, // 10195: case 0x3: {
6053 OPC_CheckPredicate, 54, // 10197: check predicate 54
6054 OPC_Decode, 131, 110, 56, // 10199: decode to AMOMAX_D_AQRL using decoder 56
6055 // 10199: }
6056 // 10199: } // switch Inst[14:12]
6057 // 10199: }
6058 96, 35, // 10203: case 0x60: {
6059 OPC_SwitchField, 12, 3, // 10205: switch Inst[14:12] {
6060 0, 6, // 10208: case 0x0: {
6061 OPC_CheckPredicate, 52, // 10210: check predicate 52
6062 OPC_Decode, 141, 110, 56, // 10212: decode to AMOMINU_B using decoder 56
6063 // 10212: }
6064 1, 6, // 10216: case 0x1: {
6065 OPC_CheckPredicate, 52, // 10218: check predicate 52
6066 OPC_Decode, 149, 110, 56, // 10220: decode to AMOMINU_H using decoder 56
6067 // 10220: }
6068 2, 6, // 10224: case 0x2: {
6069 OPC_CheckPredicate, 53, // 10226: check predicate 53
6070 OPC_Decode, 153, 110, 56, // 10228: decode to AMOMINU_W using decoder 56
6071 // 10228: }
6072 3, 0, // 10232: case 0x3: {
6073 OPC_CheckPredicate, 54, // 10234: check predicate 54
6074 OPC_Decode, 145, 110, 56, // 10236: decode to AMOMINU_D using decoder 56
6075 // 10236: }
6076 // 10236: } // switch Inst[14:12]
6077 // 10236: }
6078 97, 35, // 10240: case 0x61: {
6079 OPC_SwitchField, 12, 3, // 10242: switch Inst[14:12] {
6080 0, 6, // 10245: case 0x0: {
6081 OPC_CheckPredicate, 52, // 10247: check predicate 52
6082 OPC_Decode, 144, 110, 56, // 10249: decode to AMOMINU_B_RL using decoder 56
6083 // 10249: }
6084 1, 6, // 10253: case 0x1: {
6085 OPC_CheckPredicate, 52, // 10255: check predicate 52
6086 OPC_Decode, 152, 110, 56, // 10257: decode to AMOMINU_H_RL using decoder 56
6087 // 10257: }
6088 2, 6, // 10261: case 0x2: {
6089 OPC_CheckPredicate, 53, // 10263: check predicate 53
6090 OPC_Decode, 156, 110, 56, // 10265: decode to AMOMINU_W_RL using decoder 56
6091 // 10265: }
6092 3, 0, // 10269: case 0x3: {
6093 OPC_CheckPredicate, 54, // 10271: check predicate 54
6094 OPC_Decode, 148, 110, 56, // 10273: decode to AMOMINU_D_RL using decoder 56
6095 // 10273: }
6096 // 10273: } // switch Inst[14:12]
6097 // 10273: }
6098 98, 35, // 10277: case 0x62: {
6099 OPC_SwitchField, 12, 3, // 10279: switch Inst[14:12] {
6100 0, 6, // 10282: case 0x0: {
6101 OPC_CheckPredicate, 52, // 10284: check predicate 52
6102 OPC_Decode, 142, 110, 56, // 10286: decode to AMOMINU_B_AQ using decoder 56
6103 // 10286: }
6104 1, 6, // 10290: case 0x1: {
6105 OPC_CheckPredicate, 52, // 10292: check predicate 52
6106 OPC_Decode, 150, 110, 56, // 10294: decode to AMOMINU_H_AQ using decoder 56
6107 // 10294: }
6108 2, 6, // 10298: case 0x2: {
6109 OPC_CheckPredicate, 53, // 10300: check predicate 53
6110 OPC_Decode, 154, 110, 56, // 10302: decode to AMOMINU_W_AQ using decoder 56
6111 // 10302: }
6112 3, 0, // 10306: case 0x3: {
6113 OPC_CheckPredicate, 54, // 10308: check predicate 54
6114 OPC_Decode, 146, 110, 56, // 10310: decode to AMOMINU_D_AQ using decoder 56
6115 // 10310: }
6116 // 10310: } // switch Inst[14:12]
6117 // 10310: }
6118 99, 35, // 10314: case 0x63: {
6119 OPC_SwitchField, 12, 3, // 10316: switch Inst[14:12] {
6120 0, 6, // 10319: case 0x0: {
6121 OPC_CheckPredicate, 52, // 10321: check predicate 52
6122 OPC_Decode, 143, 110, 56, // 10323: decode to AMOMINU_B_AQRL using decoder 56
6123 // 10323: }
6124 1, 6, // 10327: case 0x1: {
6125 OPC_CheckPredicate, 52, // 10329: check predicate 52
6126 OPC_Decode, 151, 110, 56, // 10331: decode to AMOMINU_H_AQRL using decoder 56
6127 // 10331: }
6128 2, 6, // 10335: case 0x2: {
6129 OPC_CheckPredicate, 53, // 10337: check predicate 53
6130 OPC_Decode, 155, 110, 56, // 10339: decode to AMOMINU_W_AQRL using decoder 56
6131 // 10339: }
6132 3, 0, // 10343: case 0x3: {
6133 OPC_CheckPredicate, 54, // 10345: check predicate 54
6134 OPC_Decode, 147, 110, 56, // 10347: decode to AMOMINU_D_AQRL using decoder 56
6135 // 10347: }
6136 // 10347: } // switch Inst[14:12]
6137 // 10347: }
6138 104, 59, // 10351: case 0x68: {
6139 OPC_SwitchField, 12, 3, // 10353: switch Inst[14:12] {
6140 0, 6, // 10356: case 0x0: {
6141 OPC_CheckPredicate, 64, // 10358: check predicate 64
6142 OPC_Decode, 255, 116, 56, // 10360: decode to LXSB using decoder 56
6143 // 10360: }
6144 1, 6, // 10364: case 0x1: {
6145 OPC_CheckPredicate, 64, // 10366: check predicate 64
6146 OPC_Decode, 130, 117, 56, // 10368: decode to LXSH using decoder 56
6147 // 10368: }
6148 2, 6, // 10372: case 0x2: {
6149 OPC_CheckPredicate, 64, // 10374: check predicate 64
6150 OPC_Decode, 139, 117, 56, // 10376: decode to LXSW using decoder 56
6151 // 10376: }
6152 3, 6, // 10380: case 0x3: {
6153 OPC_CheckPredicate, 65, // 10382: check predicate 65
6154 OPC_Decode, 129, 117, 56, // 10384: decode to LXSD using decoder 56
6155 // 10384: }
6156 4, 6, // 10388: case 0x4: {
6157 OPC_CheckPredicate, 64, // 10390: check predicate 64
6158 OPC_Decode, 128, 117, 56, // 10392: decode to LXSBU using decoder 56
6159 // 10392: }
6160 5, 6, // 10396: case 0x5: {
6161 OPC_CheckPredicate, 64, // 10398: check predicate 64
6162 OPC_Decode, 131, 117, 56, // 10400: decode to LXSHU using decoder 56
6163 // 10400: }
6164 6, 0, // 10404: case 0x6: {
6165 OPC_CheckPredicate, 65, // 10406: check predicate 65
6166 OPC_Decode, 140, 117, 56, // 10408: decode to LXSWU using decoder 56
6167 // 10408: }
6168 // 10408: } // switch Inst[14:12]
6169 // 10408: }
6170 112, 35, // 10412: case 0x70: {
6171 OPC_SwitchField, 12, 3, // 10414: switch Inst[14:12] {
6172 0, 6, // 10417: case 0x0: {
6173 OPC_CheckPredicate, 52, // 10419: check predicate 52
6174 OPC_Decode, 237, 109, 56, // 10421: decode to AMOMAXU_B using decoder 56
6175 // 10421: }
6176 1, 6, // 10425: case 0x1: {
6177 OPC_CheckPredicate, 52, // 10427: check predicate 52
6178 OPC_Decode, 245, 109, 56, // 10429: decode to AMOMAXU_H using decoder 56
6179 // 10429: }
6180 2, 6, // 10433: case 0x2: {
6181 OPC_CheckPredicate, 53, // 10435: check predicate 53
6182 OPC_Decode, 249, 109, 56, // 10437: decode to AMOMAXU_W using decoder 56
6183 // 10437: }
6184 3, 0, // 10441: case 0x3: {
6185 OPC_CheckPredicate, 54, // 10443: check predicate 54
6186 OPC_Decode, 241, 109, 56, // 10445: decode to AMOMAXU_D using decoder 56
6187 // 10445: }
6188 // 10445: } // switch Inst[14:12]
6189 // 10445: }
6190 113, 35, // 10449: case 0x71: {
6191 OPC_SwitchField, 12, 3, // 10451: switch Inst[14:12] {
6192 0, 6, // 10454: case 0x0: {
6193 OPC_CheckPredicate, 52, // 10456: check predicate 52
6194 OPC_Decode, 240, 109, 56, // 10458: decode to AMOMAXU_B_RL using decoder 56
6195 // 10458: }
6196 1, 6, // 10462: case 0x1: {
6197 OPC_CheckPredicate, 52, // 10464: check predicate 52
6198 OPC_Decode, 248, 109, 56, // 10466: decode to AMOMAXU_H_RL using decoder 56
6199 // 10466: }
6200 2, 6, // 10470: case 0x2: {
6201 OPC_CheckPredicate, 53, // 10472: check predicate 53
6202 OPC_Decode, 252, 109, 56, // 10474: decode to AMOMAXU_W_RL using decoder 56
6203 // 10474: }
6204 3, 0, // 10478: case 0x3: {
6205 OPC_CheckPredicate, 54, // 10480: check predicate 54
6206 OPC_Decode, 244, 109, 56, // 10482: decode to AMOMAXU_D_RL using decoder 56
6207 // 10482: }
6208 // 10482: } // switch Inst[14:12]
6209 // 10482: }
6210 114, 35, // 10486: case 0x72: {
6211 OPC_SwitchField, 12, 3, // 10488: switch Inst[14:12] {
6212 0, 6, // 10491: case 0x0: {
6213 OPC_CheckPredicate, 52, // 10493: check predicate 52
6214 OPC_Decode, 238, 109, 56, // 10495: decode to AMOMAXU_B_AQ using decoder 56
6215 // 10495: }
6216 1, 6, // 10499: case 0x1: {
6217 OPC_CheckPredicate, 52, // 10501: check predicate 52
6218 OPC_Decode, 246, 109, 56, // 10503: decode to AMOMAXU_H_AQ using decoder 56
6219 // 10503: }
6220 2, 6, // 10507: case 0x2: {
6221 OPC_CheckPredicate, 53, // 10509: check predicate 53
6222 OPC_Decode, 250, 109, 56, // 10511: decode to AMOMAXU_W_AQ using decoder 56
6223 // 10511: }
6224 3, 0, // 10515: case 0x3: {
6225 OPC_CheckPredicate, 54, // 10517: check predicate 54
6226 OPC_Decode, 242, 109, 56, // 10519: decode to AMOMAXU_D_AQ using decoder 56
6227 // 10519: }
6228 // 10519: } // switch Inst[14:12]
6229 // 10519: }
6230 115, 35, // 10523: case 0x73: {
6231 OPC_SwitchField, 12, 3, // 10525: switch Inst[14:12] {
6232 0, 6, // 10528: case 0x0: {
6233 OPC_CheckPredicate, 52, // 10530: check predicate 52
6234 OPC_Decode, 239, 109, 56, // 10532: decode to AMOMAXU_B_AQRL using decoder 56
6235 // 10532: }
6236 1, 6, // 10536: case 0x1: {
6237 OPC_CheckPredicate, 52, // 10538: check predicate 52
6238 OPC_Decode, 247, 109, 56, // 10540: decode to AMOMAXU_H_AQRL using decoder 56
6239 // 10540: }
6240 2, 6, // 10544: case 0x2: {
6241 OPC_CheckPredicate, 53, // 10546: check predicate 53
6242 OPC_Decode, 251, 109, 56, // 10548: decode to AMOMAXU_W_AQRL using decoder 56
6243 // 10548: }
6244 3, 0, // 10552: case 0x3: {
6245 OPC_CheckPredicate, 54, // 10554: check predicate 54
6246 OPC_Decode, 243, 109, 56, // 10556: decode to AMOMAXU_D_AQRL using decoder 56
6247 // 10556: }
6248 // 10556: } // switch Inst[14:12]
6249 // 10556: }
6250 120, 0, // 10560: case 0x78: {
6251 OPC_SwitchField, 12, 3, // 10562: switch Inst[14:12] {
6252 0, 6, // 10565: case 0x0: {
6253 OPC_CheckPredicate, 65, // 10567: check predicate 65
6254 OPC_Decode, 132, 117, 56, // 10569: decode to LXSUWB using decoder 56
6255 // 10569: }
6256 1, 6, // 10573: case 0x1: {
6257 OPC_CheckPredicate, 65, // 10575: check predicate 65
6258 OPC_Decode, 135, 117, 56, // 10577: decode to LXSUWH using decoder 56
6259 // 10577: }
6260 2, 6, // 10581: case 0x2: {
6261 OPC_CheckPredicate, 65, // 10583: check predicate 65
6262 OPC_Decode, 137, 117, 56, // 10585: decode to LXSUWW using decoder 56
6263 // 10585: }
6264 3, 6, // 10589: case 0x3: {
6265 OPC_CheckPredicate, 65, // 10591: check predicate 65
6266 OPC_Decode, 134, 117, 56, // 10593: decode to LXSUWD using decoder 56
6267 // 10593: }
6268 4, 6, // 10597: case 0x4: {
6269 OPC_CheckPredicate, 65, // 10599: check predicate 65
6270 OPC_Decode, 133, 117, 56, // 10601: decode to LXSUWBU using decoder 56
6271 // 10601: }
6272 5, 6, // 10605: case 0x5: {
6273 OPC_CheckPredicate, 65, // 10607: check predicate 65
6274 OPC_Decode, 136, 117, 56, // 10609: decode to LXSUWHU using decoder 56
6275 // 10609: }
6276 6, 0, // 10613: case 0x6: {
6277 OPC_CheckPredicate, 65, // 10615: check predicate 65
6278 OPC_Decode, 138, 117, 56, // 10617: decode to LXSUWWU using decoder 56
6279 // 10617: }
6280 // 10617: } // switch Inst[14:12]
6281 // 10617: }
6282 // 10617: } // switch Inst[31:25]
6283 // 10617: }
6284 51, 138, 6, // 10621: case 0x33: {
6285 OPC_SwitchField, 25, 5, // 10624: switch Inst[29:25] {
6286 0, 126, // 10627: case 0x0: {
6287 OPC_SwitchField, 12, 3, // 10629: switch Inst[14:12] {
6288 0, 15, // 10632: case 0x0: {
6289 OPC_SwitchField, 30, 2, // 10634: switch Inst[31:30] {
6290 0, 4, // 10637: case 0x0: {
6291 OPC_Decode, 207, 107, 31, // 10639: decode to ADD using decoder 31
6292 // 10639: }
6293 1, 0, // 10643: case 0x1: {
6294 OPC_Decode, 184, 125, 31, // 10645: decode to SUB using decoder 31
6295 // 10645: }
6296 // 10645: } // switch Inst[31:30]
6297 // 10645: }
6298 1, 8, // 10649: case 0x1: {
6299 OPC_CheckField, 30, 2, 0, // 10651: check Inst[31:30] == 0x0
6300 OPC_Decode, 217, 124, 31, // 10655: decode to SLL using decoder 31
6301 // 10655: }
6302 2, 8, // 10659: case 0x2: {
6303 OPC_CheckField, 30, 2, 0, // 10661: check Inst[31:30] == 0x0
6304 OPC_Decode, 222, 124, 31, // 10665: decode to SLT using decoder 31
6305 // 10665: }
6306 3, 8, // 10669: case 0x3: {
6307 OPC_CheckField, 30, 2, 0, // 10671: check Inst[31:30] == 0x0
6308 OPC_Decode, 225, 124, 31, // 10675: decode to SLTU using decoder 31
6309 // 10675: }
6310 4, 19, // 10679: case 0x4: {
6311 OPC_SwitchField, 30, 2, // 10681: switch Inst[31:30] {
6312 0, 5, // 10684: case 0x0: {
6313 OPC_Decode, 162, 132, 1, 31, // 10686: decode to XOR using decoder 31
6314 // 10686: }
6315 1, 0, // 10691: case 0x1: {
6316 OPC_CheckPredicate, 44, // 10693: check predicate 44
6317 OPC_Decode, 161, 132, 1, 31, // 10695: decode to XNOR using decoder 31
6318 // 10695: }
6319 // 10695: } // switch Inst[31:30]
6320 // 10695: }
6321 5, 15, // 10700: case 0x5: {
6322 OPC_SwitchField, 30, 2, // 10702: switch Inst[31:30] {
6323 0, 4, // 10705: case 0x0: {
6324 OPC_Decode, 160, 125, 31, // 10707: decode to SRL using decoder 31
6325 // 10707: }
6326 1, 0, // 10711: case 0x1: {
6327 OPC_Decode, 153, 125, 31, // 10713: decode to SRA using decoder 31
6328 // 10713: }
6329 // 10713: } // switch Inst[31:30]
6330 // 10713: }
6331 6, 17, // 10717: case 0x6: {
6332 OPC_SwitchField, 30, 2, // 10719: switch Inst[31:30] {
6333 0, 4, // 10722: case 0x0: {
6334 OPC_Decode, 210, 118, 31, // 10724: decode to OR using decoder 31
6335 // 10724: }
6336 1, 0, // 10728: case 0x1: {
6337 OPC_CheckPredicate, 44, // 10730: check predicate 44
6338 OPC_Decode, 213, 118, 31, // 10732: decode to ORN using decoder 31
6339 // 10732: }
6340 // 10732: } // switch Inst[31:30]
6341 // 10732: }
6342 7, 0, // 10736: case 0x7: {
6343 OPC_SwitchField, 30, 2, // 10738: switch Inst[31:30] {
6344 0, 4, // 10741: case 0x0: {
6345 OPC_Decode, 221, 110, 31, // 10743: decode to AND using decoder 31
6346 // 10743: }
6347 1, 0, // 10747: case 0x1: {
6348 OPC_CheckPredicate, 44, // 10749: check predicate 44
6349 OPC_Decode, 223, 110, 31, // 10751: decode to ANDN using decoder 31
6350 // 10751: }
6351 // 10751: } // switch Inst[31:30]
6352 // 10751: }
6353 // 10751: } // switch Inst[14:12]
6354 // 10751: }
6355 1, 99, // 10755: case 0x1: {
6356 OPC_SwitchField, 12, 3, // 10757: switch Inst[14:12] {
6357 0, 10, // 10760: case 0x0: {
6358 OPC_CheckPredicate, 66, // 10762: check predicate 66
6359 OPC_CheckField, 30, 2, 0, // 10764: check Inst[31:30] == 0x0
6360 OPC_Decode, 245, 117, 31, // 10768: decode to MUL using decoder 31
6361 // 10768: }
6362 1, 10, // 10772: case 0x1: {
6363 OPC_CheckPredicate, 66, // 10774: check predicate 66
6364 OPC_CheckField, 30, 2, 0, // 10776: check Inst[31:30] == 0x0
6365 OPC_Decode, 246, 117, 31, // 10780: decode to MULH using decoder 31
6366 // 10780: }
6367 2, 10, // 10784: case 0x2: {
6368 OPC_CheckPredicate, 66, // 10786: check predicate 66
6369 OPC_CheckField, 30, 2, 0, // 10788: check Inst[31:30] == 0x0
6370 OPC_Decode, 250, 117, 31, // 10792: decode to MULHSU using decoder 31
6371 // 10792: }
6372 3, 10, // 10796: case 0x3: {
6373 OPC_CheckPredicate, 66, // 10798: check predicate 66
6374 OPC_CheckField, 30, 2, 0, // 10800: check Inst[31:30] == 0x0
6375 OPC_Decode, 253, 117, 31, // 10804: decode to MULHU using decoder 31
6376 // 10804: }
6377 4, 10, // 10808: case 0x4: {
6378 OPC_CheckPredicate, 67, // 10810: check predicate 67
6379 OPC_CheckField, 30, 2, 0, // 10812: check Inst[31:30] == 0x0
6380 OPC_Decode, 149, 114, 31, // 10816: decode to DIV using decoder 31
6381 // 10816: }
6382 5, 10, // 10820: case 0x5: {
6383 OPC_CheckPredicate, 67, // 10822: check predicate 67
6384 OPC_CheckField, 30, 2, 0, // 10824: check Inst[31:30] == 0x0
6385 OPC_Decode, 150, 114, 31, // 10828: decode to DIVU using decoder 31
6386 // 10828: }
6387 6, 10, // 10832: case 0x6: {
6388 OPC_CheckPredicate, 67, // 10834: check predicate 67
6389 OPC_CheckField, 30, 2, 0, // 10836: check Inst[31:30] == 0x0
6390 OPC_Decode, 205, 123, 31, // 10840: decode to REM using decoder 31
6391 // 10840: }
6392 7, 0, // 10844: case 0x7: {
6393 OPC_CheckPredicate, 67, // 10846: check predicate 67
6394 OPC_CheckField, 30, 2, 0, // 10848: check Inst[31:30] == 0x0
6395 OPC_Decode, 206, 123, 31, // 10852: decode to REMU using decoder 31
6396 // 10852: }
6397 // 10852: } // switch Inst[14:12]
6398 // 10852: }
6399 4, 64, // 10856: case 0x4: {
6400 OPC_SwitchField, 12, 3, // 10858: switch Inst[14:12] {
6401 1, 10, // 10861: case 0x1: {
6402 OPC_CheckPredicate, 39, // 10863: check predicate 39
6403 OPC_CheckField, 30, 2, 1, // 10865: check Inst[31:30] == 0x1
6404 OPC_Decode, 227, 110, 31, // 10869: decode to BCLR using decoder 31
6405 // 10869: }
6406 4, 23, // 10873: case 0x4: {
6407 OPC_CheckField, 30, 2, 0, // 10875: check Inst[31:30] == 0x0
6408 OPC_Scope, 11, // 10879: try {
6409 OPC_CheckField, 20, 5, 0, // 10881: check Inst[24:20] == 0x0
6410 OPC_CheckPredicate, 46, // 10885: check predicate 46
6411 OPC_Decode, 192, 132, 1, 17, // 10887: decode to ZEXT_H_RV32 using decoder 17
6412 // 10887: } else try {
6413 OPC_CheckPredicate, 68, // 10892: check predicate 68
6414 OPC_Decode, 239, 118, 31, // 10894: decode to PACK using decoder 31
6415 // 10894: }
6416 // 10894: }
6417 5, 10, // 10898: case 0x5: {
6418 OPC_CheckPredicate, 39, // 10900: check predicate 39
6419 OPC_CheckField, 30, 2, 1, // 10902: check Inst[31:30] == 0x1
6420 OPC_Decode, 231, 110, 31, // 10906: decode to BEXT using decoder 31
6421 // 10906: }
6422 7, 0, // 10910: case 0x7: {
6423 OPC_CheckPredicate, 45, // 10912: check predicate 45
6424 OPC_CheckField, 30, 2, 0, // 10914: check Inst[31:30] == 0x0
6425 OPC_Decode, 240, 118, 31, // 10918: decode to PACKH using decoder 31
6426 // 10918: }
6427 // 10918: } // switch Inst[14:12]
6428 // 10918: }
6429 5, 87, // 10922: case 0x5: {
6430 OPC_SwitchField, 12, 3, // 10924: switch Inst[14:12] {
6431 1, 10, // 10927: case 0x1: {
6432 OPC_CheckPredicate, 69, // 10929: check predicate 69
6433 OPC_CheckField, 30, 2, 0, // 10931: check Inst[31:30] == 0x0
6434 OPC_Decode, 248, 110, 31, // 10935: decode to CLMUL using decoder 31
6435 // 10935: }
6436 2, 10, // 10939: case 0x2: {
6437 OPC_CheckPredicate, 70, // 10941: check predicate 70
6438 OPC_CheckField, 30, 2, 0, // 10943: check Inst[31:30] == 0x0
6439 OPC_Decode, 250, 110, 31, // 10947: decode to CLMULR using decoder 31
6440 // 10947: }
6441 3, 10, // 10951: case 0x3: {
6442 OPC_CheckPredicate, 69, // 10953: check predicate 69
6443 OPC_CheckField, 30, 2, 0, // 10955: check Inst[31:30] == 0x0
6444 OPC_Decode, 249, 110, 31, // 10959: decode to CLMULH using decoder 31
6445 // 10959: }
6446 4, 10, // 10963: case 0x4: {
6447 OPC_CheckPredicate, 42, // 10965: check predicate 42
6448 OPC_CheckField, 30, 2, 0, // 10967: check Inst[31:30] == 0x0
6449 OPC_Decode, 174, 117, 31, // 10971: decode to MIN using decoder 31
6450 // 10971: }
6451 5, 10, // 10975: case 0x5: {
6452 OPC_CheckPredicate, 42, // 10977: check predicate 42
6453 OPC_CheckField, 30, 2, 0, // 10979: check Inst[31:30] == 0x0
6454 OPC_Decode, 175, 117, 31, // 10983: decode to MINU using decoder 31
6455 // 10983: }
6456 6, 10, // 10987: case 0x6: {
6457 OPC_CheckPredicate, 42, // 10989: check predicate 42
6458 OPC_CheckField, 30, 2, 0, // 10991: check Inst[31:30] == 0x0
6459 OPC_Decode, 159, 117, 31, // 10995: decode to MAX using decoder 31
6460 // 10995: }
6461 7, 0, // 10999: case 0x7: {
6462 OPC_CheckPredicate, 42, // 11001: check predicate 42
6463 OPC_CheckField, 30, 2, 0, // 11003: check Inst[31:30] == 0x0
6464 OPC_Decode, 160, 117, 31, // 11007: decode to MAXU using decoder 31
6465 // 11007: }
6466 // 11007: } // switch Inst[14:12]
6467 // 11007: }
6468 7, 27, // 11011: case 0x7: {
6469 OPC_SwitchField, 12, 3, // 11013: switch Inst[14:12] {
6470 5, 10, // 11016: case 0x5: {
6471 OPC_CheckPredicate, 71, // 11018: check predicate 71
6472 OPC_CheckField, 30, 2, 0, // 11020: check Inst[31:30] == 0x0
6473 OPC_Decode, 201, 113, 31, // 11024: decode to CZERO_EQZ using decoder 31
6474 // 11024: }
6475 7, 0, // 11028: case 0x7: {
6476 OPC_CheckPredicate, 71, // 11030: check predicate 71
6477 OPC_CheckField, 30, 2, 0, // 11032: check Inst[31:30] == 0x0
6478 OPC_Decode, 202, 113, 31, // 11036: decode to CZERO_NEZ using decoder 31
6479 // 11036: }
6480 // 11036: } // switch Inst[14:12]
6481 // 11036: }
6482 8, 14, // 11040: case 0x8: {
6483 OPC_CheckPredicate, 72, // 11042: check predicate 72
6484 OPC_CheckField, 30, 2, 1, // 11044: check Inst[31:30] == 0x1
6485 OPC_CheckField, 12, 3, 0, // 11048: check Inst[14:12] == 0x0
6486 OPC_Decode, 206, 124, 31, // 11052: decode to SHA512SUM0R using decoder 31
6487 // 11052: }
6488 9, 14, // 11056: case 0x9: {
6489 OPC_CheckPredicate, 72, // 11058: check predicate 72
6490 OPC_CheckField, 30, 2, 1, // 11060: check Inst[31:30] == 0x1
6491 OPC_CheckField, 12, 3, 0, // 11064: check Inst[14:12] == 0x0
6492 OPC_Decode, 208, 124, 31, // 11068: decode to SHA512SUM1R using decoder 31
6493 // 11068: }
6494 10, 14, // 11072: case 0xa: {
6495 OPC_CheckPredicate, 72, // 11074: check predicate 72
6496 OPC_CheckField, 30, 2, 1, // 11076: check Inst[31:30] == 0x1
6497 OPC_CheckField, 12, 3, 0, // 11080: check Inst[14:12] == 0x0
6498 OPC_Decode, 201, 124, 31, // 11084: decode to SHA512SIG0L using decoder 31
6499 // 11084: }
6500 11, 14, // 11088: case 0xb: {
6501 OPC_CheckPredicate, 72, // 11090: check predicate 72
6502 OPC_CheckField, 30, 2, 1, // 11092: check Inst[31:30] == 0x1
6503 OPC_CheckField, 12, 3, 0, // 11096: check Inst[14:12] == 0x0
6504 OPC_Decode, 204, 124, 31, // 11100: decode to SHA512SIG1L using decoder 31
6505 // 11100: }
6506 14, 14, // 11104: case 0xe: {
6507 OPC_CheckPredicate, 72, // 11106: check predicate 72
6508 OPC_CheckField, 30, 2, 1, // 11108: check Inst[31:30] == 0x1
6509 OPC_CheckField, 12, 3, 0, // 11112: check Inst[14:12] == 0x0
6510 OPC_Decode, 200, 124, 31, // 11116: decode to SHA512SIG0H using decoder 31
6511 // 11116: }
6512 15, 14, // 11120: case 0xf: {
6513 OPC_CheckPredicate, 72, // 11122: check predicate 72
6514 OPC_CheckField, 30, 2, 1, // 11124: check Inst[31:30] == 0x1
6515 OPC_CheckField, 12, 3, 0, // 11128: check Inst[14:12] == 0x0
6516 OPC_Decode, 203, 124, 31, // 11132: decode to SHA512SIG1H using decoder 31
6517 // 11132: }
6518 16, 63, // 11136: case 0x10: {
6519 OPC_SwitchField, 12, 3, // 11138: switch Inst[14:12] {
6520 1, 10, // 11141: case 0x1: {
6521 OPC_CheckPredicate, 44, // 11143: check predicate 44
6522 OPC_CheckField, 30, 2, 1, // 11145: check Inst[31:30] == 0x1
6523 OPC_Decode, 214, 123, 31, // 11149: decode to ROL using decoder 31
6524 // 11149: }
6525 2, 10, // 11153: case 0x2: {
6526 OPC_CheckPredicate, 73, // 11155: check predicate 73
6527 OPC_CheckField, 30, 2, 0, // 11157: check Inst[31:30] == 0x0
6528 OPC_Decode, 188, 124, 31, // 11161: decode to SH1ADD using decoder 31
6529 // 11161: }
6530 4, 10, // 11165: case 0x4: {
6531 OPC_CheckPredicate, 73, // 11167: check predicate 73
6532 OPC_CheckField, 30, 2, 0, // 11169: check Inst[31:30] == 0x0
6533 OPC_Decode, 190, 124, 31, // 11173: decode to SH2ADD using decoder 31
6534 // 11173: }
6535 5, 10, // 11177: case 0x5: {
6536 OPC_CheckPredicate, 44, // 11179: check predicate 44
6537 OPC_CheckField, 30, 2, 1, // 11181: check Inst[31:30] == 0x1
6538 OPC_Decode, 216, 123, 31, // 11185: decode to ROR using decoder 31
6539 // 11185: }
6540 6, 0, // 11189: case 0x6: {
6541 OPC_CheckPredicate, 73, // 11191: check predicate 73
6542 OPC_CheckField, 30, 2, 0, // 11193: check Inst[31:30] == 0x0
6543 OPC_Decode, 192, 124, 31, // 11197: decode to SH3ADD using decoder 31
6544 // 11197: }
6545 // 11197: } // switch Inst[14:12]
6546 // 11197: }
6547 17, 10, // 11201: case 0x11: {
6548 OPC_CheckPredicate, 74, // 11203: check predicate 74
6549 OPC_CheckField, 12, 3, 0, // 11205: check Inst[14:12] == 0x0
6550 OPC_Decode, 215, 107, 60, // 11209: decode to AES32ESI using decoder 60
6551 // 11209: }
6552 19, 10, // 11213: case 0x13: {
6553 OPC_CheckPredicate, 74, // 11215: check predicate 74
6554 OPC_CheckField, 12, 3, 0, // 11217: check Inst[14:12] == 0x0
6555 OPC_Decode, 216, 107, 60, // 11221: decode to AES32ESMI using decoder 60
6556 // 11221: }
6557 20, 50, // 11225: case 0x14: {
6558 OPC_SwitchField, 12, 3, // 11227: switch Inst[14:12] {
6559 1, 19, // 11230: case 0x1: {
6560 OPC_SwitchField, 30, 2, // 11232: switch Inst[31:30] {
6561 0, 6, // 11235: case 0x0: {
6562 OPC_CheckPredicate, 39, // 11237: check predicate 39
6563 OPC_Decode, 242, 110, 31, // 11239: decode to BSET using decoder 31
6564 // 11239: }
6565 1, 0, // 11243: case 0x1: {
6566 OPC_CheckPredicate, 39, // 11245: check predicate 39
6567 OPC_Decode, 235, 110, 31, // 11247: decode to BINV using decoder 31
6568 // 11247: }
6569 // 11247: } // switch Inst[31:30]
6570 // 11247: }
6571 2, 11, // 11251: case 0x2: {
6572 OPC_CheckPredicate, 75, // 11253: check predicate 75
6573 OPC_CheckField, 30, 2, 0, // 11255: check Inst[31:30] == 0x0
6574 OPC_Decode, 164, 132, 1, 31, // 11259: decode to XPERM4 using decoder 31
6575 // 11259: }
6576 4, 0, // 11264: case 0x4: {
6577 OPC_CheckPredicate, 75, // 11266: check predicate 75
6578 OPC_CheckField, 30, 2, 0, // 11268: check Inst[31:30] == 0x0
6579 OPC_Decode, 165, 132, 1, 31, // 11272: decode to XPERM8 using decoder 31
6580 // 11272: }
6581 // 11272: } // switch Inst[14:12]
6582 // 11272: }
6583 21, 10, // 11277: case 0x15: {
6584 OPC_CheckPredicate, 76, // 11279: check predicate 76
6585 OPC_CheckField, 12, 3, 0, // 11281: check Inst[14:12] == 0x0
6586 OPC_Decode, 213, 107, 60, // 11285: decode to AES32DSI using decoder 60
6587 // 11285: }
6588 23, 10, // 11289: case 0x17: {
6589 OPC_CheckPredicate, 76, // 11291: check predicate 76
6590 OPC_CheckField, 12, 3, 0, // 11293: check Inst[14:12] == 0x0
6591 OPC_Decode, 214, 107, 60, // 11297: decode to AES32DSMI using decoder 60
6592 // 11297: }
6593 24, 10, // 11301: case 0x18: {
6594 OPC_CheckPredicate, 77, // 11303: check predicate 77
6595 OPC_CheckField, 12, 3, 0, // 11305: check Inst[14:12] == 0x0
6596 OPC_Decode, 229, 124, 60, // 11309: decode to SM4ED using decoder 60
6597 // 11309: }
6598 25, 14, // 11313: case 0x19: {
6599 OPC_CheckPredicate, 78, // 11315: check predicate 78
6600 OPC_CheckField, 30, 2, 0, // 11317: check Inst[31:30] == 0x0
6601 OPC_CheckField, 12, 3, 0, // 11321: check Inst[14:12] == 0x0
6602 OPC_Decode, 219, 107, 31, // 11325: decode to AES64ES using decoder 31
6603 // 11325: }
6604 26, 10, // 11329: case 0x1a: {
6605 OPC_CheckPredicate, 77, // 11331: check predicate 77
6606 OPC_CheckField, 12, 3, 0, // 11333: check Inst[14:12] == 0x0
6607 OPC_Decode, 230, 124, 60, // 11337: decode to SM4KS using decoder 60
6608 // 11337: }
6609 27, 14, // 11341: case 0x1b: {
6610 OPC_CheckPredicate, 78, // 11343: check predicate 78
6611 OPC_CheckField, 30, 2, 0, // 11345: check Inst[31:30] == 0x0
6612 OPC_CheckField, 12, 3, 0, // 11349: check Inst[14:12] == 0x0
6613 OPC_Decode, 220, 107, 31, // 11353: decode to AES64ESM using decoder 31
6614 // 11353: }
6615 29, 14, // 11357: case 0x1d: {
6616 OPC_CheckPredicate, 40, // 11359: check predicate 40
6617 OPC_CheckField, 30, 2, 0, // 11361: check Inst[31:30] == 0x0
6618 OPC_CheckField, 12, 3, 0, // 11365: check Inst[14:12] == 0x0
6619 OPC_Decode, 217, 107, 31, // 11369: decode to AES64DS using decoder 31
6620 // 11369: }
6621 31, 0, // 11373: case 0x1f: {
6622 OPC_SwitchField, 30, 2, // 11375: switch Inst[31:30] {
6623 0, 10, // 11378: case 0x0: {
6624 OPC_CheckPredicate, 40, // 11380: check predicate 40
6625 OPC_CheckField, 12, 3, 0, // 11382: check Inst[14:12] == 0x0
6626 OPC_Decode, 218, 107, 31, // 11386: decode to AES64DSM using decoder 31
6627 // 11386: }
6628 1, 0, // 11390: case 0x1: {
6629 OPC_CheckPredicate, 41, // 11392: check predicate 41
6630 OPC_CheckField, 12, 3, 0, // 11394: check Inst[14:12] == 0x0
6631 OPC_Decode, 223, 107, 31, // 11398: decode to AES64KS2 using decoder 31
6632 // 11398: }
6633 // 11398: } // switch Inst[31:30]
6634 // 11398: }
6635 // 11398: } // switch Inst[29:25]
6636 // 11398: }
6637 55, 4, // 11402: case 0x37: {
6638 OPC_Decode, 246, 116, 20, // 11404: decode to LUI using decoder 20
6639 // 11404: }
6640 59, 155, 19, // 11408: case 0x3b: {
6641 OPC_SwitchField, 25, 7, // 11411: switch Inst[31:25] {
6642 0, 27, // 11414: case 0x0: {
6643 OPC_SwitchField, 12, 3, // 11416: switch Inst[14:12] {
6644 0, 6, // 11419: case 0x0: {
6645 OPC_CheckPredicate, 22, // 11421: check predicate 22
6646 OPC_Decode, 211, 107, 31, // 11423: decode to ADDW using decoder 31
6647 // 11423: }
6648 1, 6, // 11427: case 0x1: {
6649 OPC_CheckPredicate, 22, // 11429: check predicate 22
6650 OPC_Decode, 221, 124, 31, // 11431: decode to SLLW using decoder 31
6651 // 11431: }
6652 5, 0, // 11435: case 0x5: {
6653 OPC_CheckPredicate, 22, // 11437: check predicate 22
6654 OPC_Decode, 163, 125, 31, // 11439: decode to SRLW using decoder 31
6655 // 11439: }
6656 // 11439: } // switch Inst[14:12]
6657 // 11439: }
6658 1, 43, // 11443: case 0x1: {
6659 OPC_SwitchField, 12, 3, // 11445: switch Inst[14:12] {
6660 0, 6, // 11448: case 0x0: {
6661 OPC_CheckPredicate, 79, // 11450: check predicate 79
6662 OPC_Decode, 140, 118, 31, // 11452: decode to MULW using decoder 31
6663 // 11452: }
6664 4, 6, // 11456: case 0x4: {
6665 OPC_CheckPredicate, 80, // 11458: check predicate 80
6666 OPC_Decode, 152, 114, 31, // 11460: decode to DIVW using decoder 31
6667 // 11460: }
6668 5, 6, // 11464: case 0x5: {
6669 OPC_CheckPredicate, 80, // 11466: check predicate 80
6670 OPC_Decode, 151, 114, 31, // 11468: decode to DIVUW using decoder 31
6671 // 11468: }
6672 6, 6, // 11472: case 0x6: {
6673 OPC_CheckPredicate, 80, // 11474: check predicate 80
6674 OPC_Decode, 208, 123, 31, // 11476: decode to REMW using decoder 31
6675 // 11476: }
6676 7, 0, // 11480: case 0x7: {
6677 OPC_CheckPredicate, 80, // 11482: check predicate 80
6678 OPC_Decode, 207, 123, 31, // 11484: decode to REMUW using decoder 31
6679 // 11484: }
6680 // 11484: } // switch Inst[14:12]
6681 // 11484: }
6682 4, 32, // 11488: case 0x4: {
6683 OPC_SwitchField, 12, 3, // 11490: switch Inst[14:12] {
6684 0, 6, // 11493: case 0x0: {
6685 OPC_CheckPredicate, 50, // 11495: check predicate 50
6686 OPC_Decode, 212, 107, 31, // 11497: decode to ADD_UW using decoder 31
6687 // 11497: }
6688 4, 0, // 11501: case 0x4: {
6689 OPC_Scope, 11, // 11503: try {
6690 OPC_CheckField, 20, 5, 0, // 11505: check Inst[24:20] == 0x0
6691 OPC_CheckPredicate, 49, // 11509: check predicate 49
6692 OPC_Decode, 193, 132, 1, 17, // 11511: decode to ZEXT_H_RV64 using decoder 17
6693 // 11511: } else try {
6694 OPC_CheckPredicate, 81, // 11516: check predicate 81
6695 OPC_Decode, 241, 118, 31, // 11518: decode to PACKW using decoder 31
6696 // 11518: }
6697 // 11518: }
6698 // 11518: } // switch Inst[14:12]
6699 // 11518: }
6700 16, 27, // 11522: case 0x10: {
6701 OPC_SwitchField, 12, 3, // 11524: switch Inst[14:12] {
6702 2, 6, // 11527: case 0x2: {
6703 OPC_CheckPredicate, 50, // 11529: check predicate 50
6704 OPC_Decode, 189, 124, 31, // 11531: decode to SH1ADD_UW using decoder 31
6705 // 11531: }
6706 4, 6, // 11535: case 0x4: {
6707 OPC_CheckPredicate, 50, // 11537: check predicate 50
6708 OPC_Decode, 191, 124, 31, // 11539: decode to SH2ADD_UW using decoder 31
6709 // 11539: }
6710 6, 0, // 11543: case 0x6: {
6711 OPC_CheckPredicate, 50, // 11545: check predicate 50
6712 OPC_Decode, 193, 124, 31, // 11547: decode to SH3ADD_UW using decoder 31
6713 // 11547: }
6714 // 11547: } // switch Inst[14:12]
6715 // 11547: }
6716 32, 19, // 11551: case 0x20: {
6717 OPC_SwitchField, 12, 3, // 11553: switch Inst[14:12] {
6718 0, 6, // 11556: case 0x0: {
6719 OPC_CheckPredicate, 22, // 11558: check predicate 22
6720 OPC_Decode, 186, 125, 31, // 11560: decode to SUBW using decoder 31
6721 // 11560: }
6722 5, 0, // 11564: case 0x5: {
6723 OPC_CheckPredicate, 22, // 11566: check predicate 22
6724 OPC_Decode, 158, 125, 31, // 11568: decode to SRAW using decoder 31
6725 // 11568: }
6726 // 11568: } // switch Inst[14:12]
6727 // 11568: }
6728 48, 19, // 11572: case 0x30: {
6729 OPC_SwitchField, 12, 3, // 11574: switch Inst[14:12] {
6730 1, 6, // 11577: case 0x1: {
6731 OPC_CheckPredicate, 49, // 11579: check predicate 49
6732 OPC_Decode, 215, 123, 31, // 11581: decode to ROLW using decoder 31
6733 // 11581: }
6734 5, 0, // 11585: case 0x5: {
6735 OPC_CheckPredicate, 49, // 11587: check predicate 49
6736 OPC_Decode, 219, 123, 31, // 11589: decode to RORW using decoder 31
6737 // 11589: }
6738 // 11589: } // switch Inst[14:12]
6739 // 11589: }
6740 64, 59, // 11593: case 0x40: {
6741 OPC_SwitchField, 12, 3, // 11595: switch Inst[14:12] {
6742 0, 6, // 11598: case 0x0: {
6743 OPC_CheckPredicate, 43, // 11600: check predicate 43
6744 OPC_Decode, 250, 118, 31, // 11602: decode to PADD_H using decoder 31
6745 // 11602: }
6746 2, 6, // 11606: case 0x2: {
6747 OPC_CheckPredicate, 48, // 11608: check predicate 48
6748 OPC_Decode, 215, 120, 31, // 11610: decode to PNCLIPUP_B using decoder 31
6749 // 11610: }
6750 3, 6, // 11614: case 0x3: {
6751 OPC_CheckPredicate, 43, // 11616: check predicate 43
6752 OPC_Decode, 194, 120, 31, // 11618: decode to PMUL_H_B00 using decoder 31
6753 // 11618: }
6754 4, 6, // 11622: case 0x4: {
6755 OPC_CheckPredicate, 43, // 11624: check predicate 43
6756 OPC_Decode, 239, 120, 31, // 11626: decode to PPAIRE_B using decoder 31
6757 // 11626: }
6758 5, 6, // 11630: case 0x5: {
6759 OPC_CheckPredicate, 43, // 11632: check predicate 43
6760 OPC_Decode, 164, 119, 31, // 11634: decode to PM2ADD_H using decoder 31
6761 // 11634: }
6762 6, 6, // 11638: case 0x6: {
6763 OPC_CheckPredicate, 43, // 11640: check predicate 43
6764 OPC_Decode, 142, 119, 31, // 11642: decode to PAS_HX using decoder 31
6765 // 11642: }
6766 7, 0, // 11646: case 0x7: {
6767 OPC_CheckPredicate, 43, // 11648: check predicate 43
6768 OPC_Decode, 174, 120, 31, // 11650: decode to PMULH_H using decoder 31
6769 // 11650: }
6770 // 11650: } // switch Inst[14:12]
6771 // 11650: }
6772 65, 59, // 11654: case 0x41: {
6773 OPC_SwitchField, 12, 3, // 11656: switch Inst[14:12] {
6774 0, 6, // 11659: case 0x0: {
6775 OPC_CheckPredicate, 48, // 11661: check predicate 48
6776 OPC_Decode, 252, 118, 31, // 11663: decode to PADD_W using decoder 31
6777 // 11663: }
6778 2, 6, // 11667: case 0x2: {
6779 OPC_CheckPredicate, 48, // 11669: check predicate 48
6780 OPC_Decode, 216, 120, 31, // 11671: decode to PNCLIPUP_H using decoder 31
6781 // 11671: }
6782 3, 6, // 11675: case 0x3: {
6783 OPC_CheckPredicate, 48, // 11677: check predicate 48
6784 OPC_Decode, 197, 120, 31, // 11679: decode to PMUL_W_H00 using decoder 31
6785 // 11679: }
6786 4, 6, // 11683: case 0x4: {
6787 OPC_CheckPredicate, 48, // 11685: check predicate 48
6788 OPC_Decode, 242, 120, 31, // 11687: decode to PPAIRE_H using decoder 31
6789 // 11687: }
6790 5, 6, // 11691: case 0x5: {
6791 OPC_CheckPredicate, 48, // 11693: check predicate 48
6792 OPC_Decode, 166, 119, 31, // 11695: decode to PM2ADD_W using decoder 31
6793 // 11695: }
6794 6, 6, // 11699: case 0x6: {
6795 OPC_CheckPredicate, 48, // 11701: check predicate 48
6796 OPC_Decode, 143, 119, 31, // 11703: decode to PAS_WX using decoder 31
6797 // 11703: }
6798 7, 0, // 11707: case 0x7: {
6799 OPC_CheckPredicate, 48, // 11709: check predicate 48
6800 OPC_Decode, 177, 120, 31, // 11711: decode to PMULH_W using decoder 31
6801 // 11711: }
6802 // 11711: } // switch Inst[14:12]
6803 // 11711: }
6804 66, 35, // 11715: case 0x42: {
6805 OPC_SwitchField, 12, 3, // 11717: switch Inst[14:12] {
6806 0, 6, // 11720: case 0x0: {
6807 OPC_CheckPredicate, 43, // 11722: check predicate 43
6808 OPC_Decode, 242, 118, 31, // 11724: decode to PADD_B using decoder 31
6809 // 11724: }
6810 5, 6, // 11728: case 0x5: {
6811 OPC_CheckPredicate, 43, // 11730: check predicate 43
6812 OPC_Decode, 200, 119, 31, // 11732: decode to PM4ADD_B using decoder 31
6813 // 11732: }
6814 6, 6, // 11736: case 0x6: {
6815 OPC_CheckPredicate, 43, // 11738: check predicate 43
6816 OPC_Decode, 162, 121, 31, // 11740: decode to PSA_HX using decoder 31
6817 // 11740: }
6818 7, 0, // 11744: case 0x7: {
6819 OPC_CheckPredicate, 43, // 11746: check predicate 43
6820 OPC_Decode, 164, 120, 31, // 11748: decode to PMULHR_H using decoder 31
6821 // 11748: }
6822 // 11748: } // switch Inst[14:12]
6823 // 11748: }
6824 67, 43, // 11752: case 0x43: {
6825 OPC_SwitchField, 12, 3, // 11754: switch Inst[14:12] {
6826 2, 6, // 11757: case 0x2: {
6827 OPC_CheckPredicate, 48, // 11759: check predicate 48
6828 OPC_Decode, 217, 120, 31, // 11761: decode to PNCLIPUP_W using decoder 31
6829 // 11761: }
6830 3, 6, // 11765: case 0x3: {
6831 OPC_CheckPredicate, 48, // 11767: check predicate 48
6832 OPC_Decode, 144, 118, 31, // 11769: decode to MUL_W00 using decoder 31
6833 // 11769: }
6834 5, 6, // 11773: case 0x5: {
6835 OPC_CheckPredicate, 48, // 11775: check predicate 48
6836 OPC_Decode, 201, 119, 31, // 11777: decode to PM4ADD_H using decoder 31
6837 // 11777: }
6838 6, 6, // 11781: case 0x6: {
6839 OPC_CheckPredicate, 48, // 11783: check predicate 48
6840 OPC_Decode, 163, 121, 31, // 11785: decode to PSA_WX using decoder 31
6841 // 11785: }
6842 7, 0, // 11789: case 0x7: {
6843 OPC_CheckPredicate, 48, // 11791: check predicate 48
6844 OPC_Decode, 165, 120, 31, // 11793: decode to PMULHR_W using decoder 31
6845 // 11793: }
6846 // 11793: } // switch Inst[14:12]
6847 // 11793: }
6848 68, 19, // 11797: case 0x44: {
6849 OPC_SwitchField, 12, 3, // 11799: switch Inst[14:12] {
6850 5, 6, // 11802: case 0x5: {
6851 OPC_CheckPredicate, 43, // 11804: check predicate 43
6852 OPC_Decode, 156, 119, 61, // 11806: decode to PM2ADDA_H using decoder 61
6853 // 11806: }
6854 7, 0, // 11810: case 0x7: {
6855 OPC_CheckPredicate, 43, // 11812: check predicate 43
6856 OPC_Decode, 230, 119, 61, // 11814: decode to PMHACC_H using decoder 61
6857 // 11814: }
6858 // 11814: } // switch Inst[14:12]
6859 // 11814: }
6860 69, 27, // 11818: case 0x45: {
6861 OPC_SwitchField, 12, 3, // 11820: switch Inst[14:12] {
6862 3, 6, // 11823: case 0x3: {
6863 OPC_CheckPredicate, 48, // 11825: check predicate 48
6864 OPC_Decode, 207, 119, 61, // 11827: decode to PMACC_W_H00 using decoder 61
6865 // 11827: }
6866 5, 6, // 11831: case 0x5: {
6867 OPC_CheckPredicate, 48, // 11833: check predicate 48
6868 OPC_Decode, 158, 119, 61, // 11835: decode to PM2ADDA_W using decoder 61
6869 // 11835: }
6870 7, 0, // 11839: case 0x7: {
6871 OPC_CheckPredicate, 48, // 11841: check predicate 48
6872 OPC_Decode, 233, 119, 61, // 11843: decode to PMHACC_W using decoder 61
6873 // 11843: }
6874 // 11843: } // switch Inst[14:12]
6875 // 11843: }
6876 70, 19, // 11847: case 0x46: {
6877 OPC_SwitchField, 12, 3, // 11849: switch Inst[14:12] {
6878 5, 6, // 11852: case 0x5: {
6879 OPC_CheckPredicate, 43, // 11854: check predicate 43
6880 OPC_Decode, 194, 119, 61, // 11856: decode to PM4ADDA_B using decoder 61
6881 // 11856: }
6882 7, 0, // 11860: case 0x7: {
6883 OPC_CheckPredicate, 43, // 11862: check predicate 43
6884 OPC_Decode, 240, 119, 61, // 11864: decode to PMHRACC_H using decoder 61
6885 // 11864: }
6886 // 11864: } // switch Inst[14:12]
6887 // 11864: }
6888 71, 35, // 11868: case 0x47: {
6889 OPC_SwitchField, 12, 3, // 11870: switch Inst[14:12] {
6890 1, 6, // 11873: case 0x1: {
6891 OPC_CheckPredicate, 43, // 11875: check predicate 43
6892 OPC_Decode, 226, 124, 61, // 11877: decode to SLX using decoder 61
6893 // 11877: }
6894 3, 6, // 11881: case 0x3: {
6895 OPC_CheckPredicate, 48, // 11883: check predicate 48
6896 OPC_Decode, 156, 117, 61, // 11885: decode to MACC_W00 using decoder 61
6897 // 11885: }
6898 5, 6, // 11889: case 0x5: {
6899 OPC_CheckPredicate, 48, // 11891: check predicate 48
6900 OPC_Decode, 195, 119, 61, // 11893: decode to PM4ADDA_H using decoder 61
6901 // 11893: }
6902 7, 0, // 11897: case 0x7: {
6903 OPC_CheckPredicate, 48, // 11899: check predicate 48
6904 OPC_Decode, 241, 119, 61, // 11901: decode to PMHRACC_W using decoder 61
6905 // 11901: }
6906 // 11901: } // switch Inst[14:12]
6907 // 11901: }
6908 72, 59, // 11905: case 0x48: {
6909 OPC_SwitchField, 12, 3, // 11907: switch Inst[14:12] {
6910 0, 6, // 11910: case 0x0: {
6911 OPC_CheckPredicate, 43, // 11912: check predicate 43
6912 OPC_Decode, 152, 121, 31, // 11914: decode to PSADD_H using decoder 31
6913 // 11914: }
6914 1, 6, // 11918: case 0x1: {
6915 OPC_CheckPredicate, 43, // 11920: check predicate 43
6916 OPC_Decode, 195, 120, 31, // 11922: decode to PMUL_H_B01 using decoder 31
6917 // 11922: }
6918 3, 6, // 11926: case 0x3: {
6919 OPC_CheckPredicate, 43, // 11928: check predicate 43
6920 OPC_Decode, 196, 120, 31, // 11930: decode to PMUL_H_B11 using decoder 31
6921 // 11930: }
6922 4, 6, // 11934: case 0x4: {
6923 OPC_CheckPredicate, 43, // 11936: check predicate 43
6924 OPC_Decode, 234, 120, 31, // 11938: decode to PPAIREO_B using decoder 31
6925 // 11938: }
6926 5, 6, // 11942: case 0x5: {
6927 OPC_CheckPredicate, 43, // 11944: check predicate 43
6928 OPC_Decode, 165, 119, 31, // 11946: decode to PM2ADD_HX using decoder 31
6929 // 11946: }
6930 6, 6, // 11950: case 0x6: {
6931 OPC_CheckPredicate, 43, // 11952: check predicate 43
6932 OPC_Decode, 155, 121, 31, // 11954: decode to PSAS_HX using decoder 31
6933 // 11954: }
6934 7, 0, // 11958: case 0x7: {
6935 OPC_CheckPredicate, 43, // 11960: check predicate 43
6936 OPC_Decode, 172, 120, 31, // 11962: decode to PMULHU_H using decoder 31
6937 // 11962: }
6938 // 11962: } // switch Inst[14:12]
6939 // 11962: }
6940 73, 59, // 11966: case 0x49: {
6941 OPC_SwitchField, 12, 3, // 11968: switch Inst[14:12] {
6942 0, 6, // 11971: case 0x0: {
6943 OPC_CheckPredicate, 48, // 11973: check predicate 48
6944 OPC_Decode, 153, 121, 31, // 11975: decode to PSADD_W using decoder 31
6945 // 11975: }
6946 1, 6, // 11979: case 0x1: {
6947 OPC_CheckPredicate, 48, // 11981: check predicate 48
6948 OPC_Decode, 198, 120, 31, // 11983: decode to PMUL_W_H01 using decoder 31
6949 // 11983: }
6950 3, 6, // 11987: case 0x3: {
6951 OPC_CheckPredicate, 48, // 11989: check predicate 48
6952 OPC_Decode, 199, 120, 31, // 11991: decode to PMUL_W_H11 using decoder 31
6953 // 11991: }
6954 4, 6, // 11995: case 0x4: {
6955 OPC_CheckPredicate, 43, // 11997: check predicate 43
6956 OPC_Decode, 237, 120, 31, // 11999: decode to PPAIREO_H using decoder 31
6957 // 11999: }
6958 5, 6, // 12003: case 0x5: {
6959 OPC_CheckPredicate, 48, // 12005: check predicate 48
6960 OPC_Decode, 167, 119, 31, // 12007: decode to PM2ADD_WX using decoder 31
6961 // 12007: }
6962 6, 6, // 12011: case 0x6: {
6963 OPC_CheckPredicate, 48, // 12013: check predicate 48
6964 OPC_Decode, 156, 121, 31, // 12015: decode to PSAS_WX using decoder 31
6965 // 12015: }
6966 7, 0, // 12019: case 0x7: {
6967 OPC_CheckPredicate, 48, // 12021: check predicate 48
6968 OPC_Decode, 173, 120, 31, // 12023: decode to PMULHU_W using decoder 31
6969 // 12023: }
6970 // 12023: } // switch Inst[14:12]
6971 // 12023: }
6972 74, 27, // 12027: case 0x4a: {
6973 OPC_SwitchField, 12, 3, // 12029: switch Inst[14:12] {
6974 0, 6, // 12032: case 0x0: {
6975 OPC_CheckPredicate, 43, // 12034: check predicate 43
6976 OPC_Decode, 148, 121, 31, // 12036: decode to PSADD_B using decoder 31
6977 // 12036: }
6978 6, 6, // 12040: case 0x6: {
6979 OPC_CheckPredicate, 43, // 12042: check predicate 43
6980 OPC_Decode, 215, 121, 31, // 12044: decode to PSSA_HX using decoder 31
6981 // 12044: }
6982 7, 0, // 12048: case 0x7: {
6983 OPC_CheckPredicate, 43, // 12050: check predicate 43
6984 OPC_Decode, 162, 120, 31, // 12052: decode to PMULHRU_H using decoder 31
6985 // 12052: }
6986 // 12052: } // switch Inst[14:12]
6987 // 12052: }
6988 75, 43, // 12056: case 0x4b: {
6989 OPC_SwitchField, 12, 3, // 12058: switch Inst[14:12] {
6990 1, 6, // 12061: case 0x1: {
6991 OPC_CheckPredicate, 48, // 12063: check predicate 48
6992 OPC_Decode, 145, 118, 31, // 12065: decode to MUL_W01 using decoder 31
6993 // 12065: }
6994 3, 6, // 12069: case 0x3: {
6995 OPC_CheckPredicate, 48, // 12071: check predicate 48
6996 OPC_Decode, 146, 118, 31, // 12073: decode to MUL_W11 using decoder 31
6997 // 12073: }
6998 4, 6, // 12077: case 0x4: {
6999 OPC_CheckPredicate, 48, // 12079: check predicate 48
7000 OPC_Decode, 238, 120, 31, // 12081: decode to PPAIREO_W using decoder 31
7001 // 12081: }
7002 6, 6, // 12085: case 0x6: {
7003 OPC_CheckPredicate, 48, // 12087: check predicate 48
7004 OPC_Decode, 216, 121, 31, // 12089: decode to PSSA_WX using decoder 31
7005 // 12089: }
7006 7, 0, // 12093: case 0x7: {
7007 OPC_CheckPredicate, 48, // 12095: check predicate 48
7008 OPC_Decode, 163, 120, 31, // 12097: decode to PMULHRU_W using decoder 31
7009 // 12097: }
7010 // 12097: } // switch Inst[14:12]
7011 // 12097: }
7012 76, 35, // 12101: case 0x4c: {
7013 OPC_SwitchField, 12, 3, // 12103: switch Inst[14:12] {
7014 0, 6, // 12106: case 0x0: {
7015 OPC_CheckPredicate, 43, // 12108: check predicate 43
7016 OPC_Decode, 224, 118, 31, // 12110: decode to PAADD_H using decoder 31
7017 // 12110: }
7018 5, 6, // 12114: case 0x5: {
7019 OPC_CheckPredicate, 43, // 12116: check predicate 43
7020 OPC_Decode, 157, 119, 61, // 12118: decode to PM2ADDA_HX using decoder 61
7021 // 12118: }
7022 6, 6, // 12122: case 0x6: {
7023 OPC_CheckPredicate, 43, // 12124: check predicate 43
7024 OPC_Decode, 227, 118, 31, // 12126: decode to PAAS_HX using decoder 31
7025 // 12126: }
7026 7, 0, // 12130: case 0x7: {
7027 OPC_CheckPredicate, 43, // 12132: check predicate 43
7028 OPC_Decode, 228, 119, 61, // 12134: decode to PMHACCU_H using decoder 61
7029 // 12134: }
7030 // 12134: } // switch Inst[14:12]
7031 // 12134: }
7032 77, 51, // 12138: case 0x4d: {
7033 OPC_SwitchField, 12, 3, // 12140: switch Inst[14:12] {
7034 0, 6, // 12143: case 0x0: {
7035 OPC_CheckPredicate, 48, // 12145: check predicate 48
7036 OPC_Decode, 225, 118, 31, // 12147: decode to PAADD_W using decoder 31
7037 // 12147: }
7038 1, 6, // 12151: case 0x1: {
7039 OPC_CheckPredicate, 48, // 12153: check predicate 48
7040 OPC_Decode, 208, 119, 61, // 12155: decode to PMACC_W_H01 using decoder 61
7041 // 12155: }
7042 3, 6, // 12159: case 0x3: {
7043 OPC_CheckPredicate, 48, // 12161: check predicate 48
7044 OPC_Decode, 209, 119, 61, // 12163: decode to PMACC_W_H11 using decoder 61
7045 // 12163: }
7046 5, 6, // 12167: case 0x5: {
7047 OPC_CheckPredicate, 48, // 12169: check predicate 48
7048 OPC_Decode, 159, 119, 61, // 12171: decode to PM2ADDA_WX using decoder 61
7049 // 12171: }
7050 6, 6, // 12175: case 0x6: {
7051 OPC_CheckPredicate, 48, // 12177: check predicate 48
7052 OPC_Decode, 228, 118, 31, // 12179: decode to PAAS_WX using decoder 31
7053 // 12179: }
7054 7, 0, // 12183: case 0x7: {
7055 OPC_CheckPredicate, 48, // 12185: check predicate 48
7056 OPC_Decode, 229, 119, 61, // 12187: decode to PMHACCU_W using decoder 61
7057 // 12187: }
7058 // 12187: } // switch Inst[14:12]
7059 // 12187: }
7060 78, 27, // 12191: case 0x4e: {
7061 OPC_SwitchField, 12, 3, // 12193: switch Inst[14:12] {
7062 0, 6, // 12196: case 0x0: {
7063 OPC_CheckPredicate, 43, // 12198: check predicate 43
7064 OPC_Decode, 220, 118, 31, // 12200: decode to PAADD_B using decoder 31
7065 // 12200: }
7066 6, 6, // 12204: case 0x6: {
7067 OPC_CheckPredicate, 43, // 12206: check predicate 43
7068 OPC_Decode, 255, 118, 31, // 12208: decode to PASA_HX using decoder 31
7069 // 12208: }
7070 7, 0, // 12212: case 0x7: {
7071 OPC_CheckPredicate, 43, // 12214: check predicate 43
7072 OPC_Decode, 238, 119, 61, // 12216: decode to PMHRACCU_H using decoder 61
7073 // 12216: }
7074 // 12216: } // switch Inst[14:12]
7075 // 12216: }
7076 79, 35, // 12220: case 0x4f: {
7077 OPC_SwitchField, 12, 3, // 12222: switch Inst[14:12] {
7078 1, 6, // 12225: case 0x1: {
7079 OPC_CheckPredicate, 48, // 12227: check predicate 48
7080 OPC_Decode, 157, 117, 61, // 12229: decode to MACC_W01 using decoder 61
7081 // 12229: }
7082 3, 6, // 12233: case 0x3: {
7083 OPC_CheckPredicate, 48, // 12235: check predicate 48
7084 OPC_Decode, 158, 117, 61, // 12237: decode to MACC_W11 using decoder 61
7085 // 12237: }
7086 6, 6, // 12241: case 0x6: {
7087 OPC_CheckPredicate, 48, // 12243: check predicate 48
7088 OPC_Decode, 128, 119, 31, // 12245: decode to PASA_WX using decoder 31
7089 // 12245: }
7090 7, 0, // 12249: case 0x7: {
7091 OPC_CheckPredicate, 48, // 12251: check predicate 48
7092 OPC_Decode, 239, 119, 61, // 12253: decode to PMHRACCU_W using decoder 61
7093 // 12253: }
7094 // 12253: } // switch Inst[14:12]
7095 // 12253: }
7096 80, 43, // 12257: case 0x50: {
7097 OPC_SwitchField, 12, 3, // 12259: switch Inst[14:12] {
7098 2, 6, // 12262: case 0x2: {
7099 OPC_CheckPredicate, 43, // 12264: check predicate 43
7100 OPC_Decode, 172, 121, 31, // 12266: decode to PSH1ADD_H using decoder 31
7101 // 12266: }
7102 3, 6, // 12270: case 0x3: {
7103 OPC_CheckPredicate, 43, // 12272: check predicate 43
7104 OPC_Decode, 188, 120, 31, // 12274: decode to PMULU_H_B00 using decoder 31
7105 // 12274: }
7106 4, 6, // 12278: case 0x4: {
7107 OPC_CheckPredicate, 43, // 12280: check predicate 43
7108 OPC_Decode, 243, 120, 31, // 12282: decode to PPAIROE_B using decoder 31
7109 // 12282: }
7110 5, 6, // 12286: case 0x5: {
7111 OPC_CheckPredicate, 43, // 12288: check predicate 43
7112 OPC_Decode, 162, 119, 31, // 12290: decode to PM2ADDU_H using decoder 31
7113 // 12290: }
7114 7, 0, // 12294: case 0x7: {
7115 OPC_CheckPredicate, 43, // 12296: check predicate 43
7116 OPC_Decode, 175, 120, 31, // 12298: decode to PMULH_H_B0 using decoder 31
7117 // 12298: }
7118 // 12298: } // switch Inst[14:12]
7119 // 12298: }
7120 81, 43, // 12302: case 0x51: {
7121 OPC_SwitchField, 12, 3, // 12304: switch Inst[14:12] {
7122 2, 6, // 12307: case 0x2: {
7123 OPC_CheckPredicate, 48, // 12309: check predicate 48
7124 OPC_Decode, 173, 121, 31, // 12311: decode to PSH1ADD_W using decoder 31
7125 // 12311: }
7126 3, 6, // 12315: case 0x3: {
7127 OPC_CheckPredicate, 48, // 12317: check predicate 48
7128 OPC_Decode, 191, 120, 31, // 12319: decode to PMULU_W_H00 using decoder 31
7129 // 12319: }
7130 4, 6, // 12323: case 0x4: {
7131 OPC_CheckPredicate, 43, // 12325: check predicate 43
7132 OPC_Decode, 246, 120, 31, // 12327: decode to PPAIROE_H using decoder 31
7133 // 12327: }
7134 5, 6, // 12331: case 0x5: {
7135 OPC_CheckPredicate, 48, // 12333: check predicate 48
7136 OPC_Decode, 163, 119, 31, // 12335: decode to PM2ADDU_W using decoder 31
7137 // 12335: }
7138 7, 0, // 12339: case 0x7: {
7139 OPC_CheckPredicate, 48, // 12341: check predicate 48
7140 OPC_Decode, 178, 120, 31, // 12343: decode to PMULH_W_H0 using decoder 31
7141 // 12343: }
7142 // 12343: } // switch Inst[14:12]
7143 // 12343: }
7144 82, 19, // 12347: case 0x52: {
7145 OPC_SwitchField, 12, 3, // 12349: switch Inst[14:12] {
7146 5, 6, // 12352: case 0x5: {
7147 OPC_CheckPredicate, 43, // 12354: check predicate 43
7148 OPC_Decode, 198, 119, 31, // 12356: decode to PM4ADDU_B using decoder 31
7149 // 12356: }
7150 7, 0, // 12360: case 0x7: {
7151 OPC_CheckPredicate, 43, // 12362: check predicate 43
7152 OPC_Decode, 167, 120, 31, // 12364: decode to PMULHSU_H_B0 using decoder 31
7153 // 12364: }
7154 // 12364: } // switch Inst[14:12]
7155 // 12364: }
7156 83, 35, // 12368: case 0x53: {
7157 OPC_SwitchField, 12, 3, // 12370: switch Inst[14:12] {
7158 3, 6, // 12373: case 0x3: {
7159 OPC_CheckPredicate, 48, // 12375: check predicate 48
7160 OPC_Decode, 137, 118, 31, // 12377: decode to MULU_W00 using decoder 31
7161 // 12377: }
7162 4, 6, // 12381: case 0x4: {
7163 OPC_CheckPredicate, 48, // 12383: check predicate 48
7164 OPC_Decode, 247, 120, 31, // 12385: decode to PPAIROE_W using decoder 31
7165 // 12385: }
7166 5, 6, // 12389: case 0x5: {
7167 OPC_CheckPredicate, 48, // 12391: check predicate 48
7168 OPC_Decode, 199, 119, 31, // 12393: decode to PM4ADDU_H using decoder 31
7169 // 12393: }
7170 7, 0, // 12397: case 0x7: {
7171 OPC_CheckPredicate, 48, // 12399: check predicate 48
7172 OPC_Decode, 170, 120, 31, // 12401: decode to PMULHSU_W_H0 using decoder 31
7173 // 12401: }
7174 // 12401: } // switch Inst[14:12]
7175 // 12401: }
7176 84, 27, // 12405: case 0x54: {
7177 OPC_SwitchField, 12, 3, // 12407: switch Inst[14:12] {
7178 1, 6, // 12410: case 0x1: {
7179 OPC_CheckPredicate, 43, // 12412: check predicate 43
7180 OPC_Decode, 147, 118, 61, // 12414: decode to MVM using decoder 61
7181 // 12414: }
7182 5, 6, // 12418: case 0x5: {
7183 OPC_CheckPredicate, 43, // 12420: check predicate 43
7184 OPC_Decode, 154, 119, 61, // 12422: decode to PM2ADDAU_H using decoder 61
7185 // 12422: }
7186 7, 0, // 12426: case 0x7: {
7187 OPC_CheckPredicate, 43, // 12428: check predicate 43
7188 OPC_Decode, 231, 119, 61, // 12430: decode to PMHACC_H_B0 using decoder 61
7189 // 12430: }
7190 // 12430: } // switch Inst[14:12]
7191 // 12430: }
7192 85, 35, // 12434: case 0x55: {
7193 OPC_SwitchField, 12, 3, // 12436: switch Inst[14:12] {
7194 1, 6, // 12439: case 0x1: {
7195 OPC_CheckPredicate, 43, // 12441: check predicate 43
7196 OPC_Decode, 148, 118, 61, // 12443: decode to MVMN using decoder 61
7197 // 12443: }
7198 3, 6, // 12447: case 0x3: {
7199 OPC_CheckPredicate, 48, // 12449: check predicate 48
7200 OPC_Decode, 204, 119, 61, // 12451: decode to PMACCU_W_H00 using decoder 61
7201 // 12451: }
7202 5, 6, // 12455: case 0x5: {
7203 OPC_CheckPredicate, 48, // 12457: check predicate 48
7204 OPC_Decode, 155, 119, 61, // 12459: decode to PM2ADDAU_W using decoder 61
7205 // 12459: }
7206 7, 0, // 12463: case 0x7: {
7207 OPC_CheckPredicate, 48, // 12465: check predicate 48
7208 OPC_Decode, 234, 119, 61, // 12467: decode to PMHACC_W_H0 using decoder 61
7209 // 12467: }
7210 // 12467: } // switch Inst[14:12]
7211 // 12467: }
7212 86, 27, // 12471: case 0x56: {
7213 OPC_SwitchField, 12, 3, // 12473: switch Inst[14:12] {
7214 1, 6, // 12476: case 0x1: {
7215 OPC_CheckPredicate, 43, // 12478: check predicate 43
7216 OPC_Decode, 163, 117, 61, // 12480: decode to MERGE using decoder 61
7217 // 12480: }
7218 5, 6, // 12484: case 0x5: {
7219 OPC_CheckPredicate, 43, // 12486: check predicate 43
7220 OPC_Decode, 192, 119, 61, // 12488: decode to PM4ADDAU_B using decoder 61
7221 // 12488: }
7222 7, 0, // 12492: case 0x7: {
7223 OPC_CheckPredicate, 43, // 12494: check predicate 43
7224 OPC_Decode, 223, 119, 61, // 12496: decode to PMHACCSU_H_B0 using decoder 61
7225 // 12496: }
7226 // 12496: } // switch Inst[14:12]
7227 // 12496: }
7228 87, 35, // 12500: case 0x57: {
7229 OPC_SwitchField, 12, 3, // 12502: switch Inst[14:12] {
7230 1, 6, // 12505: case 0x1: {
7231 OPC_CheckPredicate, 43, // 12507: check predicate 43
7232 OPC_Decode, 164, 125, 61, // 12509: decode to SRX using decoder 61
7233 // 12509: }
7234 3, 6, // 12513: case 0x3: {
7235 OPC_CheckPredicate, 48, // 12515: check predicate 48
7236 OPC_Decode, 150, 117, 61, // 12517: decode to MACCU_W00 using decoder 61
7237 // 12517: }
7238 5, 6, // 12521: case 0x5: {
7239 OPC_CheckPredicate, 48, // 12523: check predicate 48
7240 OPC_Decode, 193, 119, 61, // 12525: decode to PM4ADDAU_H using decoder 61
7241 // 12525: }
7242 7, 0, // 12529: case 0x7: {
7243 OPC_CheckPredicate, 48, // 12531: check predicate 48
7244 OPC_Decode, 226, 119, 61, // 12533: decode to PMHACCSU_W_H0 using decoder 61
7245 // 12533: }
7246 // 12533: } // switch Inst[14:12]
7247 // 12533: }
7248 88, 59, // 12537: case 0x58: {
7249 OPC_SwitchField, 12, 3, // 12539: switch Inst[14:12] {
7250 0, 6, // 12542: case 0x0: {
7251 OPC_CheckPredicate, 43, // 12544: check predicate 43
7252 OPC_Decode, 146, 121, 31, // 12546: decode to PSADDU_H using decoder 31
7253 // 12546: }
7254 1, 6, // 12550: case 0x1: {
7255 OPC_CheckPredicate, 43, // 12552: check predicate 43
7256 OPC_Decode, 189, 120, 31, // 12554: decode to PMULU_H_B01 using decoder 31
7257 // 12554: }
7258 2, 6, // 12558: case 0x2: {
7259 OPC_CheckPredicate, 43, // 12560: check predicate 43
7260 OPC_Decode, 219, 121, 31, // 12562: decode to PSSH1SADD_H using decoder 31
7261 // 12562: }
7262 3, 6, // 12566: case 0x3: {
7263 OPC_CheckPredicate, 43, // 12568: check predicate 43
7264 OPC_Decode, 190, 120, 31, // 12570: decode to PMULU_H_B11 using decoder 31
7265 // 12570: }
7266 4, 6, // 12574: case 0x4: {
7267 OPC_CheckPredicate, 43, // 12576: check predicate 43
7268 OPC_Decode, 248, 120, 31, // 12578: decode to PPAIRO_B using decoder 31
7269 // 12578: }
7270 5, 6, // 12582: case 0x5: {
7271 OPC_CheckPredicate, 43, // 12584: check predicate 43
7272 OPC_Decode, 128, 120, 31, // 12586: decode to PMQ2ADD_H using decoder 31
7273 // 12586: }
7274 7, 0, // 12590: case 0x7: {
7275 OPC_CheckPredicate, 43, // 12592: check predicate 43
7276 OPC_Decode, 176, 120, 31, // 12594: decode to PMULH_H_B1 using decoder 31
7277 // 12594: }
7278 // 12594: } // switch Inst[14:12]
7279 // 12594: }
7280 89, 59, // 12598: case 0x59: {
7281 OPC_SwitchField, 12, 3, // 12600: switch Inst[14:12] {
7282 0, 6, // 12603: case 0x0: {
7283 OPC_CheckPredicate, 48, // 12605: check predicate 48
7284 OPC_Decode, 147, 121, 31, // 12607: decode to PSADDU_W using decoder 31
7285 // 12607: }
7286 1, 6, // 12611: case 0x1: {
7287 OPC_CheckPredicate, 48, // 12613: check predicate 48
7288 OPC_Decode, 192, 120, 31, // 12615: decode to PMULU_W_H01 using decoder 31
7289 // 12615: }
7290 2, 6, // 12619: case 0x2: {
7291 OPC_CheckPredicate, 48, // 12621: check predicate 48
7292 OPC_Decode, 220, 121, 31, // 12623: decode to PSSH1SADD_W using decoder 31
7293 // 12623: }
7294 3, 6, // 12627: case 0x3: {
7295 OPC_CheckPredicate, 48, // 12629: check predicate 48
7296 OPC_Decode, 193, 120, 31, // 12631: decode to PMULU_W_H11 using decoder 31
7297 // 12631: }
7298 4, 6, // 12635: case 0x4: {
7299 OPC_CheckPredicate, 43, // 12637: check predicate 43
7300 OPC_Decode, 251, 120, 31, // 12639: decode to PPAIRO_H using decoder 31
7301 // 12639: }
7302 5, 6, // 12643: case 0x5: {
7303 OPC_CheckPredicate, 48, // 12645: check predicate 48
7304 OPC_Decode, 129, 120, 31, // 12647: decode to PMQ2ADD_W using decoder 31
7305 // 12647: }
7306 7, 0, // 12651: case 0x7: {
7307 OPC_CheckPredicate, 48, // 12653: check predicate 48
7308 OPC_Decode, 179, 120, 31, // 12655: decode to PMULH_W_H1 using decoder 31
7309 // 12655: }
7310 // 12655: } // switch Inst[14:12]
7311 // 12655: }
7312 90, 35, // 12659: case 0x5a: {
7313 OPC_SwitchField, 12, 3, // 12661: switch Inst[14:12] {
7314 0, 6, // 12664: case 0x0: {
7315 OPC_CheckPredicate, 43, // 12666: check predicate 43
7316 OPC_Decode, 142, 121, 31, // 12668: decode to PSADDU_B using decoder 31
7317 // 12668: }
7318 1, 6, // 12672: case 0x1: {
7319 OPC_CheckPredicate, 43, // 12674: check predicate 43
7320 OPC_Decode, 230, 118, 31, // 12676: decode to PABDSUMU_B using decoder 31
7321 // 12676: }
7322 5, 6, // 12680: case 0x5: {
7323 OPC_CheckPredicate, 43, // 12682: check predicate 43
7324 OPC_Decode, 135, 120, 31, // 12684: decode to PMQR2ADD_H using decoder 31
7325 // 12684: }
7326 7, 0, // 12688: case 0x7: {
7327 OPC_CheckPredicate, 43, // 12690: check predicate 43
7328 OPC_Decode, 168, 120, 31, // 12692: decode to PMULHSU_H_B1 using decoder 31
7329 // 12692: }
7330 // 12692: } // switch Inst[14:12]
7331 // 12692: }
7332 91, 43, // 12696: case 0x5b: {
7333 OPC_SwitchField, 12, 3, // 12698: switch Inst[14:12] {
7334 1, 6, // 12701: case 0x1: {
7335 OPC_CheckPredicate, 48, // 12703: check predicate 48
7336 OPC_Decode, 138, 118, 31, // 12705: decode to MULU_W01 using decoder 31
7337 // 12705: }
7338 3, 6, // 12709: case 0x3: {
7339 OPC_CheckPredicate, 48, // 12711: check predicate 48
7340 OPC_Decode, 139, 118, 31, // 12713: decode to MULU_W11 using decoder 31
7341 // 12713: }
7342 4, 6, // 12717: case 0x4: {
7343 OPC_CheckPredicate, 48, // 12719: check predicate 48
7344 OPC_Decode, 252, 120, 31, // 12721: decode to PPAIRO_W using decoder 31
7345 // 12721: }
7346 5, 6, // 12725: case 0x5: {
7347 OPC_CheckPredicate, 48, // 12727: check predicate 48
7348 OPC_Decode, 136, 120, 31, // 12729: decode to PMQR2ADD_W using decoder 31
7349 // 12729: }
7350 7, 0, // 12733: case 0x7: {
7351 OPC_CheckPredicate, 48, // 12735: check predicate 48
7352 OPC_Decode, 171, 120, 31, // 12737: decode to PMULHSU_W_H1 using decoder 31
7353 // 12737: }
7354 // 12737: } // switch Inst[14:12]
7355 // 12737: }
7356 92, 27, // 12741: case 0x5c: {
7357 OPC_SwitchField, 12, 3, // 12743: switch Inst[14:12] {
7358 0, 6, // 12746: case 0x0: {
7359 OPC_CheckPredicate, 43, // 12748: check predicate 43
7360 OPC_Decode, 218, 118, 31, // 12750: decode to PAADDU_H using decoder 31
7361 // 12750: }
7362 5, 6, // 12754: case 0x5: {
7363 OPC_CheckPredicate, 43, // 12756: check predicate 43
7364 OPC_Decode, 254, 119, 61, // 12758: decode to PMQ2ADDA_H using decoder 61
7365 // 12758: }
7366 7, 0, // 12762: case 0x7: {
7367 OPC_CheckPredicate, 43, // 12764: check predicate 43
7368 OPC_Decode, 232, 119, 61, // 12766: decode to PMHACC_H_B1 using decoder 61
7369 // 12766: }
7370 // 12766: } // switch Inst[14:12]
7371 // 12766: }
7372 93, 43, // 12770: case 0x5d: {
7373 OPC_SwitchField, 12, 3, // 12772: switch Inst[14:12] {
7374 0, 6, // 12775: case 0x0: {
7375 OPC_CheckPredicate, 48, // 12777: check predicate 48
7376 OPC_Decode, 219, 118, 31, // 12779: decode to PAADDU_W using decoder 31
7377 // 12779: }
7378 1, 6, // 12783: case 0x1: {
7379 OPC_CheckPredicate, 48, // 12785: check predicate 48
7380 OPC_Decode, 205, 119, 61, // 12787: decode to PMACCU_W_H01 using decoder 61
7381 // 12787: }
7382 3, 6, // 12791: case 0x3: {
7383 OPC_CheckPredicate, 48, // 12793: check predicate 48
7384 OPC_Decode, 206, 119, 61, // 12795: decode to PMACCU_W_H11 using decoder 61
7385 // 12795: }
7386 5, 6, // 12799: case 0x5: {
7387 OPC_CheckPredicate, 48, // 12801: check predicate 48
7388 OPC_Decode, 255, 119, 61, // 12803: decode to PMQ2ADDA_W using decoder 61
7389 // 12803: }
7390 7, 0, // 12807: case 0x7: {
7391 OPC_CheckPredicate, 48, // 12809: check predicate 48
7392 OPC_Decode, 235, 119, 61, // 12811: decode to PMHACC_W_H1 using decoder 61
7393 // 12811: }
7394 // 12811: } // switch Inst[14:12]
7395 // 12811: }
7396 94, 35, // 12815: case 0x5e: {
7397 OPC_SwitchField, 12, 3, // 12817: switch Inst[14:12] {
7398 0, 6, // 12820: case 0x0: {
7399 OPC_CheckPredicate, 43, // 12822: check predicate 43
7400 OPC_Decode, 214, 118, 31, // 12824: decode to PAADDU_B using decoder 31
7401 // 12824: }
7402 1, 6, // 12828: case 0x1: {
7403 OPC_CheckPredicate, 43, // 12830: check predicate 43
7404 OPC_Decode, 229, 118, 61, // 12832: decode to PABDSUMAU_B using decoder 61
7405 // 12832: }
7406 5, 6, // 12836: case 0x5: {
7407 OPC_CheckPredicate, 43, // 12838: check predicate 43
7408 OPC_Decode, 133, 120, 61, // 12840: decode to PMQR2ADDA_H using decoder 61
7409 // 12840: }
7410 7, 0, // 12844: case 0x7: {
7411 OPC_CheckPredicate, 43, // 12846: check predicate 43
7412 OPC_Decode, 224, 119, 61, // 12848: decode to PMHACCSU_H_B1 using decoder 61
7413 // 12848: }
7414 // 12848: } // switch Inst[14:12]
7415 // 12848: }
7416 95, 35, // 12852: case 0x5f: {
7417 OPC_SwitchField, 12, 3, // 12854: switch Inst[14:12] {
7418 1, 6, // 12857: case 0x1: {
7419 OPC_CheckPredicate, 48, // 12859: check predicate 48
7420 OPC_Decode, 151, 117, 61, // 12861: decode to MACCU_W01 using decoder 61
7421 // 12861: }
7422 3, 6, // 12865: case 0x3: {
7423 OPC_CheckPredicate, 48, // 12867: check predicate 48
7424 OPC_Decode, 152, 117, 61, // 12869: decode to MACCU_W11 using decoder 61
7425 // 12869: }
7426 5, 6, // 12873: case 0x5: {
7427 OPC_CheckPredicate, 48, // 12875: check predicate 48
7428 OPC_Decode, 134, 120, 61, // 12877: decode to PMQR2ADDA_W using decoder 61
7429 // 12877: }
7430 7, 0, // 12881: case 0x7: {
7431 OPC_CheckPredicate, 48, // 12883: check predicate 48
7432 OPC_Decode, 227, 119, 61, // 12885: decode to PMHACCSU_W_H1 using decoder 61
7433 // 12885: }
7434 // 12885: } // switch Inst[14:12]
7435 // 12885: }
7436 96, 43, // 12889: case 0x60: {
7437 OPC_SwitchField, 12, 3, // 12891: switch Inst[14:12] {
7438 0, 6, // 12894: case 0x0: {
7439 OPC_CheckPredicate, 43, // 12896: check predicate 43
7440 OPC_Decode, 129, 122, 31, // 12898: decode to PSUB_H using decoder 31
7441 // 12898: }
7442 2, 6, // 12902: case 0x2: {
7443 OPC_CheckPredicate, 48, // 12904: check predicate 48
7444 OPC_Decode, 204, 120, 31, // 12906: decode to PNCLIPP_B using decoder 31
7445 // 12906: }
7446 5, 6, // 12910: case 0x5: {
7447 OPC_CheckPredicate, 43, // 12912: check predicate 43
7448 OPC_Decode, 174, 119, 31, // 12914: decode to PM2SUB_H using decoder 31
7449 // 12914: }
7450 6, 6, // 12918: case 0x6: {
7451 OPC_CheckPredicate, 43, // 12920: check predicate 43
7452 OPC_Decode, 146, 120, 31, // 12922: decode to PMSEQ_H using decoder 31
7453 // 12922: }
7454 7, 0, // 12926: case 0x7: {
7455 OPC_CheckPredicate, 43, // 12928: check predicate 43
7456 OPC_Decode, 166, 120, 31, // 12930: decode to PMULHSU_H using decoder 31
7457 // 12930: }
7458 // 12930: } // switch Inst[14:12]
7459 // 12930: }
7460 97, 43, // 12934: case 0x61: {
7461 OPC_SwitchField, 12, 3, // 12936: switch Inst[14:12] {
7462 0, 6, // 12939: case 0x0: {
7463 OPC_CheckPredicate, 48, // 12941: check predicate 48
7464 OPC_Decode, 130, 122, 31, // 12943: decode to PSUB_W using decoder 31
7465 // 12943: }
7466 2, 6, // 12947: case 0x2: {
7467 OPC_CheckPredicate, 48, // 12949: check predicate 48
7468 OPC_Decode, 205, 120, 31, // 12951: decode to PNCLIPP_H using decoder 31
7469 // 12951: }
7470 5, 6, // 12955: case 0x5: {
7471 OPC_CheckPredicate, 48, // 12957: check predicate 48
7472 OPC_Decode, 176, 119, 31, // 12959: decode to PM2SUB_W using decoder 31
7473 // 12959: }
7474 6, 6, // 12963: case 0x6: {
7475 OPC_CheckPredicate, 48, // 12965: check predicate 48
7476 OPC_Decode, 147, 120, 31, // 12967: decode to PMSEQ_W using decoder 31
7477 // 12967: }
7478 7, 0, // 12971: case 0x7: {
7479 OPC_CheckPredicate, 48, // 12973: check predicate 48
7480 OPC_Decode, 169, 120, 31, // 12975: decode to PMULHSU_W using decoder 31
7481 // 12975: }
7482 // 12975: } // switch Inst[14:12]
7483 // 12975: }
7484 98, 35, // 12979: case 0x62: {
7485 OPC_SwitchField, 12, 3, // 12981: switch Inst[14:12] {
7486 0, 6, // 12984: case 0x0: {
7487 OPC_CheckPredicate, 43, // 12986: check predicate 43
7488 OPC_Decode, 253, 121, 31, // 12988: decode to PSUB_B using decoder 31
7489 // 12988: }
7490 5, 6, // 12992: case 0x5: {
7491 OPC_CheckPredicate, 43, // 12994: check predicate 43
7492 OPC_Decode, 168, 119, 31, // 12996: decode to PM2SADD_H using decoder 31
7493 // 12996: }
7494 6, 6, // 13000: case 0x6: {
7495 OPC_CheckPredicate, 43, // 13002: check predicate 43
7496 OPC_Decode, 142, 120, 31, // 13004: decode to PMSEQ_B using decoder 31
7497 // 13004: }
7498 7, 0, // 13008: case 0x7: {
7499 OPC_CheckPredicate, 43, // 13010: check predicate 43
7500 OPC_Decode, 160, 120, 31, // 13012: decode to PMULHRSU_H using decoder 31
7501 // 13012: }
7502 // 13012: } // switch Inst[14:12]
7503 // 13012: }
7504 99, 19, // 13016: case 0x63: {
7505 OPC_SwitchField, 12, 3, // 13018: switch Inst[14:12] {
7506 2, 6, // 13021: case 0x2: {
7507 OPC_CheckPredicate, 48, // 13023: check predicate 48
7508 OPC_Decode, 206, 120, 31, // 13025: decode to PNCLIPP_W using decoder 31
7509 // 13025: }
7510 7, 0, // 13029: case 0x7: {
7511 OPC_CheckPredicate, 48, // 13031: check predicate 48
7512 OPC_Decode, 161, 120, 31, // 13033: decode to PMULHRSU_W using decoder 31
7513 // 13033: }
7514 // 13033: } // switch Inst[14:12]
7515 // 13033: }
7516 100, 27, // 13037: case 0x64: {
7517 OPC_SwitchField, 12, 3, // 13039: switch Inst[14:12] {
7518 0, 6, // 13042: case 0x0: {
7519 OPC_CheckPredicate, 43, // 13044: check predicate 43
7520 OPC_Decode, 238, 118, 31, // 13046: decode to PABD_H using decoder 31
7521 // 13046: }
7522 5, 6, // 13050: case 0x5: {
7523 OPC_CheckPredicate, 43, // 13052: check predicate 43
7524 OPC_Decode, 170, 119, 61, // 13054: decode to PM2SUBA_H using decoder 61
7525 // 13054: }
7526 7, 0, // 13058: case 0x7: {
7527 OPC_CheckPredicate, 43, // 13060: check predicate 43
7528 OPC_Decode, 222, 119, 61, // 13062: decode to PMHACCSU_H using decoder 61
7529 // 13062: }
7530 // 13062: } // switch Inst[14:12]
7531 // 13062: }
7532 101, 19, // 13066: case 0x65: {
7533 OPC_SwitchField, 12, 3, // 13068: switch Inst[14:12] {
7534 5, 6, // 13071: case 0x5: {
7535 OPC_CheckPredicate, 48, // 13073: check predicate 48
7536 OPC_Decode, 172, 119, 61, // 13075: decode to PM2SUBA_W using decoder 61
7537 // 13075: }
7538 7, 0, // 13079: case 0x7: {
7539 OPC_CheckPredicate, 48, // 13081: check predicate 48
7540 OPC_Decode, 225, 119, 61, // 13083: decode to PMHACCSU_W using decoder 61
7541 // 13083: }
7542 // 13083: } // switch Inst[14:12]
7543 // 13083: }
7544 102, 19, // 13087: case 0x66: {
7545 OPC_SwitchField, 12, 3, // 13089: switch Inst[14:12] {
7546 0, 6, // 13092: case 0x0: {
7547 OPC_CheckPredicate, 43, // 13094: check predicate 43
7548 OPC_Decode, 235, 118, 31, // 13096: decode to PABD_B using decoder 31
7549 // 13096: }
7550 7, 0, // 13100: case 0x7: {
7551 OPC_CheckPredicate, 43, // 13102: check predicate 43
7552 OPC_Decode, 236, 119, 61, // 13104: decode to PMHRACCSU_H using decoder 61
7553 // 13104: }
7554 // 13104: } // switch Inst[14:12]
7555 // 13104: }
7556 103, 10, // 13108: case 0x67: {
7557 OPC_CheckPredicate, 48, // 13110: check predicate 48
7558 OPC_CheckField, 12, 3, 7, // 13112: check Inst[14:12] == 0x7
7559 OPC_Decode, 237, 119, 61, // 13116: decode to PMHRACCSU_W using decoder 61
7560 // 13116: }
7561 104, 35, // 13120: case 0x68: {
7562 OPC_SwitchField, 12, 3, // 13122: switch Inst[14:12] {
7563 0, 6, // 13125: case 0x0: {
7564 OPC_CheckPredicate, 43, // 13127: check predicate 43
7565 OPC_Decode, 251, 121, 31, // 13129: decode to PSSUB_H using decoder 31
7566 // 13129: }
7567 5, 6, // 13133: case 0x5: {
7568 OPC_CheckPredicate, 43, // 13135: check predicate 43
7569 OPC_Decode, 175, 119, 31, // 13137: decode to PM2SUB_HX using decoder 31
7570 // 13137: }
7571 6, 6, // 13141: case 0x6: {
7572 OPC_CheckPredicate, 43, // 13143: check predicate 43
7573 OPC_Decode, 158, 120, 31, // 13145: decode to PMSLT_H using decoder 31
7574 // 13145: }
7575 7, 0, // 13149: case 0x7: {
7576 OPC_CheckPredicate, 43, // 13151: check predicate 43
7577 OPC_Decode, 182, 120, 31, // 13153: decode to PMULQ_H using decoder 31
7578 // 13153: }
7579 // 13153: } // switch Inst[14:12]
7580 // 13153: }
7581 105, 35, // 13157: case 0x69: {
7582 OPC_SwitchField, 12, 3, // 13159: switch Inst[14:12] {
7583 0, 6, // 13162: case 0x0: {
7584 OPC_CheckPredicate, 48, // 13164: check predicate 48
7585 OPC_Decode, 252, 121, 31, // 13166: decode to PSSUB_W using decoder 31
7586 // 13166: }
7587 5, 6, // 13170: case 0x5: {
7588 OPC_CheckPredicate, 48, // 13172: check predicate 48
7589 OPC_Decode, 177, 119, 31, // 13174: decode to PM2SUB_WX using decoder 31
7590 // 13174: }
7591 6, 6, // 13178: case 0x6: {
7592 OPC_CheckPredicate, 48, // 13180: check predicate 48
7593 OPC_Decode, 159, 120, 31, // 13182: decode to PMSLT_W using decoder 31
7594 // 13182: }
7595 7, 0, // 13186: case 0x7: {
7596 OPC_CheckPredicate, 48, // 13188: check predicate 48
7597 OPC_Decode, 183, 120, 31, // 13190: decode to PMULQ_W using decoder 31
7598 // 13190: }
7599 // 13190: } // switch Inst[14:12]
7600 // 13190: }
7601 106, 35, // 13194: case 0x6a: {
7602 OPC_SwitchField, 12, 3, // 13196: switch Inst[14:12] {
7603 0, 6, // 13199: case 0x0: {
7604 OPC_CheckPredicate, 43, // 13201: check predicate 43
7605 OPC_Decode, 247, 121, 31, // 13203: decode to PSSUB_B using decoder 31
7606 // 13203: }
7607 5, 6, // 13207: case 0x5: {
7608 OPC_CheckPredicate, 43, // 13209: check predicate 43
7609 OPC_Decode, 169, 119, 31, // 13211: decode to PM2SADD_HX using decoder 31
7610 // 13211: }
7611 6, 6, // 13215: case 0x6: {
7612 OPC_CheckPredicate, 43, // 13217: check predicate 43
7613 OPC_Decode, 154, 120, 31, // 13219: decode to PMSLT_B using decoder 31
7614 // 13219: }
7615 7, 0, // 13223: case 0x7: {
7616 OPC_CheckPredicate, 43, // 13225: check predicate 43
7617 OPC_Decode, 180, 120, 31, // 13227: decode to PMULQR_H using decoder 31
7618 // 13227: }
7619 // 13227: } // switch Inst[14:12]
7620 // 13227: }
7621 107, 10, // 13231: case 0x6b: {
7622 OPC_CheckPredicate, 48, // 13233: check predicate 48
7623 OPC_CheckField, 12, 3, 7, // 13235: check Inst[14:12] == 0x7
7624 OPC_Decode, 181, 120, 31, // 13239: decode to PMULQR_W using decoder 31
7625 // 13239: }
7626 108, 27, // 13243: case 0x6c: {
7627 OPC_SwitchField, 12, 3, // 13245: switch Inst[14:12] {
7628 0, 6, // 13248: case 0x0: {
7629 OPC_CheckPredicate, 43, // 13250: check predicate 43
7630 OPC_Decode, 139, 119, 31, // 13252: decode to PASUB_H using decoder 31
7631 // 13252: }
7632 5, 6, // 13256: case 0x5: {
7633 OPC_CheckPredicate, 43, // 13258: check predicate 43
7634 OPC_Decode, 171, 119, 61, // 13260: decode to PM2SUBA_HX using decoder 61
7635 // 13260: }
7636 6, 0, // 13264: case 0x6: {
7637 OPC_CheckPredicate, 43, // 13266: check predicate 43
7638 OPC_Decode, 152, 120, 31, // 13268: decode to PMSLTU_H using decoder 31
7639 // 13268: }
7640 // 13268: } // switch Inst[14:12]
7641 // 13268: }
7642 109, 27, // 13272: case 0x6d: {
7643 OPC_SwitchField, 12, 3, // 13274: switch Inst[14:12] {
7644 0, 6, // 13277: case 0x0: {
7645 OPC_CheckPredicate, 48, // 13279: check predicate 48
7646 OPC_Decode, 140, 119, 31, // 13281: decode to PASUB_W using decoder 31
7647 // 13281: }
7648 5, 6, // 13285: case 0x5: {
7649 OPC_CheckPredicate, 48, // 13287: check predicate 48
7650 OPC_Decode, 173, 119, 61, // 13289: decode to PM2SUBA_WX using decoder 61
7651 // 13289: }
7652 6, 0, // 13293: case 0x6: {
7653 OPC_CheckPredicate, 48, // 13295: check predicate 48
7654 OPC_Decode, 153, 120, 31, // 13297: decode to PMSLTU_W using decoder 31
7655 // 13297: }
7656 // 13297: } // switch Inst[14:12]
7657 // 13297: }
7658 110, 19, // 13301: case 0x6e: {
7659 OPC_SwitchField, 12, 3, // 13303: switch Inst[14:12] {
7660 0, 6, // 13306: case 0x0: {
7661 OPC_CheckPredicate, 43, // 13308: check predicate 43
7662 OPC_Decode, 135, 119, 31, // 13310: decode to PASUB_B using decoder 31
7663 // 13310: }
7664 6, 0, // 13314: case 0x6: {
7665 OPC_CheckPredicate, 43, // 13316: check predicate 43
7666 OPC_Decode, 148, 120, 31, // 13318: decode to PMSLTU_B using decoder 31
7667 // 13318: }
7668 // 13318: } // switch Inst[14:12]
7669 // 13318: }
7670 112, 35, // 13322: case 0x70: {
7671 OPC_SwitchField, 12, 3, // 13324: switch Inst[14:12] {
7672 2, 6, // 13327: case 0x2: {
7673 OPC_CheckPredicate, 48, // 13329: check predicate 48
7674 OPC_Decode, 176, 126, 31, // 13331: decode to UNZIP8P using decoder 31
7675 // 13331: }
7676 3, 6, // 13335: case 0x3: {
7677 OPC_CheckPredicate, 43, // 13337: check predicate 43
7678 OPC_Decode, 184, 120, 31, // 13339: decode to PMULSU_H_B00 using decoder 31
7679 // 13339: }
7680 5, 6, // 13343: case 0x5: {
7681 OPC_CheckPredicate, 43, // 13345: check predicate 43
7682 OPC_Decode, 160, 119, 31, // 13347: decode to PM2ADDSU_H using decoder 31
7683 // 13347: }
7684 6, 0, // 13351: case 0x6: {
7685 OPC_CheckPredicate, 43, // 13353: check predicate 43
7686 OPC_Decode, 252, 119, 31, // 13355: decode to PMIN_H using decoder 31
7687 // 13355: }
7688 // 13355: } // switch Inst[14:12]
7689 // 13355: }
7690 113, 35, // 13359: case 0x71: {
7691 OPC_SwitchField, 12, 3, // 13361: switch Inst[14:12] {
7692 2, 6, // 13364: case 0x2: {
7693 OPC_CheckPredicate, 48, // 13366: check predicate 48
7694 OPC_Decode, 174, 126, 31, // 13368: decode to UNZIP16P using decoder 31
7695 // 13368: }
7696 3, 6, // 13372: case 0x3: {
7697 OPC_CheckPredicate, 48, // 13374: check predicate 48
7698 OPC_Decode, 186, 120, 31, // 13376: decode to PMULSU_W_H00 using decoder 31
7699 // 13376: }
7700 5, 6, // 13380: case 0x5: {
7701 OPC_CheckPredicate, 48, // 13382: check predicate 48
7702 OPC_Decode, 161, 119, 31, // 13384: decode to PM2ADDSU_W using decoder 31
7703 // 13384: }
7704 6, 0, // 13388: case 0x6: {
7705 OPC_CheckPredicate, 48, // 13390: check predicate 48
7706 OPC_Decode, 253, 119, 31, // 13392: decode to PMIN_W using decoder 31
7707 // 13392: }
7708 // 13392: } // switch Inst[14:12]
7709 // 13392: }
7710 114, 27, // 13396: case 0x72: {
7711 OPC_SwitchField, 12, 3, // 13398: switch Inst[14:12] {
7712 2, 6, // 13401: case 0x2: {
7713 OPC_CheckPredicate, 48, // 13403: check predicate 48
7714 OPC_Decode, 175, 126, 31, // 13405: decode to UNZIP8HP using decoder 31
7715 // 13405: }
7716 5, 6, // 13409: case 0x5: {
7717 OPC_CheckPredicate, 43, // 13411: check predicate 43
7718 OPC_Decode, 196, 119, 31, // 13413: decode to PM4ADDSU_B using decoder 31
7719 // 13413: }
7720 6, 0, // 13417: case 0x6: {
7721 OPC_CheckPredicate, 43, // 13419: check predicate 43
7722 OPC_Decode, 248, 119, 31, // 13421: decode to PMIN_B using decoder 31
7723 // 13421: }
7724 // 13421: } // switch Inst[14:12]
7725 // 13421: }
7726 115, 27, // 13425: case 0x73: {
7727 OPC_SwitchField, 12, 3, // 13427: switch Inst[14:12] {
7728 2, 6, // 13430: case 0x2: {
7729 OPC_CheckPredicate, 48, // 13432: check predicate 48
7730 OPC_Decode, 173, 126, 31, // 13434: decode to UNZIP16HP using decoder 31
7731 // 13434: }
7732 3, 6, // 13438: case 0x3: {
7733 OPC_CheckPredicate, 48, // 13440: check predicate 48
7734 OPC_Decode, 132, 118, 31, // 13442: decode to MULSU_W00 using decoder 31
7735 // 13442: }
7736 5, 0, // 13446: case 0x5: {
7737 OPC_CheckPredicate, 48, // 13448: check predicate 48
7738 OPC_Decode, 197, 119, 31, // 13450: decode to PM4ADDSU_H using decoder 31
7739 // 13450: }
7740 // 13450: } // switch Inst[14:12]
7741 // 13450: }
7742 116, 35, // 13454: case 0x74: {
7743 OPC_SwitchField, 12, 3, // 13456: switch Inst[14:12] {
7744 0, 6, // 13459: case 0x0: {
7745 OPC_CheckPredicate, 43, // 13461: check predicate 43
7746 OPC_Decode, 234, 118, 31, // 13463: decode to PABDU_H using decoder 31
7747 // 13463: }
7748 5, 6, // 13467: case 0x5: {
7749 OPC_CheckPredicate, 43, // 13469: check predicate 43
7750 OPC_Decode, 152, 119, 61, // 13471: decode to PM2ADDASU_H using decoder 61
7751 // 13471: }
7752 6, 6, // 13475: case 0x6: {
7753 OPC_CheckPredicate, 43, // 13477: check predicate 43
7754 OPC_Decode, 246, 119, 31, // 13479: decode to PMINU_H using decoder 31
7755 // 13479: }
7756 7, 0, // 13483: case 0x7: {
7757 OPC_CheckPredicate, 48, // 13485: check predicate 48
7758 OPC_Decode, 130, 120, 61, // 13487: decode to PMQACC_W_H00 using decoder 61
7759 // 13487: }
7760 // 13487: } // switch Inst[14:12]
7761 // 13487: }
7762 117, 35, // 13491: case 0x75: {
7763 OPC_SwitchField, 12, 3, // 13493: switch Inst[14:12] {
7764 3, 6, // 13496: case 0x3: {
7765 OPC_CheckPredicate, 48, // 13498: check predicate 48
7766 OPC_Decode, 202, 119, 61, // 13500: decode to PMACCSU_W_H00 using decoder 61
7767 // 13500: }
7768 5, 6, // 13504: case 0x5: {
7769 OPC_CheckPredicate, 48, // 13506: check predicate 48
7770 OPC_Decode, 153, 119, 61, // 13508: decode to PM2ADDASU_W using decoder 61
7771 // 13508: }
7772 6, 6, // 13512: case 0x6: {
7773 OPC_CheckPredicate, 48, // 13514: check predicate 48
7774 OPC_Decode, 247, 119, 31, // 13516: decode to PMINU_W using decoder 31
7775 // 13516: }
7776 7, 0, // 13520: case 0x7: {
7777 OPC_CheckPredicate, 48, // 13522: check predicate 48
7778 OPC_Decode, 230, 117, 61, // 13524: decode to MQACC_W00 using decoder 61
7779 // 13524: }
7780 // 13524: } // switch Inst[14:12]
7781 // 13524: }
7782 118, 35, // 13528: case 0x76: {
7783 OPC_SwitchField, 12, 3, // 13530: switch Inst[14:12] {
7784 0, 6, // 13533: case 0x0: {
7785 OPC_CheckPredicate, 43, // 13535: check predicate 43
7786 OPC_Decode, 231, 118, 31, // 13537: decode to PABDU_B using decoder 31
7787 // 13537: }
7788 5, 6, // 13541: case 0x5: {
7789 OPC_CheckPredicate, 43, // 13543: check predicate 43
7790 OPC_Decode, 190, 119, 61, // 13545: decode to PM4ADDASU_B using decoder 61
7791 // 13545: }
7792 6, 6, // 13549: case 0x6: {
7793 OPC_CheckPredicate, 43, // 13551: check predicate 43
7794 OPC_Decode, 242, 119, 31, // 13553: decode to PMINU_B using decoder 31
7795 // 13553: }
7796 7, 0, // 13557: case 0x7: {
7797 OPC_CheckPredicate, 48, // 13559: check predicate 48
7798 OPC_Decode, 137, 120, 61, // 13561: decode to PMQRACC_W_H00 using decoder 61
7799 // 13561: }
7800 // 13561: } // switch Inst[14:12]
7801 // 13561: }
7802 119, 27, // 13565: case 0x77: {
7803 OPC_SwitchField, 12, 3, // 13567: switch Inst[14:12] {
7804 3, 6, // 13570: case 0x3: {
7805 OPC_CheckPredicate, 48, // 13572: check predicate 48
7806 OPC_Decode, 145, 117, 61, // 13574: decode to MACCSU_W00 using decoder 61
7807 // 13574: }
7808 5, 6, // 13578: case 0x5: {
7809 OPC_CheckPredicate, 48, // 13580: check predicate 48
7810 OPC_Decode, 191, 119, 61, // 13582: decode to PM4ADDASU_H using decoder 61
7811 // 13582: }
7812 7, 0, // 13586: case 0x7: {
7813 OPC_CheckPredicate, 48, // 13588: check predicate 48
7814 OPC_Decode, 236, 117, 61, // 13590: decode to MQRACC_W00 using decoder 61
7815 // 13590: }
7816 // 13590: } // switch Inst[14:12]
7817 // 13590: }
7818 120, 36, // 13594: case 0x78: {
7819 OPC_SwitchField, 12, 3, // 13596: switch Inst[14:12] {
7820 0, 6, // 13599: case 0x0: {
7821 OPC_CheckPredicate, 43, // 13601: check predicate 43
7822 OPC_Decode, 245, 121, 31, // 13603: decode to PSSUBU_H using decoder 31
7823 // 13603: }
7824 2, 7, // 13607: case 0x2: {
7825 OPC_CheckPredicate, 48, // 13609: check predicate 48
7826 OPC_Decode, 197, 132, 1, 31, // 13611: decode to ZIP8P using decoder 31
7827 // 13611: }
7828 3, 6, // 13616: case 0x3: {
7829 OPC_CheckPredicate, 43, // 13618: check predicate 43
7830 OPC_Decode, 185, 120, 31, // 13620: decode to PMULSU_H_B11 using decoder 31
7831 // 13620: }
7832 6, 0, // 13624: case 0x6: {
7833 OPC_CheckPredicate, 43, // 13626: check predicate 43
7834 OPC_Decode, 220, 119, 31, // 13628: decode to PMAX_H using decoder 31
7835 // 13628: }
7836 // 13628: } // switch Inst[14:12]
7837 // 13628: }
7838 121, 36, // 13632: case 0x79: {
7839 OPC_SwitchField, 12, 3, // 13634: switch Inst[14:12] {
7840 0, 6, // 13637: case 0x0: {
7841 OPC_CheckPredicate, 48, // 13639: check predicate 48
7842 OPC_Decode, 246, 121, 31, // 13641: decode to PSSUBU_W using decoder 31
7843 // 13641: }
7844 2, 7, // 13645: case 0x2: {
7845 OPC_CheckPredicate, 48, // 13647: check predicate 48
7846 OPC_Decode, 195, 132, 1, 31, // 13649: decode to ZIP16P using decoder 31
7847 // 13649: }
7848 3, 6, // 13654: case 0x3: {
7849 OPC_CheckPredicate, 48, // 13656: check predicate 48
7850 OPC_Decode, 187, 120, 31, // 13658: decode to PMULSU_W_H11 using decoder 31
7851 // 13658: }
7852 6, 0, // 13662: case 0x6: {
7853 OPC_CheckPredicate, 48, // 13664: check predicate 48
7854 OPC_Decode, 221, 119, 31, // 13666: decode to PMAX_W using decoder 31
7855 // 13666: }
7856 // 13666: } // switch Inst[14:12]
7857 // 13666: }
7858 122, 28, // 13670: case 0x7a: {
7859 OPC_SwitchField, 12, 3, // 13672: switch Inst[14:12] {
7860 0, 6, // 13675: case 0x0: {
7861 OPC_CheckPredicate, 43, // 13677: check predicate 43
7862 OPC_Decode, 241, 121, 31, // 13679: decode to PSSUBU_B using decoder 31
7863 // 13679: }
7864 2, 7, // 13683: case 0x2: {
7865 OPC_CheckPredicate, 48, // 13685: check predicate 48
7866 OPC_Decode, 196, 132, 1, 31, // 13687: decode to ZIP8HP using decoder 31
7867 // 13687: }
7868 6, 0, // 13692: case 0x6: {
7869 OPC_CheckPredicate, 43, // 13694: check predicate 43
7870 OPC_Decode, 216, 119, 31, // 13696: decode to PMAX_B using decoder 31
7871 // 13696: }
7872 // 13696: } // switch Inst[14:12]
7873 // 13696: }
7874 123, 20, // 13700: case 0x7b: {
7875 OPC_SwitchField, 12, 3, // 13702: switch Inst[14:12] {
7876 2, 7, // 13705: case 0x2: {
7877 OPC_CheckPredicate, 48, // 13707: check predicate 48
7878 OPC_Decode, 194, 132, 1, 31, // 13709: decode to ZIP16HP using decoder 31
7879 // 13709: }
7880 3, 0, // 13714: case 0x3: {
7881 OPC_CheckPredicate, 48, // 13716: check predicate 48
7882 OPC_Decode, 133, 118, 31, // 13718: decode to MULSU_W11 using decoder 31
7883 // 13718: }
7884 // 13718: } // switch Inst[14:12]
7885 // 13718: }
7886 124, 35, // 13722: case 0x7c: {
7887 OPC_SwitchField, 12, 3, // 13724: switch Inst[14:12] {
7888 0, 6, // 13727: case 0x0: {
7889 OPC_CheckPredicate, 43, // 13729: check predicate 43
7890 OPC_Decode, 133, 119, 31, // 13731: decode to PASUBU_H using decoder 31
7891 // 13731: }
7892 5, 6, // 13735: case 0x5: {
7893 OPC_CheckPredicate, 48, // 13737: check predicate 48
7894 OPC_Decode, 131, 120, 61, // 13739: decode to PMQACC_W_H01 using decoder 61
7895 // 13739: }
7896 6, 6, // 13743: case 0x6: {
7897 OPC_CheckPredicate, 43, // 13745: check predicate 43
7898 OPC_Decode, 214, 119, 31, // 13747: decode to PMAXU_H using decoder 31
7899 // 13747: }
7900 7, 0, // 13751: case 0x7: {
7901 OPC_CheckPredicate, 48, // 13753: check predicate 48
7902 OPC_Decode, 132, 120, 61, // 13755: decode to PMQACC_W_H11 using decoder 61
7903 // 13755: }
7904 // 13755: } // switch Inst[14:12]
7905 // 13755: }
7906 125, 43, // 13759: case 0x7d: {
7907 OPC_SwitchField, 12, 3, // 13761: switch Inst[14:12] {
7908 0, 6, // 13764: case 0x0: {
7909 OPC_CheckPredicate, 48, // 13766: check predicate 48
7910 OPC_Decode, 134, 119, 31, // 13768: decode to PASUBU_W using decoder 31
7911 // 13768: }
7912 3, 6, // 13772: case 0x3: {
7913 OPC_CheckPredicate, 48, // 13774: check predicate 48
7914 OPC_Decode, 203, 119, 61, // 13776: decode to PMACCSU_W_H11 using decoder 61
7915 // 13776: }
7916 5, 6, // 13780: case 0x5: {
7917 OPC_CheckPredicate, 48, // 13782: check predicate 48
7918 OPC_Decode, 231, 117, 61, // 13784: decode to MQACC_W01 using decoder 61
7919 // 13784: }
7920 6, 6, // 13788: case 0x6: {
7921 OPC_CheckPredicate, 48, // 13790: check predicate 48
7922 OPC_Decode, 215, 119, 31, // 13792: decode to PMAXU_W using decoder 31
7923 // 13792: }
7924 7, 0, // 13796: case 0x7: {
7925 OPC_CheckPredicate, 48, // 13798: check predicate 48
7926 OPC_Decode, 232, 117, 61, // 13800: decode to MQACC_W11 using decoder 61
7927 // 13800: }
7928 // 13800: } // switch Inst[14:12]
7929 // 13800: }
7930 126, 35, // 13804: case 0x7e: {
7931 OPC_SwitchField, 12, 3, // 13806: switch Inst[14:12] {
7932 0, 6, // 13809: case 0x0: {
7933 OPC_CheckPredicate, 43, // 13811: check predicate 43
7934 OPC_Decode, 129, 119, 31, // 13813: decode to PASUBU_B using decoder 31
7935 // 13813: }
7936 5, 6, // 13817: case 0x5: {
7937 OPC_CheckPredicate, 48, // 13819: check predicate 48
7938 OPC_Decode, 138, 120, 61, // 13821: decode to PMQRACC_W_H01 using decoder 61
7939 // 13821: }
7940 6, 6, // 13825: case 0x6: {
7941 OPC_CheckPredicate, 43, // 13827: check predicate 43
7942 OPC_Decode, 210, 119, 31, // 13829: decode to PMAXU_B using decoder 31
7943 // 13829: }
7944 7, 0, // 13833: case 0x7: {
7945 OPC_CheckPredicate, 48, // 13835: check predicate 48
7946 OPC_Decode, 139, 120, 61, // 13837: decode to PMQRACC_W_H11 using decoder 61
7947 // 13837: }
7948 // 13837: } // switch Inst[14:12]
7949 // 13837: }
7950 127, 0, // 13841: case 0x7f: {
7951 OPC_SwitchField, 12, 3, // 13843: switch Inst[14:12] {
7952 3, 6, // 13846: case 0x3: {
7953 OPC_CheckPredicate, 48, // 13848: check predicate 48
7954 OPC_Decode, 146, 117, 61, // 13850: decode to MACCSU_W11 using decoder 61
7955 // 13850: }
7956 5, 6, // 13854: case 0x5: {
7957 OPC_CheckPredicate, 48, // 13856: check predicate 48
7958 OPC_Decode, 237, 117, 61, // 13858: decode to MQRACC_W01 using decoder 61
7959 // 13858: }
7960 7, 0, // 13862: case 0x7: {
7961 OPC_CheckPredicate, 48, // 13864: check predicate 48
7962 OPC_Decode, 238, 117, 61, // 13866: decode to MQRACC_W11 using decoder 61
7963 // 13866: }
7964 // 13866: } // switch Inst[14:12]
7965 // 13866: }
7966 // 13866: } // switch Inst[31:25]
7967 // 13866: }
7968 67, 35, // 13870: case 0x43: {
7969 OPC_SwitchField, 25, 2, // 13872: switch Inst[26:25] {
7970 0, 6, // 13875: case 0x0: {
7971 OPC_CheckPredicate, 25, // 13877: check predicate 25
7972 OPC_Decode, 186, 115, 62, // 13879: decode to FMADD_S using decoder 62
7973 // 13879: }
7974 1, 6, // 13883: case 0x1: {
7975 OPC_CheckPredicate, 26, // 13885: check predicate 26
7976 OPC_Decode, 180, 115, 63, // 13887: decode to FMADD_D using decoder 63
7977 // 13887: }
7978 2, 6, // 13891: case 0x2: {
7979 OPC_CheckPredicate, 82, // 13893: check predicate 82
7980 OPC_Decode, 183, 115, 64, // 13895: decode to FMADD_H using decoder 64
7981 // 13895: }
7982 3, 0, // 13899: case 0x3: {
7983 OPC_CheckPredicate, 27, // 13901: check predicate 27
7984 OPC_Decode, 185, 115, 65, // 13903: decode to FMADD_Q using decoder 65
7985 // 13903: }
7986 // 13903: } // switch Inst[26:25]
7987 // 13903: }
7988 71, 35, // 13907: case 0x47: {
7989 OPC_SwitchField, 25, 2, // 13909: switch Inst[26:25] {
7990 0, 6, // 13912: case 0x0: {
7991 OPC_CheckPredicate, 25, // 13914: check predicate 25
7992 OPC_Decode, 218, 115, 62, // 13916: decode to FMSUB_S using decoder 62
7993 // 13916: }
7994 1, 6, // 13920: case 0x1: {
7995 OPC_CheckPredicate, 26, // 13922: check predicate 26
7996 OPC_Decode, 212, 115, 63, // 13924: decode to FMSUB_D using decoder 63
7997 // 13924: }
7998 2, 6, // 13928: case 0x2: {
7999 OPC_CheckPredicate, 82, // 13930: check predicate 82
8000 OPC_Decode, 215, 115, 64, // 13932: decode to FMSUB_H using decoder 64
8001 // 13932: }
8002 3, 0, // 13936: case 0x3: {
8003 OPC_CheckPredicate, 27, // 13938: check predicate 27
8004 OPC_Decode, 217, 115, 65, // 13940: decode to FMSUB_Q using decoder 65
8005 // 13940: }
8006 // 13940: } // switch Inst[26:25]
8007 // 13940: }
8008 75, 35, // 13944: case 0x4b: {
8009 OPC_SwitchField, 25, 2, // 13946: switch Inst[26:25] {
8010 0, 6, // 13949: case 0x0: {
8011 OPC_CheckPredicate, 25, // 13951: check predicate 25
8012 OPC_Decode, 253, 115, 62, // 13953: decode to FNMSUB_S using decoder 62
8013 // 13953: }
8014 1, 6, // 13957: case 0x1: {
8015 OPC_CheckPredicate, 26, // 13959: check predicate 26
8016 OPC_Decode, 247, 115, 63, // 13961: decode to FNMSUB_D using decoder 63
8017 // 13961: }
8018 2, 6, // 13965: case 0x2: {
8019 OPC_CheckPredicate, 82, // 13967: check predicate 82
8020 OPC_Decode, 250, 115, 64, // 13969: decode to FNMSUB_H using decoder 64
8021 // 13969: }
8022 3, 0, // 13973: case 0x3: {
8023 OPC_CheckPredicate, 27, // 13975: check predicate 27
8024 OPC_Decode, 252, 115, 65, // 13977: decode to FNMSUB_Q using decoder 65
8025 // 13977: }
8026 // 13977: } // switch Inst[26:25]
8027 // 13977: }
8028 79, 35, // 13981: case 0x4f: {
8029 OPC_SwitchField, 25, 2, // 13983: switch Inst[26:25] {
8030 0, 6, // 13986: case 0x0: {
8031 OPC_CheckPredicate, 25, // 13988: check predicate 25
8032 OPC_Decode, 245, 115, 62, // 13990: decode to FNMADD_S using decoder 62
8033 // 13990: }
8034 1, 6, // 13994: case 0x1: {
8035 OPC_CheckPredicate, 26, // 13996: check predicate 26
8036 OPC_Decode, 239, 115, 63, // 13998: decode to FNMADD_D using decoder 63
8037 // 13998: }
8038 2, 6, // 14002: case 0x2: {
8039 OPC_CheckPredicate, 82, // 14004: check predicate 82
8040 OPC_Decode, 242, 115, 64, // 14006: decode to FNMADD_H using decoder 64
8041 // 14006: }
8042 3, 0, // 14010: case 0x3: {
8043 OPC_CheckPredicate, 27, // 14012: check predicate 27
8044 OPC_Decode, 244, 115, 65, // 14014: decode to FNMADD_Q using decoder 65
8045 // 14014: }
8046 // 14014: } // switch Inst[26:25]
8047 // 14014: }
8048 83, 227, 10, // 14018: case 0x53: {
8049 OPC_SwitchField, 25, 7, // 14021: switch Inst[31:25] {
8050 0, 6, // 14024: case 0x0: {
8051 OPC_CheckPredicate, 25, // 14026: check predicate 25
8052 OPC_Decode, 162, 114, 66, // 14028: decode to FADD_S using decoder 66
8053 // 14028: }
8054 1, 6, // 14032: case 0x1: {
8055 OPC_CheckPredicate, 26, // 14034: check predicate 26
8056 OPC_Decode, 156, 114, 67, // 14036: decode to FADD_D using decoder 67
8057 // 14036: }
8058 2, 6, // 14040: case 0x2: {
8059 OPC_CheckPredicate, 82, // 14042: check predicate 82
8060 OPC_Decode, 159, 114, 68, // 14044: decode to FADD_H using decoder 68
8061 // 14044: }
8062 3, 6, // 14048: case 0x3: {
8063 OPC_CheckPredicate, 27, // 14050: check predicate 27
8064 OPC_Decode, 161, 114, 69, // 14052: decode to FADD_Q using decoder 69
8065 // 14052: }
8066 4, 6, // 14056: case 0x4: {
8067 OPC_CheckPredicate, 25, // 14058: check predicate 25
8068 OPC_Decode, 176, 116, 66, // 14060: decode to FSUB_S using decoder 66
8069 // 14060: }
8070 5, 6, // 14064: case 0x5: {
8071 OPC_CheckPredicate, 26, // 14066: check predicate 26
8072 OPC_Decode, 170, 116, 67, // 14068: decode to FSUB_D using decoder 67
8073 // 14068: }
8074 6, 6, // 14072: case 0x6: {
8075 OPC_CheckPredicate, 82, // 14074: check predicate 82
8076 OPC_Decode, 173, 116, 68, // 14076: decode to FSUB_H using decoder 68
8077 // 14076: }
8078 7, 6, // 14080: case 0x7: {
8079 OPC_CheckPredicate, 27, // 14082: check predicate 27
8080 OPC_Decode, 175, 116, 69, // 14084: decode to FSUB_Q using decoder 69
8081 // 14084: }
8082 8, 6, // 14088: case 0x8: {
8083 OPC_CheckPredicate, 25, // 14090: check predicate 25
8084 OPC_Decode, 226, 115, 66, // 14092: decode to FMUL_S using decoder 66
8085 // 14092: }
8086 9, 6, // 14096: case 0x9: {
8087 OPC_CheckPredicate, 26, // 14098: check predicate 26
8088 OPC_Decode, 220, 115, 67, // 14100: decode to FMUL_D using decoder 67
8089 // 14100: }
8090 10, 6, // 14104: case 0xa: {
8091 OPC_CheckPredicate, 82, // 14106: check predicate 82
8092 OPC_Decode, 223, 115, 68, // 14108: decode to FMUL_H using decoder 68
8093 // 14108: }
8094 11, 6, // 14112: case 0xb: {
8095 OPC_CheckPredicate, 27, // 14114: check predicate 27
8096 OPC_Decode, 225, 115, 69, // 14116: decode to FMUL_Q using decoder 69
8097 // 14116: }
8098 12, 6, // 14120: case 0xc: {
8099 OPC_CheckPredicate, 25, // 14122: check predicate 25
8100 OPC_Decode, 135, 115, 66, // 14124: decode to FDIV_S using decoder 66
8101 // 14124: }
8102 13, 6, // 14128: case 0xd: {
8103 OPC_CheckPredicate, 26, // 14130: check predicate 26
8104 OPC_Decode, 129, 115, 67, // 14132: decode to FDIV_D using decoder 67
8105 // 14132: }
8106 14, 6, // 14136: case 0xe: {
8107 OPC_CheckPredicate, 82, // 14138: check predicate 82
8108 OPC_Decode, 132, 115, 68, // 14140: decode to FDIV_H using decoder 68
8109 // 14140: }
8110 15, 6, // 14144: case 0xf: {
8111 OPC_CheckPredicate, 27, // 14146: check predicate 27
8112 OPC_Decode, 134, 115, 69, // 14148: decode to FDIV_Q using decoder 69
8113 // 14148: }
8114 16, 27, // 14152: case 0x10: {
8115 OPC_SwitchField, 12, 3, // 14154: switch Inst[14:12] {
8116 0, 6, // 14157: case 0x0: {
8117 OPC_CheckPredicate, 25, // 14159: check predicate 25
8118 OPC_Decode, 158, 116, 70, // 14161: decode to FSGNJ_S using decoder 70
8119 // 14161: }
8120 1, 6, // 14165: case 0x1: {
8121 OPC_CheckPredicate, 25, // 14167: check predicate 25
8122 OPC_Decode, 142, 116, 70, // 14169: decode to FSGNJN_S using decoder 70
8123 // 14169: }
8124 2, 0, // 14173: case 0x2: {
8125 OPC_CheckPredicate, 25, // 14175: check predicate 25
8126 OPC_Decode, 150, 116, 70, // 14177: decode to FSGNJX_S using decoder 70
8127 // 14177: }
8128 // 14177: } // switch Inst[14:12]
8129 // 14177: }
8130 17, 27, // 14181: case 0x11: {
8131 OPC_SwitchField, 12, 3, // 14183: switch Inst[14:12] {
8132 0, 6, // 14186: case 0x0: {
8133 OPC_CheckPredicate, 26, // 14188: check predicate 26
8134 OPC_Decode, 152, 116, 71, // 14190: decode to FSGNJ_D using decoder 71
8135 // 14190: }
8136 1, 6, // 14194: case 0x1: {
8137 OPC_CheckPredicate, 26, // 14196: check predicate 26
8138 OPC_Decode, 136, 116, 71, // 14198: decode to FSGNJN_D using decoder 71
8139 // 14198: }
8140 2, 0, // 14202: case 0x2: {
8141 OPC_CheckPredicate, 26, // 14204: check predicate 26
8142 OPC_Decode, 144, 116, 71, // 14206: decode to FSGNJX_D using decoder 71
8143 // 14206: }
8144 // 14206: } // switch Inst[14:12]
8145 // 14206: }
8146 18, 27, // 14210: case 0x12: {
8147 OPC_SwitchField, 12, 3, // 14212: switch Inst[14:12] {
8148 0, 6, // 14215: case 0x0: {
8149 OPC_CheckPredicate, 82, // 14217: check predicate 82
8150 OPC_Decode, 155, 116, 72, // 14219: decode to FSGNJ_H using decoder 72
8151 // 14219: }
8152 1, 6, // 14223: case 0x1: {
8153 OPC_CheckPredicate, 82, // 14225: check predicate 82
8154 OPC_Decode, 139, 116, 72, // 14227: decode to FSGNJN_H using decoder 72
8155 // 14227: }
8156 2, 0, // 14231: case 0x2: {
8157 OPC_CheckPredicate, 82, // 14233: check predicate 82
8158 OPC_Decode, 147, 116, 72, // 14235: decode to FSGNJX_H using decoder 72
8159 // 14235: }
8160 // 14235: } // switch Inst[14:12]
8161 // 14235: }
8162 19, 27, // 14239: case 0x13: {
8163 OPC_SwitchField, 12, 3, // 14241: switch Inst[14:12] {
8164 0, 6, // 14244: case 0x0: {
8165 OPC_CheckPredicate, 27, // 14246: check predicate 27
8166 OPC_Decode, 157, 116, 73, // 14248: decode to FSGNJ_Q using decoder 73
8167 // 14248: }
8168 1, 6, // 14252: case 0x1: {
8169 OPC_CheckPredicate, 27, // 14254: check predicate 27
8170 OPC_Decode, 141, 116, 73, // 14256: decode to FSGNJN_Q using decoder 73
8171 // 14256: }
8172 2, 0, // 14260: case 0x2: {
8173 OPC_CheckPredicate, 27, // 14262: check predicate 27
8174 OPC_Decode, 149, 116, 73, // 14264: decode to FSGNJX_Q using decoder 73
8175 // 14264: }
8176 // 14264: } // switch Inst[14:12]
8177 // 14264: }
8178 20, 35, // 14268: case 0x14: {
8179 OPC_SwitchField, 12, 3, // 14270: switch Inst[14:12] {
8180 0, 6, // 14273: case 0x0: {
8181 OPC_CheckPredicate, 25, // 14275: check predicate 25
8182 OPC_Decode, 210, 115, 70, // 14277: decode to FMIN_S using decoder 70
8183 // 14277: }
8184 1, 6, // 14281: case 0x1: {
8185 OPC_CheckPredicate, 25, // 14283: check predicate 25
8186 OPC_Decode, 198, 115, 70, // 14285: decode to FMAX_S using decoder 70
8187 // 14285: }
8188 2, 6, // 14289: case 0x2: {
8189 OPC_CheckPredicate, 83, // 14291: check predicate 83
8190 OPC_Decode, 203, 115, 70, // 14293: decode to FMINM_S using decoder 70
8191 // 14293: }
8192 3, 0, // 14297: case 0x3: {
8193 OPC_CheckPredicate, 83, // 14299: check predicate 83
8194 OPC_Decode, 191, 115, 70, // 14301: decode to FMAXM_S using decoder 70
8195 // 14301: }
8196 // 14301: } // switch Inst[14:12]
8197 // 14301: }
8198 21, 35, // 14305: case 0x15: {
8199 OPC_SwitchField, 12, 3, // 14307: switch Inst[14:12] {
8200 0, 6, // 14310: case 0x0: {
8201 OPC_CheckPredicate, 26, // 14312: check predicate 26
8202 OPC_Decode, 204, 115, 71, // 14314: decode to FMIN_D using decoder 71
8203 // 14314: }
8204 1, 6, // 14318: case 0x1: {
8205 OPC_CheckPredicate, 26, // 14320: check predicate 26
8206 OPC_Decode, 192, 115, 71, // 14322: decode to FMAX_D using decoder 71
8207 // 14322: }
8208 2, 6, // 14326: case 0x2: {
8209 OPC_CheckPredicate, 84, // 14328: check predicate 84
8210 OPC_Decode, 200, 115, 71, // 14330: decode to FMINM_D using decoder 71
8211 // 14330: }
8212 3, 0, // 14334: case 0x3: {
8213 OPC_CheckPredicate, 84, // 14336: check predicate 84
8214 OPC_Decode, 188, 115, 71, // 14338: decode to FMAXM_D using decoder 71
8215 // 14338: }
8216 // 14338: } // switch Inst[14:12]
8217 // 14338: }
8218 22, 35, // 14342: case 0x16: {
8219 OPC_SwitchField, 12, 3, // 14344: switch Inst[14:12] {
8220 0, 6, // 14347: case 0x0: {
8221 OPC_CheckPredicate, 82, // 14349: check predicate 82
8222 OPC_Decode, 207, 115, 72, // 14351: decode to FMIN_H using decoder 72
8223 // 14351: }
8224 1, 6, // 14355: case 0x1: {
8225 OPC_CheckPredicate, 82, // 14357: check predicate 82
8226 OPC_Decode, 195, 115, 72, // 14359: decode to FMAX_H using decoder 72
8227 // 14359: }
8228 2, 6, // 14363: case 0x2: {
8229 OPC_CheckPredicate, 85, // 14365: check predicate 85
8230 OPC_Decode, 201, 115, 72, // 14367: decode to FMINM_H using decoder 72
8231 // 14367: }
8232 3, 0, // 14371: case 0x3: {
8233 OPC_CheckPredicate, 85, // 14373: check predicate 85
8234 OPC_Decode, 189, 115, 72, // 14375: decode to FMAXM_H using decoder 72
8235 // 14375: }
8236 // 14375: } // switch Inst[14:12]
8237 // 14375: }
8238 23, 35, // 14379: case 0x17: {
8239 OPC_SwitchField, 12, 3, // 14381: switch Inst[14:12] {
8240 0, 6, // 14384: case 0x0: {
8241 OPC_CheckPredicate, 27, // 14386: check predicate 27
8242 OPC_Decode, 209, 115, 73, // 14388: decode to FMIN_Q using decoder 73
8243 // 14388: }
8244 1, 6, // 14392: case 0x1: {
8245 OPC_CheckPredicate, 27, // 14394: check predicate 27
8246 OPC_Decode, 197, 115, 73, // 14396: decode to FMAX_Q using decoder 73
8247 // 14396: }
8248 2, 6, // 14400: case 0x2: {
8249 OPC_CheckPredicate, 86, // 14402: check predicate 86
8250 OPC_Decode, 202, 115, 73, // 14404: decode to FMINM_Q using decoder 73
8251 // 14404: }
8252 3, 0, // 14408: case 0x3: {
8253 OPC_CheckPredicate, 86, // 14410: check predicate 86
8254 OPC_Decode, 190, 115, 73, // 14412: decode to FMAXM_Q using decoder 73
8255 // 14412: }
8256 // 14412: } // switch Inst[14:12]
8257 // 14412: }
8258 32, 51, // 14416: case 0x20: {
8259 OPC_SwitchField, 20, 5, // 14418: switch Inst[24:20] {
8260 1, 6, // 14421: case 0x1: {
8261 OPC_CheckPredicate, 26, // 14423: check predicate 26
8262 OPC_Decode, 227, 114, 74, // 14425: decode to FCVT_S_D using decoder 74
8263 // 14425: }
8264 2, 6, // 14429: case 0x2: {
8265 OPC_CheckPredicate, 87, // 14431: check predicate 87
8266 OPC_Decode, 230, 114, 75, // 14433: decode to FCVT_S_H using decoder 75
8267 // 14433: }
8268 3, 6, // 14437: case 0x3: {
8269 OPC_CheckPredicate, 27, // 14439: check predicate 27
8270 OPC_Decode, 236, 114, 76, // 14441: decode to FCVT_S_Q using decoder 76
8271 // 14441: }
8272 4, 6, // 14445: case 0x4: {
8273 OPC_CheckPredicate, 83, // 14447: check predicate 83
8274 OPC_Decode, 134, 116, 77, // 14449: decode to FROUND_S using decoder 77
8275 // 14449: }
8276 5, 6, // 14453: case 0x5: {
8277 OPC_CheckPredicate, 83, // 14455: check predicate 83
8278 OPC_Decode, 130, 116, 77, // 14457: decode to FROUNDNX_S using decoder 77
8279 // 14457: }
8280 6, 0, // 14461: case 0x6: {
8281 OPC_CheckPredicate, 88, // 14463: check predicate 88
8282 OPC_Decode, 226, 114, 75, // 14465: decode to FCVT_S_BF16 using decoder 75
8283 // 14465: }
8284 // 14465: } // switch Inst[24:20]
8285 // 14465: }
8286 33, 43, // 14469: case 0x21: {
8287 OPC_SwitchField, 20, 5, // 14471: switch Inst[24:20] {
8288 0, 6, // 14474: case 0x0: {
8289 OPC_CheckPredicate, 26, // 14476: check predicate 26
8290 OPC_Decode, 182, 114, 78, // 14478: decode to FCVT_D_S using decoder 78
8291 // 14478: }
8292 2, 6, // 14482: case 0x2: {
8293 OPC_CheckPredicate, 89, // 14484: check predicate 89
8294 OPC_Decode, 174, 114, 79, // 14486: decode to FCVT_D_H using decoder 79
8295 // 14486: }
8296 3, 6, // 14490: case 0x3: {
8297 OPC_CheckPredicate, 27, // 14492: check predicate 27
8298 OPC_Decode, 181, 114, 80, // 14494: decode to FCVT_D_Q using decoder 80
8299 // 14494: }
8300 4, 6, // 14498: case 0x4: {
8301 OPC_CheckPredicate, 84, // 14500: check predicate 84
8302 OPC_Decode, 131, 116, 81, // 14502: decode to FROUND_D using decoder 81
8303 // 14502: }
8304 5, 0, // 14506: case 0x5: {
8305 OPC_CheckPredicate, 84, // 14508: check predicate 84
8306 OPC_Decode, 255, 115, 81, // 14510: decode to FROUNDNX_D using decoder 81
8307 // 14510: }
8308 // 14510: } // switch Inst[24:20]
8309 // 14510: }
8310 34, 51, // 14514: case 0x22: {
8311 OPC_SwitchField, 20, 5, // 14516: switch Inst[24:20] {
8312 0, 6, // 14519: case 0x0: {
8313 OPC_CheckPredicate, 87, // 14521: check predicate 87
8314 OPC_Decode, 199, 114, 82, // 14523: decode to FCVT_H_S using decoder 82
8315 // 14523: }
8316 1, 6, // 14527: case 0x1: {
8317 OPC_CheckPredicate, 89, // 14529: check predicate 89
8318 OPC_Decode, 191, 114, 83, // 14531: decode to FCVT_H_D using decoder 83
8319 // 14531: }
8320 3, 6, // 14535: case 0x3: {
8321 OPC_CheckPredicate, 90, // 14537: check predicate 90
8322 OPC_Decode, 198, 114, 84, // 14539: decode to FCVT_H_Q using decoder 84
8323 // 14539: }
8324 4, 6, // 14543: case 0x4: {
8325 OPC_CheckPredicate, 85, // 14545: check predicate 85
8326 OPC_Decode, 132, 116, 85, // 14547: decode to FROUND_H using decoder 85
8327 // 14547: }
8328 5, 6, // 14551: case 0x5: {
8329 OPC_CheckPredicate, 85, // 14553: check predicate 85
8330 OPC_Decode, 128, 116, 85, // 14555: decode to FROUNDNX_H using decoder 85
8331 // 14555: }
8332 8, 0, // 14559: case 0x8: {
8333 OPC_CheckPredicate, 88, // 14561: check predicate 88
8334 OPC_Decode, 173, 114, 82, // 14563: decode to FCVT_BF16_S using decoder 82
8335 // 14563: }
8336 // 14563: } // switch Inst[24:20]
8337 // 14563: }
8338 35, 43, // 14567: case 0x23: {
8339 OPC_SwitchField, 20, 5, // 14569: switch Inst[24:20] {
8340 0, 6, // 14572: case 0x0: {
8341 OPC_CheckPredicate, 27, // 14574: check predicate 27
8342 OPC_Decode, 223, 114, 86, // 14576: decode to FCVT_Q_S using decoder 86
8343 // 14576: }
8344 1, 6, // 14580: case 0x1: {
8345 OPC_CheckPredicate, 27, // 14582: check predicate 27
8346 OPC_Decode, 219, 114, 87, // 14584: decode to FCVT_Q_D using decoder 87
8347 // 14584: }
8348 2, 6, // 14588: case 0x2: {
8349 OPC_CheckPredicate, 90, // 14590: check predicate 90
8350 OPC_Decode, 220, 114, 88, // 14592: decode to FCVT_Q_H using decoder 88
8351 // 14592: }
8352 4, 6, // 14596: case 0x4: {
8353 OPC_CheckPredicate, 86, // 14598: check predicate 86
8354 OPC_Decode, 133, 116, 89, // 14600: decode to FROUND_Q using decoder 89
8355 // 14600: }
8356 5, 0, // 14604: case 0x5: {
8357 OPC_CheckPredicate, 86, // 14606: check predicate 86
8358 OPC_Decode, 129, 116, 89, // 14608: decode to FROUNDNX_Q using decoder 89
8359 // 14608: }
8360 // 14608: } // switch Inst[24:20]
8361 // 14608: }
8362 44, 10, // 14612: case 0x2c: {
8363 OPC_CheckPredicate, 25, // 14614: check predicate 25
8364 OPC_CheckField, 20, 5, 0, // 14616: check Inst[24:20] == 0x0
8365 OPC_Decode, 168, 116, 77, // 14620: decode to FSQRT_S using decoder 77
8366 // 14620: }
8367 45, 10, // 14624: case 0x2d: {
8368 OPC_CheckPredicate, 26, // 14626: check predicate 26
8369 OPC_CheckField, 20, 5, 0, // 14628: check Inst[24:20] == 0x0
8370 OPC_Decode, 162, 116, 81, // 14632: decode to FSQRT_D using decoder 81
8371 // 14632: }
8372 46, 10, // 14636: case 0x2e: {
8373 OPC_CheckPredicate, 82, // 14638: check predicate 82
8374 OPC_CheckField, 20, 5, 0, // 14640: check Inst[24:20] == 0x0
8375 OPC_Decode, 165, 116, 85, // 14644: decode to FSQRT_H using decoder 85
8376 // 14644: }
8377 47, 10, // 14648: case 0x2f: {
8378 OPC_CheckPredicate, 27, // 14650: check predicate 27
8379 OPC_CheckField, 20, 5, 0, // 14652: check Inst[24:20] == 0x0
8380 OPC_Decode, 167, 116, 89, // 14656: decode to FSQRT_Q using decoder 89
8381 // 14656: }
8382 80, 43, // 14660: case 0x50: {
8383 OPC_SwitchField, 12, 3, // 14662: switch Inst[14:12] {
8384 0, 6, // 14665: case 0x0: {
8385 OPC_CheckPredicate, 25, // 14667: check predicate 25
8386 OPC_Decode, 159, 115, 90, // 14669: decode to FLE_S using decoder 90
8387 // 14669: }
8388 1, 6, // 14673: case 0x1: {
8389 OPC_CheckPredicate, 25, // 14675: check predicate 25
8390 OPC_Decode, 177, 115, 90, // 14677: decode to FLT_S using decoder 90
8391 // 14677: }
8392 2, 6, // 14681: case 0x2: {
8393 OPC_CheckPredicate, 25, // 14683: check predicate 25
8394 OPC_Decode, 146, 115, 90, // 14685: decode to FEQ_S using decoder 90
8395 // 14685: }
8396 4, 6, // 14689: case 0x4: {
8397 OPC_CheckPredicate, 83, // 14691: check predicate 83
8398 OPC_Decode, 152, 115, 90, // 14693: decode to FLEQ_S using decoder 90
8399 // 14693: }
8400 5, 0, // 14697: case 0x5: {
8401 OPC_CheckPredicate, 83, // 14699: check predicate 83
8402 OPC_Decode, 170, 115, 90, // 14701: decode to FLTQ_S using decoder 90
8403 // 14701: }
8404 // 14701: } // switch Inst[14:12]
8405 // 14701: }
8406 81, 43, // 14705: case 0x51: {
8407 OPC_SwitchField, 12, 3, // 14707: switch Inst[14:12] {
8408 0, 6, // 14710: case 0x0: {
8409 OPC_CheckPredicate, 26, // 14712: check predicate 26
8410 OPC_Decode, 153, 115, 91, // 14714: decode to FLE_D using decoder 91
8411 // 14714: }
8412 1, 6, // 14718: case 0x1: {
8413 OPC_CheckPredicate, 26, // 14720: check predicate 26
8414 OPC_Decode, 171, 115, 91, // 14722: decode to FLT_D using decoder 91
8415 // 14722: }
8416 2, 6, // 14726: case 0x2: {
8417 OPC_CheckPredicate, 26, // 14728: check predicate 26
8418 OPC_Decode, 140, 115, 91, // 14730: decode to FEQ_D using decoder 91
8419 // 14730: }
8420 4, 6, // 14734: case 0x4: {
8421 OPC_CheckPredicate, 84, // 14736: check predicate 84
8422 OPC_Decode, 149, 115, 91, // 14738: decode to FLEQ_D using decoder 91
8423 // 14738: }
8424 5, 0, // 14742: case 0x5: {
8425 OPC_CheckPredicate, 84, // 14744: check predicate 84
8426 OPC_Decode, 167, 115, 91, // 14746: decode to FLTQ_D using decoder 91
8427 // 14746: }
8428 // 14746: } // switch Inst[14:12]
8429 // 14746: }
8430 82, 43, // 14750: case 0x52: {
8431 OPC_SwitchField, 12, 3, // 14752: switch Inst[14:12] {
8432 0, 6, // 14755: case 0x0: {
8433 OPC_CheckPredicate, 82, // 14757: check predicate 82
8434 OPC_Decode, 156, 115, 92, // 14759: decode to FLE_H using decoder 92
8435 // 14759: }
8436 1, 6, // 14763: case 0x1: {
8437 OPC_CheckPredicate, 82, // 14765: check predicate 82
8438 OPC_Decode, 174, 115, 92, // 14767: decode to FLT_H using decoder 92
8439 // 14767: }
8440 2, 6, // 14771: case 0x2: {
8441 OPC_CheckPredicate, 82, // 14773: check predicate 82
8442 OPC_Decode, 143, 115, 92, // 14775: decode to FEQ_H using decoder 92
8443 // 14775: }
8444 4, 6, // 14779: case 0x4: {
8445 OPC_CheckPredicate, 85, // 14781: check predicate 85
8446 OPC_Decode, 150, 115, 92, // 14783: decode to FLEQ_H using decoder 92
8447 // 14783: }
8448 5, 0, // 14787: case 0x5: {
8449 OPC_CheckPredicate, 85, // 14789: check predicate 85
8450 OPC_Decode, 168, 115, 92, // 14791: decode to FLTQ_H using decoder 92
8451 // 14791: }
8452 // 14791: } // switch Inst[14:12]
8453 // 14791: }
8454 83, 43, // 14795: case 0x53: {
8455 OPC_SwitchField, 12, 3, // 14797: switch Inst[14:12] {
8456 0, 6, // 14800: case 0x0: {
8457 OPC_CheckPredicate, 27, // 14802: check predicate 27
8458 OPC_Decode, 158, 115, 93, // 14804: decode to FLE_Q using decoder 93
8459 // 14804: }
8460 1, 6, // 14808: case 0x1: {
8461 OPC_CheckPredicate, 27, // 14810: check predicate 27
8462 OPC_Decode, 176, 115, 93, // 14812: decode to FLT_Q using decoder 93
8463 // 14812: }
8464 2, 6, // 14816: case 0x2: {
8465 OPC_CheckPredicate, 27, // 14818: check predicate 27
8466 OPC_Decode, 145, 115, 93, // 14820: decode to FEQ_Q using decoder 93
8467 // 14820: }
8468 4, 6, // 14824: case 0x4: {
8469 OPC_CheckPredicate, 86, // 14826: check predicate 86
8470 OPC_Decode, 151, 115, 93, // 14828: decode to FLEQ_Q using decoder 93
8471 // 14828: }
8472 5, 0, // 14832: case 0x5: {
8473 OPC_CheckPredicate, 86, // 14834: check predicate 86
8474 OPC_Decode, 169, 115, 93, // 14836: decode to FLTQ_Q using decoder 93
8475 // 14836: }
8476 // 14836: } // switch Inst[14:12]
8477 // 14836: }
8478 89, 10, // 14840: case 0x59: {
8479 OPC_CheckPredicate, 91, // 14842: check predicate 91
8480 OPC_CheckField, 12, 3, 0, // 14844: check Inst[14:12] == 0x0
8481 OPC_Decode, 230, 115, 94, // 14848: decode to FMVP_D_X using decoder 94
8482 // 14848: }
8483 91, 10, // 14852: case 0x5b: {
8484 OPC_CheckPredicate, 92, // 14854: check predicate 92
8485 OPC_CheckField, 12, 3, 0, // 14856: check Inst[14:12] == 0x0
8486 OPC_Decode, 231, 115, 95, // 14860: decode to FMVP_Q_X using decoder 95
8487 // 14860: }
8488 96, 35, // 14864: case 0x60: {
8489 OPC_SwitchField, 20, 5, // 14866: switch Inst[24:20] {
8490 0, 6, // 14869: case 0x0: {
8491 OPC_CheckPredicate, 25, // 14871: check predicate 25
8492 OPC_Decode, 255, 114, 96, // 14873: decode to FCVT_W_S using decoder 96
8493 // 14873: }
8494 1, 6, // 14877: case 0x1: {
8495 OPC_CheckPredicate, 25, // 14879: check predicate 25
8496 OPC_Decode, 247, 114, 96, // 14881: decode to FCVT_WU_S using decoder 96
8497 // 14881: }
8498 2, 6, // 14885: case 0x2: {
8499 OPC_CheckPredicate, 93, // 14887: check predicate 93
8500 OPC_Decode, 217, 114, 96, // 14889: decode to FCVT_L_S using decoder 96
8501 // 14889: }
8502 3, 0, // 14893: case 0x3: {
8503 OPC_CheckPredicate, 93, // 14895: check predicate 93
8504 OPC_Decode, 210, 114, 96, // 14897: decode to FCVT_LU_S using decoder 96
8505 // 14897: }
8506 // 14897: } // switch Inst[24:20]
8507 // 14897: }
8508 97, 47, // 14901: case 0x61: {
8509 OPC_SwitchField, 20, 5, // 14903: switch Inst[24:20] {
8510 0, 6, // 14906: case 0x0: {
8511 OPC_CheckPredicate, 26, // 14908: check predicate 26
8512 OPC_Decode, 249, 114, 97, // 14910: decode to FCVT_W_D using decoder 97
8513 // 14910: }
8514 1, 6, // 14914: case 0x1: {
8515 OPC_CheckPredicate, 26, // 14916: check predicate 26
8516 OPC_Decode, 241, 114, 97, // 14918: decode to FCVT_WU_D using decoder 97
8517 // 14918: }
8518 2, 6, // 14922: case 0x2: {
8519 OPC_CheckPredicate, 94, // 14924: check predicate 94
8520 OPC_Decode, 212, 114, 97, // 14926: decode to FCVT_L_D using decoder 97
8521 // 14926: }
8522 3, 6, // 14930: case 0x3: {
8523 OPC_CheckPredicate, 94, // 14932: check predicate 94
8524 OPC_Decode, 205, 114, 97, // 14934: decode to FCVT_LU_D using decoder 97
8525 // 14934: }
8526 8, 0, // 14938: case 0x8: {
8527 OPC_CheckPredicate, 84, // 14940: check predicate 84
8528 OPC_CheckField, 12, 3, 1, // 14942: check Inst[14:12] == 0x1
8529 OPC_Decode, 172, 114, 98, // 14946: decode to FCVTMOD_W_D using decoder 98
8530 // 14946: }
8531 // 14946: } // switch Inst[24:20]
8532 // 14946: }
8533 98, 35, // 14950: case 0x62: {
8534 OPC_SwitchField, 20, 5, // 14952: switch Inst[24:20] {
8535 0, 6, // 14955: case 0x0: {
8536 OPC_CheckPredicate, 82, // 14957: check predicate 82
8537 OPC_Decode, 252, 114, 99, // 14959: decode to FCVT_W_H using decoder 99
8538 // 14959: }
8539 1, 6, // 14963: case 0x1: {
8540 OPC_CheckPredicate, 82, // 14965: check predicate 82
8541 OPC_Decode, 244, 114, 99, // 14967: decode to FCVT_WU_H using decoder 99
8542 // 14967: }
8543 2, 6, // 14971: case 0x2: {
8544 OPC_CheckPredicate, 95, // 14973: check predicate 95
8545 OPC_Decode, 214, 114, 99, // 14975: decode to FCVT_L_H using decoder 99
8546 // 14975: }
8547 3, 0, // 14979: case 0x3: {
8548 OPC_CheckPredicate, 95, // 14981: check predicate 95
8549 OPC_Decode, 207, 114, 99, // 14983: decode to FCVT_LU_H using decoder 99
8550 // 14983: }
8551 // 14983: } // switch Inst[24:20]
8552 // 14983: }
8553 99, 35, // 14987: case 0x63: {
8554 OPC_SwitchField, 20, 5, // 14989: switch Inst[24:20] {
8555 0, 6, // 14992: case 0x0: {
8556 OPC_CheckPredicate, 27, // 14994: check predicate 27
8557 OPC_Decode, 254, 114, 100, // 14996: decode to FCVT_W_Q using decoder 100
8558 // 14996: }
8559 1, 6, // 15000: case 0x1: {
8560 OPC_CheckPredicate, 27, // 15002: check predicate 27
8561 OPC_Decode, 246, 114, 100, // 15004: decode to FCVT_WU_Q using decoder 100
8562 // 15004: }
8563 2, 6, // 15008: case 0x2: {
8564 OPC_CheckPredicate, 96, // 15010: check predicate 96
8565 OPC_Decode, 216, 114, 100, // 15012: decode to FCVT_L_Q using decoder 100
8566 // 15012: }
8567 3, 0, // 15016: case 0x3: {
8568 OPC_CheckPredicate, 96, // 15018: check predicate 96
8569 OPC_Decode, 209, 114, 100, // 15020: decode to FCVT_LU_Q using decoder 100
8570 // 15020: }
8571 // 15020: } // switch Inst[24:20]
8572 // 15020: }
8573 104, 35, // 15024: case 0x68: {
8574 OPC_SwitchField, 20, 5, // 15026: switch Inst[24:20] {
8575 0, 6, // 15029: case 0x0: {
8576 OPC_CheckPredicate, 25, // 15031: check predicate 25
8577 OPC_Decode, 237, 114, 101, // 15033: decode to FCVT_S_W using decoder 101
8578 // 15033: }
8579 1, 6, // 15037: case 0x1: {
8580 OPC_CheckPredicate, 25, // 15039: check predicate 25
8581 OPC_Decode, 238, 114, 101, // 15041: decode to FCVT_S_WU using decoder 101
8582 // 15041: }
8583 2, 6, // 15045: case 0x2: {
8584 OPC_CheckPredicate, 93, // 15047: check predicate 93
8585 OPC_Decode, 232, 114, 101, // 15049: decode to FCVT_S_L using decoder 101
8586 // 15049: }
8587 3, 0, // 15053: case 0x3: {
8588 OPC_CheckPredicate, 93, // 15055: check predicate 93
8589 OPC_Decode, 233, 114, 101, // 15057: decode to FCVT_S_LU using decoder 101
8590 // 15057: }
8591 // 15057: } // switch Inst[24:20]
8592 // 15057: }
8593 105, 35, // 15061: case 0x69: {
8594 OPC_SwitchField, 20, 5, // 15063: switch Inst[24:20] {
8595 0, 6, // 15066: case 0x0: {
8596 OPC_CheckPredicate, 26, // 15068: check predicate 26
8597 OPC_Decode, 185, 114, 102, // 15070: decode to FCVT_D_W using decoder 102
8598 // 15070: }
8599 1, 6, // 15074: case 0x1: {
8600 OPC_CheckPredicate, 26, // 15076: check predicate 26
8601 OPC_Decode, 186, 114, 102, // 15078: decode to FCVT_D_WU using decoder 102
8602 // 15078: }
8603 2, 6, // 15082: case 0x2: {
8604 OPC_CheckPredicate, 94, // 15084: check predicate 94
8605 OPC_Decode, 177, 114, 102, // 15086: decode to FCVT_D_L using decoder 102
8606 // 15086: }
8607 3, 0, // 15090: case 0x3: {
8608 OPC_CheckPredicate, 94, // 15092: check predicate 94
8609 OPC_Decode, 178, 114, 102, // 15094: decode to FCVT_D_LU using decoder 102
8610 // 15094: }
8611 // 15094: } // switch Inst[24:20]
8612 // 15094: }
8613 106, 35, // 15098: case 0x6a: {
8614 OPC_SwitchField, 20, 5, // 15100: switch Inst[24:20] {
8615 0, 6, // 15103: case 0x0: {
8616 OPC_CheckPredicate, 82, // 15105: check predicate 82
8617 OPC_Decode, 201, 114, 103, // 15107: decode to FCVT_H_W using decoder 103
8618 // 15107: }
8619 1, 6, // 15111: case 0x1: {
8620 OPC_CheckPredicate, 82, // 15113: check predicate 82
8621 OPC_Decode, 202, 114, 103, // 15115: decode to FCVT_H_WU using decoder 103
8622 // 15115: }
8623 2, 6, // 15119: case 0x2: {
8624 OPC_CheckPredicate, 95, // 15121: check predicate 95
8625 OPC_Decode, 194, 114, 103, // 15123: decode to FCVT_H_L using decoder 103
8626 // 15123: }
8627 3, 0, // 15127: case 0x3: {
8628 OPC_CheckPredicate, 95, // 15129: check predicate 95
8629 OPC_Decode, 195, 114, 103, // 15131: decode to FCVT_H_LU using decoder 103
8630 // 15131: }
8631 // 15131: } // switch Inst[24:20]
8632 // 15131: }
8633 107, 35, // 15135: case 0x6b: {
8634 OPC_SwitchField, 20, 5, // 15137: switch Inst[24:20] {
8635 0, 6, // 15140: case 0x0: {
8636 OPC_CheckPredicate, 27, // 15142: check predicate 27
8637 OPC_Decode, 224, 114, 104, // 15144: decode to FCVT_Q_W using decoder 104
8638 // 15144: }
8639 1, 6, // 15148: case 0x1: {
8640 OPC_CheckPredicate, 27, // 15150: check predicate 27
8641 OPC_Decode, 225, 114, 104, // 15152: decode to FCVT_Q_WU using decoder 104
8642 // 15152: }
8643 2, 6, // 15156: case 0x2: {
8644 OPC_CheckPredicate, 96, // 15158: check predicate 96
8645 OPC_Decode, 221, 114, 104, // 15160: decode to FCVT_Q_L using decoder 104
8646 // 15160: }
8647 3, 0, // 15164: case 0x3: {
8648 OPC_CheckPredicate, 96, // 15166: check predicate 96
8649 OPC_Decode, 222, 114, 104, // 15168: decode to FCVT_Q_LU using decoder 104
8650 // 15168: }
8651 // 15168: } // switch Inst[24:20]
8652 // 15168: }
8653 112, 27, // 15172: case 0x70: {
8654 OPC_SwitchField, 12, 3, // 15174: switch Inst[14:12] {
8655 0, 10, // 15177: case 0x0: {
8656 OPC_CheckPredicate, 25, // 15179: check predicate 25
8657 OPC_CheckField, 20, 5, 0, // 15181: check Inst[24:20] == 0x0
8658 OPC_Decode, 237, 115, 105, // 15185: decode to FMV_X_W using decoder 105
8659 // 15185: }
8660 1, 0, // 15189: case 0x1: {
8661 OPC_CheckPredicate, 25, // 15191: check predicate 25
8662 OPC_CheckField, 20, 5, 0, // 15193: check Inst[24:20] == 0x0
8663 OPC_Decode, 170, 114, 105, // 15197: decode to FCLASS_S using decoder 105
8664 // 15197: }
8665 // 15197: } // switch Inst[14:12]
8666 // 15197: }
8667 113, 36, // 15201: case 0x71: {
8668 OPC_SwitchField, 12, 3, // 15203: switch Inst[14:12] {
8669 0, 19, // 15206: case 0x0: {
8670 OPC_SwitchField, 20, 5, // 15208: switch Inst[24:20] {
8671 0, 6, // 15211: case 0x0: {
8672 OPC_CheckPredicate, 94, // 15213: check predicate 94
8673 OPC_Decode, 235, 115, 106, // 15215: decode to FMV_X_D using decoder 106
8674 // 15215: }
8675 1, 0, // 15219: case 0x1: {
8676 OPC_CheckPredicate, 91, // 15221: check predicate 91
8677 OPC_Decode, 228, 115, 106, // 15223: decode to FMVH_X_D using decoder 106
8678 // 15223: }
8679 // 15223: } // switch Inst[24:20]
8680 // 15223: }
8681 1, 0, // 15227: case 0x1: {
8682 OPC_CheckPredicate, 26, // 15229: check predicate 26
8683 OPC_CheckField, 20, 5, 0, // 15231: check Inst[24:20] == 0x0
8684 OPC_Decode, 164, 114, 106, // 15235: decode to FCLASS_D using decoder 106
8685 // 15235: }
8686 // 15235: } // switch Inst[14:12]
8687 // 15235: }
8688 114, 27, // 15239: case 0x72: {
8689 OPC_SwitchField, 12, 3, // 15241: switch Inst[14:12] {
8690 0, 10, // 15244: case 0x0: {
8691 OPC_CheckPredicate, 24, // 15246: check predicate 24
8692 OPC_CheckField, 20, 5, 0, // 15248: check Inst[24:20] == 0x0
8693 OPC_Decode, 236, 115, 107, // 15252: decode to FMV_X_H using decoder 107
8694 // 15252: }
8695 1, 0, // 15256: case 0x1: {
8696 OPC_CheckPredicate, 82, // 15258: check predicate 82
8697 OPC_CheckField, 20, 5, 0, // 15260: check Inst[24:20] == 0x0
8698 OPC_Decode, 167, 114, 107, // 15264: decode to FCLASS_H using decoder 107
8699 // 15264: }
8700 // 15264: } // switch Inst[14:12]
8701 // 15264: }
8702 115, 27, // 15268: case 0x73: {
8703 OPC_SwitchField, 12, 3, // 15270: switch Inst[14:12] {
8704 0, 10, // 15273: case 0x0: {
8705 OPC_CheckPredicate, 92, // 15275: check predicate 92
8706 OPC_CheckField, 20, 5, 1, // 15277: check Inst[24:20] == 0x1
8707 OPC_Decode, 229, 115, 108, // 15281: decode to FMVH_X_Q using decoder 108
8708 // 15281: }
8709 1, 0, // 15285: case 0x1: {
8710 OPC_CheckPredicate, 27, // 15287: check predicate 27
8711 OPC_CheckField, 20, 5, 0, // 15289: check Inst[24:20] == 0x0
8712 OPC_Decode, 169, 114, 108, // 15293: decode to FCLASS_Q using decoder 108
8713 // 15293: }
8714 // 15293: } // switch Inst[14:12]
8715 // 15293: }
8716 120, 27, // 15297: case 0x78: {
8717 OPC_SwitchField, 20, 5, // 15299: switch Inst[24:20] {
8718 0, 10, // 15302: case 0x0: {
8719 OPC_CheckPredicate, 25, // 15304: check predicate 25
8720 OPC_CheckField, 12, 3, 0, // 15306: check Inst[14:12] == 0x0
8721 OPC_Decode, 234, 115, 109, // 15310: decode to FMV_W_X using decoder 109
8722 // 15310: }
8723 1, 0, // 15314: case 0x1: {
8724 OPC_CheckPredicate, 83, // 15316: check predicate 83
8725 OPC_CheckField, 12, 3, 0, // 15318: check Inst[14:12] == 0x0
8726 OPC_Decode, 165, 115, 110, // 15322: decode to FLI_S using decoder 110
8727 // 15322: }
8728 // 15322: } // switch Inst[24:20]
8729 // 15322: }
8730 121, 27, // 15326: case 0x79: {
8731 OPC_SwitchField, 20, 5, // 15328: switch Inst[24:20] {
8732 0, 10, // 15331: case 0x0: {
8733 OPC_CheckPredicate, 94, // 15333: check predicate 94
8734 OPC_CheckField, 12, 3, 0, // 15335: check Inst[14:12] == 0x0
8735 OPC_Decode, 232, 115, 111, // 15339: decode to FMV_D_X using decoder 111
8736 // 15339: }
8737 1, 0, // 15343: case 0x1: {
8738 OPC_CheckPredicate, 84, // 15345: check predicate 84
8739 OPC_CheckField, 12, 3, 0, // 15347: check Inst[14:12] == 0x0
8740 OPC_Decode, 162, 115, 112, // 15351: decode to FLI_D using decoder 112
8741 // 15351: }
8742 // 15351: } // switch Inst[24:20]
8743 // 15351: }
8744 122, 27, // 15355: case 0x7a: {
8745 OPC_SwitchField, 20, 5, // 15357: switch Inst[24:20] {
8746 0, 10, // 15360: case 0x0: {
8747 OPC_CheckPredicate, 24, // 15362: check predicate 24
8748 OPC_CheckField, 12, 3, 0, // 15364: check Inst[14:12] == 0x0
8749 OPC_Decode, 233, 115, 113, // 15368: decode to FMV_H_X using decoder 113
8750 // 15368: }
8751 1, 0, // 15372: case 0x1: {
8752 OPC_CheckPredicate, 97, // 15374: check predicate 97
8753 OPC_CheckField, 12, 3, 0, // 15376: check Inst[14:12] == 0x0
8754 OPC_Decode, 163, 115, 114, // 15380: decode to FLI_H using decoder 114
8755 // 15380: }
8756 // 15380: } // switch Inst[24:20]
8757 // 15380: }
8758 123, 0, // 15384: case 0x7b: {
8759 OPC_CheckPredicate, 86, // 15386: check predicate 86
8760 OPC_CheckField, 20, 5, 1, // 15388: check Inst[24:20] == 0x1
8761 OPC_CheckField, 12, 3, 0, // 15392: check Inst[14:12] == 0x0
8762 OPC_Decode, 164, 115, 115, // 15396: decode to FLI_Q using decoder 115
8763 // 15396: }
8764 // 15396: } // switch Inst[31:25]
8765 // 15396: }
8766 87, 185, 29, // 15400: case 0x57: {
8767 OPC_SwitchField, 12, 3, // 15403: switch Inst[14:12] {
8768 0, 152, 4, // 15406: case 0x0: {
8769 OPC_SwitchField, 26, 6, // 15409: switch Inst[31:26] {
8770 0, 6, // 15412: case 0x0: {
8771 OPC_CheckPredicate, 23, // 15414: check predicate 23
8772 OPC_Decode, 193, 126, 116, // 15416: decode to VADD_VV using decoder 116
8773 // 15416: }
8774 1, 6, // 15420: case 0x1: {
8775 OPC_CheckPredicate, 98, // 15422: check predicate 98
8776 OPC_Decode, 206, 126, 116, // 15424: decode to VANDN_VV using decoder 116
8777 // 15424: }
8778 2, 7, // 15428: case 0x2: {
8779 OPC_CheckPredicate, 23, // 15430: check predicate 23
8780 OPC_Decode, 184, 131, 1, 116, // 15432: decode to VSUB_VV using decoder 116
8781 // 15432: }
8782 4, 7, // 15437: case 0x4: {
8783 OPC_CheckPredicate, 23, // 15439: check predicate 23
8784 OPC_Decode, 181, 129, 1, 116, // 15441: decode to VMINU_VV using decoder 116
8785 // 15441: }
8786 5, 7, // 15446: case 0x5: {
8787 OPC_CheckPredicate, 23, // 15448: check predicate 23
8788 OPC_Decode, 183, 129, 1, 116, // 15450: decode to VMIN_VV using decoder 116
8789 // 15450: }
8790 6, 7, // 15455: case 0x6: {
8791 OPC_CheckPredicate, 23, // 15457: check predicate 23
8792 OPC_Decode, 164, 129, 1, 116, // 15459: decode to VMAXU_VV using decoder 116
8793 // 15459: }
8794 7, 7, // 15464: case 0x7: {
8795 OPC_CheckPredicate, 23, // 15466: check predicate 23
8796 OPC_Decode, 166, 129, 1, 116, // 15468: decode to VMAX_VV using decoder 116
8797 // 15468: }
8798 9, 6, // 15473: case 0x9: {
8799 OPC_CheckPredicate, 23, // 15475: check predicate 23
8800 OPC_Decode, 209, 126, 116, // 15477: decode to VAND_VV using decoder 116
8801 // 15477: }
8802 10, 7, // 15481: case 0xa: {
8803 OPC_CheckPredicate, 23, // 15483: check predicate 23
8804 OPC_Decode, 129, 130, 1, 116, // 15485: decode to VOR_VV using decoder 116
8805 // 15485: }
8806 11, 7, // 15490: case 0xb: {
8807 OPC_CheckPredicate, 23, // 15492: check predicate 23
8808 OPC_Decode, 132, 132, 1, 116, // 15494: decode to VXOR_VV using decoder 116
8809 // 15494: }
8810 12, 7, // 15499: case 0xc: {
8811 OPC_CheckPredicate, 23, // 15501: check predicate 23
8812 OPC_Decode, 153, 130, 1, 116, // 15503: decode to VRGATHER_VV using decoder 116
8813 // 15503: }
8814 14, 7, // 15508: case 0xe: {
8815 OPC_CheckPredicate, 23, // 15510: check predicate 23
8816 OPC_Decode, 151, 130, 1, 116, // 15512: decode to VRGATHEREI16_VV using decoder 116
8817 // 15512: }
8818 15, 7, // 15517: case 0xf: {
8819 OPC_CheckPredicate, 99, // 15519: check predicate 99
8820 OPC_Decode, 131, 130, 1, 116, // 15521: decode to VPAIRE_VV using decoder 116
8821 // 15521: }
8822 16, 10, // 15526: case 0x10: {
8823 OPC_CheckPredicate, 23, // 15528: check predicate 23
8824 OPC_CheckField, 25, 1, 0, // 15530: check Inst[25] == 0x0
8825 OPC_Decode, 190, 126, 117, // 15534: decode to VADC_VVM using decoder 117
8826 // 15534: }
8827 17, 21, // 15538: case 0x11: {
8828 OPC_SwitchField, 25, 1, // 15540: switch Inst[25] {
8829 0, 7, // 15543: case 0x0: {
8830 OPC_CheckPredicate, 23, // 15545: check predicate 23
8831 OPC_Decode, 157, 129, 1, 117, // 15547: decode to VMADC_VVM using decoder 117
8832 // 15547: }
8833 1, 0, // 15552: case 0x1: {
8834 OPC_CheckPredicate, 23, // 15554: check predicate 23
8835 OPC_Decode, 156, 129, 1, 118, // 15556: decode to VMADC_VV using decoder 118
8836 // 15556: }
8837 // 15556: } // switch Inst[25]
8838 // 15556: }
8839 18, 11, // 15561: case 0x12: {
8840 OPC_CheckPredicate, 23, // 15563: check predicate 23
8841 OPC_CheckField, 25, 1, 0, // 15565: check Inst[25] == 0x0
8842 OPC_Decode, 172, 130, 1, 117, // 15569: decode to VSBC_VVM using decoder 117
8843 // 15569: }
8844 19, 21, // 15574: case 0x13: {
8845 OPC_SwitchField, 25, 1, // 15576: switch Inst[25] {
8846 0, 7, // 15579: case 0x0: {
8847 OPC_CheckPredicate, 23, // 15581: check predicate 23
8848 OPC_Decode, 191, 129, 1, 117, // 15583: decode to VMSBC_VVM using decoder 117
8849 // 15583: }
8850 1, 0, // 15588: case 0x1: {
8851 OPC_CheckPredicate, 23, // 15590: check predicate 23
8852 OPC_Decode, 190, 129, 1, 118, // 15592: decode to VMSBC_VV using decoder 118
8853 // 15592: }
8854 // 15592: } // switch Inst[25]
8855 // 15592: }
8856 20, 7, // 15597: case 0x14: {
8857 OPC_CheckPredicate, 98, // 15599: check predicate 98
8858 OPC_Decode, 158, 130, 1, 116, // 15601: decode to VROR_VV using decoder 116
8859 // 15601: }
8860 21, 7, // 15606: case 0x15: {
8861 OPC_CheckPredicate, 98, // 15608: check predicate 98
8862 OPC_Decode, 155, 130, 1, 116, // 15610: decode to VROL_VV using decoder 116
8863 // 15610: }
8864 23, 25, // 15615: case 0x17: {
8865 OPC_SwitchField, 25, 1, // 15617: switch Inst[25] {
8866 0, 7, // 15620: case 0x0: {
8867 OPC_CheckPredicate, 23, // 15622: check predicate 23
8868 OPC_Decode, 169, 129, 1, 117, // 15624: decode to VMERGE_VVM using decoder 117
8869 // 15624: }
8870 1, 0, // 15629: case 0x1: {
8871 OPC_CheckPredicate, 23, // 15631: check predicate 23
8872 OPC_CheckField, 20, 5, 0, // 15633: check Inst[24:20] == 0x0
8873 OPC_Decode, 235, 129, 1, 119, // 15637: decode to VMV_V_V using decoder 119
8874 // 15637: }
8875 // 15637: } // switch Inst[25]
8876 // 15637: }
8877 24, 7, // 15642: case 0x18: {
8878 OPC_CheckPredicate, 23, // 15644: check predicate 23
8879 OPC_Decode, 196, 129, 1, 116, // 15646: decode to VMSEQ_VV using decoder 116
8880 // 15646: }
8881 25, 7, // 15651: case 0x19: {
8882 OPC_CheckPredicate, 23, // 15653: check predicate 23
8883 OPC_Decode, 214, 129, 1, 116, // 15655: decode to VMSNE_VV using decoder 116
8884 // 15655: }
8885 26, 7, // 15660: case 0x1a: {
8886 OPC_CheckPredicate, 23, // 15662: check predicate 23
8887 OPC_Decode, 209, 129, 1, 116, // 15664: decode to VMSLTU_VV using decoder 116
8888 // 15664: }
8889 27, 7, // 15669: case 0x1b: {
8890 OPC_CheckPredicate, 23, // 15671: check predicate 23
8891 OPC_Decode, 211, 129, 1, 116, // 15673: decode to VMSLT_VV using decoder 116
8892 // 15673: }
8893 28, 7, // 15678: case 0x1c: {
8894 OPC_CheckPredicate, 23, // 15680: check predicate 23
8895 OPC_Decode, 204, 129, 1, 116, // 15682: decode to VMSLEU_VV using decoder 116
8896 // 15682: }
8897 29, 7, // 15687: case 0x1d: {
8898 OPC_CheckPredicate, 23, // 15689: check predicate 23
8899 OPC_Decode, 207, 129, 1, 116, // 15691: decode to VMSLE_VV using decoder 116
8900 // 15691: }
8901 32, 7, // 15696: case 0x20: {
8902 OPC_CheckPredicate, 23, // 15698: check predicate 23
8903 OPC_Decode, 167, 130, 1, 116, // 15700: decode to VSADDU_VV using decoder 116
8904 // 15700: }
8905 33, 7, // 15705: case 0x21: {
8906 OPC_CheckPredicate, 23, // 15707: check predicate 23
8907 OPC_Decode, 170, 130, 1, 116, // 15709: decode to VSADD_VV using decoder 116
8908 // 15709: }
8909 34, 7, // 15714: case 0x22: {
8910 OPC_CheckPredicate, 23, // 15716: check predicate 23
8911 OPC_Decode, 180, 131, 1, 116, // 15718: decode to VSSUBU_VV using decoder 116
8912 // 15718: }
8913 35, 7, // 15723: case 0x23: {
8914 OPC_CheckPredicate, 23, // 15725: check predicate 23
8915 OPC_Decode, 182, 131, 1, 116, // 15727: decode to VSSUB_VV using decoder 116
8916 // 15727: }
8917 37, 7, // 15732: case 0x25: {
8918 OPC_CheckPredicate, 23, // 15734: check predicate 23
8919 OPC_Decode, 194, 130, 1, 116, // 15736: decode to VSLL_VV using decoder 116
8920 // 15736: }
8921 39, 7, // 15741: case 0x27: {
8922 OPC_CheckPredicate, 23, // 15743: check predicate 23
8923 OPC_Decode, 201, 130, 1, 116, // 15745: decode to VSMUL_VV using decoder 116
8924 // 15745: }
8925 40, 7, // 15750: case 0x28: {
8926 OPC_CheckPredicate, 23, // 15752: check predicate 23
8927 OPC_Decode, 240, 130, 1, 116, // 15754: decode to VSRL_VV using decoder 116
8928 // 15754: }
8929 41, 7, // 15759: case 0x29: {
8930 OPC_CheckPredicate, 23, // 15761: check predicate 23
8931 OPC_Decode, 237, 130, 1, 116, // 15763: decode to VSRA_VV using decoder 116
8932 // 15763: }
8933 42, 7, // 15768: case 0x2a: {
8934 OPC_CheckPredicate, 23, // 15770: check predicate 23
8935 OPC_Decode, 150, 131, 1, 116, // 15772: decode to VSSRL_VV using decoder 116
8936 // 15772: }
8937 43, 7, // 15777: case 0x2b: {
8938 OPC_CheckPredicate, 23, // 15779: check predicate 23
8939 OPC_Decode, 147, 131, 1, 116, // 15781: decode to VSSRA_VV using decoder 116
8940 // 15781: }
8941 44, 7, // 15786: case 0x2c: {
8942 OPC_CheckPredicate, 23, // 15788: check predicate 23
8943 OPC_Decode, 254, 129, 1, 116, // 15790: decode to VNSRL_WV using decoder 116
8944 // 15790: }
8945 45, 7, // 15795: case 0x2d: {
8946 OPC_CheckPredicate, 23, // 15797: check predicate 23
8947 OPC_Decode, 251, 129, 1, 116, // 15799: decode to VNSRA_WV using decoder 116
8948 // 15799: }
8949 46, 7, // 15804: case 0x2e: {
8950 OPC_CheckPredicate, 23, // 15806: check predicate 23
8951 OPC_Decode, 241, 129, 1, 116, // 15808: decode to VNCLIPU_WV using decoder 116
8952 // 15808: }
8953 47, 7, // 15813: case 0x2f: {
8954 OPC_CheckPredicate, 23, // 15815: check predicate 23
8955 OPC_Decode, 244, 129, 1, 116, // 15817: decode to VNCLIP_WV using decoder 116
8956 // 15817: }
8957 48, 7, // 15822: case 0x30: {
8958 OPC_CheckPredicate, 23, // 15824: check predicate 23
8959 OPC_Decode, 246, 131, 1, 116, // 15826: decode to VWREDSUMU_VS using decoder 116
8960 // 15826: }
8961 49, 7, // 15831: case 0x31: {
8962 OPC_CheckPredicate, 23, // 15833: check predicate 23
8963 OPC_Decode, 247, 131, 1, 116, // 15835: decode to VWREDSUM_VS using decoder 116
8964 // 15835: }
8965 53, 7, // 15840: case 0x35: {
8966 OPC_CheckPredicate, 100, // 15842: check predicate 100
8967 OPC_Decode, 249, 131, 1, 116, // 15844: decode to VWSLL_VV using decoder 116
8968 // 15844: }
8969 56, 11, // 15849: case 0x38: {
8970 OPC_CheckPredicate, 101, // 15851: check predicate 101
8971 OPC_CheckField, 25, 1, 1, // 15853: check Inst[25] == 0x1
8972 OPC_Decode, 185, 129, 1, 120, // 15857: decode to VMMACC_VV using decoder 120
8973 // 15857: }
8974 57, 20, // 15862: case 0x39: {
8975 OPC_SwitchField, 25, 1, // 15864: switch Inst[25] {
8976 0, 6, // 15867: case 0x0: {
8977 OPC_CheckPredicate, 102, // 15869: check predicate 102
8978 OPC_Decode, 204, 127, 121, // 15871: decode to VFWIMMACC_VV using decoder 121
8979 // 15871: }
8980 1, 0, // 15875: case 0x1: {
8981 OPC_CheckPredicate, 101, // 15877: check predicate 101
8982 OPC_Decode, 239, 131, 1, 120, // 15879: decode to VWMMACC_VV using decoder 120
8983 // 15879: }
8984 // 15879: } // switch Inst[25]
8985 // 15879: }
8986 58, 20, // 15884: case 0x3a: {
8987 OPC_SwitchField, 25, 1, // 15886: switch Inst[25] {
8988 0, 6, // 15889: case 0x0: {
8989 OPC_CheckPredicate, 102, // 15891: check predicate 102
8990 OPC_Decode, 164, 127, 121, // 15893: decode to VFQIMMACC_VV using decoder 121
8991 // 15893: }
8992 1, 0, // 15897: case 0x1: {
8993 OPC_CheckPredicate, 101, // 15899: check predicate 101
8994 OPC_Decode, 133, 130, 1, 120, // 15901: decode to VQMMACC_VV using decoder 120
8995 // 15901: }
8996 // 15901: } // switch Inst[25]
8997 // 15901: }
8998 59, 19, // 15906: case 0x3b: {
8999 OPC_SwitchField, 25, 1, // 15908: switch Inst[25] {
9000 0, 6, // 15911: case 0x0: {
9001 OPC_CheckPredicate, 102, // 15913: check predicate 102
9002 OPC_Decode, 237, 126, 121, // 15915: decode to VF8WIMMACC_VV using decoder 121
9003 // 15915: }
9004 1, 0, // 15919: case 0x1: {
9005 OPC_CheckPredicate, 101, // 15921: check predicate 101
9006 OPC_Decode, 180, 126, 120, // 15923: decode to V8WMMACC_VV using decoder 120
9007 // 15923: }
9008 // 15923: } // switch Inst[25]
9009 // 15923: }
9010 61, 7, // 15927: case 0x3d: {
9011 OPC_CheckPredicate, 103, // 15929: check predicate 103
9012 OPC_Decode, 222, 131, 1, 122, // 15931: decode to VWABDA_VV using decoder 122
9013 // 15931: }
9014 62, 0, // 15936: case 0x3e: {
9015 OPC_CheckPredicate, 103, // 15938: check predicate 103
9016 OPC_Decode, 220, 131, 1, 122, // 15940: decode to VWABDAU_VV using decoder 122
9017 // 15940: }
9018 // 15940: } // switch Inst[31:26]
9019 // 15940: }
9020 1, 133, 5, // 15945: case 0x1: {
9021 OPC_SwitchField, 26, 6, // 15948: switch Inst[31:26] {
9022 0, 6, // 15951: case 0x0: {
9023 OPC_CheckPredicate, 104, // 15953: check predicate 104
9024 OPC_Decode, 241, 126, 116, // 15955: decode to VFADD_VV using decoder 116
9025 // 15955: }
9026 1, 6, // 15959: case 0x1: {
9027 OPC_CheckPredicate, 104, // 15961: check predicate 104
9028 OPC_Decode, 176, 127, 116, // 15963: decode to VFREDUSUM_VS using decoder 116
9029 // 15963: }
9030 2, 6, // 15967: case 0x2: {
9031 OPC_CheckPredicate, 104, // 15969: check predicate 104
9032 OPC_Decode, 189, 127, 116, // 15971: decode to VFSUB_VV using decoder 116
9033 // 15971: }
9034 3, 6, // 15975: case 0x3: {
9035 OPC_CheckPredicate, 104, // 15977: check predicate 104
9036 OPC_Decode, 175, 127, 116, // 15979: decode to VFREDOSUM_VS using decoder 116
9037 // 15979: }
9038 4, 6, // 15983: case 0x4: {
9039 OPC_CheckPredicate, 104, // 15985: check predicate 104
9040 OPC_Decode, 133, 127, 116, // 15987: decode to VFMIN_VV using decoder 116
9041 // 15987: }
9042 5, 6, // 15991: case 0x5: {
9043 OPC_CheckPredicate, 104, // 15993: check predicate 104
9044 OPC_Decode, 174, 127, 116, // 15995: decode to VFREDMIN_VS using decoder 116
9045 // 15995: }
9046 6, 6, // 15999: case 0x6: {
9047 OPC_CheckPredicate, 104, // 16001: check predicate 104
9048 OPC_Decode, 130, 127, 116, // 16003: decode to VFMAX_VV using decoder 116
9049 // 16003: }
9050 7, 6, // 16007: case 0x7: {
9051 OPC_CheckPredicate, 104, // 16009: check predicate 104
9052 OPC_Decode, 173, 127, 116, // 16011: decode to VFREDMAX_VS using decoder 116
9053 // 16011: }
9054 8, 6, // 16015: case 0x8: {
9055 OPC_CheckPredicate, 104, // 16017: check predicate 104
9056 OPC_Decode, 184, 127, 116, // 16019: decode to VFSGNJ_VV using decoder 116
9057 // 16019: }
9058 9, 6, // 16023: case 0x9: {
9059 OPC_CheckPredicate, 104, // 16025: check predicate 104
9060 OPC_Decode, 180, 127, 116, // 16027: decode to VFSGNJN_VV using decoder 116
9061 // 16027: }
9062 10, 6, // 16031: case 0xa: {
9063 OPC_CheckPredicate, 104, // 16033: check predicate 104
9064 OPC_Decode, 182, 127, 116, // 16035: decode to VFSGNJX_VV using decoder 116
9065 // 16035: }
9066 16, 14, // 16039: case 0x10: {
9067 OPC_CheckPredicate, 104, // 16041: check predicate 104
9068 OPC_CheckField, 25, 1, 1, // 16043: check Inst[25] == 0x1
9069 OPC_CheckField, 15, 5, 0, // 16047: check Inst[19:15] == 0x0
9070 OPC_Decode, 141, 127, 123, // 16051: decode to VFMV_F_S using decoder 123
9071 // 16051: }
9072 18, 211, 1, // 16055: case 0x12: {
9073 OPC_SwitchField, 15, 5, // 16058: switch Inst[19:15] {
9074 0, 6, // 16061: case 0x0: {
9075 OPC_CheckPredicate, 104, // 16063: check predicate 104
9076 OPC_Decode, 248, 126, 124, // 16065: decode to VFCVT_XU_F_V using decoder 124
9077 // 16065: }
9078 1, 6, // 16069: case 0x1: {
9079 OPC_CheckPredicate, 104, // 16071: check predicate 104
9080 OPC_Decode, 249, 126, 124, // 16073: decode to VFCVT_X_F_V using decoder 124
9081 // 16073: }
9082 2, 6, // 16077: case 0x2: {
9083 OPC_CheckPredicate, 104, // 16079: check predicate 104
9084 OPC_Decode, 244, 126, 124, // 16081: decode to VFCVT_F_XU_V using decoder 124
9085 // 16081: }
9086 3, 6, // 16085: case 0x3: {
9087 OPC_CheckPredicate, 104, // 16087: check predicate 104
9088 OPC_Decode, 245, 126, 124, // 16089: decode to VFCVT_F_X_V using decoder 124
9089 // 16089: }
9090 6, 6, // 16093: case 0x6: {
9091 OPC_CheckPredicate, 104, // 16095: check predicate 104
9092 OPC_Decode, 246, 126, 124, // 16097: decode to VFCVT_RTZ_XU_F_V using decoder 124
9093 // 16097: }
9094 7, 6, // 16101: case 0x7: {
9095 OPC_CheckPredicate, 104, // 16103: check predicate 104
9096 OPC_Decode, 247, 126, 124, // 16105: decode to VFCVT_RTZ_X_F_V using decoder 124
9097 // 16105: }
9098 8, 6, // 16109: case 0x8: {
9099 OPC_CheckPredicate, 104, // 16111: check predicate 104
9100 OPC_Decode, 201, 127, 124, // 16113: decode to VFWCVT_XU_F_V using decoder 124
9101 // 16113: }
9102 9, 6, // 16117: case 0x9: {
9103 OPC_CheckPredicate, 104, // 16119: check predicate 104
9104 OPC_Decode, 202, 127, 124, // 16121: decode to VFWCVT_X_F_V using decoder 124
9105 // 16121: }
9106 10, 6, // 16125: case 0xa: {
9107 OPC_CheckPredicate, 104, // 16127: check predicate 104
9108 OPC_Decode, 197, 127, 124, // 16129: decode to VFWCVT_F_XU_V using decoder 124
9109 // 16129: }
9110 11, 6, // 16133: case 0xb: {
9111 OPC_CheckPredicate, 104, // 16135: check predicate 104
9112 OPC_Decode, 198, 127, 124, // 16137: decode to VFWCVT_F_X_V using decoder 124
9113 // 16137: }
9114 12, 6, // 16141: case 0xc: {
9115 OPC_CheckPredicate, 104, // 16143: check predicate 104
9116 OPC_Decode, 196, 127, 124, // 16145: decode to VFWCVT_F_F_V using decoder 124
9117 // 16145: }
9118 13, 6, // 16149: case 0xd: {
9119 OPC_CheckPredicate, 105, // 16151: check predicate 105
9120 OPC_Decode, 195, 127, 124, // 16153: decode to VFWCVTBF16_F_F_V using decoder 124
9121 // 16153: }
9122 14, 6, // 16157: case 0xe: {
9123 OPC_CheckPredicate, 104, // 16159: check predicate 104
9124 OPC_Decode, 199, 127, 124, // 16161: decode to VFWCVT_RTZ_XU_F_V using decoder 124
9125 // 16161: }
9126 15, 6, // 16165: case 0xf: {
9127 OPC_CheckPredicate, 104, // 16167: check predicate 104
9128 OPC_Decode, 200, 127, 124, // 16169: decode to VFWCVT_RTZ_X_F_V using decoder 124
9129 // 16169: }
9130 16, 6, // 16173: case 0x10: {
9131 OPC_CheckPredicate, 104, // 16175: check predicate 104
9132 OPC_Decode, 154, 127, 124, // 16177: decode to VFNCVT_XU_F_W using decoder 124
9133 // 16177: }
9134 17, 6, // 16181: case 0x11: {
9135 OPC_CheckPredicate, 104, // 16183: check predicate 104
9136 OPC_Decode, 155, 127, 124, // 16185: decode to VFNCVT_X_F_W using decoder 124
9137 // 16185: }
9138 18, 6, // 16189: case 0x12: {
9139 OPC_CheckPredicate, 104, // 16191: check predicate 104
9140 OPC_Decode, 148, 127, 124, // 16193: decode to VFNCVT_F_XU_W using decoder 124
9141 // 16193: }
9142 19, 6, // 16197: case 0x13: {
9143 OPC_CheckPredicate, 104, // 16199: check predicate 104
9144 OPC_Decode, 149, 127, 124, // 16201: decode to VFNCVT_F_X_W using decoder 124
9145 // 16201: }
9146 20, 6, // 16205: case 0x14: {
9147 OPC_CheckPredicate, 104, // 16207: check predicate 104
9148 OPC_Decode, 147, 127, 124, // 16209: decode to VFNCVT_F_F_W using decoder 124
9149 // 16209: }
9150 21, 6, // 16213: case 0x15: {
9151 OPC_CheckPredicate, 104, // 16215: check predicate 104
9152 OPC_Decode, 150, 127, 124, // 16217: decode to VFNCVT_ROD_F_F_W using decoder 124
9153 // 16217: }
9154 22, 6, // 16221: case 0x16: {
9155 OPC_CheckPredicate, 104, // 16223: check predicate 104
9156 OPC_Decode, 151, 127, 124, // 16225: decode to VFNCVT_RTZ_XU_F_W using decoder 124
9157 // 16225: }
9158 23, 6, // 16229: case 0x17: {
9159 OPC_CheckPredicate, 104, // 16231: check predicate 104
9160 OPC_Decode, 152, 127, 124, // 16233: decode to VFNCVT_RTZ_X_F_W using decoder 124
9161 // 16233: }
9162 25, 6, // 16237: case 0x19: {
9163 OPC_CheckPredicate, 106, // 16239: check predicate 106
9164 OPC_Decode, 146, 127, 124, // 16241: decode to VFNCVT_F_F_Q using decoder 124
9165 // 16241: }
9166 27, 6, // 16245: case 0x1b: {
9167 OPC_CheckPredicate, 106, // 16247: check predicate 106
9168 OPC_Decode, 153, 127, 124, // 16249: decode to VFNCVT_SAT_F_F_Q using decoder 124
9169 // 16249: }
9170 29, 6, // 16253: case 0x1d: {
9171 OPC_CheckPredicate, 105, // 16255: check predicate 105
9172 OPC_Decode, 144, 127, 124, // 16257: decode to VFNCVTBF16_F_F_W using decoder 124
9173 // 16257: }
9174 31, 0, // 16261: case 0x1f: {
9175 OPC_CheckPredicate, 106, // 16263: check predicate 106
9176 OPC_Decode, 145, 127, 124, // 16265: decode to VFNCVTBF16_SAT_F_F_W using decoder 124
9177 // 16265: }
9178 // 16265: } // switch Inst[19:15]
9179 // 16265: }
9180 19, 35, // 16269: case 0x13: {
9181 OPC_SwitchField, 15, 5, // 16271: switch Inst[19:15] {
9182 0, 6, // 16274: case 0x0: {
9183 OPC_CheckPredicate, 104, // 16276: check predicate 104
9184 OPC_Decode, 187, 127, 124, // 16278: decode to VFSQRT_V using decoder 124
9185 // 16278: }
9186 4, 6, // 16282: case 0x4: {
9187 OPC_CheckPredicate, 104, // 16284: check predicate 104
9188 OPC_Decode, 177, 127, 124, // 16286: decode to VFRSQRT7_V using decoder 124
9189 // 16286: }
9190 5, 6, // 16290: case 0x5: {
9191 OPC_CheckPredicate, 104, // 16292: check predicate 104
9192 OPC_Decode, 172, 127, 124, // 16294: decode to VFREC7_V using decoder 124
9193 // 16294: }
9194 16, 0, // 16298: case 0x10: {
9195 OPC_CheckPredicate, 104, // 16300: check predicate 104
9196 OPC_Decode, 243, 126, 124, // 16302: decode to VFCLASS_V using decoder 124
9197 // 16302: }
9198 // 16302: } // switch Inst[19:15]
9199 // 16302: }
9200 20, 10, // 16306: case 0x14: {
9201 OPC_CheckPredicate, 102, // 16308: check predicate 102
9202 OPC_CheckField, 25, 1, 1, // 16310: check Inst[25] == 0x1
9203 OPC_Decode, 134, 127, 120, // 16314: decode to VFMMACC_VV using decoder 120
9204 // 16314: }
9205 21, 19, // 16318: case 0x15: {
9206 OPC_SwitchField, 25, 1, // 16320: switch Inst[25] {
9207 0, 6, // 16323: case 0x0: {
9208 OPC_CheckPredicate, 102, // 16325: check predicate 102
9209 OPC_Decode, 210, 127, 121, // 16327: decode to VFWMMACC_VV_SCALE using decoder 121
9210 // 16327: }
9211 1, 0, // 16331: case 0x1: {
9212 OPC_CheckPredicate, 102, // 16333: check predicate 102
9213 OPC_Decode, 209, 127, 120, // 16335: decode to VFWMMACC_VV using decoder 120
9214 // 16335: }
9215 // 16335: } // switch Inst[25]
9216 // 16335: }
9217 22, 19, // 16339: case 0x16: {
9218 OPC_SwitchField, 25, 1, // 16341: switch Inst[25] {
9219 0, 6, // 16344: case 0x0: {
9220 OPC_CheckPredicate, 102, // 16346: check predicate 102
9221 OPC_Decode, 166, 127, 121, // 16348: decode to VFQMMACC_VV_SCALE using decoder 121
9222 // 16348: }
9223 1, 0, // 16352: case 0x1: {
9224 OPC_CheckPredicate, 102, // 16354: check predicate 102
9225 OPC_Decode, 165, 127, 120, // 16356: decode to VFQMMACC_VV using decoder 120
9226 // 16356: }
9227 // 16356: } // switch Inst[25]
9228 // 16356: }
9229 23, 19, // 16360: case 0x17: {
9230 OPC_SwitchField, 25, 1, // 16362: switch Inst[25] {
9231 0, 6, // 16365: case 0x0: {
9232 OPC_CheckPredicate, 102, // 16367: check predicate 102
9233 OPC_Decode, 239, 126, 121, // 16369: decode to VF8WMMACC_VV_SCALE using decoder 121
9234 // 16369: }
9235 1, 0, // 16373: case 0x1: {
9236 OPC_CheckPredicate, 102, // 16375: check predicate 102
9237 OPC_Decode, 238, 126, 120, // 16377: decode to VF8WMMACC_VV using decoder 120
9238 // 16377: }
9239 // 16377: } // switch Inst[25]
9240 // 16377: }
9241 24, 7, // 16381: case 0x18: {
9242 OPC_CheckPredicate, 104, // 16383: check predicate 104
9243 OPC_Decode, 172, 129, 1, 116, // 16385: decode to VMFEQ_VV using decoder 116
9244 // 16385: }
9245 25, 7, // 16390: case 0x19: {
9246 OPC_CheckPredicate, 104, // 16392: check predicate 104
9247 OPC_Decode, 176, 129, 1, 116, // 16394: decode to VMFLE_VV using decoder 116
9248 // 16394: }
9249 27, 7, // 16399: case 0x1b: {
9250 OPC_CheckPredicate, 104, // 16401: check predicate 104
9251 OPC_Decode, 178, 129, 1, 116, // 16403: decode to VMFLT_VV using decoder 116
9252 // 16403: }
9253 28, 7, // 16408: case 0x1c: {
9254 OPC_CheckPredicate, 104, // 16410: check predicate 104
9255 OPC_Decode, 180, 129, 1, 116, // 16412: decode to VMFNE_VV using decoder 116
9256 // 16412: }
9257 32, 6, // 16417: case 0x20: {
9258 OPC_CheckPredicate, 104, // 16419: check predicate 104
9259 OPC_Decode, 251, 126, 116, // 16421: decode to VFDIV_VV using decoder 116
9260 // 16421: }
9261 36, 6, // 16425: case 0x24: {
9262 OPC_CheckPredicate, 104, // 16427: check predicate 104
9263 OPC_Decode, 140, 127, 116, // 16429: decode to VFMUL_VV using decoder 116
9264 // 16429: }
9265 40, 6, // 16433: case 0x28: {
9266 OPC_CheckPredicate, 104, // 16435: check predicate 104
9267 OPC_Decode, 128, 127, 125, // 16437: decode to VFMADD_VV using decoder 125
9268 // 16437: }
9269 41, 6, // 16441: case 0x29: {
9270 OPC_CheckPredicate, 104, // 16443: check predicate 104
9271 OPC_Decode, 159, 127, 125, // 16445: decode to VFNMADD_VV using decoder 125
9272 // 16445: }
9273 42, 6, // 16449: case 0x2a: {
9274 OPC_CheckPredicate, 104, // 16451: check predicate 104
9275 OPC_Decode, 138, 127, 125, // 16453: decode to VFMSUB_VV using decoder 125
9276 // 16453: }
9277 43, 6, // 16457: case 0x2b: {
9278 OPC_CheckPredicate, 104, // 16459: check predicate 104
9279 OPC_Decode, 163, 127, 125, // 16461: decode to VFNMSUB_VV using decoder 125
9280 // 16461: }
9281 44, 6, // 16465: case 0x2c: {
9282 OPC_CheckPredicate, 104, // 16467: check predicate 104
9283 OPC_Decode, 254, 126, 125, // 16469: decode to VFMACC_VV using decoder 125
9284 // 16469: }
9285 45, 6, // 16473: case 0x2d: {
9286 OPC_CheckPredicate, 104, // 16475: check predicate 104
9287 OPC_Decode, 157, 127, 125, // 16477: decode to VFNMACC_VV using decoder 125
9288 // 16477: }
9289 46, 6, // 16481: case 0x2e: {
9290 OPC_CheckPredicate, 104, // 16483: check predicate 104
9291 OPC_Decode, 136, 127, 125, // 16485: decode to VFMSAC_VV using decoder 125
9292 // 16485: }
9293 47, 6, // 16489: case 0x2f: {
9294 OPC_CheckPredicate, 104, // 16491: check predicate 104
9295 OPC_Decode, 161, 127, 125, // 16493: decode to VFNMSAC_VV using decoder 125
9296 // 16493: }
9297 48, 6, // 16497: case 0x30: {
9298 OPC_CheckPredicate, 104, // 16499: check predicate 104
9299 OPC_Decode, 191, 127, 116, // 16501: decode to VFWADD_VV using decoder 116
9300 // 16501: }
9301 49, 6, // 16505: case 0x31: {
9302 OPC_CheckPredicate, 104, // 16507: check predicate 104
9303 OPC_Decode, 220, 127, 116, // 16509: decode to VFWREDUSUM_VS using decoder 116
9304 // 16509: }
9305 50, 6, // 16513: case 0x32: {
9306 OPC_CheckPredicate, 104, // 16515: check predicate 104
9307 OPC_Decode, 222, 127, 116, // 16517: decode to VFWSUB_VV using decoder 116
9308 // 16517: }
9309 51, 6, // 16521: case 0x33: {
9310 OPC_CheckPredicate, 104, // 16523: check predicate 104
9311 OPC_Decode, 219, 127, 116, // 16525: decode to VFWREDOSUM_VS using decoder 116
9312 // 16525: }
9313 52, 6, // 16529: case 0x34: {
9314 OPC_CheckPredicate, 104, // 16531: check predicate 104
9315 OPC_Decode, 193, 127, 116, // 16533: decode to VFWADD_WV using decoder 116
9316 // 16533: }
9317 54, 6, // 16537: case 0x36: {
9318 OPC_CheckPredicate, 104, // 16539: check predicate 104
9319 OPC_Decode, 224, 127, 116, // 16541: decode to VFWSUB_WV using decoder 116
9320 // 16541: }
9321 56, 6, // 16545: case 0x38: {
9322 OPC_CheckPredicate, 104, // 16547: check predicate 104
9323 OPC_Decode, 214, 127, 116, // 16549: decode to VFWMUL_VV using decoder 116
9324 // 16549: }
9325 59, 6, // 16553: case 0x3b: {
9326 OPC_CheckPredicate, 107, // 16555: check predicate 107
9327 OPC_Decode, 206, 127, 125, // 16557: decode to VFWMACCBF16_VV using decoder 125
9328 // 16557: }
9329 60, 6, // 16561: case 0x3c: {
9330 OPC_CheckPredicate, 104, // 16563: check predicate 104
9331 OPC_Decode, 208, 127, 125, // 16565: decode to VFWMACC_VV using decoder 125
9332 // 16565: }
9333 61, 6, // 16569: case 0x3d: {
9334 OPC_CheckPredicate, 104, // 16571: check predicate 104
9335 OPC_Decode, 216, 127, 125, // 16573: decode to VFWNMACC_VV using decoder 125
9336 // 16573: }
9337 62, 6, // 16577: case 0x3e: {
9338 OPC_CheckPredicate, 104, // 16579: check predicate 104
9339 OPC_Decode, 212, 127, 125, // 16581: decode to VFWMSAC_VV using decoder 125
9340 // 16581: }
9341 63, 0, // 16585: case 0x3f: {
9342 OPC_CheckPredicate, 104, // 16587: check predicate 104
9343 OPC_Decode, 218, 127, 125, // 16589: decode to VFWNMSAC_VV using decoder 125
9344 // 16589: }
9345 // 16589: } // switch Inst[31:26]
9346 // 16589: }
9347 2, 230, 5, // 16593: case 0x2: {
9348 OPC_SwitchField, 26, 6, // 16596: switch Inst[31:26] {
9349 0, 7, // 16599: case 0x0: {
9350 OPC_CheckPredicate, 23, // 16601: check predicate 23
9351 OPC_Decode, 144, 130, 1, 116, // 16603: decode to VREDSUM_VS using decoder 116
9352 // 16603: }
9353 1, 7, // 16608: case 0x1: {
9354 OPC_CheckPredicate, 23, // 16610: check predicate 23
9355 OPC_Decode, 138, 130, 1, 116, // 16612: decode to VREDAND_VS using decoder 116
9356 // 16612: }
9357 2, 7, // 16617: case 0x2: {
9358 OPC_CheckPredicate, 23, // 16619: check predicate 23
9359 OPC_Decode, 143, 130, 1, 116, // 16621: decode to VREDOR_VS using decoder 116
9360 // 16621: }
9361 3, 7, // 16626: case 0x3: {
9362 OPC_CheckPredicate, 23, // 16628: check predicate 23
9363 OPC_Decode, 145, 130, 1, 116, // 16630: decode to VREDXOR_VS using decoder 116
9364 // 16630: }
9365 4, 7, // 16635: case 0x4: {
9366 OPC_CheckPredicate, 23, // 16637: check predicate 23
9367 OPC_Decode, 141, 130, 1, 116, // 16639: decode to VREDMINU_VS using decoder 116
9368 // 16639: }
9369 5, 7, // 16644: case 0x5: {
9370 OPC_CheckPredicate, 23, // 16646: check predicate 23
9371 OPC_Decode, 142, 130, 1, 116, // 16648: decode to VREDMIN_VS using decoder 116
9372 // 16648: }
9373 6, 7, // 16653: case 0x6: {
9374 OPC_CheckPredicate, 23, // 16655: check predicate 23
9375 OPC_Decode, 139, 130, 1, 116, // 16657: decode to VREDMAXU_VS using decoder 116
9376 // 16657: }
9377 7, 7, // 16662: case 0x7: {
9378 OPC_CheckPredicate, 23, // 16664: check predicate 23
9379 OPC_Decode, 140, 130, 1, 116, // 16666: decode to VREDMAX_VS using decoder 116
9380 // 16666: }
9381 8, 6, // 16671: case 0x8: {
9382 OPC_CheckPredicate, 23, // 16673: check predicate 23
9383 OPC_Decode, 181, 126, 116, // 16675: decode to VAADDU_VV using decoder 116
9384 // 16675: }
9385 9, 6, // 16679: case 0x9: {
9386 OPC_CheckPredicate, 23, // 16681: check predicate 23
9387 OPC_Decode, 183, 126, 116, // 16683: decode to VAADD_VV using decoder 116
9388 // 16683: }
9389 10, 6, // 16687: case 0xa: {
9390 OPC_CheckPredicate, 23, // 16689: check predicate 23
9391 OPC_Decode, 211, 126, 116, // 16691: decode to VASUBU_VV using decoder 116
9392 // 16691: }
9393 11, 6, // 16695: case 0xb: {
9394 OPC_CheckPredicate, 23, // 16697: check predicate 23
9395 OPC_Decode, 213, 126, 116, // 16699: decode to VASUB_VV using decoder 116
9396 // 16699: }
9397 12, 6, // 16703: case 0xc: {
9398 OPC_CheckPredicate, 108, // 16705: check predicate 108
9399 OPC_Decode, 219, 126, 116, // 16707: decode to VCLMUL_VV using decoder 116
9400 // 16707: }
9401 13, 6, // 16711: case 0xd: {
9402 OPC_CheckPredicate, 108, // 16713: check predicate 108
9403 OPC_Decode, 217, 126, 116, // 16715: decode to VCLMULH_VV using decoder 116
9404 // 16715: }
9405 15, 7, // 16719: case 0xf: {
9406 OPC_CheckPredicate, 99, // 16721: check predicate 99
9407 OPC_Decode, 132, 130, 1, 116, // 16723: decode to VPAIRO_VV using decoder 116
9408 // 16723: }
9409 16, 32, // 16728: case 0x10: {
9410 OPC_SwitchField, 15, 5, // 16730: switch Inst[19:15] {
9411 0, 11, // 16733: case 0x0: {
9412 OPC_CheckPredicate, 23, // 16735: check predicate 23
9413 OPC_CheckField, 25, 1, 1, // 16737: check Inst[25] == 0x1
9414 OPC_Decode, 237, 129, 1, 126, // 16741: decode to VMV_X_S using decoder 126
9415 // 16741: }
9416 16, 6, // 16746: case 0x10: {
9417 OPC_CheckPredicate, 23, // 16748: check predicate 23
9418 OPC_Decode, 223, 126, 127, // 16750: decode to VCPOP_M using decoder 127
9419 // 16750: }
9420 17, 0, // 16754: case 0x11: {
9421 OPC_CheckPredicate, 23, // 16756: check predicate 23
9422 OPC_Decode, 252, 126, 127, // 16758: decode to VFIRST_M using decoder 127
9423 // 16758: }
9424 // 16758: } // switch Inst[19:15]
9425 // 16758: }
9426 18, 124, // 16762: case 0x12: {
9427 OPC_SwitchField, 15, 5, // 16764: switch Inst[19:15] {
9428 2, 7, // 16767: case 0x2: {
9429 OPC_CheckPredicate, 23, // 16769: check predicate 23
9430 OPC_Decode, 136, 132, 1, 124, // 16771: decode to VZEXT_VF8 using decoder 124
9431 // 16771: }
9432 3, 7, // 16776: case 0x3: {
9433 OPC_CheckPredicate, 23, // 16778: check predicate 23
9434 OPC_Decode, 183, 130, 1, 124, // 16780: decode to VSEXT_VF8 using decoder 124
9435 // 16780: }
9436 4, 7, // 16785: case 0x4: {
9437 OPC_CheckPredicate, 23, // 16787: check predicate 23
9438 OPC_Decode, 135, 132, 1, 124, // 16789: decode to VZEXT_VF4 using decoder 124
9439 // 16789: }
9440 5, 7, // 16794: case 0x5: {
9441 OPC_CheckPredicate, 23, // 16796: check predicate 23
9442 OPC_Decode, 182, 130, 1, 124, // 16798: decode to VSEXT_VF4 using decoder 124
9443 // 16798: }
9444 6, 7, // 16803: case 0x6: {
9445 OPC_CheckPredicate, 23, // 16805: check predicate 23
9446 OPC_Decode, 134, 132, 1, 124, // 16807: decode to VZEXT_VF2 using decoder 124
9447 // 16807: }
9448 7, 7, // 16812: case 0x7: {
9449 OPC_CheckPredicate, 23, // 16814: check predicate 23
9450 OPC_Decode, 181, 130, 1, 124, // 16816: decode to VSEXT_VF2 using decoder 124
9451 // 16816: }
9452 8, 6, // 16821: case 0x8: {
9453 OPC_CheckPredicate, 98, // 16823: check predicate 98
9454 OPC_Decode, 215, 126, 124, // 16825: decode to VBREV8_V using decoder 124
9455 // 16825: }
9456 9, 7, // 16829: case 0x9: {
9457 OPC_CheckPredicate, 98, // 16831: check predicate 98
9458 OPC_Decode, 150, 130, 1, 124, // 16833: decode to VREV8_V using decoder 124
9459 // 16833: }
9460 10, 6, // 16838: case 0xa: {
9461 OPC_CheckPredicate, 100, // 16840: check predicate 100
9462 OPC_Decode, 216, 126, 124, // 16842: decode to VBREV_V using decoder 124
9463 // 16842: }
9464 11, 7, // 16846: case 0xb: {
9465 OPC_CheckPredicate, 99, // 16848: check predicate 99
9466 OPC_Decode, 218, 131, 1, 124, // 16850: decode to VUNZIPE_V using decoder 124
9467 // 16850: }
9468 12, 6, // 16855: case 0xc: {
9469 OPC_CheckPredicate, 100, // 16857: check predicate 100
9470 OPC_Decode, 221, 126, 124, // 16859: decode to VCLZ_V using decoder 124
9471 // 16859: }
9472 13, 6, // 16863: case 0xd: {
9473 OPC_CheckPredicate, 100, // 16865: check predicate 100
9474 OPC_Decode, 225, 126, 124, // 16867: decode to VCTZ_V using decoder 124
9475 // 16867: }
9476 14, 6, // 16871: case 0xe: {
9477 OPC_CheckPredicate, 100, // 16873: check predicate 100
9478 OPC_Decode, 224, 126, 124, // 16875: decode to VCPOP_V using decoder 124
9479 // 16875: }
9480 15, 0, // 16879: case 0xf: {
9481 OPC_CheckPredicate, 99, // 16881: check predicate 99
9482 OPC_Decode, 219, 131, 1, 124, // 16883: decode to VUNZIPO_V using decoder 124
9483 // 16883: }
9484 // 16883: } // switch Inst[19:15]
9485 // 16883: }
9486 20, 51, // 16888: case 0x14: {
9487 OPC_SwitchField, 15, 5, // 16890: switch Inst[19:15] {
9488 1, 7, // 16893: case 0x1: {
9489 OPC_CheckPredicate, 23, // 16895: check predicate 23
9490 OPC_Decode, 194, 129, 1, 124, // 16897: decode to VMSBF_M using decoder 124
9491 // 16897: }
9492 2, 7, // 16902: case 0x2: {
9493 OPC_CheckPredicate, 23, // 16904: check predicate 23
9494 OPC_Decode, 216, 129, 1, 124, // 16906: decode to VMSOF_M using decoder 124
9495 // 16906: }
9496 3, 7, // 16911: case 0x3: {
9497 OPC_CheckPredicate, 23, // 16913: check predicate 23
9498 OPC_Decode, 202, 129, 1, 124, // 16915: decode to VMSIF_M using decoder 124
9499 // 16915: }
9500 16, 6, // 16920: case 0x10: {
9501 OPC_CheckPredicate, 23, // 16922: check predicate 23
9502 OPC_Decode, 230, 127, 124, // 16924: decode to VIOTA_M using decoder 124
9503 // 16924: }
9504 17, 0, // 16928: case 0x11: {
9505 OPC_CheckPredicate, 23, // 16930: check predicate 23
9506 OPC_CheckField, 20, 5, 0, // 16932: check Inst[24:20] == 0x0
9507 OPC_Decode, 229, 127, 128, 1, // 16936: decode to VID_V using decoder 128
9508 // 16936: }
9509 // 16936: } // switch Inst[19:15]
9510 // 16936: }
9511 21, 6, // 16941: case 0x15: {
9512 OPC_CheckPredicate, 103, // 16943: check predicate 103
9513 OPC_Decode, 187, 126, 116, // 16945: decode to VABD_VV using decoder 116
9514 // 16945: }
9515 22, 6, // 16949: case 0x16: {
9516 OPC_CheckPredicate, 103, // 16951: check predicate 103
9517 OPC_Decode, 185, 126, 116, // 16953: decode to VABDU_VV using decoder 116
9518 // 16953: }
9519 23, 10, // 16957: case 0x17: {
9520 OPC_CheckPredicate, 23, // 16959: check predicate 23
9521 OPC_CheckField, 25, 1, 1, // 16961: check Inst[25] == 0x1
9522 OPC_Decode, 222, 126, 118, // 16965: decode to VCOMPRESS_VM using decoder 118
9523 // 16965: }
9524 24, 11, // 16969: case 0x18: {
9525 OPC_CheckPredicate, 23, // 16971: check predicate 23
9526 OPC_CheckField, 25, 1, 1, // 16973: check Inst[25] == 0x1
9527 OPC_Decode, 162, 129, 1, 118, // 16977: decode to VMANDN_MM using decoder 118
9528 // 16977: }
9529 25, 11, // 16982: case 0x19: {
9530 OPC_CheckPredicate, 23, // 16984: check predicate 23
9531 OPC_CheckField, 25, 1, 1, // 16986: check Inst[25] == 0x1
9532 OPC_Decode, 163, 129, 1, 118, // 16990: decode to VMAND_MM using decoder 118
9533 // 16990: }
9534 26, 11, // 16995: case 0x1a: {
9535 OPC_CheckPredicate, 23, // 16997: check predicate 23
9536 OPC_CheckField, 25, 1, 1, // 16999: check Inst[25] == 0x1
9537 OPC_Decode, 189, 129, 1, 118, // 17003: decode to VMOR_MM using decoder 118
9538 // 17003: }
9539 27, 11, // 17008: case 0x1b: {
9540 OPC_CheckPredicate, 23, // 17010: check predicate 23
9541 OPC_CheckField, 25, 1, 1, // 17012: check Inst[25] == 0x1
9542 OPC_Decode, 239, 129, 1, 118, // 17016: decode to VMXOR_MM using decoder 118
9543 // 17016: }
9544 28, 11, // 17021: case 0x1c: {
9545 OPC_CheckPredicate, 23, // 17023: check predicate 23
9546 OPC_CheckField, 25, 1, 1, // 17025: check Inst[25] == 0x1
9547 OPC_Decode, 188, 129, 1, 118, // 17029: decode to VMORN_MM using decoder 118
9548 // 17029: }
9549 29, 11, // 17034: case 0x1d: {
9550 OPC_CheckPredicate, 23, // 17036: check predicate 23
9551 OPC_CheckField, 25, 1, 1, // 17038: check Inst[25] == 0x1
9552 OPC_Decode, 186, 129, 1, 118, // 17042: decode to VMNAND_MM using decoder 118
9553 // 17042: }
9554 30, 11, // 17047: case 0x1e: {
9555 OPC_CheckPredicate, 23, // 17049: check predicate 23
9556 OPC_CheckField, 25, 1, 1, // 17051: check Inst[25] == 0x1
9557 OPC_Decode, 187, 129, 1, 118, // 17055: decode to VMNOR_MM using decoder 118
9558 // 17055: }
9559 31, 11, // 17060: case 0x1f: {
9560 OPC_CheckPredicate, 23, // 17062: check predicate 23
9561 OPC_CheckField, 25, 1, 1, // 17064: check Inst[25] == 0x1
9562 OPC_Decode, 238, 129, 1, 118, // 17068: decode to VMXNOR_MM using decoder 118
9563 // 17068: }
9564 32, 6, // 17073: case 0x20: {
9565 OPC_CheckPredicate, 23, // 17075: check predicate 23
9566 OPC_Decode, 226, 126, 116, // 17077: decode to VDIVU_VV using decoder 116
9567 // 17077: }
9568 33, 6, // 17081: case 0x21: {
9569 OPC_CheckPredicate, 23, // 17083: check predicate 23
9570 OPC_Decode, 228, 126, 116, // 17085: decode to VDIV_VV using decoder 116
9571 // 17085: }
9572 34, 7, // 17089: case 0x22: {
9573 OPC_CheckPredicate, 23, // 17091: check predicate 23
9574 OPC_Decode, 146, 130, 1, 116, // 17093: decode to VREMU_VV using decoder 116
9575 // 17093: }
9576 35, 7, // 17098: case 0x23: {
9577 OPC_CheckPredicate, 23, // 17100: check predicate 23
9578 OPC_Decode, 148, 130, 1, 116, // 17102: decode to VREM_VV using decoder 116
9579 // 17102: }
9580 36, 7, // 17107: case 0x24: {
9581 OPC_CheckPredicate, 23, // 17109: check predicate 23
9582 OPC_Decode, 223, 129, 1, 116, // 17111: decode to VMULHU_VV using decoder 116
9583 // 17111: }
9584 37, 7, // 17116: case 0x25: {
9585 OPC_CheckPredicate, 23, // 17118: check predicate 23
9586 OPC_Decode, 227, 129, 1, 116, // 17120: decode to VMUL_VV using decoder 116
9587 // 17120: }
9588 38, 7, // 17125: case 0x26: {
9589 OPC_CheckPredicate, 23, // 17127: check predicate 23
9590 OPC_Decode, 221, 129, 1, 116, // 17129: decode to VMULHSU_VV using decoder 116
9591 // 17129: }
9592 39, 7, // 17134: case 0x27: {
9593 OPC_CheckPredicate, 23, // 17136: check predicate 23
9594 OPC_Decode, 225, 129, 1, 116, // 17138: decode to VMULH_VV using decoder 116
9595 // 17138: }
9596 40, 6, // 17143: case 0x28: {
9597 OPC_CheckPredicate, 109, // 17145: check predicate 109
9598 OPC_Decode, 233, 126, 122, // 17147: decode to VDOT4AU_VV using decoder 122
9599 // 17147: }
9600 41, 7, // 17151: case 0x29: {
9601 OPC_CheckPredicate, 23, // 17153: check predicate 23
9602 OPC_Decode, 160, 129, 1, 125, // 17155: decode to VMADD_VV using decoder 125
9603 // 17155: }
9604 42, 6, // 17160: case 0x2a: {
9605 OPC_CheckPredicate, 109, // 17162: check predicate 109
9606 OPC_Decode, 230, 126, 122, // 17164: decode to VDOT4ASU_VV using decoder 122
9607 // 17164: }
9608 43, 7, // 17168: case 0x2b: {
9609 OPC_CheckPredicate, 23, // 17170: check predicate 23
9610 OPC_Decode, 248, 129, 1, 125, // 17172: decode to VNMSUB_VV using decoder 125
9611 // 17172: }
9612 44, 6, // 17177: case 0x2c: {
9613 OPC_CheckPredicate, 109, // 17179: check predicate 109
9614 OPC_Decode, 235, 126, 122, // 17181: decode to VDOT4A_VV using decoder 122
9615 // 17181: }
9616 45, 7, // 17185: case 0x2d: {
9617 OPC_CheckPredicate, 23, // 17187: check predicate 23
9618 OPC_Decode, 152, 129, 1, 125, // 17189: decode to VMACC_VV using decoder 125
9619 // 17189: }
9620 47, 7, // 17194: case 0x2f: {
9621 OPC_CheckPredicate, 23, // 17196: check predicate 23
9622 OPC_Decode, 246, 129, 1, 125, // 17198: decode to VNMSAC_VV using decoder 125
9623 // 17198: }
9624 48, 7, // 17203: case 0x30: {
9625 OPC_CheckPredicate, 23, // 17205: check predicate 23
9626 OPC_Decode, 224, 131, 1, 116, // 17207: decode to VWADDU_VV using decoder 116
9627 // 17207: }
9628 49, 7, // 17212: case 0x31: {
9629 OPC_CheckPredicate, 23, // 17214: check predicate 23
9630 OPC_Decode, 228, 131, 1, 116, // 17216: decode to VWADD_VV using decoder 116
9631 // 17216: }
9632 50, 7, // 17221: case 0x32: {
9633 OPC_CheckPredicate, 23, // 17223: check predicate 23
9634 OPC_Decode, 251, 131, 1, 116, // 17225: decode to VWSUBU_VV using decoder 116
9635 // 17225: }
9636 51, 7, // 17230: case 0x33: {
9637 OPC_CheckPredicate, 23, // 17232: check predicate 23
9638 OPC_Decode, 255, 131, 1, 116, // 17234: decode to VWSUB_VV using decoder 116
9639 // 17234: }
9640 52, 7, // 17239: case 0x34: {
9641 OPC_CheckPredicate, 23, // 17241: check predicate 23
9642 OPC_Decode, 226, 131, 1, 116, // 17243: decode to VWADDU_WV using decoder 116
9643 // 17243: }
9644 53, 7, // 17248: case 0x35: {
9645 OPC_CheckPredicate, 23, // 17250: check predicate 23
9646 OPC_Decode, 230, 131, 1, 116, // 17252: decode to VWADD_WV using decoder 116
9647 // 17252: }
9648 54, 7, // 17257: case 0x36: {
9649 OPC_CheckPredicate, 23, // 17259: check predicate 23
9650 OPC_Decode, 253, 131, 1, 116, // 17261: decode to VWSUBU_WV using decoder 116
9651 // 17261: }
9652 55, 7, // 17266: case 0x37: {
9653 OPC_CheckPredicate, 23, // 17268: check predicate 23
9654 OPC_Decode, 129, 132, 1, 116, // 17270: decode to VWSUB_WV using decoder 116
9655 // 17270: }
9656 56, 7, // 17275: case 0x38: {
9657 OPC_CheckPredicate, 23, // 17277: check predicate 23
9658 OPC_Decode, 242, 131, 1, 116, // 17279: decode to VWMULU_VV using decoder 116
9659 // 17279: }
9660 58, 7, // 17284: case 0x3a: {
9661 OPC_CheckPredicate, 23, // 17286: check predicate 23
9662 OPC_Decode, 240, 131, 1, 116, // 17288: decode to VWMULSU_VV using decoder 116
9663 // 17288: }
9664 59, 7, // 17293: case 0x3b: {
9665 OPC_CheckPredicate, 23, // 17295: check predicate 23
9666 OPC_Decode, 244, 131, 1, 116, // 17297: decode to VWMUL_VV using decoder 116
9667 // 17297: }
9668 60, 7, // 17302: case 0x3c: {
9669 OPC_CheckPredicate, 23, // 17304: check predicate 23
9670 OPC_Decode, 235, 131, 1, 125, // 17306: decode to VWMACCU_VV using decoder 125
9671 // 17306: }
9672 61, 7, // 17311: case 0x3d: {
9673 OPC_CheckPredicate, 23, // 17313: check predicate 23
9674 OPC_Decode, 237, 131, 1, 125, // 17315: decode to VWMACC_VV using decoder 125
9675 // 17315: }
9676 62, 7, // 17320: case 0x3e: {
9677 OPC_CheckPredicate, 99, // 17322: check predicate 99
9678 OPC_Decode, 137, 132, 1, 116, // 17324: decode to VZIP_VV using decoder 116
9679 // 17324: }
9680 63, 0, // 17329: case 0x3f: {
9681 OPC_CheckPredicate, 23, // 17331: check predicate 23
9682 OPC_Decode, 232, 131, 1, 125, // 17333: decode to VWMACCSU_VV using decoder 125
9683 // 17333: }
9684 // 17333: } // switch Inst[31:26]
9685 // 17333: }
9686 3, 213, 3, // 17338: case 0x3: {
9687 OPC_SwitchField, 27, 5, // 17341: switch Inst[31:27] {
9688 0, 11, // 17344: case 0x0: {
9689 OPC_CheckPredicate, 23, // 17346: check predicate 23
9690 OPC_CheckField, 26, 1, 0, // 17348: check Inst[26] == 0x0
9691 OPC_Decode, 192, 126, 129, 1, // 17352: decode to VADD_VI using decoder 129
9692 // 17352: }
9693 1, 12, // 17357: case 0x1: {
9694 OPC_CheckPredicate, 23, // 17359: check predicate 23
9695 OPC_CheckField, 26, 1, 1, // 17361: check Inst[26] == 0x1
9696 OPC_Decode, 160, 130, 1, 129, 1, // 17365: decode to VRSUB_VI using decoder 129
9697 // 17365: }
9698 4, 11, // 17371: case 0x4: {
9699 OPC_CheckPredicate, 23, // 17373: check predicate 23
9700 OPC_CheckField, 26, 1, 1, // 17375: check Inst[26] == 0x1
9701 OPC_Decode, 208, 126, 129, 1, // 17379: decode to VAND_VI using decoder 129
9702 // 17379: }
9703 5, 23, // 17384: case 0x5: {
9704 OPC_SwitchField, 26, 1, // 17386: switch Inst[26] {
9705 0, 8, // 17389: case 0x0: {
9706 OPC_CheckPredicate, 23, // 17391: check predicate 23
9707 OPC_Decode, 128, 130, 1, 129, 1, // 17393: decode to VOR_VI using decoder 129
9708 // 17393: }
9709 1, 0, // 17399: case 0x1: {
9710 OPC_CheckPredicate, 23, // 17401: check predicate 23
9711 OPC_Decode, 131, 132, 1, 129, 1, // 17403: decode to VXOR_VI using decoder 129
9712 // 17403: }
9713 // 17403: } // switch Inst[26]
9714 // 17403: }
9715 6, 12, // 17409: case 0x6: {
9716 OPC_CheckPredicate, 23, // 17411: check predicate 23
9717 OPC_CheckField, 26, 1, 0, // 17413: check Inst[26] == 0x0
9718 OPC_Decode, 152, 130, 1, 130, 1, // 17417: decode to VRGATHER_VI using decoder 130
9719 // 17417: }
9720 7, 23, // 17423: case 0x7: {
9721 OPC_SwitchField, 26, 1, // 17425: switch Inst[26] {
9722 0, 8, // 17428: case 0x0: {
9723 OPC_CheckPredicate, 23, // 17430: check predicate 23
9724 OPC_Decode, 191, 130, 1, 130, 1, // 17432: decode to VSLIDEUP_VI using decoder 130
9725 // 17432: }
9726 1, 0, // 17438: case 0x1: {
9727 OPC_CheckPredicate, 23, // 17440: check predicate 23
9728 OPC_Decode, 189, 130, 1, 130, 1, // 17442: decode to VSLIDEDOWN_VI using decoder 130
9729 // 17442: }
9730 // 17442: } // switch Inst[26]
9731 // 17442: }
9732 8, 32, // 17448: case 0x8: {
9733 OPC_SwitchField, 25, 2, // 17450: switch Inst[26:25] {
9734 0, 7, // 17453: case 0x0: {
9735 OPC_CheckPredicate, 23, // 17455: check predicate 23
9736 OPC_Decode, 189, 126, 131, 1, // 17457: decode to VADC_VIM using decoder 131
9737 // 17457: }
9738 2, 8, // 17462: case 0x2: {
9739 OPC_CheckPredicate, 23, // 17464: check predicate 23
9740 OPC_Decode, 155, 129, 1, 131, 1, // 17466: decode to VMADC_VIM using decoder 131
9741 // 17466: }
9742 3, 0, // 17472: case 0x3: {
9743 OPC_CheckPredicate, 23, // 17474: check predicate 23
9744 OPC_Decode, 154, 129, 1, 132, 1, // 17476: decode to VMADC_VI using decoder 132
9745 // 17476: }
9746 // 17476: } // switch Inst[26:25]
9747 // 17476: }
9748 10, 8, // 17482: case 0xa: {
9749 OPC_CheckPredicate, 98, // 17484: check predicate 98
9750 OPC_Decode, 157, 130, 1, 133, 1, // 17486: decode to VROR_VI using decoder 133
9751 // 17486: }
9752 11, 27, // 17492: case 0xb: {
9753 OPC_SwitchField, 25, 2, // 17494: switch Inst[26:25] {
9754 2, 8, // 17497: case 0x2: {
9755 OPC_CheckPredicate, 23, // 17499: check predicate 23
9756 OPC_Decode, 168, 129, 1, 131, 1, // 17501: decode to VMERGE_VIM using decoder 131
9757 // 17501: }
9758 3, 0, // 17507: case 0x3: {
9759 OPC_CheckPredicate, 23, // 17509: check predicate 23
9760 OPC_CheckField, 20, 5, 0, // 17511: check Inst[24:20] == 0x0
9761 OPC_Decode, 234, 129, 1, 134, 1, // 17515: decode to VMV_V_I using decoder 134
9762 // 17515: }
9763 // 17515: } // switch Inst[26:25]
9764 // 17515: }
9765 12, 23, // 17521: case 0xc: {
9766 OPC_SwitchField, 26, 1, // 17523: switch Inst[26] {
9767 0, 8, // 17526: case 0x0: {
9768 OPC_CheckPredicate, 23, // 17528: check predicate 23
9769 OPC_Decode, 195, 129, 1, 129, 1, // 17530: decode to VMSEQ_VI using decoder 129
9770 // 17530: }
9771 1, 0, // 17536: case 0x1: {
9772 OPC_CheckPredicate, 23, // 17538: check predicate 23
9773 OPC_Decode, 213, 129, 1, 129, 1, // 17540: decode to VMSNE_VI using decoder 129
9774 // 17540: }
9775 // 17540: } // switch Inst[26]
9776 // 17540: }
9777 14, 23, // 17546: case 0xe: {
9778 OPC_SwitchField, 26, 1, // 17548: switch Inst[26] {
9779 0, 8, // 17551: case 0x0: {
9780 OPC_CheckPredicate, 23, // 17553: check predicate 23
9781 OPC_Decode, 203, 129, 1, 129, 1, // 17555: decode to VMSLEU_VI using decoder 129
9782 // 17555: }
9783 1, 0, // 17561: case 0x1: {
9784 OPC_CheckPredicate, 23, // 17563: check predicate 23
9785 OPC_Decode, 206, 129, 1, 129, 1, // 17565: decode to VMSLE_VI using decoder 129
9786 // 17565: }
9787 // 17565: } // switch Inst[26]
9788 // 17565: }
9789 15, 23, // 17571: case 0xf: {
9790 OPC_SwitchField, 26, 1, // 17573: switch Inst[26] {
9791 0, 8, // 17576: case 0x0: {
9792 OPC_CheckPredicate, 23, // 17578: check predicate 23
9793 OPC_Decode, 198, 129, 1, 129, 1, // 17580: decode to VMSGTU_VI using decoder 129
9794 // 17580: }
9795 1, 0, // 17586: case 0x1: {
9796 OPC_CheckPredicate, 23, // 17588: check predicate 23
9797 OPC_Decode, 200, 129, 1, 129, 1, // 17590: decode to VMSGT_VI using decoder 129
9798 // 17590: }
9799 // 17590: } // switch Inst[26]
9800 // 17590: }
9801 16, 23, // 17596: case 0x10: {
9802 OPC_SwitchField, 26, 1, // 17598: switch Inst[26] {
9803 0, 8, // 17601: case 0x0: {
9804 OPC_CheckPredicate, 23, // 17603: check predicate 23
9805 OPC_Decode, 166, 130, 1, 129, 1, // 17605: decode to VSADDU_VI using decoder 129
9806 // 17605: }
9807 1, 0, // 17611: case 0x1: {
9808 OPC_CheckPredicate, 23, // 17613: check predicate 23
9809 OPC_Decode, 169, 130, 1, 129, 1, // 17615: decode to VSADD_VI using decoder 129
9810 // 17615: }
9811 // 17615: } // switch Inst[26]
9812 // 17615: }
9813 18, 12, // 17621: case 0x12: {
9814 OPC_CheckPredicate, 23, // 17623: check predicate 23
9815 OPC_CheckField, 26, 1, 1, // 17625: check Inst[26] == 0x1
9816 OPC_Decode, 193, 130, 1, 130, 1, // 17629: decode to VSLL_VI using decoder 130
9817 // 17629: }
9818 19, 59, // 17635: case 0x13: {
9819 OPC_SwitchField, 15, 5, // 17637: switch Inst[19:15] {
9820 0, 12, // 17640: case 0x0: {
9821 OPC_CheckPredicate, 23, // 17642: check predicate 23
9822 OPC_CheckField, 25, 2, 3, // 17644: check Inst[26:25] == 0x3
9823 OPC_Decode, 229, 129, 1, 135, 1, // 17648: decode to VMV1R_V using decoder 135
9824 // 17648: }
9825 1, 12, // 17654: case 0x1: {
9826 OPC_CheckPredicate, 23, // 17656: check predicate 23
9827 OPC_CheckField, 25, 2, 3, // 17658: check Inst[26:25] == 0x3
9828 OPC_Decode, 230, 129, 1, 136, 1, // 17662: decode to VMV2R_V using decoder 136
9829 // 17662: }
9830 3, 12, // 17668: case 0x3: {
9831 OPC_CheckPredicate, 23, // 17670: check predicate 23
9832 OPC_CheckField, 25, 2, 3, // 17672: check Inst[26:25] == 0x3
9833 OPC_Decode, 231, 129, 1, 137, 1, // 17676: decode to VMV4R_V using decoder 137
9834 // 17676: }
9835 7, 0, // 17682: case 0x7: {
9836 OPC_CheckPredicate, 23, // 17684: check predicate 23
9837 OPC_CheckField, 25, 2, 3, // 17686: check Inst[26:25] == 0x3
9838 OPC_Decode, 232, 129, 1, 138, 1, // 17690: decode to VMV8R_V using decoder 138
9839 // 17690: }
9840 // 17690: } // switch Inst[19:15]
9841 // 17690: }
9842 20, 23, // 17696: case 0x14: {
9843 OPC_SwitchField, 26, 1, // 17698: switch Inst[26] {
9844 0, 8, // 17701: case 0x0: {
9845 OPC_CheckPredicate, 23, // 17703: check predicate 23
9846 OPC_Decode, 239, 130, 1, 130, 1, // 17705: decode to VSRL_VI using decoder 130
9847 // 17705: }
9848 1, 0, // 17711: case 0x1: {
9849 OPC_CheckPredicate, 23, // 17713: check predicate 23
9850 OPC_Decode, 236, 130, 1, 130, 1, // 17715: decode to VSRA_VI using decoder 130
9851 // 17715: }
9852 // 17715: } // switch Inst[26]
9853 // 17715: }
9854 21, 23, // 17721: case 0x15: {
9855 OPC_SwitchField, 26, 1, // 17723: switch Inst[26] {
9856 0, 8, // 17726: case 0x0: {
9857 OPC_CheckPredicate, 23, // 17728: check predicate 23
9858 OPC_Decode, 149, 131, 1, 130, 1, // 17730: decode to VSSRL_VI using decoder 130
9859 // 17730: }
9860 1, 0, // 17736: case 0x1: {
9861 OPC_CheckPredicate, 23, // 17738: check predicate 23
9862 OPC_Decode, 146, 131, 1, 130, 1, // 17740: decode to VSSRA_VI using decoder 130
9863 // 17740: }
9864 // 17740: } // switch Inst[26]
9865 // 17740: }
9866 22, 23, // 17746: case 0x16: {
9867 OPC_SwitchField, 26, 1, // 17748: switch Inst[26] {
9868 0, 8, // 17751: case 0x0: {
9869 OPC_CheckPredicate, 23, // 17753: check predicate 23
9870 OPC_Decode, 253, 129, 1, 130, 1, // 17755: decode to VNSRL_WI using decoder 130
9871 // 17755: }
9872 1, 0, // 17761: case 0x1: {
9873 OPC_CheckPredicate, 23, // 17763: check predicate 23
9874 OPC_Decode, 250, 129, 1, 130, 1, // 17765: decode to VNSRA_WI using decoder 130
9875 // 17765: }
9876 // 17765: } // switch Inst[26]
9877 // 17765: }
9878 23, 23, // 17771: case 0x17: {
9879 OPC_SwitchField, 26, 1, // 17773: switch Inst[26] {
9880 0, 8, // 17776: case 0x0: {
9881 OPC_CheckPredicate, 23, // 17778: check predicate 23
9882 OPC_Decode, 240, 129, 1, 130, 1, // 17780: decode to VNCLIPU_WI using decoder 130
9883 // 17780: }
9884 1, 0, // 17786: case 0x1: {
9885 OPC_CheckPredicate, 23, // 17788: check predicate 23
9886 OPC_Decode, 243, 129, 1, 130, 1, // 17790: decode to VNCLIP_WI using decoder 130
9887 // 17790: }
9888 // 17790: } // switch Inst[26]
9889 // 17790: }
9890 26, 0, // 17796: case 0x1a: {
9891 OPC_CheckPredicate, 100, // 17798: check predicate 100
9892 OPC_CheckField, 26, 1, 1, // 17800: check Inst[26] == 0x1
9893 OPC_Decode, 248, 131, 1, 130, 1, // 17804: decode to VWSLL_VI using decoder 130
9894 // 17804: }
9895 // 17804: } // switch Inst[31:27]
9896 // 17804: }
9897 4, 131, 4, // 17810: case 0x4: {
9898 OPC_SwitchField, 26, 6, // 17813: switch Inst[31:26] {
9899 0, 7, // 17816: case 0x0: {
9900 OPC_CheckPredicate, 23, // 17818: check predicate 23
9901 OPC_Decode, 194, 126, 139, 1, // 17820: decode to VADD_VX using decoder 139
9902 // 17820: }
9903 1, 7, // 17825: case 0x1: {
9904 OPC_CheckPredicate, 98, // 17827: check predicate 98
9905 OPC_Decode, 207, 126, 139, 1, // 17829: decode to VANDN_VX using decoder 139
9906 // 17829: }
9907 2, 8, // 17834: case 0x2: {
9908 OPC_CheckPredicate, 23, // 17836: check predicate 23
9909 OPC_Decode, 185, 131, 1, 139, 1, // 17838: decode to VSUB_VX using decoder 139
9910 // 17838: }
9911 3, 8, // 17844: case 0x3: {
9912 OPC_CheckPredicate, 23, // 17846: check predicate 23
9913 OPC_Decode, 161, 130, 1, 139, 1, // 17848: decode to VRSUB_VX using decoder 139
9914 // 17848: }
9915 4, 8, // 17854: case 0x4: {
9916 OPC_CheckPredicate, 23, // 17856: check predicate 23
9917 OPC_Decode, 182, 129, 1, 139, 1, // 17858: decode to VMINU_VX using decoder 139
9918 // 17858: }
9919 5, 8, // 17864: case 0x5: {
9920 OPC_CheckPredicate, 23, // 17866: check predicate 23
9921 OPC_Decode, 184, 129, 1, 139, 1, // 17868: decode to VMIN_VX using decoder 139
9922 // 17868: }
9923 6, 8, // 17874: case 0x6: {
9924 OPC_CheckPredicate, 23, // 17876: check predicate 23
9925 OPC_Decode, 165, 129, 1, 139, 1, // 17878: decode to VMAXU_VX using decoder 139
9926 // 17878: }
9927 7, 8, // 17884: case 0x7: {
9928 OPC_CheckPredicate, 23, // 17886: check predicate 23
9929 OPC_Decode, 167, 129, 1, 139, 1, // 17888: decode to VMAX_VX using decoder 139
9930 // 17888: }
9931 9, 7, // 17894: case 0x9: {
9932 OPC_CheckPredicate, 23, // 17896: check predicate 23
9933 OPC_Decode, 210, 126, 139, 1, // 17898: decode to VAND_VX using decoder 139
9934 // 17898: }
9935 10, 8, // 17903: case 0xa: {
9936 OPC_CheckPredicate, 23, // 17905: check predicate 23
9937 OPC_Decode, 130, 130, 1, 139, 1, // 17907: decode to VOR_VX using decoder 139
9938 // 17907: }
9939 11, 8, // 17913: case 0xb: {
9940 OPC_CheckPredicate, 23, // 17915: check predicate 23
9941 OPC_Decode, 133, 132, 1, 139, 1, // 17917: decode to VXOR_VX using decoder 139
9942 // 17917: }
9943 12, 8, // 17923: case 0xc: {
9944 OPC_CheckPredicate, 23, // 17925: check predicate 23
9945 OPC_Decode, 154, 130, 1, 139, 1, // 17927: decode to VRGATHER_VX using decoder 139
9946 // 17927: }
9947 14, 8, // 17933: case 0xe: {
9948 OPC_CheckPredicate, 23, // 17935: check predicate 23
9949 OPC_Decode, 192, 130, 1, 139, 1, // 17937: decode to VSLIDEUP_VX using decoder 139
9950 // 17937: }
9951 15, 8, // 17943: case 0xf: {
9952 OPC_CheckPredicate, 23, // 17945: check predicate 23
9953 OPC_Decode, 190, 130, 1, 139, 1, // 17947: decode to VSLIDEDOWN_VX using decoder 139
9954 // 17947: }
9955 16, 11, // 17953: case 0x10: {
9956 OPC_CheckPredicate, 23, // 17955: check predicate 23
9957 OPC_CheckField, 25, 1, 0, // 17957: check Inst[25] == 0x0
9958 OPC_Decode, 191, 126, 140, 1, // 17961: decode to VADC_VXM using decoder 140
9959 // 17961: }
9960 17, 23, // 17966: case 0x11: {
9961 OPC_SwitchField, 25, 1, // 17968: switch Inst[25] {
9962 0, 8, // 17971: case 0x0: {
9963 OPC_CheckPredicate, 23, // 17973: check predicate 23
9964 OPC_Decode, 159, 129, 1, 140, 1, // 17975: decode to VMADC_VXM using decoder 140
9965 // 17975: }
9966 1, 0, // 17981: case 0x1: {
9967 OPC_CheckPredicate, 23, // 17983: check predicate 23
9968 OPC_Decode, 158, 129, 1, 141, 1, // 17985: decode to VMADC_VX using decoder 141
9969 // 17985: }
9970 // 17985: } // switch Inst[25]
9971 // 17985: }
9972 18, 12, // 17991: case 0x12: {
9973 OPC_CheckPredicate, 23, // 17993: check predicate 23
9974 OPC_CheckField, 25, 1, 0, // 17995: check Inst[25] == 0x0
9975 OPC_Decode, 173, 130, 1, 140, 1, // 17999: decode to VSBC_VXM using decoder 140
9976 // 17999: }
9977 19, 23, // 18005: case 0x13: {
9978 OPC_SwitchField, 25, 1, // 18007: switch Inst[25] {
9979 0, 8, // 18010: case 0x0: {
9980 OPC_CheckPredicate, 23, // 18012: check predicate 23
9981 OPC_Decode, 193, 129, 1, 140, 1, // 18014: decode to VMSBC_VXM using decoder 140
9982 // 18014: }
9983 1, 0, // 18020: case 0x1: {
9984 OPC_CheckPredicate, 23, // 18022: check predicate 23
9985 OPC_Decode, 192, 129, 1, 141, 1, // 18024: decode to VMSBC_VX using decoder 141
9986 // 18024: }
9987 // 18024: } // switch Inst[25]
9988 // 18024: }
9989 20, 8, // 18030: case 0x14: {
9990 OPC_CheckPredicate, 98, // 18032: check predicate 98
9991 OPC_Decode, 159, 130, 1, 139, 1, // 18034: decode to VROR_VX using decoder 139
9992 // 18034: }
9993 21, 8, // 18040: case 0x15: {
9994 OPC_CheckPredicate, 98, // 18042: check predicate 98
9995 OPC_Decode, 156, 130, 1, 139, 1, // 18044: decode to VROL_VX using decoder 139
9996 // 18044: }
9997 23, 26, // 18050: case 0x17: {
9998 OPC_SwitchField, 25, 1, // 18052: switch Inst[25] {
9999 0, 8, // 18055: case 0x0: {
10000 OPC_CheckPredicate, 23, // 18057: check predicate 23
10001 OPC_Decode, 170, 129, 1, 140, 1, // 18059: decode to VMERGE_VXM using decoder 140
10002 // 18059: }
10003 1, 0, // 18065: case 0x1: {
10004 OPC_CheckPredicate, 23, // 18067: check predicate 23
10005 OPC_CheckField, 20, 5, 0, // 18069: check Inst[24:20] == 0x0
10006 OPC_Decode, 236, 129, 1, 2, // 18073: decode to VMV_V_X using decoder 2
10007 // 18073: }
10008 // 18073: } // switch Inst[25]
10009 // 18073: }
10010 24, 8, // 18078: case 0x18: {
10011 OPC_CheckPredicate, 23, // 18080: check predicate 23
10012 OPC_Decode, 197, 129, 1, 139, 1, // 18082: decode to VMSEQ_VX using decoder 139
10013 // 18082: }
10014 25, 8, // 18088: case 0x19: {
10015 OPC_CheckPredicate, 23, // 18090: check predicate 23
10016 OPC_Decode, 215, 129, 1, 139, 1, // 18092: decode to VMSNE_VX using decoder 139
10017 // 18092: }
10018 26, 8, // 18098: case 0x1a: {
10019 OPC_CheckPredicate, 23, // 18100: check predicate 23
10020 OPC_Decode, 210, 129, 1, 139, 1, // 18102: decode to VMSLTU_VX using decoder 139
10021 // 18102: }
10022 27, 8, // 18108: case 0x1b: {
10023 OPC_CheckPredicate, 23, // 18110: check predicate 23
10024 OPC_Decode, 212, 129, 1, 139, 1, // 18112: decode to VMSLT_VX using decoder 139
10025 // 18112: }
10026 28, 8, // 18118: case 0x1c: {
10027 OPC_CheckPredicate, 23, // 18120: check predicate 23
10028 OPC_Decode, 205, 129, 1, 139, 1, // 18122: decode to VMSLEU_VX using decoder 139
10029 // 18122: }
10030 29, 8, // 18128: case 0x1d: {
10031 OPC_CheckPredicate, 23, // 18130: check predicate 23
10032 OPC_Decode, 208, 129, 1, 139, 1, // 18132: decode to VMSLE_VX using decoder 139
10033 // 18132: }
10034 30, 8, // 18138: case 0x1e: {
10035 OPC_CheckPredicate, 23, // 18140: check predicate 23
10036 OPC_Decode, 199, 129, 1, 139, 1, // 18142: decode to VMSGTU_VX using decoder 139
10037 // 18142: }
10038 31, 8, // 18148: case 0x1f: {
10039 OPC_CheckPredicate, 23, // 18150: check predicate 23
10040 OPC_Decode, 201, 129, 1, 139, 1, // 18152: decode to VMSGT_VX using decoder 139
10041 // 18152: }
10042 32, 8, // 18158: case 0x20: {
10043 OPC_CheckPredicate, 23, // 18160: check predicate 23
10044 OPC_Decode, 168, 130, 1, 139, 1, // 18162: decode to VSADDU_VX using decoder 139
10045 // 18162: }
10046 33, 8, // 18168: case 0x21: {
10047 OPC_CheckPredicate, 23, // 18170: check predicate 23
10048 OPC_Decode, 171, 130, 1, 139, 1, // 18172: decode to VSADD_VX using decoder 139
10049 // 18172: }
10050 34, 8, // 18178: case 0x22: {
10051 OPC_CheckPredicate, 23, // 18180: check predicate 23
10052 OPC_Decode, 181, 131, 1, 139, 1, // 18182: decode to VSSUBU_VX using decoder 139
10053 // 18182: }
10054 35, 8, // 18188: case 0x23: {
10055 OPC_CheckPredicate, 23, // 18190: check predicate 23
10056 OPC_Decode, 183, 131, 1, 139, 1, // 18192: decode to VSSUB_VX using decoder 139
10057 // 18192: }
10058 37, 8, // 18198: case 0x25: {
10059 OPC_CheckPredicate, 23, // 18200: check predicate 23
10060 OPC_Decode, 195, 130, 1, 139, 1, // 18202: decode to VSLL_VX using decoder 139
10061 // 18202: }
10062 39, 8, // 18208: case 0x27: {
10063 OPC_CheckPredicate, 23, // 18210: check predicate 23
10064 OPC_Decode, 202, 130, 1, 139, 1, // 18212: decode to VSMUL_VX using decoder 139
10065 // 18212: }
10066 40, 8, // 18218: case 0x28: {
10067 OPC_CheckPredicate, 23, // 18220: check predicate 23
10068 OPC_Decode, 241, 130, 1, 139, 1, // 18222: decode to VSRL_VX using decoder 139
10069 // 18222: }
10070 41, 8, // 18228: case 0x29: {
10071 OPC_CheckPredicate, 23, // 18230: check predicate 23
10072 OPC_Decode, 238, 130, 1, 139, 1, // 18232: decode to VSRA_VX using decoder 139
10073 // 18232: }
10074 42, 8, // 18238: case 0x2a: {
10075 OPC_CheckPredicate, 23, // 18240: check predicate 23
10076 OPC_Decode, 151, 131, 1, 139, 1, // 18242: decode to VSSRL_VX using decoder 139
10077 // 18242: }
10078 43, 8, // 18248: case 0x2b: {
10079 OPC_CheckPredicate, 23, // 18250: check predicate 23
10080 OPC_Decode, 148, 131, 1, 139, 1, // 18252: decode to VSSRA_VX using decoder 139
10081 // 18252: }
10082 44, 8, // 18258: case 0x2c: {
10083 OPC_CheckPredicate, 23, // 18260: check predicate 23
10084 OPC_Decode, 255, 129, 1, 139, 1, // 18262: decode to VNSRL_WX using decoder 139
10085 // 18262: }
10086 45, 8, // 18268: case 0x2d: {
10087 OPC_CheckPredicate, 23, // 18270: check predicate 23
10088 OPC_Decode, 252, 129, 1, 139, 1, // 18272: decode to VNSRA_WX using decoder 139
10089 // 18272: }
10090 46, 8, // 18278: case 0x2e: {
10091 OPC_CheckPredicate, 23, // 18280: check predicate 23
10092 OPC_Decode, 242, 129, 1, 139, 1, // 18282: decode to VNCLIPU_WX using decoder 139
10093 // 18282: }
10094 47, 8, // 18288: case 0x2f: {
10095 OPC_CheckPredicate, 23, // 18290: check predicate 23
10096 OPC_Decode, 245, 129, 1, 139, 1, // 18292: decode to VNCLIP_WX using decoder 139
10097 // 18292: }
10098 53, 8, // 18298: case 0x35: {
10099 OPC_CheckPredicate, 100, // 18300: check predicate 100
10100 OPC_Decode, 250, 131, 1, 139, 1, // 18302: decode to VWSLL_VX using decoder 139
10101 // 18302: }
10102 61, 8, // 18308: case 0x3d: {
10103 OPC_CheckPredicate, 103, // 18310: check predicate 103
10104 OPC_Decode, 223, 131, 1, 142, 1, // 18312: decode to VWABDA_VX using decoder 142
10105 // 18312: }
10106 62, 0, // 18318: case 0x3e: {
10107 OPC_CheckPredicate, 103, // 18320: check predicate 103
10108 OPC_Decode, 221, 131, 1, 142, 1, // 18322: decode to VWABDAU_VX using decoder 142
10109 // 18322: }
10110 // 18322: } // switch Inst[31:26]
10111 // 18322: }
10112 5, 254, 2, // 18328: case 0x5: {
10113 OPC_SwitchField, 26, 6, // 18331: switch Inst[31:26] {
10114 0, 7, // 18334: case 0x0: {
10115 OPC_CheckPredicate, 104, // 18336: check predicate 104
10116 OPC_Decode, 240, 126, 143, 1, // 18338: decode to VFADD_VF using decoder 143
10117 // 18338: }
10118 2, 7, // 18343: case 0x2: {
10119 OPC_CheckPredicate, 104, // 18345: check predicate 104
10120 OPC_Decode, 188, 127, 143, 1, // 18347: decode to VFSUB_VF using decoder 143
10121 // 18347: }
10122 4, 7, // 18352: case 0x4: {
10123 OPC_CheckPredicate, 104, // 18354: check predicate 104
10124 OPC_Decode, 132, 127, 143, 1, // 18356: decode to VFMIN_VF using decoder 143
10125 // 18356: }
10126 6, 7, // 18361: case 0x6: {
10127 OPC_CheckPredicate, 104, // 18363: check predicate 104
10128 OPC_Decode, 129, 127, 143, 1, // 18365: decode to VFMAX_VF using decoder 143
10129 // 18365: }
10130 8, 7, // 18370: case 0x8: {
10131 OPC_CheckPredicate, 104, // 18372: check predicate 104
10132 OPC_Decode, 183, 127, 143, 1, // 18374: decode to VFSGNJ_VF using decoder 143
10133 // 18374: }
10134 9, 7, // 18379: case 0x9: {
10135 OPC_CheckPredicate, 104, // 18381: check predicate 104
10136 OPC_Decode, 179, 127, 143, 1, // 18383: decode to VFSGNJN_VF using decoder 143
10137 // 18383: }
10138 10, 7, // 18388: case 0xa: {
10139 OPC_CheckPredicate, 104, // 18390: check predicate 104
10140 OPC_Decode, 181, 127, 143, 1, // 18392: decode to VFSGNJX_VF using decoder 143
10141 // 18392: }
10142 14, 7, // 18397: case 0xe: {
10143 OPC_CheckPredicate, 104, // 18399: check predicate 104
10144 OPC_Decode, 186, 127, 143, 1, // 18401: decode to VFSLIDE1UP_VF using decoder 143
10145 // 18401: }
10146 15, 7, // 18406: case 0xf: {
10147 OPC_CheckPredicate, 104, // 18408: check predicate 104
10148 OPC_Decode, 185, 127, 143, 1, // 18410: decode to VFSLIDE1DOWN_VF using decoder 143
10149 // 18410: }
10150 16, 11, // 18415: case 0x10: {
10151 OPC_CheckPredicate, 104, // 18417: check predicate 104
10152 OPC_CheckField, 20, 6, 32, // 18419: check Inst[25:20] == 0x20
10153 OPC_Decode, 142, 127, 144, 1, // 18423: decode to VFMV_S_F using decoder 144
10154 // 18423: }
10155 23, 25, // 18428: case 0x17: {
10156 OPC_SwitchField, 25, 1, // 18430: switch Inst[25] {
10157 0, 7, // 18433: case 0x0: {
10158 OPC_CheckPredicate, 104, // 18435: check predicate 104
10159 OPC_Decode, 131, 127, 145, 1, // 18437: decode to VFMERGE_VFM using decoder 145
10160 // 18437: }
10161 1, 0, // 18442: case 0x1: {
10162 OPC_CheckPredicate, 104, // 18444: check predicate 104
10163 OPC_CheckField, 20, 5, 0, // 18446: check Inst[24:20] == 0x0
10164 OPC_Decode, 143, 127, 146, 1, // 18450: decode to VFMV_V_F using decoder 146
10165 // 18450: }
10166 // 18450: } // switch Inst[25]
10167 // 18450: }
10168 24, 8, // 18455: case 0x18: {
10169 OPC_CheckPredicate, 104, // 18457: check predicate 104
10170 OPC_Decode, 171, 129, 1, 143, 1, // 18459: decode to VMFEQ_VF using decoder 143
10171 // 18459: }
10172 25, 8, // 18465: case 0x19: {
10173 OPC_CheckPredicate, 104, // 18467: check predicate 104
10174 OPC_Decode, 175, 129, 1, 143, 1, // 18469: decode to VMFLE_VF using decoder 143
10175 // 18469: }
10176 27, 8, // 18475: case 0x1b: {
10177 OPC_CheckPredicate, 104, // 18477: check predicate 104
10178 OPC_Decode, 177, 129, 1, 143, 1, // 18479: decode to VMFLT_VF using decoder 143
10179 // 18479: }
10180 28, 8, // 18485: case 0x1c: {
10181 OPC_CheckPredicate, 104, // 18487: check predicate 104
10182 OPC_Decode, 179, 129, 1, 143, 1, // 18489: decode to VMFNE_VF using decoder 143
10183 // 18489: }
10184 29, 8, // 18495: case 0x1d: {
10185 OPC_CheckPredicate, 104, // 18497: check predicate 104
10186 OPC_Decode, 174, 129, 1, 143, 1, // 18499: decode to VMFGT_VF using decoder 143
10187 // 18499: }
10188 31, 8, // 18505: case 0x1f: {
10189 OPC_CheckPredicate, 104, // 18507: check predicate 104
10190 OPC_Decode, 173, 129, 1, 143, 1, // 18509: decode to VMFGE_VF using decoder 143
10191 // 18509: }
10192 32, 7, // 18515: case 0x20: {
10193 OPC_CheckPredicate, 104, // 18517: check predicate 104
10194 OPC_Decode, 250, 126, 143, 1, // 18519: decode to VFDIV_VF using decoder 143
10195 // 18519: }
10196 33, 7, // 18524: case 0x21: {
10197 OPC_CheckPredicate, 104, // 18526: check predicate 104
10198 OPC_Decode, 171, 127, 143, 1, // 18528: decode to VFRDIV_VF using decoder 143
10199 // 18528: }
10200 36, 7, // 18533: case 0x24: {
10201 OPC_CheckPredicate, 104, // 18535: check predicate 104
10202 OPC_Decode, 139, 127, 143, 1, // 18537: decode to VFMUL_VF using decoder 143
10203 // 18537: }
10204 39, 7, // 18542: case 0x27: {
10205 OPC_CheckPredicate, 104, // 18544: check predicate 104
10206 OPC_Decode, 178, 127, 143, 1, // 18546: decode to VFRSUB_VF using decoder 143
10207 // 18546: }
10208 40, 7, // 18551: case 0x28: {
10209 OPC_CheckPredicate, 104, // 18553: check predicate 104
10210 OPC_Decode, 255, 126, 147, 1, // 18555: decode to VFMADD_VF using decoder 147
10211 // 18555: }
10212 41, 7, // 18560: case 0x29: {
10213 OPC_CheckPredicate, 104, // 18562: check predicate 104
10214 OPC_Decode, 158, 127, 147, 1, // 18564: decode to VFNMADD_VF using decoder 147
10215 // 18564: }
10216 42, 7, // 18569: case 0x2a: {
10217 OPC_CheckPredicate, 104, // 18571: check predicate 104
10218 OPC_Decode, 137, 127, 147, 1, // 18573: decode to VFMSUB_VF using decoder 147
10219 // 18573: }
10220 43, 7, // 18578: case 0x2b: {
10221 OPC_CheckPredicate, 104, // 18580: check predicate 104
10222 OPC_Decode, 162, 127, 147, 1, // 18582: decode to VFNMSUB_VF using decoder 147
10223 // 18582: }
10224 44, 7, // 18587: case 0x2c: {
10225 OPC_CheckPredicate, 104, // 18589: check predicate 104
10226 OPC_Decode, 253, 126, 147, 1, // 18591: decode to VFMACC_VF using decoder 147
10227 // 18591: }
10228 45, 7, // 18596: case 0x2d: {
10229 OPC_CheckPredicate, 104, // 18598: check predicate 104
10230 OPC_Decode, 156, 127, 147, 1, // 18600: decode to VFNMACC_VF using decoder 147
10231 // 18600: }
10232 46, 7, // 18605: case 0x2e: {
10233 OPC_CheckPredicate, 104, // 18607: check predicate 104
10234 OPC_Decode, 135, 127, 147, 1, // 18609: decode to VFMSAC_VF using decoder 147
10235 // 18609: }
10236 47, 7, // 18614: case 0x2f: {
10237 OPC_CheckPredicate, 104, // 18616: check predicate 104
10238 OPC_Decode, 160, 127, 147, 1, // 18618: decode to VFNMSAC_VF using decoder 147
10239 // 18618: }
10240 48, 7, // 18623: case 0x30: {
10241 OPC_CheckPredicate, 104, // 18625: check predicate 104
10242 OPC_Decode, 190, 127, 143, 1, // 18627: decode to VFWADD_VF using decoder 143
10243 // 18627: }
10244 50, 7, // 18632: case 0x32: {
10245 OPC_CheckPredicate, 104, // 18634: check predicate 104
10246 OPC_Decode, 221, 127, 143, 1, // 18636: decode to VFWSUB_VF using decoder 143
10247 // 18636: }
10248 52, 7, // 18641: case 0x34: {
10249 OPC_CheckPredicate, 104, // 18643: check predicate 104
10250 OPC_Decode, 192, 127, 143, 1, // 18645: decode to VFWADD_WF using decoder 143
10251 // 18645: }
10252 54, 7, // 18650: case 0x36: {
10253 OPC_CheckPredicate, 104, // 18652: check predicate 104
10254 OPC_Decode, 223, 127, 143, 1, // 18654: decode to VFWSUB_WF using decoder 143
10255 // 18654: }
10256 56, 7, // 18659: case 0x38: {
10257 OPC_CheckPredicate, 104, // 18661: check predicate 104
10258 OPC_Decode, 213, 127, 143, 1, // 18663: decode to VFWMUL_VF using decoder 143
10259 // 18663: }
10260 59, 7, // 18668: case 0x3b: {
10261 OPC_CheckPredicate, 107, // 18670: check predicate 107
10262 OPC_Decode, 205, 127, 147, 1, // 18672: decode to VFWMACCBF16_VF using decoder 147
10263 // 18672: }
10264 60, 7, // 18677: case 0x3c: {
10265 OPC_CheckPredicate, 104, // 18679: check predicate 104
10266 OPC_Decode, 207, 127, 147, 1, // 18681: decode to VFWMACC_VF using decoder 147
10267 // 18681: }
10268 61, 7, // 18686: case 0x3d: {
10269 OPC_CheckPredicate, 104, // 18688: check predicate 104
10270 OPC_Decode, 215, 127, 147, 1, // 18690: decode to VFWNMACC_VF using decoder 147
10271 // 18690: }
10272 62, 7, // 18695: case 0x3e: {
10273 OPC_CheckPredicate, 104, // 18697: check predicate 104
10274 OPC_Decode, 211, 127, 147, 1, // 18699: decode to VFWMSAC_VF using decoder 147
10275 // 18699: }
10276 63, 0, // 18704: case 0x3f: {
10277 OPC_CheckPredicate, 104, // 18706: check predicate 104
10278 OPC_Decode, 217, 127, 147, 1, // 18708: decode to VFWNMSAC_VF using decoder 147
10279 // 18708: }
10280 // 18708: } // switch Inst[31:26]
10281 // 18708: }
10282 6, 157, 3, // 18713: case 0x6: {
10283 OPC_SwitchField, 26, 6, // 18716: switch Inst[31:26] {
10284 8, 7, // 18719: case 0x8: {
10285 OPC_CheckPredicate, 23, // 18721: check predicate 23
10286 OPC_Decode, 182, 126, 139, 1, // 18723: decode to VAADDU_VX using decoder 139
10287 // 18723: }
10288 9, 7, // 18728: case 0x9: {
10289 OPC_CheckPredicate, 23, // 18730: check predicate 23
10290 OPC_Decode, 184, 126, 139, 1, // 18732: decode to VAADD_VX using decoder 139
10291 // 18732: }
10292 10, 7, // 18737: case 0xa: {
10293 OPC_CheckPredicate, 23, // 18739: check predicate 23
10294 OPC_Decode, 212, 126, 139, 1, // 18741: decode to VASUBU_VX using decoder 139
10295 // 18741: }
10296 11, 7, // 18746: case 0xb: {
10297 OPC_CheckPredicate, 23, // 18748: check predicate 23
10298 OPC_Decode, 214, 126, 139, 1, // 18750: decode to VASUB_VX using decoder 139
10299 // 18750: }
10300 12, 7, // 18755: case 0xc: {
10301 OPC_CheckPredicate, 108, // 18757: check predicate 108
10302 OPC_Decode, 220, 126, 139, 1, // 18759: decode to VCLMUL_VX using decoder 139
10303 // 18759: }
10304 13, 7, // 18764: case 0xd: {
10305 OPC_CheckPredicate, 108, // 18766: check predicate 108
10306 OPC_Decode, 218, 126, 139, 1, // 18768: decode to VCLMULH_VX using decoder 139
10307 // 18768: }
10308 14, 8, // 18773: case 0xe: {
10309 OPC_CheckPredicate, 23, // 18775: check predicate 23
10310 OPC_Decode, 188, 130, 1, 139, 1, // 18777: decode to VSLIDE1UP_VX using decoder 139
10311 // 18777: }
10312 15, 8, // 18783: case 0xf: {
10313 OPC_CheckPredicate, 23, // 18785: check predicate 23
10314 OPC_Decode, 187, 130, 1, 139, 1, // 18787: decode to VSLIDE1DOWN_VX using decoder 139
10315 // 18787: }
10316 16, 12, // 18793: case 0x10: {
10317 OPC_CheckPredicate, 23, // 18795: check predicate 23
10318 OPC_CheckField, 20, 6, 32, // 18797: check Inst[25:20] == 0x20
10319 OPC_Decode, 233, 129, 1, 148, 1, // 18801: decode to VMV_S_X using decoder 148
10320 // 18801: }
10321 21, 7, // 18807: case 0x15: {
10322 OPC_CheckPredicate, 103, // 18809: check predicate 103
10323 OPC_Decode, 188, 126, 139, 1, // 18811: decode to VABD_VX using decoder 139
10324 // 18811: }
10325 22, 7, // 18816: case 0x16: {
10326 OPC_CheckPredicate, 103, // 18818: check predicate 103
10327 OPC_Decode, 186, 126, 139, 1, // 18820: decode to VABDU_VX using decoder 139
10328 // 18820: }
10329 32, 7, // 18825: case 0x20: {
10330 OPC_CheckPredicate, 23, // 18827: check predicate 23
10331 OPC_Decode, 227, 126, 139, 1, // 18829: decode to VDIVU_VX using decoder 139
10332 // 18829: }
10333 33, 7, // 18834: case 0x21: {
10334 OPC_CheckPredicate, 23, // 18836: check predicate 23
10335 OPC_Decode, 229, 126, 139, 1, // 18838: decode to VDIV_VX using decoder 139
10336 // 18838: }
10337 34, 8, // 18843: case 0x22: {
10338 OPC_CheckPredicate, 23, // 18845: check predicate 23
10339 OPC_Decode, 147, 130, 1, 139, 1, // 18847: decode to VREMU_VX using decoder 139
10340 // 18847: }
10341 35, 8, // 18853: case 0x23: {
10342 OPC_CheckPredicate, 23, // 18855: check predicate 23
10343 OPC_Decode, 149, 130, 1, 139, 1, // 18857: decode to VREM_VX using decoder 139
10344 // 18857: }
10345 36, 8, // 18863: case 0x24: {
10346 OPC_CheckPredicate, 23, // 18865: check predicate 23
10347 OPC_Decode, 224, 129, 1, 139, 1, // 18867: decode to VMULHU_VX using decoder 139
10348 // 18867: }
10349 37, 8, // 18873: case 0x25: {
10350 OPC_CheckPredicate, 23, // 18875: check predicate 23
10351 OPC_Decode, 228, 129, 1, 139, 1, // 18877: decode to VMUL_VX using decoder 139
10352 // 18877: }
10353 38, 8, // 18883: case 0x26: {
10354 OPC_CheckPredicate, 23, // 18885: check predicate 23
10355 OPC_Decode, 222, 129, 1, 139, 1, // 18887: decode to VMULHSU_VX using decoder 139
10356 // 18887: }
10357 39, 8, // 18893: case 0x27: {
10358 OPC_CheckPredicate, 23, // 18895: check predicate 23
10359 OPC_Decode, 226, 129, 1, 139, 1, // 18897: decode to VMULH_VX using decoder 139
10360 // 18897: }
10361 40, 7, // 18903: case 0x28: {
10362 OPC_CheckPredicate, 109, // 18905: check predicate 109
10363 OPC_Decode, 234, 126, 142, 1, // 18907: decode to VDOT4AU_VX using decoder 142
10364 // 18907: }
10365 41, 8, // 18912: case 0x29: {
10366 OPC_CheckPredicate, 23, // 18914: check predicate 23
10367 OPC_Decode, 161, 129, 1, 149, 1, // 18916: decode to VMADD_VX using decoder 149
10368 // 18916: }
10369 42, 7, // 18922: case 0x2a: {
10370 OPC_CheckPredicate, 109, // 18924: check predicate 109
10371 OPC_Decode, 231, 126, 142, 1, // 18926: decode to VDOT4ASU_VX using decoder 142
10372 // 18926: }
10373 43, 8, // 18931: case 0x2b: {
10374 OPC_CheckPredicate, 23, // 18933: check predicate 23
10375 OPC_Decode, 249, 129, 1, 149, 1, // 18935: decode to VNMSUB_VX using decoder 149
10376 // 18935: }
10377 44, 7, // 18941: case 0x2c: {
10378 OPC_CheckPredicate, 109, // 18943: check predicate 109
10379 OPC_Decode, 236, 126, 142, 1, // 18945: decode to VDOT4A_VX using decoder 142
10380 // 18945: }
10381 45, 8, // 18950: case 0x2d: {
10382 OPC_CheckPredicate, 23, // 18952: check predicate 23
10383 OPC_Decode, 153, 129, 1, 149, 1, // 18954: decode to VMACC_VX using decoder 149
10384 // 18954: }
10385 46, 7, // 18960: case 0x2e: {
10386 OPC_CheckPredicate, 109, // 18962: check predicate 109
10387 OPC_Decode, 232, 126, 142, 1, // 18964: decode to VDOT4AUS_VX using decoder 142
10388 // 18964: }
10389 47, 8, // 18969: case 0x2f: {
10390 OPC_CheckPredicate, 23, // 18971: check predicate 23
10391 OPC_Decode, 247, 129, 1, 149, 1, // 18973: decode to VNMSAC_VX using decoder 149
10392 // 18973: }
10393 48, 8, // 18979: case 0x30: {
10394 OPC_CheckPredicate, 23, // 18981: check predicate 23
10395 OPC_Decode, 225, 131, 1, 139, 1, // 18983: decode to VWADDU_VX using decoder 139
10396 // 18983: }
10397 49, 8, // 18989: case 0x31: {
10398 OPC_CheckPredicate, 23, // 18991: check predicate 23
10399 OPC_Decode, 229, 131, 1, 139, 1, // 18993: decode to VWADD_VX using decoder 139
10400 // 18993: }
10401 50, 8, // 18999: case 0x32: {
10402 OPC_CheckPredicate, 23, // 19001: check predicate 23
10403 OPC_Decode, 252, 131, 1, 139, 1, // 19003: decode to VWSUBU_VX using decoder 139
10404 // 19003: }
10405 51, 8, // 19009: case 0x33: {
10406 OPC_CheckPredicate, 23, // 19011: check predicate 23
10407 OPC_Decode, 128, 132, 1, 139, 1, // 19013: decode to VWSUB_VX using decoder 139
10408 // 19013: }
10409 52, 8, // 19019: case 0x34: {
10410 OPC_CheckPredicate, 23, // 19021: check predicate 23
10411 OPC_Decode, 227, 131, 1, 139, 1, // 19023: decode to VWADDU_WX using decoder 139
10412 // 19023: }
10413 53, 8, // 19029: case 0x35: {
10414 OPC_CheckPredicate, 23, // 19031: check predicate 23
10415 OPC_Decode, 231, 131, 1, 139, 1, // 19033: decode to VWADD_WX using decoder 139
10416 // 19033: }
10417 54, 8, // 19039: case 0x36: {
10418 OPC_CheckPredicate, 23, // 19041: check predicate 23
10419 OPC_Decode, 254, 131, 1, 139, 1, // 19043: decode to VWSUBU_WX using decoder 139
10420 // 19043: }
10421 55, 8, // 19049: case 0x37: {
10422 OPC_CheckPredicate, 23, // 19051: check predicate 23
10423 OPC_Decode, 130, 132, 1, 139, 1, // 19053: decode to VWSUB_WX using decoder 139
10424 // 19053: }
10425 56, 8, // 19059: case 0x38: {
10426 OPC_CheckPredicate, 23, // 19061: check predicate 23
10427 OPC_Decode, 243, 131, 1, 139, 1, // 19063: decode to VWMULU_VX using decoder 139
10428 // 19063: }
10429 58, 8, // 19069: case 0x3a: {
10430 OPC_CheckPredicate, 23, // 19071: check predicate 23
10431 OPC_Decode, 241, 131, 1, 139, 1, // 19073: decode to VWMULSU_VX using decoder 139
10432 // 19073: }
10433 59, 8, // 19079: case 0x3b: {
10434 OPC_CheckPredicate, 23, // 19081: check predicate 23
10435 OPC_Decode, 245, 131, 1, 139, 1, // 19083: decode to VWMUL_VX using decoder 139
10436 // 19083: }
10437 60, 8, // 19089: case 0x3c: {
10438 OPC_CheckPredicate, 23, // 19091: check predicate 23
10439 OPC_Decode, 236, 131, 1, 149, 1, // 19093: decode to VWMACCU_VX using decoder 149
10440 // 19093: }
10441 61, 8, // 19099: case 0x3d: {
10442 OPC_CheckPredicate, 23, // 19101: check predicate 23
10443 OPC_Decode, 238, 131, 1, 149, 1, // 19103: decode to VWMACC_VX using decoder 149
10444 // 19103: }
10445 62, 8, // 19109: case 0x3e: {
10446 OPC_CheckPredicate, 23, // 19111: check predicate 23
10447 OPC_Decode, 234, 131, 1, 149, 1, // 19113: decode to VWMACCUS_VX using decoder 149
10448 // 19113: }
10449 63, 0, // 19119: case 0x3f: {
10450 OPC_CheckPredicate, 23, // 19121: check predicate 23
10451 OPC_Decode, 233, 131, 1, 149, 1, // 19123: decode to VWMACCSU_VX using decoder 149
10452 // 19123: }
10453 // 19123: } // switch Inst[31:26]
10454 // 19123: }
10455 7, 0, // 19129: case 0x7: {
10456 OPC_SwitchField, 31, 1, // 19131: switch Inst[31] {
10457 0, 8, // 19134: case 0x0: {
10458 OPC_CheckPredicate, 23, // 19136: check predicate 23
10459 OPC_Decode, 180, 130, 1, 150, 1, // 19138: decode to VSETVLI using decoder 150
10460 // 19138: }
10461 1, 0, // 19144: case 0x1: {
10462 OPC_SwitchField, 30, 1, // 19146: switch Inst[30] {
10463 0, 11, // 19149: case 0x0: {
10464 OPC_CheckPredicate, 23, // 19151: check predicate 23
10465 OPC_CheckField, 25, 5, 0, // 19153: check Inst[29:25] == 0x0
10466 OPC_Decode, 179, 130, 1, 31, // 19157: decode to VSETVL using decoder 31
10467 // 19157: }
10468 1, 0, // 19162: case 0x1: {
10469 OPC_CheckPredicate, 23, // 19164: check predicate 23
10470 OPC_Decode, 178, 130, 1, 151, 1, // 19166: decode to VSETIVLI using decoder 151
10471 // 19166: }
10472 // 19166: } // switch Inst[30]
10473 // 19166: }
10474 // 19166: } // switch Inst[31]
10475 // 19166: }
10476 // 19166: } // switch Inst[14:12]
10477 // 19166: }
10478 99, 63, // 19172: case 0x63: {
10479 OPC_SwitchField, 12, 3, // 19174: switch Inst[14:12] {
10480 0, 5, // 19177: case 0x0: {
10481 OPC_Decode, 229, 110, 152, 1, // 19179: decode to BEQ using decoder 152
10482 // 19179: }
10483 1, 5, // 19184: case 0x1: {
10484 OPC_Decode, 239, 110, 152, 1, // 19186: decode to BNE using decoder 152
10485 // 19186: }
10486 2, 7, // 19191: case 0x2: {
10487 OPC_CheckPredicate, 110, // 19193: check predicate 110
10488 OPC_Decode, 230, 110, 153, 1, // 19195: decode to BEQI using decoder 153
10489 // 19195: }
10490 3, 7, // 19200: case 0x3: {
10491 OPC_CheckPredicate, 110, // 19202: check predicate 110
10492 OPC_Decode, 240, 110, 153, 1, // 19204: decode to BNEI using decoder 153
10493 // 19204: }
10494 4, 5, // 19209: case 0x4: {
10495 OPC_Decode, 237, 110, 152, 1, // 19211: decode to BLT using decoder 152
10496 // 19211: }
10497 5, 5, // 19216: case 0x5: {
10498 OPC_Decode, 233, 110, 152, 1, // 19218: decode to BGE using decoder 152
10499 // 19218: }
10500 6, 5, // 19223: case 0x6: {
10501 OPC_Decode, 238, 110, 152, 1, // 19225: decode to BLTU using decoder 152
10502 // 19225: }
10503 7, 0, // 19230: case 0x7: {
10504 OPC_Decode, 234, 110, 152, 1, // 19232: decode to BGEU using decoder 152
10505 // 19232: }
10506 // 19232: } // switch Inst[14:12]
10507 // 19232: }
10508 103, 8, // 19237: case 0x67: {
10509 OPC_CheckField, 12, 3, 0, // 19239: check Inst[14:12] == 0x0
10510 OPC_Decode, 224, 116, 0, // 19243: decode to JALR using decoder 0
10511 // 19243: }
10512 111, 5, // 19247: case 0x6f: {
10513 OPC_Decode, 223, 116, 154, 1, // 19249: decode to JAL using decoder 154
10514 // 19249: }
10515 115, 173, 7, // 19254: case 0x73: {
10516 OPC_SwitchField, 12, 3, // 19257: switch Inst[14:12] {
10517 0, 201, 2, // 19260: case 0x0: {
10518 OPC_SwitchField, 25, 7, // 19263: switch Inst[31:25] {
10519 0, 51, // 19266: case 0x0: {
10520 OPC_SwitchField, 15, 10, // 19268: switch Inst[24:15] {
10521 0, 8, // 19271: case 0x0: {
10522 OPC_CheckField, 7, 5, 0, // 19273: check Inst[11:7] == 0x0
10523 OPC_Decode, 155, 114, 14, // 19277: decode to ECALL using decoder 14
10524 // 19277: }
10525 32, 8, // 19281: case 0x20: {
10526 OPC_CheckField, 7, 5, 0, // 19283: check Inst[11:7] == 0x0
10527 OPC_Decode, 154, 114, 14, // 19287: decode to EBREAK using decoder 14
10528 // 19287: }
10529 160, 3, 11, // 19291: case 0x1a0: {
10530 OPC_CheckPredicate, 111, // 19294: check predicate 111
10531 OPC_CheckField, 7, 5, 0, // 19296: check Inst[11:7] == 0x0
10532 OPC_Decode, 149, 132, 1, 14, // 19300: decode to WRS_NTO using decoder 14
10533 // 19300: }
10534 160, 7, 0, // 19305: case 0x3a0: {
10535 OPC_CheckPredicate, 111, // 19308: check predicate 111
10536 OPC_CheckField, 7, 5, 0, // 19310: check Inst[11:7] == 0x0
10537 OPC_Decode, 150, 132, 1, 14, // 19314: decode to WRS_STO using decoder 14
10538 // 19314: }
10539 // 19314: } // switch Inst[24:15]
10540 // 19314: }
10541 8, 82, // 19319: case 0x8: {
10542 OPC_SwitchField, 20, 5, // 19321: switch Inst[24:20] {
10543 2, 12, // 19324: case 0x2: {
10544 OPC_CheckField, 15, 5, 0, // 19326: check Inst[19:15] == 0x0
10545 OPC_CheckField, 7, 5, 0, // 19330: check Inst[11:7] == 0x0
10546 OPC_Decode, 159, 125, 14, // 19334: decode to SRET using decoder 14
10547 // 19334: }
10548 4, 14, // 19338: case 0x4: {
10549 OPC_CheckPredicate, 112, // 19340: check predicate 112
10550 OPC_CheckField, 15, 5, 0, // 19342: check Inst[19:15] == 0x0
10551 OPC_CheckField, 7, 5, 0, // 19346: check Inst[11:7] == 0x0
10552 OPC_Decode, 229, 123, 14, // 19350: decode to SCTRCLR using decoder 14
10553 // 19350: }
10554 5, 13, // 19354: case 0x5: {
10555 OPC_CheckField, 15, 5, 0, // 19356: check Inst[19:15] == 0x0
10556 OPC_CheckField, 7, 5, 0, // 19360: check Inst[11:7] == 0x0
10557 OPC_Decode, 142, 132, 1, 14, // 19364: decode to WFI using decoder 14
10558 // 19364: }
10559 8, 14, // 19369: case 0x8: {
10560 OPC_CheckPredicate, 113, // 19371: check predicate 113
10561 OPC_CheckField, 15, 5, 0, // 19373: check Inst[19:15] == 0x0
10562 OPC_CheckField, 7, 5, 0, // 19377: check Inst[11:7] == 0x0
10563 OPC_Decode, 216, 124, 14, // 19381: decode to SIPOPRET using decoder 14
10564 // 19381: }
10565 9, 7, // 19385: case 0x9: {
10566 OPC_CheckPredicate, 114, // 19387: check predicate 114
10567 OPC_Decode, 228, 123, 155, 1, // 19389: decode to SCSPSPUSH using decoder 155
10568 // 19389: }
10569 12, 0, // 19394: case 0xc: {
10570 OPC_CheckPredicate, 114, // 19396: check predicate 114
10571 OPC_Decode, 227, 123, 155, 1, // 19398: decode to SCSPSPOP using decoder 155
10572 // 19398: }
10573 // 19398: } // switch Inst[24:20]
10574 // 19398: }
10575 9, 9, // 19403: case 0x9: {
10576 OPC_CheckField, 7, 5, 0, // 19405: check Inst[11:7] == 0x0
10577 OPC_Decode, 245, 123, 156, 1, // 19409: decode to SFENCE_VMA using decoder 156
10578 // 19409: }
10579 11, 11, // 19414: case 0xb: {
10580 OPC_CheckPredicate, 115, // 19416: check predicate 115
10581 OPC_CheckField, 7, 5, 0, // 19418: check Inst[11:7] == 0x0
10582 OPC_Decode, 215, 124, 156, 1, // 19422: decode to SINVAL_VMA using decoder 156
10583 // 19422: }
10584 12, 27, // 19427: case 0xc: {
10585 OPC_SwitchField, 15, 10, // 19429: switch Inst[24:15] {
10586 0, 10, // 19432: case 0x0: {
10587 OPC_CheckPredicate, 115, // 19434: check predicate 115
10588 OPC_CheckField, 7, 5, 0, // 19436: check Inst[11:7] == 0x0
10589 OPC_Decode, 246, 123, 14, // 19440: decode to SFENCE_W_INVAL using decoder 14
10590 // 19440: }
10591 32, 0, // 19444: case 0x20: {
10592 OPC_CheckPredicate, 115, // 19446: check predicate 115
10593 OPC_CheckField, 7, 5, 0, // 19448: check Inst[11:7] == 0x0
10594 OPC_Decode, 244, 123, 14, // 19452: decode to SFENCE_INVAL_IR using decoder 14
10595 // 19452: }
10596 // 19452: } // switch Inst[24:15]
10597 // 19452: }
10598 17, 11, // 19456: case 0x11: {
10599 OPC_CheckPredicate, 116, // 19458: check predicate 116
10600 OPC_CheckField, 7, 5, 0, // 19460: check Inst[11:7] == 0x0
10601 OPC_Decode, 180, 116, 156, 1, // 19464: decode to HFENCE_VVMA using decoder 156
10602 // 19464: }
10603 19, 11, // 19469: case 0x13: {
10604 OPC_CheckPredicate, 117, // 19471: check predicate 117
10605 OPC_CheckField, 7, 5, 0, // 19473: check Inst[11:7] == 0x0
10606 OPC_Decode, 182, 116, 156, 1, // 19477: decode to HINVAL_VVMA using decoder 156
10607 // 19477: }
10608 24, 51, // 19482: case 0x18: {
10609 OPC_SwitchField, 20, 5, // 19484: switch Inst[24:20] {
10610 2, 12, // 19487: case 0x2: {
10611 OPC_CheckField, 15, 5, 0, // 19489: check Inst[19:15] == 0x0
10612 OPC_CheckField, 7, 5, 0, // 19493: check Inst[11:7] == 0x0
10613 OPC_Decode, 241, 117, 14, // 19497: decode to MRET using decoder 14
10614 // 19497: }
10615 8, 14, // 19501: case 0x8: {
10616 OPC_CheckPredicate, 118, // 19503: check predicate 118
10617 OPC_CheckField, 15, 5, 0, // 19505: check Inst[19:15] == 0x0
10618 OPC_CheckField, 7, 5, 0, // 19509: check Inst[11:7] == 0x0
10619 OPC_Decode, 176, 117, 14, // 19513: decode to MIPOPRET using decoder 14
10620 // 19513: }
10621 9, 7, // 19517: case 0x9: {
10622 OPC_CheckPredicate, 119, // 19519: check predicate 119
10623 OPC_Decode, 162, 117, 155, 1, // 19521: decode to MCSPSPUSH using decoder 155
10624 // 19521: }
10625 12, 0, // 19526: case 0xc: {
10626 OPC_CheckPredicate, 119, // 19528: check predicate 119
10627 OPC_Decode, 161, 117, 155, 1, // 19530: decode to MCSPSPOP using decoder 155
10628 // 19530: }
10629 // 19530: } // switch Inst[24:20]
10630 // 19530: }
10631 49, 11, // 19535: case 0x31: {
10632 OPC_CheckPredicate, 116, // 19537: check predicate 116
10633 OPC_CheckField, 7, 5, 0, // 19539: check Inst[11:7] == 0x0
10634 OPC_Decode, 179, 116, 156, 1, // 19543: decode to HFENCE_GVMA using decoder 156
10635 // 19543: }
10636 51, 11, // 19548: case 0x33: {
10637 OPC_CheckPredicate, 117, // 19550: check predicate 117
10638 OPC_CheckField, 7, 5, 0, // 19552: check Inst[11:7] == 0x0
10639 OPC_Decode, 181, 116, 156, 1, // 19556: decode to HINVAL_GVMA using decoder 156
10640 // 19556: }
10641 56, 14, // 19561: case 0x38: {
10642 OPC_CheckPredicate, 120, // 19563: check predicate 120
10643 OPC_CheckField, 15, 10, 64, // 19565: check Inst[24:15] == 0x40
10644 OPC_CheckField, 7, 5, 0, // 19569: check Inst[11:7] == 0x0
10645 OPC_Decode, 186, 117, 14, // 19573: decode to MNRET using decoder 14
10646 // 19573: }
10647 61, 0, // 19577: case 0x3d: {
10648 OPC_CheckField, 15, 10, 192, 4, // 19579: check Inst[24:15] == 0x240
10649 OPC_CheckField, 7, 5, 0, // 19584: check Inst[11:7] == 0x0
10650 OPC_Decode, 153, 114, 14, // 19588: decode to DRET using decoder 14
10651 // 19588: }
10652 // 19588: } // switch Inst[31:25]
10653 // 19588: }
10654 1, 21, // 19592: case 0x1: {
10655 OPC_Scope, 14, // 19594: try {
10656 OPC_CheckField, 7, 5, 0, // 19596: check Inst[11:7] == 0x0
10657 OPC_CheckField, 15, 17, 128, 128, 6, // 19600: check Inst[31:15] == 0x18000
10658 OPC_Decode, 172, 126, 14, // 19606: decode to UNIMP using decoder 14
10659 // 19606: } else try {
10660 OPC_Decode, 141, 111, 157, 1, // 19610: decode to CSRRW using decoder 157
10661 // 19610: }
10662 // 19610: }
10663 2, 5, // 19615: case 0x2: {
10664 OPC_Decode, 139, 111, 157, 1, // 19617: decode to CSRRS using decoder 157
10665 // 19617: }
10666 3, 5, // 19622: case 0x3: {
10667 OPC_Decode, 137, 111, 157, 1, // 19624: decode to CSRRC using decoder 157
10668 // 19624: }
10669 4, 161, 4, // 19629: case 0x4: {
10670 OPC_SwitchField, 25, 7, // 19632: switch Inst[31:25] {
10671 48, 19, // 19635: case 0x30: {
10672 OPC_SwitchField, 20, 5, // 19637: switch Inst[24:20] {
10673 0, 6, // 19640: case 0x0: {
10674 OPC_CheckPredicate, 116, // 19642: check predicate 116
10675 OPC_Decode, 185, 116, 17, // 19644: decode to HLV_B using decoder 17
10676 // 19644: }
10677 1, 0, // 19648: case 0x1: {
10678 OPC_CheckPredicate, 116, // 19650: check predicate 116
10679 OPC_Decode, 186, 116, 17, // 19652: decode to HLV_BU using decoder 17
10680 // 19652: }
10681 // 19652: } // switch Inst[24:20]
10682 // 19652: }
10683 49, 10, // 19656: case 0x31: {
10684 OPC_CheckPredicate, 116, // 19658: check predicate 116
10685 OPC_CheckField, 7, 5, 0, // 19660: check Inst[11:7] == 0x0
10686 OPC_Decode, 192, 116, 59, // 19664: decode to HSV_B using decoder 59
10687 // 19664: }
10688 50, 27, // 19668: case 0x32: {
10689 OPC_SwitchField, 20, 5, // 19670: switch Inst[24:20] {
10690 0, 6, // 19673: case 0x0: {
10691 OPC_CheckPredicate, 116, // 19675: check predicate 116
10692 OPC_Decode, 188, 116, 17, // 19677: decode to HLV_H using decoder 17
10693 // 19677: }
10694 1, 6, // 19681: case 0x1: {
10695 OPC_CheckPredicate, 116, // 19683: check predicate 116
10696 OPC_Decode, 189, 116, 17, // 19685: decode to HLV_HU using decoder 17
10697 // 19685: }
10698 3, 0, // 19689: case 0x3: {
10699 OPC_CheckPredicate, 116, // 19691: check predicate 116
10700 OPC_Decode, 183, 116, 17, // 19693: decode to HLVX_HU using decoder 17
10701 // 19693: }
10702 // 19693: } // switch Inst[24:20]
10703 // 19693: }
10704 51, 10, // 19697: case 0x33: {
10705 OPC_CheckPredicate, 116, // 19699: check predicate 116
10706 OPC_CheckField, 7, 5, 0, // 19701: check Inst[11:7] == 0x0
10707 OPC_Decode, 194, 116, 59, // 19705: decode to HSV_H using decoder 59
10708 // 19705: }
10709 52, 27, // 19709: case 0x34: {
10710 OPC_SwitchField, 20, 5, // 19711: switch Inst[24:20] {
10711 0, 6, // 19714: case 0x0: {
10712 OPC_CheckPredicate, 116, // 19716: check predicate 116
10713 OPC_Decode, 190, 116, 17, // 19718: decode to HLV_W using decoder 17
10714 // 19718: }
10715 1, 6, // 19722: case 0x1: {
10716 OPC_CheckPredicate, 121, // 19724: check predicate 121
10717 OPC_Decode, 191, 116, 17, // 19726: decode to HLV_WU using decoder 17
10718 // 19726: }
10719 3, 0, // 19730: case 0x3: {
10720 OPC_CheckPredicate, 116, // 19732: check predicate 116
10721 OPC_Decode, 184, 116, 17, // 19734: decode to HLVX_WU using decoder 17
10722 // 19734: }
10723 // 19734: } // switch Inst[24:20]
10724 // 19734: }
10725 53, 10, // 19738: case 0x35: {
10726 OPC_CheckPredicate, 116, // 19740: check predicate 116
10727 OPC_CheckField, 7, 5, 0, // 19742: check Inst[11:7] == 0x0
10728 OPC_Decode, 195, 116, 59, // 19746: decode to HSV_W using decoder 59
10729 // 19746: }
10730 54, 10, // 19750: case 0x36: {
10731 OPC_CheckPredicate, 121, // 19752: check predicate 121
10732 OPC_CheckField, 20, 5, 0, // 19754: check Inst[24:20] == 0x0
10733 OPC_Decode, 187, 116, 17, // 19758: decode to HLV_D using decoder 17
10734 // 19758: }
10735 55, 10, // 19762: case 0x37: {
10736 OPC_CheckPredicate, 121, // 19764: check predicate 121
10737 OPC_CheckField, 7, 5, 0, // 19766: check Inst[11:7] == 0x0
10738 OPC_Decode, 193, 116, 59, // 19770: decode to HSV_D using decoder 59
10739 // 19770: }
10740 64, 35, // 19774: case 0x40: {
10741 OPC_SwitchField, 20, 5, // 19776: switch Inst[24:20] {
10742 28, 6, // 19779: case 0x1c: {
10743 OPC_CheckPredicate, 122, // 19781: check predicate 122
10744 OPC_Decode, 195, 117, 17, // 19783: decode to MOP_R_0 using decoder 17
10745 // 19783: }
10746 29, 6, // 19787: case 0x1d: {
10747 OPC_CheckPredicate, 122, // 19789: check predicate 122
10748 OPC_Decode, 196, 117, 17, // 19791: decode to MOP_R_1 using decoder 17
10749 // 19791: }
10750 30, 6, // 19795: case 0x1e: {
10751 OPC_CheckPredicate, 122, // 19797: check predicate 122
10752 OPC_Decode, 207, 117, 17, // 19799: decode to MOP_R_2 using decoder 17
10753 // 19799: }
10754 31, 0, // 19803: case 0x1f: {
10755 OPC_CheckPredicate, 122, // 19805: check predicate 122
10756 OPC_Decode, 218, 117, 17, // 19807: decode to MOP_R_3 using decoder 17
10757 // 19807: }
10758 // 19807: } // switch Inst[24:20]
10759 // 19807: }
10760 65, 6, // 19811: case 0x41: {
10761 OPC_CheckPredicate, 122, // 19813: check predicate 122
10762 OPC_Decode, 187, 117, 31, // 19815: decode to MOP_RR_0 using decoder 31
10763 // 19815: }
10764 66, 35, // 19819: case 0x42: {
10765 OPC_SwitchField, 20, 5, // 19821: switch Inst[24:20] {
10766 28, 6, // 19824: case 0x1c: {
10767 OPC_CheckPredicate, 122, // 19826: check predicate 122
10768 OPC_Decode, 221, 117, 17, // 19828: decode to MOP_R_4 using decoder 17
10769 // 19828: }
10770 29, 6, // 19832: case 0x1d: {
10771 OPC_CheckPredicate, 122, // 19834: check predicate 122
10772 OPC_Decode, 222, 117, 17, // 19836: decode to MOP_R_5 using decoder 17
10773 // 19836: }
10774 30, 6, // 19840: case 0x1e: {
10775 OPC_CheckPredicate, 122, // 19842: check predicate 122
10776 OPC_Decode, 223, 117, 17, // 19844: decode to MOP_R_6 using decoder 17
10777 // 19844: }
10778 31, 0, // 19848: case 0x1f: {
10779 OPC_CheckPredicate, 122, // 19850: check predicate 122
10780 OPC_Decode, 224, 117, 17, // 19852: decode to MOP_R_7 using decoder 17
10781 // 19852: }
10782 // 19852: } // switch Inst[24:20]
10783 // 19852: }
10784 67, 6, // 19856: case 0x43: {
10785 OPC_CheckPredicate, 122, // 19858: check predicate 122
10786 OPC_Decode, 188, 117, 31, // 19860: decode to MOP_RR_1 using decoder 31
10787 // 19860: }
10788 68, 35, // 19864: case 0x44: {
10789 OPC_SwitchField, 20, 5, // 19866: switch Inst[24:20] {
10790 28, 6, // 19869: case 0x1c: {
10791 OPC_CheckPredicate, 122, // 19871: check predicate 122
10792 OPC_Decode, 225, 117, 17, // 19873: decode to MOP_R_8 using decoder 17
10793 // 19873: }
10794 29, 6, // 19877: case 0x1d: {
10795 OPC_CheckPredicate, 122, // 19879: check predicate 122
10796 OPC_Decode, 226, 117, 17, // 19881: decode to MOP_R_9 using decoder 17
10797 // 19881: }
10798 30, 6, // 19885: case 0x1e: {
10799 OPC_CheckPredicate, 122, // 19887: check predicate 122
10800 OPC_Decode, 197, 117, 17, // 19889: decode to MOP_R_10 using decoder 17
10801 // 19889: }
10802 31, 0, // 19893: case 0x1f: {
10803 OPC_CheckPredicate, 122, // 19895: check predicate 122
10804 OPC_Decode, 198, 117, 17, // 19897: decode to MOP_R_11 using decoder 17
10805 // 19897: }
10806 // 19897: } // switch Inst[24:20]
10807 // 19897: }
10808 69, 6, // 19901: case 0x45: {
10809 OPC_CheckPredicate, 122, // 19903: check predicate 122
10810 OPC_Decode, 189, 117, 31, // 19905: decode to MOP_RR_2 using decoder 31
10811 // 19905: }
10812 70, 35, // 19909: case 0x46: {
10813 OPC_SwitchField, 20, 5, // 19911: switch Inst[24:20] {
10814 28, 6, // 19914: case 0x1c: {
10815 OPC_CheckPredicate, 122, // 19916: check predicate 122
10816 OPC_Decode, 199, 117, 17, // 19918: decode to MOP_R_12 using decoder 17
10817 // 19918: }
10818 29, 6, // 19922: case 0x1d: {
10819 OPC_CheckPredicate, 122, // 19924: check predicate 122
10820 OPC_Decode, 200, 117, 17, // 19926: decode to MOP_R_13 using decoder 17
10821 // 19926: }
10822 30, 6, // 19930: case 0x1e: {
10823 OPC_CheckPredicate, 122, // 19932: check predicate 122
10824 OPC_Decode, 201, 117, 17, // 19934: decode to MOP_R_14 using decoder 17
10825 // 19934: }
10826 31, 0, // 19938: case 0x1f: {
10827 OPC_CheckPredicate, 122, // 19940: check predicate 122
10828 OPC_Decode, 202, 117, 17, // 19942: decode to MOP_R_15 using decoder 17
10829 // 19942: }
10830 // 19942: } // switch Inst[24:20]
10831 // 19942: }
10832 71, 6, // 19946: case 0x47: {
10833 OPC_CheckPredicate, 122, // 19948: check predicate 122
10834 OPC_Decode, 190, 117, 31, // 19950: decode to MOP_RR_3 using decoder 31
10835 // 19950: }
10836 96, 35, // 19954: case 0x60: {
10837 OPC_SwitchField, 20, 5, // 19956: switch Inst[24:20] {
10838 28, 6, // 19959: case 0x1c: {
10839 OPC_CheckPredicate, 122, // 19961: check predicate 122
10840 OPC_Decode, 203, 117, 17, // 19963: decode to MOP_R_16 using decoder 17
10841 // 19963: }
10842 29, 6, // 19967: case 0x1d: {
10843 OPC_CheckPredicate, 122, // 19969: check predicate 122
10844 OPC_Decode, 204, 117, 17, // 19971: decode to MOP_R_17 using decoder 17
10845 // 19971: }
10846 30, 6, // 19975: case 0x1e: {
10847 OPC_CheckPredicate, 122, // 19977: check predicate 122
10848 OPC_Decode, 205, 117, 17, // 19979: decode to MOP_R_18 using decoder 17
10849 // 19979: }
10850 31, 0, // 19983: case 0x1f: {
10851 OPC_CheckPredicate, 122, // 19985: check predicate 122
10852 OPC_Decode, 206, 117, 17, // 19987: decode to MOP_R_19 using decoder 17
10853 // 19987: }
10854 // 19987: } // switch Inst[24:20]
10855 // 19987: }
10856 97, 6, // 19991: case 0x61: {
10857 OPC_CheckPredicate, 122, // 19993: check predicate 122
10858 OPC_Decode, 191, 117, 31, // 19995: decode to MOP_RR_4 using decoder 31
10859 // 19995: }
10860 98, 35, // 19999: case 0x62: {
10861 OPC_SwitchField, 20, 5, // 20001: switch Inst[24:20] {
10862 28, 6, // 20004: case 0x1c: {
10863 OPC_CheckPredicate, 122, // 20006: check predicate 122
10864 OPC_Decode, 208, 117, 17, // 20008: decode to MOP_R_20 using decoder 17
10865 // 20008: }
10866 29, 6, // 20012: case 0x1d: {
10867 OPC_CheckPredicate, 122, // 20014: check predicate 122
10868 OPC_Decode, 209, 117, 17, // 20016: decode to MOP_R_21 using decoder 17
10869 // 20016: }
10870 30, 6, // 20020: case 0x1e: {
10871 OPC_CheckPredicate, 122, // 20022: check predicate 122
10872 OPC_Decode, 210, 117, 17, // 20024: decode to MOP_R_22 using decoder 17
10873 // 20024: }
10874 31, 0, // 20028: case 0x1f: {
10875 OPC_CheckPredicate, 122, // 20030: check predicate 122
10876 OPC_Decode, 211, 117, 17, // 20032: decode to MOP_R_23 using decoder 17
10877 // 20032: }
10878 // 20032: } // switch Inst[24:20]
10879 // 20032: }
10880 99, 6, // 20036: case 0x63: {
10881 OPC_CheckPredicate, 122, // 20038: check predicate 122
10882 OPC_Decode, 192, 117, 31, // 20040: decode to MOP_RR_5 using decoder 31
10883 // 20040: }
10884 100, 35, // 20044: case 0x64: {
10885 OPC_SwitchField, 20, 5, // 20046: switch Inst[24:20] {
10886 28, 6, // 20049: case 0x1c: {
10887 OPC_CheckPredicate, 122, // 20051: check predicate 122
10888 OPC_Decode, 212, 117, 17, // 20053: decode to MOP_R_24 using decoder 17
10889 // 20053: }
10890 29, 6, // 20057: case 0x1d: {
10891 OPC_CheckPredicate, 122, // 20059: check predicate 122
10892 OPC_Decode, 213, 117, 17, // 20061: decode to MOP_R_25 using decoder 17
10893 // 20061: }
10894 30, 6, // 20065: case 0x1e: {
10895 OPC_CheckPredicate, 122, // 20067: check predicate 122
10896 OPC_Decode, 214, 117, 17, // 20069: decode to MOP_R_26 using decoder 17
10897 // 20069: }
10898 31, 0, // 20073: case 0x1f: {
10899 OPC_CheckPredicate, 122, // 20075: check predicate 122
10900 OPC_Decode, 215, 117, 17, // 20077: decode to MOP_R_27 using decoder 17
10901 // 20077: }
10902 // 20077: } // switch Inst[24:20]
10903 // 20077: }
10904 101, 6, // 20081: case 0x65: {
10905 OPC_CheckPredicate, 122, // 20083: check predicate 122
10906 OPC_Decode, 193, 117, 31, // 20085: decode to MOP_RR_6 using decoder 31
10907 // 20085: }
10908 102, 61, // 20089: case 0x66: {
10909 OPC_SwitchField, 20, 5, // 20091: switch Inst[24:20] {
10910 28, 32, // 20094: case 0x1c: {
10911 OPC_Scope, 11, // 20096: try {
10912 OPC_CheckField, 7, 5, 0, // 20098: check Inst[11:7] == 0x0
10913 OPC_CheckPredicate, 122, // 20102: check predicate 122
10914 OPC_Decode, 179, 125, 158, 1, // 20104: decode to SSPOPCHK using decoder 158
10915 OPC_Scope, 11, // 20109: } else try {
10916 OPC_CheckField, 15, 5, 0, // 20111: check Inst[19:15] == 0x0
10917 OPC_CheckPredicate, 122, // 20115: check predicate 122
10918 OPC_Decode, 181, 125, 159, 1, // 20117: decode to SSRDP using decoder 159
10919 // 20117: } else try {
10920 OPC_CheckPredicate, 122, // 20122: check predicate 122
10921 OPC_Decode, 216, 117, 17, // 20124: decode to MOP_R_28 using decoder 17
10922 // 20124: }
10923 // 20124: }
10924 29, 6, // 20128: case 0x1d: {
10925 OPC_CheckPredicate, 122, // 20130: check predicate 122
10926 OPC_Decode, 217, 117, 17, // 20132: decode to MOP_R_29 using decoder 17
10927 // 20132: }
10928 30, 6, // 20136: case 0x1e: {
10929 OPC_CheckPredicate, 122, // 20138: check predicate 122
10930 OPC_Decode, 219, 117, 17, // 20140: decode to MOP_R_30 using decoder 17
10931 // 20140: }
10932 31, 0, // 20144: case 0x1f: {
10933 OPC_CheckPredicate, 122, // 20146: check predicate 122
10934 OPC_Decode, 220, 117, 17, // 20148: decode to MOP_R_31 using decoder 17
10935 // 20148: }
10936 // 20148: } // switch Inst[24:20]
10937 // 20148: }
10938 103, 0, // 20152: case 0x67: {
10939 OPC_Scope, 15, // 20154: try {
10940 OPC_CheckField, 7, 5, 0, // 20156: check Inst[11:7] == 0x0
10941 OPC_CheckPredicate, 122, // 20160: check predicate 122
10942 OPC_CheckField, 15, 5, 0, // 20162: check Inst[19:15] == 0x0
10943 OPC_Decode, 180, 125, 160, 1, // 20166: decode to SSPUSH using decoder 160
10944 // 20166: } else try {
10945 OPC_CheckPredicate, 122, // 20171: check predicate 122
10946 OPC_Decode, 194, 117, 31, // 20173: decode to MOP_RR_7 using decoder 31
10947 // 20173: }
10948 // 20173: }
10949 // 20173: } // switch Inst[31:25]
10950 // 20173: }
10951 5, 5, // 20177: case 0x5: {
10952 OPC_Decode, 142, 111, 161, 1, // 20179: decode to CSRRWI using decoder 161
10953 // 20179: }
10954 6, 5, // 20184: case 0x6: {
10955 OPC_Decode, 140, 111, 161, 1, // 20186: decode to CSRRSI using decoder 161
10956 // 20186: }
10957 7, 0, // 20191: case 0x7: {
10958 OPC_Decode, 138, 111, 161, 1, // 20193: decode to CSRRCI using decoder 161
10959 // 20193: }
10960 // 20193: } // switch Inst[14:12]
10961 // 20193: }
10962 119, 238, 3, // 20198: case 0x77: {
10963 OPC_SwitchField, 26, 6, // 20201: switch Inst[31:26] {
10964 32, 15, // 20204: case 0x20: {
10965 OPC_CheckPredicate, 123, // 20206: check predicate 123
10966 OPC_CheckField, 25, 1, 1, // 20208: check Inst[25] == 0x1
10967 OPC_CheckField, 12, 3, 2, // 20212: check Inst[14:12] == 0x2
10968 OPC_Decode, 197, 130, 1, 118, // 20216: decode to VSM3ME_VV using decoder 118
10969 // 20216: }
10970 33, 16, // 20221: case 0x21: {
10971 OPC_CheckPredicate, 124, // 20223: check predicate 124
10972 OPC_CheckField, 25, 1, 1, // 20225: check Inst[25] == 0x1
10973 OPC_CheckField, 12, 3, 2, // 20229: check Inst[14:12] == 0x2
10974 OPC_Decode, 198, 130, 1, 162, 1, // 20233: decode to VSM4K_VI using decoder 162
10975 // 20233: }
10976 34, 15, // 20239: case 0x22: {
10977 OPC_CheckPredicate, 125, // 20241: check predicate 125
10978 OPC_CheckField, 25, 1, 1, // 20243: check Inst[25] == 0x1
10979 OPC_CheckField, 12, 3, 2, // 20247: check Inst[14:12] == 0x2
10980 OPC_Decode, 203, 126, 162, 1, // 20251: decode to VAESKF1_VI using decoder 162
10981 // 20251: }
10982 35, 15, // 20256: case 0x23: {
10983 OPC_CheckPredicate, 126, // 20258: check predicate 126
10984 OPC_CheckField, 25, 1, 1, // 20260: check Inst[25] == 0x1
10985 OPC_CheckField, 12, 3, 2, // 20264: check Inst[14:12] == 0x2
10986 OPC_Decode, 225, 127, 163, 1, // 20268: decode to VGHSH_VS using decoder 163
10987 // 20268: }
10988 36, 10, // 20273: case 0x24: {
10989 OPC_CheckPredicate, 127, // 20275: check predicate 127
10990 OPC_CheckField, 12, 3, 1, // 20277: check Inst[14:12] == 0x1
10991 OPC_Decode, 203, 127, 122, // 20281: decode to VFWDOTA_VV using decoder 122
10992 // 20281: }
10993 38, 22, // 20285: case 0x26: {
10994 OPC_SwitchField, 12, 3, // 20287: switch Inst[14:12] {
10995 0, 8, // 20290: case 0x0: {
10996 OPC_CheckPredicate, 128, 1, // 20292: check predicate 128
10997 OPC_Decode, 137, 130, 1, 122, // 20295: decode to VQWDOTAU_VV using decoder 122
10998 // 20295: }
10999 1, 0, // 20300: case 0x1: {
11000 OPC_CheckPredicate, 129, 1, // 20302: check predicate 129
11001 OPC_Decode, 170, 127, 122, // 20305: decode to VFQWDOTA_VV using decoder 122
11002 // 20305: }
11003 // 20305: } // switch Inst[14:12]
11004 // 20305: }
11005 39, 22, // 20309: case 0x27: {
11006 OPC_SwitchField, 12, 3, // 20311: switch Inst[14:12] {
11007 0, 8, // 20314: case 0x0: {
11008 OPC_CheckPredicate, 128, 1, // 20316: check predicate 128
11009 OPC_Decode, 136, 130, 1, 122, // 20319: decode to VQWDOTAS_VV using decoder 122
11010 // 20319: }
11011 1, 0, // 20324: case 0x1: {
11012 OPC_CheckPredicate, 129, 1, // 20326: check predicate 129
11013 OPC_Decode, 169, 127, 122, // 20329: decode to VFQWDOTA_ALT_VV using decoder 122
11014 // 20329: }
11015 // 20329: } // switch Inst[14:12]
11016 // 20329: }
11017 40, 85, // 20333: case 0x28: {
11018 OPC_SwitchField, 12, 8, // 20335: switch Inst[19:12] {
11019 2, 11, // 20338: case 0x2: {
11020 OPC_CheckPredicate, 125, // 20340: check predicate 125
11021 OPC_CheckField, 25, 1, 1, // 20342: check Inst[25] == 0x1
11022 OPC_Decode, 198, 126, 164, 1, // 20346: decode to VAESDM_VV using decoder 164
11023 // 20346: }
11024 10, 11, // 20351: case 0xa: {
11025 OPC_CheckPredicate, 125, // 20353: check predicate 125
11026 OPC_CheckField, 25, 1, 1, // 20355: check Inst[25] == 0x1
11027 OPC_Decode, 196, 126, 164, 1, // 20359: decode to VAESDF_VV using decoder 164
11028 // 20359: }
11029 18, 11, // 20364: case 0x12: {
11030 OPC_CheckPredicate, 125, // 20366: check predicate 125
11031 OPC_CheckField, 25, 1, 1, // 20368: check Inst[25] == 0x1
11032 OPC_Decode, 202, 126, 164, 1, // 20372: decode to VAESEM_VV using decoder 164
11033 // 20372: }
11034 26, 11, // 20377: case 0x1a: {
11035 OPC_CheckPredicate, 125, // 20379: check predicate 125
11036 OPC_CheckField, 25, 1, 1, // 20381: check Inst[25] == 0x1
11037 OPC_Decode, 200, 126, 164, 1, // 20385: decode to VAESEF_VV using decoder 164
11038 // 20385: }
11039 130, 1, 12, // 20390: case 0x82: {
11040 OPC_CheckPredicate, 124, // 20393: check predicate 124
11041 OPC_CheckField, 25, 1, 1, // 20395: check Inst[25] == 0x1
11042 OPC_Decode, 200, 130, 1, 164, 1, // 20399: decode to VSM4R_VV using decoder 164
11043 // 20399: }
11044 138, 1, 0, // 20405: case 0x8a: {
11045 OPC_CheckPredicate, 130, 1, // 20408: check predicate 130
11046 OPC_CheckField, 25, 1, 1, // 20411: check Inst[25] == 0x1
11047 OPC_Decode, 228, 127, 164, 1, // 20415: decode to VGMUL_VV using decoder 164
11048 // 20415: }
11049 // 20415: } // switch Inst[19:12]
11050 // 20415: }
11051 41, 97, // 20420: case 0x29: {
11052 OPC_SwitchField, 12, 8, // 20422: switch Inst[19:12] {
11053 2, 11, // 20425: case 0x2: {
11054 OPC_CheckPredicate, 125, // 20427: check predicate 125
11055 OPC_CheckField, 25, 1, 1, // 20429: check Inst[25] == 0x1
11056 OPC_Decode, 197, 126, 164, 1, // 20433: decode to VAESDM_VS using decoder 164
11057 // 20433: }
11058 10, 11, // 20438: case 0xa: {
11059 OPC_CheckPredicate, 125, // 20440: check predicate 125
11060 OPC_CheckField, 25, 1, 1, // 20442: check Inst[25] == 0x1
11061 OPC_Decode, 195, 126, 164, 1, // 20446: decode to VAESDF_VS using decoder 164
11062 // 20446: }
11063 18, 11, // 20451: case 0x12: {
11064 OPC_CheckPredicate, 125, // 20453: check predicate 125
11065 OPC_CheckField, 25, 1, 1, // 20455: check Inst[25] == 0x1
11066 OPC_Decode, 201, 126, 164, 1, // 20459: decode to VAESEM_VS using decoder 164
11067 // 20459: }
11068 26, 11, // 20464: case 0x1a: {
11069 OPC_CheckPredicate, 125, // 20466: check predicate 125
11070 OPC_CheckField, 25, 1, 1, // 20468: check Inst[25] == 0x1
11071 OPC_Decode, 199, 126, 164, 1, // 20472: decode to VAESEF_VS using decoder 164
11072 // 20472: }
11073 58, 11, // 20477: case 0x3a: {
11074 OPC_CheckPredicate, 125, // 20479: check predicate 125
11075 OPC_CheckField, 25, 1, 1, // 20481: check Inst[25] == 0x1
11076 OPC_Decode, 205, 126, 164, 1, // 20485: decode to VAESZ_VS using decoder 164
11077 // 20485: }
11078 130, 1, 12, // 20490: case 0x82: {
11079 OPC_CheckPredicate, 124, // 20493: check predicate 124
11080 OPC_CheckField, 25, 1, 1, // 20495: check Inst[25] == 0x1
11081 OPC_Decode, 199, 130, 1, 164, 1, // 20499: decode to VSM4R_VS using decoder 164
11082 // 20499: }
11083 138, 1, 0, // 20505: case 0x8a: {
11084 OPC_CheckPredicate, 126, // 20508: check predicate 126
11085 OPC_CheckField, 25, 1, 1, // 20510: check Inst[25] == 0x1
11086 OPC_Decode, 227, 127, 164, 1, // 20514: decode to VGMUL_VS using decoder 164
11087 // 20514: }
11088 // 20514: } // switch Inst[19:12]
11089 // 20514: }
11090 42, 15, // 20519: case 0x2a: {
11091 OPC_CheckPredicate, 125, // 20521: check predicate 125
11092 OPC_CheckField, 25, 1, 1, // 20523: check Inst[25] == 0x1
11093 OPC_CheckField, 12, 3, 2, // 20527: check Inst[14:12] == 0x2
11094 OPC_Decode, 204, 126, 165, 1, // 20531: decode to VAESKF2_VI using decoder 165
11095 // 20531: }
11096 43, 27, // 20536: case 0x2b: {
11097 OPC_SwitchField, 12, 3, // 20538: switch Inst[14:12] {
11098 1, 8, // 20541: case 0x1: {
11099 OPC_CheckPredicate, 131, 1, // 20543: check predicate 131
11100 OPC_Decode, 242, 126, 166, 1, // 20546: decode to VFBDOTA_VV using decoder 166
11101 // 20546: }
11102 2, 0, // 20551: case 0x2: {
11103 OPC_CheckPredicate, 123, // 20553: check predicate 123
11104 OPC_CheckField, 25, 1, 1, // 20555: check Inst[25] == 0x1
11105 OPC_Decode, 196, 130, 1, 165, 1, // 20559: decode to VSM3C_VI using decoder 165
11106 // 20559: }
11107 // 20559: } // switch Inst[14:12]
11108 // 20559: }
11109 44, 27, // 20565: case 0x2c: {
11110 OPC_SwitchField, 12, 3, // 20567: switch Inst[14:12] {
11111 1, 8, // 20570: case 0x1: {
11112 OPC_CheckPredicate, 132, 1, // 20572: check predicate 132
11113 OPC_Decode, 194, 127, 166, 1, // 20575: decode to VFWBDOTA_VV using decoder 166
11114 // 20575: }
11115 2, 0, // 20580: case 0x2: {
11116 OPC_CheckPredicate, 130, 1, // 20582: check predicate 130
11117 OPC_CheckField, 25, 1, 1, // 20585: check Inst[25] == 0x1
11118 OPC_Decode, 226, 127, 163, 1, // 20589: decode to VGHSH_VV using decoder 163
11119 // 20589: }
11120 // 20589: } // switch Inst[14:12]
11121 // 20589: }
11122 45, 17, // 20594: case 0x2d: {
11123 OPC_CheckPredicate, 133, 1, // 20596: check predicate 133
11124 OPC_CheckField, 25, 1, 1, // 20599: check Inst[25] == 0x1
11125 OPC_CheckField, 12, 3, 2, // 20603: check Inst[14:12] == 0x2
11126 OPC_Decode, 186, 130, 1, 163, 1, // 20607: decode to VSHA2MS_VV using decoder 163
11127 // 20607: }
11128 46, 39, // 20613: case 0x2e: {
11129 OPC_SwitchField, 12, 3, // 20615: switch Inst[14:12] {
11130 0, 9, // 20618: case 0x0: {
11131 OPC_CheckPredicate, 134, 1, // 20620: check predicate 134
11132 OPC_Decode, 135, 130, 1, 166, 1, // 20623: decode to VQWBDOTAU_VV using decoder 166
11133 // 20623: }
11134 1, 8, // 20629: case 0x1: {
11135 OPC_CheckPredicate, 135, 1, // 20631: check predicate 135
11136 OPC_Decode, 168, 127, 166, 1, // 20634: decode to VFQWBDOTA_VV using decoder 166
11137 // 20634: }
11138 2, 0, // 20639: case 0x2: {
11139 OPC_CheckPredicate, 133, 1, // 20641: check predicate 133
11140 OPC_CheckField, 25, 1, 1, // 20644: check Inst[25] == 0x1
11141 OPC_Decode, 184, 130, 1, 163, 1, // 20648: decode to VSHA2CH_VV using decoder 163
11142 // 20648: }
11143 // 20648: } // switch Inst[14:12]
11144 // 20648: }
11145 47, 0, // 20654: case 0x2f: {
11146 OPC_SwitchField, 12, 3, // 20656: switch Inst[14:12] {
11147 0, 9, // 20659: case 0x0: {
11148 OPC_CheckPredicate, 134, 1, // 20661: check predicate 134
11149 OPC_Decode, 134, 130, 1, 166, 1, // 20664: decode to VQWBDOTAS_VV using decoder 166
11150 // 20664: }
11151 1, 8, // 20670: case 0x1: {
11152 OPC_CheckPredicate, 135, 1, // 20672: check predicate 135
11153 OPC_Decode, 167, 127, 166, 1, // 20675: decode to VFQWBDOTA_ALT_VV using decoder 166
11154 // 20675: }
11155 2, 0, // 20680: case 0x2: {
11156 OPC_CheckPredicate, 133, 1, // 20682: check predicate 133
11157 OPC_CheckField, 25, 1, 1, // 20685: check Inst[25] == 0x1
11158 OPC_Decode, 185, 130, 1, 163, 1, // 20689: decode to VSHA2CL_VV using decoder 163
11159 // 20689: }
11160 // 20689: } // switch Inst[14:12]
11161 // 20689: }
11162 // 20689: } // switch Inst[31:26]
11163 // 20689: }
11164 123, 0, // 20695: case 0x7b: {
11165 OPC_SwitchField, 12, 3, // 20697: switch Inst[14:12] {
11166 0, 166, 2, // 20700: case 0x0: {
11167 OPC_SwitchField, 25, 7, // 20703: switch Inst[31:25] {
11168 1, 9, // 20706: case 0x1: {
11169 OPC_CheckPredicate, 136, 1, // 20708: check predicate 136
11170 OPC_Decode, 177, 132, 1, 167, 1, // 20711: decode to YHIW using decoder 167
11171 // 20711: }
11172 3, 24, // 20717: case 0x3: {
11173 OPC_Scope, 13, // 20719: try {
11174 OPC_CheckField, 20, 5, 0, // 20721: check Inst[24:20] == 0x0
11175 OPC_CheckPredicate, 136, 1, // 20725: check predicate 136
11176 OPC_Decode, 183, 132, 1, 168, 1, // 20728: decode to YMV using decoder 168
11177 // 20728: } else try {
11178 OPC_CheckPredicate, 136, 1, // 20734: check predicate 136
11179 OPC_Decode, 166, 132, 1, 169, 1, // 20737: decode to YADD using decoder 169
11180 // 20737: }
11181 // 20737: }
11182 6, 9, // 20743: case 0x6: {
11183 OPC_CheckPredicate, 136, 1, // 20745: check predicate 136
11184 OPC_Decode, 175, 132, 1, 170, 1, // 20748: decode to YEQ using decoder 170
11185 // 20748: }
11186 7, 9, // 20754: case 0x7: {
11187 OPC_CheckPredicate, 136, 1, // 20756: check predicate 136
11188 OPC_Decode, 191, 132, 1, 171, 1, // 20759: decode to YUNSEALS using decoder 171
11189 // 20759: }
11190 11, 9, // 20765: case 0xb: {
11191 OPC_CheckPredicate, 136, 1, // 20767: check predicate 136
11192 OPC_Decode, 168, 132, 1, 172, 1, // 20770: decode to YADDRW using decoder 172
11193 // 20770: }
11194 14, 9, // 20776: case 0xe: {
11195 OPC_CheckPredicate, 136, 1, // 20778: check predicate 136
11196 OPC_Decode, 187, 132, 1, 170, 1, // 20781: decode to YSS using decoder 170
11197 // 20781: }
11198 15, 9, // 20787: case 0xf: {
11199 OPC_CheckPredicate, 136, 1, // 20789: check predicate 136
11200 OPC_Decode, 171, 132, 1, 171, 1, // 20792: decode to YBLD using decoder 171
11201 // 20792: }
11202 19, 9, // 20798: case 0x13: {
11203 OPC_CheckPredicate, 136, 1, // 20800: check predicate 136
11204 OPC_Decode, 184, 132, 1, 172, 1, // 20803: decode to YPERMC using decoder 172
11205 // 20803: }
11206 23, 13, // 20809: case 0x17: {
11207 OPC_CheckPredicate, 136, 1, // 20811: check predicate 136
11208 OPC_CheckField, 15, 5, 0, // 20814: check Inst[19:15] == 0x0
11209 OPC_Decode, 186, 132, 1, 173, 1, // 20818: decode to YSEALE using decoder 173
11210 // 20818: }
11211 27, 9, // 20824: case 0x1b: {
11212 OPC_CheckPredicate, 136, 1, // 20826: check predicate 136
11213 OPC_Decode, 173, 132, 1, 172, 1, // 20829: decode to YBNDSW using decoder 172
11214 // 20829: }
11215 35, 9, // 20835: case 0x23: {
11216 OPC_CheckPredicate, 136, 1, // 20837: check predicate 136
11217 OPC_Decode, 172, 132, 1, 172, 1, // 20840: decode to YBNDSRW using decoder 172
11218 // 20840: }
11219 43, 42, // 20846: case 0x2b: {
11220 OPC_Scope, 31, // 20848: try {
11221 OPC_SwitchField, 15, 10, // 20850: switch Inst[24:15] {
11222 0, 12, // 20853: case 0x0: {
11223 OPC_CheckPredicate, 137, 1, // 20855: check predicate 137
11224 OPC_CheckField, 7, 5, 0, // 20858: check Inst[11:7] == 0x0
11225 OPC_Decode, 181, 132, 1, 14, // 20862: decode to YMODESWY using decoder 14
11226 // 20862: }
11227 32, 0, // 20867: case 0x20: {
11228 OPC_CheckPredicate, 137, 1, // 20869: check predicate 137
11229 OPC_CheckField, 7, 5, 0, // 20872: check Inst[11:7] == 0x0
11230 OPC_Decode, 180, 132, 1, 14, // 20876: decode to YMODESWI using decoder 14
11231 // 20876: }
11232 // 20876: } // switch Inst[24:15]
11233 // 20876: } else try {
11234 OPC_CheckPredicate, 137, 1, // 20881: check predicate 137
11235 OPC_Decode, 182, 132, 1, 174, 1, // 20884: decode to YMODEW using decoder 174
11236 // 20884: }
11237 // 20884: }
11238 120, 12, // 20890: case 0x78: {
11239 OPC_CheckPredicate, 136, 1, // 20892: check predicate 136
11240 OPC_CheckField, 20, 5, 0, // 20895: check Inst[24:20] == 0x0
11241 OPC_Decode, 169, 132, 1, 17, // 20899: decode to YAMASK using decoder 17
11242 // 20899: }
11243 122, 0, // 20904: case 0x7a: {
11244 OPC_SwitchField, 20, 5, // 20906: switch Inst[24:20] {
11245 0, 9, // 20909: case 0x0: {
11246 OPC_CheckPredicate, 136, 1, // 20911: check predicate 136
11247 OPC_Decode, 170, 132, 1, 175, 1, // 20914: decode to YBASER using decoder 175
11248 // 20914: }
11249 1, 9, // 20920: case 0x1: {
11250 OPC_CheckPredicate, 136, 1, // 20922: check predicate 136
11251 OPC_Decode, 185, 132, 1, 175, 1, // 20925: decode to YPERMR using decoder 175
11252 // 20925: }
11253 2, 9, // 20931: case 0x2: {
11254 OPC_CheckPredicate, 136, 1, // 20933: check predicate 136
11255 OPC_Decode, 189, 132, 1, 175, 1, // 20936: decode to YTOPR using decoder 175
11256 // 20936: }
11257 3, 9, // 20942: case 0x3: {
11258 OPC_CheckPredicate, 136, 1, // 20944: check predicate 136
11259 OPC_Decode, 178, 132, 1, 175, 1, // 20947: decode to YLENR using decoder 175
11260 // 20947: }
11261 4, 9, // 20953: case 0x4: {
11262 OPC_CheckPredicate, 136, 1, // 20955: check predicate 136
11263 OPC_Decode, 188, 132, 1, 175, 1, // 20958: decode to YTAGR using decoder 175
11264 // 20958: }
11265 5, 9, // 20964: case 0x5: {
11266 OPC_CheckPredicate, 136, 1, // 20966: check predicate 136
11267 OPC_Decode, 190, 132, 1, 175, 1, // 20969: decode to YTYPER using decoder 175
11268 // 20969: }
11269 6, 9, // 20975: case 0x6: {
11270 OPC_CheckPredicate, 137, 1, // 20977: check predicate 137
11271 OPC_Decode, 179, 132, 1, 175, 1, // 20980: decode to YMODER using decoder 175
11272 // 20980: }
11273 7, 0, // 20986: case 0x7: {
11274 OPC_CheckPredicate, 136, 1, // 20988: check predicate 136
11275 OPC_Decode, 176, 132, 1, 175, 1, // 20991: decode to YHIR using decoder 175
11276 // 20991: }
11277 // 20991: } // switch Inst[24:20]
11278 // 20991: }
11279 // 20991: } // switch Inst[31:25]
11280 // 20991: }
11281 4, 9, // 20997: case 0x4: {
11282 OPC_CheckPredicate, 136, 1, // 20999: check predicate 136
11283 OPC_Decode, 167, 132, 1, 176, 1, // 21002: decode to YADDI using decoder 176
11284 // 21002: }
11285 5, 0, // 21008: case 0x5: {
11286 OPC_CheckPredicate, 136, 1, // 21010: check predicate 136
11287 OPC_CheckField, 29, 3, 7, // 21013: check Inst[31:29] == 0x7
11288 OPC_Decode, 174, 132, 1, 177, 1, // 21017: decode to YBNDSWI using decoder 177
11289 // 21017: }
11290 // 21017: } // switch Inst[14:12]
11291 // 21017: }
11292 // 21017: } // switch Inst[6:0]
11293};
11294static const uint8_t DecoderTableRV32Only32[795] = {
11295 32, // 0: BitWidth 32
11296 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
11297 0, 99, // 4: case 0x0: {
11298 OPC_SwitchField, 25, 7, // 6: switch Inst[31:25] {
11299 73, 10, // 9: case 0x49: {
11300 OPC_CheckPredicate, 47, // 11: check predicate 47
11301 OPC_CheckField, 0, 7, 59, // 13: check Inst[6:0] == 0x3b
11302 OPC_Decode, 220, 123, 31, // 17: decode to SADD using decoder 31
11303 // 17: }
11304 77, 10, // 21: case 0x4d: {
11305 OPC_CheckPredicate, 47, // 23: check predicate 47
11306 OPC_CheckField, 0, 7, 59, // 25: check Inst[6:0] == 0x3b
11307 OPC_Decode, 203, 107, 31, // 29: decode to AADD using decoder 31
11308 // 29: }
11309 89, 10, // 33: case 0x59: {
11310 OPC_CheckPredicate, 47, // 35: check predicate 47
11311 OPC_CheckField, 0, 7, 59, // 37: check Inst[6:0] == 0x3b
11312 OPC_Decode, 221, 123, 31, // 41: decode to SADDU using decoder 31
11313 // 41: }
11314 93, 10, // 45: case 0x5d: {
11315 OPC_CheckPredicate, 47, // 47: check predicate 47
11316 OPC_CheckField, 0, 7, 59, // 49: check Inst[6:0] == 0x3b
11317 OPC_Decode, 204, 107, 31, // 53: decode to AADDU using decoder 31
11318 // 53: }
11319 105, 10, // 57: case 0x69: {
11320 OPC_CheckPredicate, 47, // 59: check predicate 47
11321 OPC_CheckField, 0, 7, 59, // 61: check Inst[6:0] == 0x3b
11322 OPC_Decode, 182, 125, 31, // 65: decode to SSUB using decoder 31
11323 // 65: }
11324 109, 10, // 69: case 0x6d: {
11325 OPC_CheckPredicate, 47, // 71: check predicate 47
11326 OPC_CheckField, 0, 7, 59, // 73: check Inst[6:0] == 0x3b
11327 OPC_Decode, 224, 110, 31, // 77: decode to ASUB using decoder 31
11328 // 77: }
11329 121, 10, // 81: case 0x79: {
11330 OPC_CheckPredicate, 47, // 83: check predicate 47
11331 OPC_CheckField, 0, 7, 59, // 85: check Inst[6:0] == 0x3b
11332 OPC_Decode, 183, 125, 31, // 89: decode to SSUBU using decoder 31
11333 // 89: }
11334 125, 0, // 93: case 0x7d: {
11335 OPC_CheckPredicate, 47, // 95: check predicate 47
11336 OPC_CheckField, 0, 7, 59, // 97: check Inst[6:0] == 0x3b
11337 OPC_Decode, 225, 110, 31, // 101: decode to ASUBU using decoder 31
11338 // 101: }
11339 // 101: } // switch Inst[31:25]
11340 // 101: }
11341 1, 51, // 105: case 0x1: {
11342 OPC_SwitchField, 25, 7, // 107: switch Inst[31:25] {
11343 73, 10, // 110: case 0x49: {
11344 OPC_CheckPredicate, 47, // 112: check predicate 47
11345 OPC_CheckField, 0, 7, 59, // 114: check Inst[6:0] == 0x3b
11346 OPC_Decode, 142, 118, 31, // 118: decode to MUL_H01 using decoder 31
11347 // 118: }
11348 77, 10, // 122: case 0x4d: {
11349 OPC_CheckPredicate, 47, // 124: check predicate 47
11350 OPC_CheckField, 0, 7, 59, // 126: check Inst[6:0] == 0x3b
11351 OPC_Decode, 154, 117, 61, // 130: decode to MACC_H01 using decoder 61
11352 // 130: }
11353 89, 10, // 134: case 0x59: {
11354 OPC_CheckPredicate, 47, // 136: check predicate 47
11355 OPC_CheckField, 0, 7, 59, // 138: check Inst[6:0] == 0x3b
11356 OPC_Decode, 135, 118, 31, // 142: decode to MULU_H01 using decoder 31
11357 // 142: }
11358 93, 0, // 146: case 0x5d: {
11359 OPC_CheckPredicate, 47, // 148: check predicate 47
11360 OPC_CheckField, 0, 7, 59, // 150: check Inst[6:0] == 0x3b
11361 OPC_Decode, 148, 117, 61, // 154: decode to MACCU_H01 using decoder 61
11362 // 154: }
11363 // 154: } // switch Inst[31:25]
11364 // 154: }
11365 2, 75, // 158: case 0x2: {
11366 OPC_SwitchField, 25, 7, // 160: switch Inst[31:25] {
11367 85, 10, // 163: case 0x55: {
11368 OPC_CheckPredicate, 47, // 165: check predicate 47
11369 OPC_CheckField, 0, 7, 27, // 167: check Inst[6:0] == 0x1b
11370 OPC_Decode, 176, 125, 31, // 171: decode to SSHL using decoder 31
11371 // 171: }
11372 89, 10, // 175: case 0x59: {
11373 OPC_CheckPredicate, 47, // 177: check predicate 47
11374 OPC_CheckField, 0, 7, 59, // 179: check Inst[6:0] == 0x3b
11375 OPC_Decode, 173, 125, 31, // 183: decode to SSH1SADD using decoder 31
11376 // 183: }
11377 93, 10, // 187: case 0x5d: {
11378 OPC_CheckPredicate, 47, // 189: check predicate 47
11379 OPC_CheckField, 0, 7, 27, // 191: check Inst[6:0] == 0x1b
11380 OPC_Decode, 177, 125, 31, // 195: decode to SSHLR using decoder 31
11381 // 195: }
11382 105, 10, // 199: case 0x69: {
11383 OPC_CheckPredicate, 47, // 201: check predicate 47
11384 OPC_CheckField, 0, 7, 27, // 203: check Inst[6:0] == 0x1b
11385 OPC_Decode, 178, 125, 21, // 207: decode to SSLAI using decoder 21
11386 // 207: }
11387 117, 10, // 211: case 0x75: {
11388 OPC_CheckPredicate, 47, // 213: check predicate 47
11389 OPC_CheckField, 0, 7, 27, // 215: check Inst[6:0] == 0x1b
11390 OPC_Decode, 174, 125, 31, // 219: decode to SSHA using decoder 31
11391 // 219: }
11392 125, 0, // 223: case 0x7d: {
11393 OPC_CheckPredicate, 47, // 225: check predicate 47
11394 OPC_CheckField, 0, 7, 27, // 227: check Inst[6:0] == 0x1b
11395 OPC_Decode, 175, 125, 31, // 231: decode to SSHAR using decoder 31
11396 // 231: }
11397 // 231: } // switch Inst[31:25]
11398 // 231: }
11399 3, 165, 1, // 235: case 0x3: {
11400 OPC_SwitchField, 0, 7, // 238: switch Inst[6:0] {
11401 3, 8, // 241: case 0x3: {
11402 OPC_CheckPredicate, 138, 1, // 243: check predicate 138
11403 OPC_Decode, 232, 116, 178, 1, // 246: decode to LD_RV32 using decoder 178
11404 // 246: }
11405 35, 8, // 251: case 0x23: {
11406 OPC_CheckPredicate, 138, 1, // 253: check predicate 138
11407 OPC_Decode, 241, 123, 179, 1, // 256: decode to SD_RV32 using decoder 179
11408 // 256: }
11409 47, 39, // 261: case 0x2f: {
11410 OPC_SwitchField, 25, 7, // 263: switch Inst[31:25] {
11411 20, 7, // 266: case 0x14: {
11412 OPC_CheckPredicate, 139, 1, // 268: check predicate 139
11413 OPC_Decode, 217, 109, 58, // 271: decode to AMOCAS_D_RV32 using decoder 58
11414 // 271: }
11415 21, 7, // 275: case 0x15: {
11416 OPC_CheckPredicate, 139, 1, // 277: check predicate 139
11417 OPC_Decode, 220, 109, 58, // 280: decode to AMOCAS_D_RV32_RL using decoder 58
11418 // 280: }
11419 22, 7, // 284: case 0x16: {
11420 OPC_CheckPredicate, 139, 1, // 286: check predicate 139
11421 OPC_Decode, 218, 109, 58, // 289: decode to AMOCAS_D_RV32_AQ using decoder 58
11422 // 289: }
11423 23, 0, // 293: case 0x17: {
11424 OPC_CheckPredicate, 139, 1, // 295: check predicate 139
11425 OPC_Decode, 219, 109, 58, // 298: decode to AMOCAS_D_RV32_AQRL using decoder 58
11426 // 298: }
11427 // 298: } // switch Inst[31:25]
11428 // 298: }
11429 59, 0, // 302: case 0x3b: {
11430 OPC_SwitchField, 25, 7, // 304: switch Inst[31:25] {
11431 65, 6, // 307: case 0x41: {
11432 OPC_CheckPredicate, 47, // 309: check predicate 47
11433 OPC_Decode, 141, 118, 31, // 311: decode to MUL_H00 using decoder 31
11434 // 311: }
11435 69, 6, // 315: case 0x45: {
11436 OPC_CheckPredicate, 47, // 317: check predicate 47
11437 OPC_Decode, 153, 117, 61, // 319: decode to MACC_H00 using decoder 61
11438 // 319: }
11439 73, 6, // 323: case 0x49: {
11440 OPC_CheckPredicate, 47, // 325: check predicate 47
11441 OPC_Decode, 143, 118, 31, // 327: decode to MUL_H11 using decoder 31
11442 // 327: }
11443 77, 6, // 331: case 0x4d: {
11444 OPC_CheckPredicate, 47, // 333: check predicate 47
11445 OPC_Decode, 155, 117, 61, // 335: decode to MACC_H11 using decoder 61
11446 // 335: }
11447 81, 6, // 339: case 0x51: {
11448 OPC_CheckPredicate, 47, // 341: check predicate 47
11449 OPC_Decode, 134, 118, 31, // 343: decode to MULU_H00 using decoder 31
11450 // 343: }
11451 85, 6, // 347: case 0x55: {
11452 OPC_CheckPredicate, 47, // 349: check predicate 47
11453 OPC_Decode, 147, 117, 61, // 351: decode to MACCU_H00 using decoder 61
11454 // 351: }
11455 89, 6, // 355: case 0x59: {
11456 OPC_CheckPredicate, 47, // 357: check predicate 47
11457 OPC_Decode, 136, 118, 31, // 359: decode to MULU_H11 using decoder 31
11458 // 359: }
11459 93, 6, // 363: case 0x5d: {
11460 OPC_CheckPredicate, 47, // 365: check predicate 47
11461 OPC_Decode, 149, 117, 61, // 367: decode to MACCU_H11 using decoder 61
11462 // 367: }
11463 113, 6, // 371: case 0x71: {
11464 OPC_CheckPredicate, 47, // 373: check predicate 47
11465 OPC_Decode, 130, 118, 31, // 375: decode to MULSU_H00 using decoder 31
11466 // 375: }
11467 117, 6, // 379: case 0x75: {
11468 OPC_CheckPredicate, 47, // 381: check predicate 47
11469 OPC_Decode, 143, 117, 61, // 383: decode to MACCSU_H00 using decoder 61
11470 // 383: }
11471 121, 6, // 387: case 0x79: {
11472 OPC_CheckPredicate, 47, // 389: check predicate 47
11473 OPC_Decode, 131, 118, 31, // 391: decode to MULSU_H11 using decoder 31
11474 // 391: }
11475 125, 0, // 395: case 0x7d: {
11476 OPC_CheckPredicate, 47, // 397: check predicate 47
11477 OPC_Decode, 144, 117, 61, // 399: decode to MACCSU_H11 using decoder 61
11478 // 399: }
11479 // 399: } // switch Inst[31:25]
11480 // 399: }
11481 // 399: } // switch Inst[6:0]
11482 // 399: }
11483 4, 39, // 403: case 0x4: {
11484 OPC_SwitchField, 25, 7, // 405: switch Inst[31:25] {
11485 81, 10, // 408: case 0x51: {
11486 OPC_CheckPredicate, 47, // 410: check predicate 47
11487 OPC_CheckField, 0, 7, 27, // 412: check Inst[6:0] == 0x1b
11488 OPC_Decode, 178, 126, 21, // 416: decode to USATI_RV32 using decoder 21
11489 // 416: }
11490 105, 10, // 420: case 0x69: {
11491 OPC_CheckPredicate, 47, // 422: check predicate 47
11492 OPC_CheckField, 0, 7, 27, // 424: check Inst[6:0] == 0x1b
11493 OPC_Decode, 156, 125, 21, // 428: decode to SRARI_RV32 using decoder 21
11494 // 428: }
11495 113, 0, // 432: case 0x71: {
11496 OPC_CheckPredicate, 47, // 434: check predicate 47
11497 OPC_CheckField, 0, 7, 27, // 436: check Inst[6:0] == 0x1b
11498 OPC_Decode, 222, 123, 41, // 440: decode to SATI_RV32 using decoder 41
11499 // 440: }
11500 // 440: } // switch Inst[31:25]
11501 // 440: }
11502 5, 27, // 444: case 0x5: {
11503 OPC_SwitchField, 25, 7, // 446: switch Inst[31:25] {
11504 124, 10, // 449: case 0x7c: {
11505 OPC_CheckPredicate, 47, // 451: check predicate 47
11506 OPC_CheckField, 0, 7, 59, // 453: check Inst[6:0] == 0x3b
11507 OPC_Decode, 228, 117, 61, // 457: decode to MQACC_H01 using decoder 61
11508 // 457: }
11509 126, 0, // 461: case 0x7e: {
11510 OPC_CheckPredicate, 47, // 463: check predicate 47
11511 OPC_CheckField, 0, 7, 59, // 465: check Inst[6:0] == 0x3b
11512 OPC_Decode, 234, 117, 61, // 469: decode to MQRACC_H01 using decoder 61
11513 // 469: }
11514 // 469: } // switch Inst[31:25]
11515 // 469: }
11516 6, 39, // 473: case 0x6: {
11517 OPC_SwitchField, 25, 7, // 475: switch Inst[31:25] {
11518 97, 10, // 478: case 0x61: {
11519 OPC_CheckPredicate, 47, // 480: check predicate 47
11520 OPC_CheckField, 0, 7, 59, // 482: check Inst[6:0] == 0x3b
11521 OPC_Decode, 242, 117, 31, // 486: decode to MSEQ using decoder 31
11522 // 486: }
11523 105, 10, // 490: case 0x69: {
11524 OPC_CheckPredicate, 47, // 492: check predicate 47
11525 OPC_CheckField, 0, 7, 59, // 494: check Inst[6:0] == 0x3b
11526 OPC_Decode, 243, 117, 31, // 498: decode to MSLT using decoder 31
11527 // 498: }
11528 109, 0, // 502: case 0x6d: {
11529 OPC_CheckPredicate, 47, // 504: check predicate 47
11530 OPC_CheckField, 0, 7, 59, // 506: check Inst[6:0] == 0x3b
11531 OPC_Decode, 244, 117, 31, // 510: decode to MSLTU using decoder 31
11532 // 510: }
11533 // 510: } // switch Inst[31:25]
11534 // 510: }
11535 7, 0, // 514: case 0x7: {
11536 OPC_SwitchField, 25, 7, // 516: switch Inst[31:25] {
11537 67, 10, // 519: case 0x43: {
11538 OPC_CheckPredicate, 47, // 521: check predicate 47
11539 OPC_CheckField, 0, 7, 59, // 523: check Inst[6:0] == 0x3b
11540 OPC_Decode, 247, 117, 31, // 527: decode to MULHR using decoder 31
11541 // 527: }
11542 69, 10, // 531: case 0x45: {
11543 OPC_CheckPredicate, 47, // 533: check predicate 47
11544 OPC_CheckField, 0, 7, 59, // 535: check Inst[6:0] == 0x3b
11545 OPC_Decode, 164, 117, 61, // 539: decode to MHACC using decoder 61
11546 // 539: }
11547 71, 10, // 543: case 0x47: {
11548 OPC_CheckPredicate, 47, // 545: check predicate 47
11549 OPC_CheckField, 0, 7, 59, // 547: check Inst[6:0] == 0x3b
11550 OPC_Decode, 171, 117, 61, // 551: decode to MHRACC using decoder 61
11551 // 551: }
11552 75, 10, // 555: case 0x4b: {
11553 OPC_CheckPredicate, 47, // 557: check predicate 47
11554 OPC_CheckField, 0, 7, 59, // 559: check Inst[6:0] == 0x3b
11555 OPC_Decode, 249, 117, 31, // 563: decode to MULHRU using decoder 31
11556 // 563: }
11557 77, 10, // 567: case 0x4d: {
11558 OPC_CheckPredicate, 47, // 569: check predicate 47
11559 OPC_CheckField, 0, 7, 59, // 571: check Inst[6:0] == 0x3b
11560 OPC_Decode, 168, 117, 61, // 575: decode to MHACCU using decoder 61
11561 // 575: }
11562 79, 10, // 579: case 0x4f: {
11563 OPC_CheckPredicate, 47, // 581: check predicate 47
11564 OPC_CheckField, 0, 7, 59, // 583: check Inst[6:0] == 0x3b
11565 OPC_Decode, 173, 117, 61, // 587: decode to MHRACCU using decoder 61
11566 // 587: }
11567 81, 10, // 591: case 0x51: {
11568 OPC_CheckPredicate, 47, // 593: check predicate 47
11569 OPC_CheckField, 0, 7, 59, // 595: check Inst[6:0] == 0x3b
11570 OPC_Decode, 254, 117, 31, // 599: decode to MULH_H0 using decoder 31
11571 // 599: }
11572 83, 10, // 603: case 0x53: {
11573 OPC_CheckPredicate, 47, // 605: check predicate 47
11574 OPC_CheckField, 0, 7, 59, // 607: check Inst[6:0] == 0x3b
11575 OPC_Decode, 251, 117, 31, // 611: decode to MULHSU_H0 using decoder 31
11576 // 611: }
11577 85, 10, // 615: case 0x55: {
11578 OPC_CheckPredicate, 47, // 617: check predicate 47
11579 OPC_CheckField, 0, 7, 59, // 619: check Inst[6:0] == 0x3b
11580 OPC_Decode, 169, 117, 61, // 623: decode to MHACC_H0 using decoder 61
11581 // 623: }
11582 87, 10, // 627: case 0x57: {
11583 OPC_CheckPredicate, 47, // 629: check predicate 47
11584 OPC_CheckField, 0, 7, 59, // 631: check Inst[6:0] == 0x3b
11585 OPC_Decode, 166, 117, 61, // 635: decode to MHACCSU_H0 using decoder 61
11586 // 635: }
11587 89, 10, // 639: case 0x59: {
11588 OPC_CheckPredicate, 47, // 641: check predicate 47
11589 OPC_CheckField, 0, 7, 59, // 643: check Inst[6:0] == 0x3b
11590 OPC_Decode, 255, 117, 31, // 647: decode to MULH_H1 using decoder 31
11591 // 647: }
11592 91, 10, // 651: case 0x5b: {
11593 OPC_CheckPredicate, 47, // 653: check predicate 47
11594 OPC_CheckField, 0, 7, 59, // 655: check Inst[6:0] == 0x3b
11595 OPC_Decode, 252, 117, 31, // 659: decode to MULHSU_H1 using decoder 31
11596 // 659: }
11597 93, 10, // 663: case 0x5d: {
11598 OPC_CheckPredicate, 47, // 665: check predicate 47
11599 OPC_CheckField, 0, 7, 59, // 667: check Inst[6:0] == 0x3b
11600 OPC_Decode, 170, 117, 61, // 671: decode to MHACC_H1 using decoder 61
11601 // 671: }
11602 95, 10, // 675: case 0x5f: {
11603 OPC_CheckPredicate, 47, // 677: check predicate 47
11604 OPC_CheckField, 0, 7, 59, // 679: check Inst[6:0] == 0x3b
11605 OPC_Decode, 167, 117, 61, // 683: decode to MHACCSU_H1 using decoder 61
11606 // 683: }
11607 99, 10, // 687: case 0x63: {
11608 OPC_CheckPredicate, 47, // 689: check predicate 47
11609 OPC_CheckField, 0, 7, 59, // 691: check Inst[6:0] == 0x3b
11610 OPC_Decode, 248, 117, 31, // 695: decode to MULHRSU using decoder 31
11611 // 695: }
11612 101, 10, // 699: case 0x65: {
11613 OPC_CheckPredicate, 47, // 701: check predicate 47
11614 OPC_CheckField, 0, 7, 59, // 703: check Inst[6:0] == 0x3b
11615 OPC_Decode, 165, 117, 61, // 707: decode to MHACCSU using decoder 61
11616 // 707: }
11617 103, 10, // 711: case 0x67: {
11618 OPC_CheckPredicate, 47, // 713: check predicate 47
11619 OPC_CheckField, 0, 7, 59, // 715: check Inst[6:0] == 0x3b
11620 OPC_Decode, 172, 117, 61, // 719: decode to MHRACCSU using decoder 61
11621 // 719: }
11622 105, 10, // 723: case 0x69: {
11623 OPC_CheckPredicate, 47, // 725: check predicate 47
11624 OPC_CheckField, 0, 7, 59, // 727: check Inst[6:0] == 0x3b
11625 OPC_Decode, 128, 118, 31, // 731: decode to MULQ using decoder 31
11626 // 731: }
11627 107, 10, // 735: case 0x6b: {
11628 OPC_CheckPredicate, 47, // 737: check predicate 47
11629 OPC_CheckField, 0, 7, 59, // 739: check Inst[6:0] == 0x3b
11630 OPC_Decode, 129, 118, 31, // 743: decode to MULQR using decoder 31
11631 // 743: }
11632 116, 10, // 747: case 0x74: {
11633 OPC_CheckPredicate, 47, // 749: check predicate 47
11634 OPC_CheckField, 0, 7, 59, // 751: check Inst[6:0] == 0x3b
11635 OPC_Decode, 227, 117, 61, // 755: decode to MQACC_H00 using decoder 61
11636 // 755: }
11637 118, 10, // 759: case 0x76: {
11638 OPC_CheckPredicate, 47, // 761: check predicate 47
11639 OPC_CheckField, 0, 7, 59, // 763: check Inst[6:0] == 0x3b
11640 OPC_Decode, 233, 117, 61, // 767: decode to MQRACC_H00 using decoder 61
11641 // 767: }
11642 124, 10, // 771: case 0x7c: {
11643 OPC_CheckPredicate, 47, // 773: check predicate 47
11644 OPC_CheckField, 0, 7, 59, // 775: check Inst[6:0] == 0x3b
11645 OPC_Decode, 229, 117, 61, // 779: decode to MQACC_H11 using decoder 61
11646 // 779: }
11647 126, 0, // 783: case 0x7e: {
11648 OPC_CheckPredicate, 47, // 785: check predicate 47
11649 OPC_CheckField, 0, 7, 59, // 787: check Inst[6:0] == 0x3b
11650 OPC_Decode, 235, 117, 61, // 791: decode to MQRACC_H11 using decoder 61
11651 // 791: }
11652 // 791: } // switch Inst[31:25]
11653 // 791: }
11654 // 791: } // switch Inst[14:12]
11655};
11656static const uint8_t DecoderTableXAIF32[2612] = {
11657 32, // 0: BitWidth 32
11658 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
11659 7, 12, // 4: case 0x7: {
11660 OPC_CheckPredicate, 140, 1, // 6: check predicate 140
11661 OPC_CheckField, 12, 3, 5, // 9: check Inst[14:12] == 0x5
11662 OPC_Decode, 225, 108, 180, 1, // 13: decode to AIF_FLQ2 using decoder 180
11663 // 13: }
11664 11, 195, 4, // 18: case 0xb: {
11665 OPC_SwitchField, 12, 3, // 21: switch Inst[14:12] {
11666 0, 8, // 24: case 0x0: {
11667 OPC_CheckPredicate, 140, 1, // 26: check predicate 140
11668 OPC_Decode, 171, 108, 180, 1, // 29: decode to AIF_FBC_PS using decoder 180
11669 // 29: }
11670 1, 123, // 34: case 0x1: {
11671 OPC_SwitchField, 25, 7, // 36: switch Inst[31:25] {
11672 4, 8, // 39: case 0x4: {
11673 OPC_CheckPredicate, 140, 1, // 41: check predicate 140
11674 OPC_Decode, 209, 108, 181, 1, // 44: decode to AIF_FG32B_PS using decoder 181
11675 // 44: }
11676 8, 8, // 49: case 0x8: {
11677 OPC_CheckPredicate, 140, 1, // 51: check predicate 140
11678 OPC_Decode, 210, 108, 181, 1, // 54: decode to AIF_FG32H_PS using decoder 181
11679 // 54: }
11680 16, 8, // 59: case 0x10: {
11681 OPC_CheckPredicate, 140, 1, // 61: check predicate 140
11682 OPC_Decode, 211, 108, 181, 1, // 64: decode to AIF_FG32W_PS using decoder 181
11683 // 64: }
11684 36, 8, // 69: case 0x24: {
11685 OPC_CheckPredicate, 140, 1, // 71: check predicate 140
11686 OPC_Decode, 214, 108, 182, 1, // 74: decode to AIF_FGB_PS using decoder 182
11687 // 74: }
11688 40, 8, // 79: case 0x28: {
11689 OPC_CheckPredicate, 140, 1, // 81: check predicate 140
11690 OPC_Decode, 217, 108, 182, 1, // 84: decode to AIF_FGH_PS using decoder 182
11691 // 84: }
11692 48, 8, // 89: case 0x30: {
11693 OPC_CheckPredicate, 140, 1, // 91: check predicate 140
11694 OPC_Decode, 220, 108, 182, 1, // 94: decode to AIF_FGW_PS using decoder 182
11695 // 94: }
11696 68, 8, // 99: case 0x44: {
11697 OPC_CheckPredicate, 140, 1, // 101: check predicate 140
11698 OPC_Decode, 134, 109, 181, 1, // 104: decode to AIF_FSC32B_PS using decoder 181
11699 // 104: }
11700 72, 8, // 109: case 0x48: {
11701 OPC_CheckPredicate, 140, 1, // 111: check predicate 140
11702 OPC_Decode, 135, 109, 181, 1, // 114: decode to AIF_FSC32H_PS using decoder 181
11703 // 114: }
11704 80, 8, // 119: case 0x50: {
11705 OPC_CheckPredicate, 140, 1, // 121: check predicate 140
11706 OPC_Decode, 136, 109, 181, 1, // 124: decode to AIF_FSC32W_PS using decoder 181
11707 // 124: }
11708 100, 8, // 129: case 0x64: {
11709 OPC_CheckPredicate, 140, 1, // 131: check predicate 140
11710 OPC_Decode, 139, 109, 182, 1, // 134: decode to AIF_FSCB_PS using decoder 182
11711 // 134: }
11712 104, 8, // 139: case 0x68: {
11713 OPC_CheckPredicate, 140, 1, // 141: check predicate 140
11714 OPC_Decode, 142, 109, 182, 1, // 144: decode to AIF_FSCH_PS using decoder 182
11715 // 144: }
11716 112, 0, // 149: case 0x70: {
11717 OPC_CheckPredicate, 140, 1, // 151: check predicate 140
11718 OPC_Decode, 145, 109, 182, 1, // 154: decode to AIF_FSCW_PS using decoder 182
11719 // 154: }
11720 // 154: } // switch Inst[31:25]
11721 // 154: }
11722 2, 8, // 159: case 0x2: {
11723 OPC_CheckPredicate, 140, 1, // 161: check predicate 140
11724 OPC_Decode, 233, 108, 180, 1, // 164: decode to AIF_FLW_PS using decoder 180
11725 // 164: }
11726 3, 12, // 169: case 0x3: {
11727 OPC_CheckPredicate, 140, 1, // 171: check predicate 140
11728 OPC_CheckField, 20, 12, 0, // 174: check Inst[31:20] == 0x0
11729 OPC_Decode, 170, 108, 183, 1, // 178: decode to AIF_FBCX_PS using decoder 183
11730 // 178: }
11731 4, 223, 1, // 183: case 0x4: {
11732 OPC_SwitchField, 25, 7, // 186: switch Inst[31:25] {
11733 3, 8, // 189: case 0x3: {
11734 OPC_CheckPredicate, 140, 1, // 191: check predicate 140
11735 OPC_Decode, 145, 108, 182, 1, // 194: decode to AIF_FAMOADDL_PI using decoder 182
11736 // 194: }
11737 7, 8, // 199: case 0x7: {
11738 OPC_CheckPredicate, 140, 1, // 201: check predicate 140
11739 OPC_Decode, 163, 108, 182, 1, // 204: decode to AIF_FAMOSWAPL_PI using decoder 182
11740 // 204: }
11741 11, 8, // 209: case 0xb: {
11742 OPC_CheckPredicate, 140, 1, // 211: check predicate 140
11743 OPC_Decode, 147, 108, 182, 1, // 214: decode to AIF_FAMOANDL_PI using decoder 182
11744 // 214: }
11745 15, 8, // 219: case 0xf: {
11746 OPC_CheckPredicate, 140, 1, // 221: check predicate 140
11747 OPC_Decode, 161, 108, 182, 1, // 224: decode to AIF_FAMOORL_PI using decoder 182
11748 // 224: }
11749 19, 8, // 229: case 0x13: {
11750 OPC_CheckPredicate, 140, 1, // 231: check predicate 140
11751 OPC_Decode, 165, 108, 182, 1, // 234: decode to AIF_FAMOXORL_PI using decoder 182
11752 // 234: }
11753 20, 8, // 239: case 0x14: {
11754 OPC_CheckPredicate, 140, 1, // 241: check predicate 140
11755 OPC_Decode, 151, 108, 182, 1, // 244: decode to AIF_FAMOMAXL_PS using decoder 182
11756 // 244: }
11757 23, 8, // 249: case 0x17: {
11758 OPC_CheckPredicate, 140, 1, // 251: check predicate 140
11759 OPC_Decode, 156, 108, 182, 1, // 254: decode to AIF_FAMOMINL_PI using decoder 182
11760 // 254: }
11761 24, 8, // 259: case 0x18: {
11762 OPC_CheckPredicate, 140, 1, // 261: check predicate 140
11763 OPC_Decode, 157, 108, 182, 1, // 264: decode to AIF_FAMOMINL_PS using decoder 182
11764 // 264: }
11765 27, 8, // 269: case 0x1b: {
11766 OPC_CheckPredicate, 140, 1, // 271: check predicate 140
11767 OPC_Decode, 150, 108, 182, 1, // 274: decode to AIF_FAMOMAXL_PI using decoder 182
11768 // 274: }
11769 31, 8, // 279: case 0x1f: {
11770 OPC_CheckPredicate, 140, 1, // 281: check predicate 140
11771 OPC_Decode, 159, 108, 182, 1, // 284: decode to AIF_FAMOMINUL_PI using decoder 182
11772 // 284: }
11773 35, 8, // 289: case 0x23: {
11774 OPC_CheckPredicate, 140, 1, // 291: check predicate 140
11775 OPC_Decode, 153, 108, 182, 1, // 294: decode to AIF_FAMOMAXUL_PI using decoder 182
11776 // 294: }
11777 67, 8, // 299: case 0x43: {
11778 OPC_CheckPredicate, 140, 1, // 301: check predicate 140
11779 OPC_Decode, 144, 108, 182, 1, // 304: decode to AIF_FAMOADDG_PI using decoder 182
11780 // 304: }
11781 71, 8, // 309: case 0x47: {
11782 OPC_CheckPredicate, 140, 1, // 311: check predicate 140
11783 OPC_Decode, 162, 108, 182, 1, // 314: decode to AIF_FAMOSWAPG_PI using decoder 182
11784 // 314: }
11785 75, 8, // 319: case 0x4b: {
11786 OPC_CheckPredicate, 140, 1, // 321: check predicate 140
11787 OPC_Decode, 146, 108, 182, 1, // 324: decode to AIF_FAMOANDG_PI using decoder 182
11788 // 324: }
11789 79, 8, // 329: case 0x4f: {
11790 OPC_CheckPredicate, 140, 1, // 331: check predicate 140
11791 OPC_Decode, 160, 108, 182, 1, // 334: decode to AIF_FAMOORG_PI using decoder 182
11792 // 334: }
11793 83, 8, // 339: case 0x53: {
11794 OPC_CheckPredicate, 140, 1, // 341: check predicate 140
11795 OPC_Decode, 164, 108, 182, 1, // 344: decode to AIF_FAMOXORG_PI using decoder 182
11796 // 344: }
11797 84, 8, // 349: case 0x54: {
11798 OPC_CheckPredicate, 140, 1, // 351: check predicate 140
11799 OPC_Decode, 149, 108, 182, 1, // 354: decode to AIF_FAMOMAXG_PS using decoder 182
11800 // 354: }
11801 87, 8, // 359: case 0x57: {
11802 OPC_CheckPredicate, 140, 1, // 361: check predicate 140
11803 OPC_Decode, 154, 108, 182, 1, // 364: decode to AIF_FAMOMING_PI using decoder 182
11804 // 364: }
11805 88, 8, // 369: case 0x58: {
11806 OPC_CheckPredicate, 140, 1, // 371: check predicate 140
11807 OPC_Decode, 155, 108, 182, 1, // 374: decode to AIF_FAMOMING_PS using decoder 182
11808 // 374: }
11809 91, 8, // 379: case 0x5b: {
11810 OPC_CheckPredicate, 140, 1, // 381: check predicate 140
11811 OPC_Decode, 148, 108, 182, 1, // 384: decode to AIF_FAMOMAXG_PI using decoder 182
11812 // 384: }
11813 95, 8, // 389: case 0x5f: {
11814 OPC_CheckPredicate, 140, 1, // 391: check predicate 140
11815 OPC_Decode, 158, 108, 182, 1, // 394: decode to AIF_FAMOMINUG_PI using decoder 182
11816 // 394: }
11817 99, 0, // 399: case 0x63: {
11818 OPC_CheckPredicate, 140, 1, // 401: check predicate 140
11819 OPC_Decode, 152, 108, 182, 1, // 404: decode to AIF_FAMOMAXUG_PI using decoder 182
11820 // 404: }
11821 // 404: } // switch Inst[31:25]
11822 // 404: }
11823 6, 8, // 409: case 0x6: {
11824 OPC_CheckPredicate, 140, 1, // 411: check predicate 140
11825 OPC_Decode, 164, 109, 184, 1, // 414: decode to AIF_FSW_PS using decoder 184
11826 // 414: }
11827 7, 0, // 419: case 0x7: {
11828 OPC_SwitchField, 25, 7, // 421: switch Inst[31:25] {
11829 8, 12, // 424: case 0x8: {
11830 OPC_CheckPredicate, 140, 1, // 426: check predicate 140
11831 OPC_CheckField, 20, 5, 0, // 429: check Inst[24:20] == 0x0
11832 OPC_Decode, 232, 108, 183, 1, // 433: decode to AIF_FLWL_PS using decoder 183
11833 // 433: }
11834 9, 12, // 438: case 0x9: {
11835 OPC_CheckPredicate, 140, 1, // 440: check predicate 140
11836 OPC_CheckField, 20, 5, 0, // 443: check Inst[24:20] == 0x0
11837 OPC_Decode, 231, 108, 183, 1, // 447: decode to AIF_FLWG_PS using decoder 183
11838 // 447: }
11839 40, 12, // 452: case 0x28: {
11840 OPC_CheckPredicate, 140, 1, // 454: check predicate 140
11841 OPC_CheckField, 20, 5, 0, // 457: check Inst[24:20] == 0x0
11842 OPC_Decode, 163, 109, 183, 1, // 461: decode to AIF_FSWL_PS using decoder 183
11843 // 461: }
11844 41, 12, // 466: case 0x29: {
11845 OPC_CheckPredicate, 140, 1, // 468: check predicate 140
11846 OPC_CheckField, 20, 5, 0, // 471: check Inst[24:20] == 0x0
11847 OPC_Decode, 161, 109, 183, 1, // 475: decode to AIF_FSWG_PS using decoder 183
11848 // 475: }
11849 64, 8, // 480: case 0x40: {
11850 OPC_CheckPredicate, 140, 1, // 482: check predicate 140
11851 OPC_Decode, 213, 108, 182, 1, // 485: decode to AIF_FGBL_PS using decoder 182
11852 // 485: }
11853 65, 8, // 490: case 0x41: {
11854 OPC_CheckPredicate, 140, 1, // 492: check predicate 140
11855 OPC_Decode, 212, 108, 182, 1, // 495: decode to AIF_FGBG_PS using decoder 182
11856 // 495: }
11857 68, 8, // 500: case 0x44: {
11858 OPC_CheckPredicate, 140, 1, // 502: check predicate 140
11859 OPC_Decode, 216, 108, 182, 1, // 505: decode to AIF_FGHL_PS using decoder 182
11860 // 505: }
11861 69, 8, // 510: case 0x45: {
11862 OPC_CheckPredicate, 140, 1, // 512: check predicate 140
11863 OPC_Decode, 215, 108, 182, 1, // 515: decode to AIF_FGHG_PS using decoder 182
11864 // 515: }
11865 72, 8, // 520: case 0x48: {
11866 OPC_CheckPredicate, 140, 1, // 522: check predicate 140
11867 OPC_Decode, 219, 108, 182, 1, // 525: decode to AIF_FGWL_PS using decoder 182
11868 // 525: }
11869 73, 8, // 530: case 0x49: {
11870 OPC_CheckPredicate, 140, 1, // 532: check predicate 140
11871 OPC_Decode, 218, 108, 182, 1, // 535: decode to AIF_FGWG_PS using decoder 182
11872 // 535: }
11873 96, 8, // 540: case 0x60: {
11874 OPC_CheckPredicate, 140, 1, // 542: check predicate 140
11875 OPC_Decode, 138, 109, 182, 1, // 545: decode to AIF_FSCBL_PS using decoder 182
11876 // 545: }
11877 97, 8, // 550: case 0x61: {
11878 OPC_CheckPredicate, 140, 1, // 552: check predicate 140
11879 OPC_Decode, 137, 109, 182, 1, // 555: decode to AIF_FSCBG_PS using decoder 182
11880 // 555: }
11881 100, 8, // 560: case 0x64: {
11882 OPC_CheckPredicate, 140, 1, // 562: check predicate 140
11883 OPC_Decode, 141, 109, 182, 1, // 565: decode to AIF_FSCHL_PS using decoder 182
11884 // 565: }
11885 101, 8, // 570: case 0x65: {
11886 OPC_CheckPredicate, 140, 1, // 572: check predicate 140
11887 OPC_Decode, 140, 109, 182, 1, // 575: decode to AIF_FSCHG_PS using decoder 182
11888 // 575: }
11889 104, 8, // 580: case 0x68: {
11890 OPC_CheckPredicate, 140, 1, // 582: check predicate 140
11891 OPC_Decode, 144, 109, 182, 1, // 585: decode to AIF_FSCWL_PS using decoder 182
11892 // 585: }
11893 105, 0, // 590: case 0x69: {
11894 OPC_CheckPredicate, 140, 1, // 592: check predicate 140
11895 OPC_Decode, 143, 109, 182, 1, // 595: decode to AIF_FSCWG_PS using decoder 182
11896 // 595: }
11897 // 595: } // switch Inst[31:25]
11898 // 595: }
11899 // 595: } // switch Inst[14:12]
11900 // 595: }
11901 31, 8, // 600: case 0x1f: {
11902 OPC_CheckPredicate, 140, 1, // 602: check predicate 140
11903 OPC_Decode, 169, 108, 185, 1, // 605: decode to AIF_FBCI_PS using decoder 185
11904 // 605: }
11905 39, 12, // 610: case 0x27: {
11906 OPC_CheckPredicate, 140, 1, // 612: check predicate 140
11907 OPC_CheckField, 12, 3, 5, // 615: check Inst[14:12] == 0x5
11908 OPC_Decode, 153, 109, 184, 1, // 619: decode to AIF_FSQ2 using decoder 184
11909 // 619: }
11910 59, 149, 4, // 624: case 0x3b: {
11911 OPC_SwitchField, 25, 7, // 627: switch Inst[31:25] {
11912 0, 21, // 630: case 0x0: {
11913 OPC_SwitchField, 12, 3, // 632: switch Inst[14:12] {
11914 2, 7, // 635: case 0x2: {
11915 OPC_CheckPredicate, 140, 1, // 637: check predicate 140
11916 OPC_Decode, 227, 107, 56, // 640: decode to AIF_AMOADDL_W using decoder 56
11917 // 640: }
11918 3, 0, // 644: case 0x3: {
11919 OPC_CheckPredicate, 140, 1, // 646: check predicate 140
11920 OPC_Decode, 226, 107, 56, // 649: decode to AIF_AMOADDL_D using decoder 56
11921 // 649: }
11922 // 649: } // switch Inst[14:12]
11923 // 649: }
11924 1, 21, // 653: case 0x1: {
11925 OPC_SwitchField, 12, 3, // 655: switch Inst[14:12] {
11926 2, 7, // 658: case 0x2: {
11927 OPC_CheckPredicate, 140, 1, // 660: check predicate 140
11928 OPC_Decode, 225, 107, 56, // 663: decode to AIF_AMOADDG_W using decoder 56
11929 // 663: }
11930 3, 0, // 667: case 0x3: {
11931 OPC_CheckPredicate, 140, 1, // 669: check predicate 140
11932 OPC_Decode, 224, 107, 56, // 672: decode to AIF_AMOADDG_D using decoder 56
11933 // 672: }
11934 // 672: } // switch Inst[14:12]
11935 // 672: }
11936 4, 21, // 676: case 0x4: {
11937 OPC_SwitchField, 12, 3, // 678: switch Inst[14:12] {
11938 2, 7, // 681: case 0x2: {
11939 OPC_CheckPredicate, 140, 1, // 683: check predicate 140
11940 OPC_Decode, 131, 108, 56, // 686: decode to AIF_AMOSWAPL_W using decoder 56
11941 // 686: }
11942 3, 0, // 690: case 0x3: {
11943 OPC_CheckPredicate, 140, 1, // 692: check predicate 140
11944 OPC_Decode, 130, 108, 56, // 695: decode to AIF_AMOSWAPL_D using decoder 56
11945 // 695: }
11946 // 695: } // switch Inst[14:12]
11947 // 695: }
11948 5, 21, // 699: case 0x5: {
11949 OPC_SwitchField, 12, 3, // 701: switch Inst[14:12] {
11950 2, 7, // 704: case 0x2: {
11951 OPC_CheckPredicate, 140, 1, // 706: check predicate 140
11952 OPC_Decode, 129, 108, 56, // 709: decode to AIF_AMOSWAPG_W using decoder 56
11953 // 709: }
11954 3, 0, // 713: case 0x3: {
11955 OPC_CheckPredicate, 140, 1, // 715: check predicate 140
11956 OPC_Decode, 128, 108, 56, // 718: decode to AIF_AMOSWAPG_D using decoder 56
11957 // 718: }
11958 // 718: } // switch Inst[14:12]
11959 // 718: }
11960 8, 11, // 722: case 0x8: {
11961 OPC_CheckPredicate, 140, 1, // 724: check predicate 140
11962 OPC_CheckField, 7, 8, 96, // 727: check Inst[14:7] == 0x60
11963 OPC_Decode, 178, 109, 59, // 731: decode to AIF_SBL using decoder 59
11964 // 731: }
11965 9, 11, // 735: case 0x9: {
11966 OPC_CheckPredicate, 140, 1, // 737: check predicate 140
11967 OPC_CheckField, 7, 8, 96, // 740: check Inst[14:7] == 0x60
11968 OPC_Decode, 177, 109, 59, // 744: decode to AIF_SBG using decoder 59
11969 // 744: }
11970 12, 11, // 748: case 0xc: {
11971 OPC_CheckPredicate, 140, 1, // 750: check predicate 140
11972 OPC_CheckField, 7, 8, 96, // 753: check Inst[14:7] == 0x60
11973 OPC_Decode, 180, 109, 59, // 757: decode to AIF_SHL using decoder 59
11974 // 757: }
11975 13, 11, // 761: case 0xd: {
11976 OPC_CheckPredicate, 140, 1, // 763: check predicate 140
11977 OPC_CheckField, 7, 8, 96, // 766: check Inst[14:7] == 0x60
11978 OPC_Decode, 179, 109, 59, // 770: decode to AIF_SHG using decoder 59
11979 // 770: }
11980 16, 21, // 774: case 0x10: {
11981 OPC_SwitchField, 12, 3, // 776: switch Inst[14:12] {
11982 2, 7, // 779: case 0x2: {
11983 OPC_CheckPredicate, 140, 1, // 781: check predicate 140
11984 OPC_Decode, 135, 108, 56, // 784: decode to AIF_AMOXORL_W using decoder 56
11985 // 784: }
11986 3, 0, // 788: case 0x3: {
11987 OPC_CheckPredicate, 140, 1, // 790: check predicate 140
11988 OPC_Decode, 134, 108, 56, // 793: decode to AIF_AMOXORL_D using decoder 56
11989 // 793: }
11990 // 793: } // switch Inst[14:12]
11991 // 793: }
11992 17, 21, // 797: case 0x11: {
11993 OPC_SwitchField, 12, 3, // 799: switch Inst[14:12] {
11994 2, 7, // 802: case 0x2: {
11995 OPC_CheckPredicate, 140, 1, // 804: check predicate 140
11996 OPC_Decode, 133, 108, 56, // 807: decode to AIF_AMOXORG_W using decoder 56
11997 // 807: }
11998 3, 0, // 811: case 0x3: {
11999 OPC_CheckPredicate, 140, 1, // 813: check predicate 140
12000 OPC_Decode, 132, 108, 56, // 816: decode to AIF_AMOXORG_D using decoder 56
12001 // 816: }
12002 // 816: } // switch Inst[14:12]
12003 // 816: }
12004 32, 21, // 820: case 0x20: {
12005 OPC_SwitchField, 12, 3, // 822: switch Inst[14:12] {
12006 2, 7, // 825: case 0x2: {
12007 OPC_CheckPredicate, 140, 1, // 827: check predicate 140
12008 OPC_Decode, 255, 107, 56, // 830: decode to AIF_AMOORL_W using decoder 56
12009 // 830: }
12010 3, 0, // 834: case 0x3: {
12011 OPC_CheckPredicate, 140, 1, // 836: check predicate 140
12012 OPC_Decode, 254, 107, 56, // 839: decode to AIF_AMOORL_D using decoder 56
12013 // 839: }
12014 // 839: } // switch Inst[14:12]
12015 // 839: }
12016 33, 21, // 843: case 0x21: {
12017 OPC_SwitchField, 12, 3, // 845: switch Inst[14:12] {
12018 2, 7, // 848: case 0x2: {
12019 OPC_CheckPredicate, 140, 1, // 850: check predicate 140
12020 OPC_Decode, 253, 107, 56, // 853: decode to AIF_AMOORG_W using decoder 56
12021 // 853: }
12022 3, 0, // 857: case 0x3: {
12023 OPC_CheckPredicate, 140, 1, // 859: check predicate 140
12024 OPC_Decode, 252, 107, 56, // 862: decode to AIF_AMOORG_D using decoder 56
12025 // 862: }
12026 // 862: } // switch Inst[14:12]
12027 // 862: }
12028 48, 21, // 866: case 0x30: {
12029 OPC_SwitchField, 12, 3, // 868: switch Inst[14:12] {
12030 2, 7, // 871: case 0x2: {
12031 OPC_CheckPredicate, 140, 1, // 873: check predicate 140
12032 OPC_Decode, 231, 107, 56, // 876: decode to AIF_AMOANDL_W using decoder 56
12033 // 876: }
12034 3, 0, // 880: case 0x3: {
12035 OPC_CheckPredicate, 140, 1, // 882: check predicate 140
12036 OPC_Decode, 230, 107, 56, // 885: decode to AIF_AMOANDL_D using decoder 56
12037 // 885: }
12038 // 885: } // switch Inst[14:12]
12039 // 885: }
12040 49, 21, // 889: case 0x31: {
12041 OPC_SwitchField, 12, 3, // 891: switch Inst[14:12] {
12042 2, 7, // 894: case 0x2: {
12043 OPC_CheckPredicate, 140, 1, // 896: check predicate 140
12044 OPC_Decode, 229, 107, 56, // 899: decode to AIF_AMOANDG_W using decoder 56
12045 // 899: }
12046 3, 0, // 903: case 0x3: {
12047 OPC_CheckPredicate, 140, 1, // 905: check predicate 140
12048 OPC_Decode, 228, 107, 56, // 908: decode to AIF_AMOANDG_D using decoder 56
12049 // 908: }
12050 // 908: } // switch Inst[14:12]
12051 // 908: }
12052 64, 39, // 912: case 0x40: {
12053 OPC_SwitchField, 12, 3, // 914: switch Inst[14:12] {
12054 2, 7, // 917: case 0x2: {
12055 OPC_CheckPredicate, 140, 1, // 919: check predicate 140
12056 OPC_Decode, 247, 107, 56, // 922: decode to AIF_AMOMINL_W using decoder 56
12057 // 922: }
12058 3, 7, // 926: case 0x3: {
12059 OPC_CheckPredicate, 140, 1, // 928: check predicate 140
12060 OPC_Decode, 246, 107, 56, // 931: decode to AIF_AMOMINL_D using decoder 56
12061 // 931: }
12062 6, 7, // 935: case 0x6: {
12063 OPC_CheckPredicate, 140, 1, // 937: check predicate 140
12064 OPC_Decode, 176, 109, 31, // 940: decode to AIF_PACKB using decoder 31
12065 // 940: }
12066 7, 0, // 944: case 0x7: {
12067 OPC_CheckPredicate, 140, 1, // 946: check predicate 140
12068 OPC_Decode, 136, 108, 31, // 949: decode to AIF_BITMIXB using decoder 31
12069 // 949: }
12070 // 949: } // switch Inst[14:12]
12071 // 949: }
12072 65, 21, // 953: case 0x41: {
12073 OPC_SwitchField, 12, 3, // 955: switch Inst[14:12] {
12074 2, 7, // 958: case 0x2: {
12075 OPC_CheckPredicate, 140, 1, // 960: check predicate 140
12076 OPC_Decode, 245, 107, 56, // 963: decode to AIF_AMOMING_W using decoder 56
12077 // 963: }
12078 3, 0, // 967: case 0x3: {
12079 OPC_CheckPredicate, 140, 1, // 969: check predicate 140
12080 OPC_Decode, 244, 107, 56, // 972: decode to AIF_AMOMING_D using decoder 56
12081 // 972: }
12082 // 972: } // switch Inst[14:12]
12083 // 972: }
12084 80, 21, // 976: case 0x50: {
12085 OPC_SwitchField, 12, 3, // 978: switch Inst[14:12] {
12086 2, 7, // 981: case 0x2: {
12087 OPC_CheckPredicate, 140, 1, // 983: check predicate 140
12088 OPC_Decode, 239, 107, 56, // 986: decode to AIF_AMOMAXL_W using decoder 56
12089 // 986: }
12090 3, 0, // 990: case 0x3: {
12091 OPC_CheckPredicate, 140, 1, // 992: check predicate 140
12092 OPC_Decode, 238, 107, 56, // 995: decode to AIF_AMOMAXL_D using decoder 56
12093 // 995: }
12094 // 995: } // switch Inst[14:12]
12095 // 995: }
12096 81, 21, // 999: case 0x51: {
12097 OPC_SwitchField, 12, 3, // 1001: switch Inst[14:12] {
12098 2, 7, // 1004: case 0x2: {
12099 OPC_CheckPredicate, 140, 1, // 1006: check predicate 140
12100 OPC_Decode, 237, 107, 56, // 1009: decode to AIF_AMOMAXG_W using decoder 56
12101 // 1009: }
12102 3, 0, // 1013: case 0x3: {
12103 OPC_CheckPredicate, 140, 1, // 1015: check predicate 140
12104 OPC_Decode, 236, 107, 56, // 1018: decode to AIF_AMOMAXG_D using decoder 56
12105 // 1018: }
12106 // 1018: } // switch Inst[14:12]
12107 // 1018: }
12108 96, 21, // 1022: case 0x60: {
12109 OPC_SwitchField, 12, 3, // 1024: switch Inst[14:12] {
12110 2, 7, // 1027: case 0x2: {
12111 OPC_CheckPredicate, 140, 1, // 1029: check predicate 140
12112 OPC_Decode, 251, 107, 56, // 1032: decode to AIF_AMOMINUL_W using decoder 56
12113 // 1032: }
12114 3, 0, // 1036: case 0x3: {
12115 OPC_CheckPredicate, 140, 1, // 1038: check predicate 140
12116 OPC_Decode, 250, 107, 56, // 1041: decode to AIF_AMOMINUL_D using decoder 56
12117 // 1041: }
12118 // 1041: } // switch Inst[14:12]
12119 // 1041: }
12120 97, 21, // 1045: case 0x61: {
12121 OPC_SwitchField, 12, 3, // 1047: switch Inst[14:12] {
12122 2, 7, // 1050: case 0x2: {
12123 OPC_CheckPredicate, 140, 1, // 1052: check predicate 140
12124 OPC_Decode, 249, 107, 56, // 1055: decode to AIF_AMOMINUG_W using decoder 56
12125 // 1055: }
12126 3, 0, // 1059: case 0x3: {
12127 OPC_CheckPredicate, 140, 1, // 1061: check predicate 140
12128 OPC_Decode, 248, 107, 56, // 1064: decode to AIF_AMOMINUG_D using decoder 56
12129 // 1064: }
12130 // 1064: } // switch Inst[14:12]
12131 // 1064: }
12132 112, 21, // 1068: case 0x70: {
12133 OPC_SwitchField, 12, 3, // 1070: switch Inst[14:12] {
12134 2, 7, // 1073: case 0x2: {
12135 OPC_CheckPredicate, 140, 1, // 1075: check predicate 140
12136 OPC_Decode, 243, 107, 56, // 1078: decode to AIF_AMOMAXUL_W using decoder 56
12137 // 1078: }
12138 3, 0, // 1082: case 0x3: {
12139 OPC_CheckPredicate, 140, 1, // 1084: check predicate 140
12140 OPC_Decode, 242, 107, 56, // 1087: decode to AIF_AMOMAXUL_D using decoder 56
12141 // 1087: }
12142 // 1087: } // switch Inst[14:12]
12143 // 1087: }
12144 113, 21, // 1091: case 0x71: {
12145 OPC_SwitchField, 12, 3, // 1093: switch Inst[14:12] {
12146 2, 7, // 1096: case 0x2: {
12147 OPC_CheckPredicate, 140, 1, // 1098: check predicate 140
12148 OPC_Decode, 241, 107, 56, // 1101: decode to AIF_AMOMAXUG_W using decoder 56
12149 // 1101: }
12150 3, 0, // 1105: case 0x3: {
12151 OPC_CheckPredicate, 140, 1, // 1107: check predicate 140
12152 OPC_Decode, 240, 107, 56, // 1110: decode to AIF_AMOMAXUG_D using decoder 56
12153 // 1110: }
12154 // 1110: } // switch Inst[14:12]
12155 // 1110: }
12156 120, 21, // 1114: case 0x78: {
12157 OPC_SwitchField, 12, 3, // 1116: switch Inst[14:12] {
12158 2, 7, // 1119: case 0x2: {
12159 OPC_CheckPredicate, 140, 1, // 1121: check predicate 140
12160 OPC_Decode, 235, 107, 56, // 1124: decode to AIF_AMOCMPSWAPL_W using decoder 56
12161 // 1124: }
12162 3, 0, // 1128: case 0x3: {
12163 OPC_CheckPredicate, 140, 1, // 1130: check predicate 140
12164 OPC_Decode, 234, 107, 56, // 1133: decode to AIF_AMOCMPSWAPL_D using decoder 56
12165 // 1133: }
12166 // 1133: } // switch Inst[14:12]
12167 // 1133: }
12168 121, 0, // 1137: case 0x79: {
12169 OPC_SwitchField, 12, 3, // 1139: switch Inst[14:12] {
12170 2, 7, // 1142: case 0x2: {
12171 OPC_CheckPredicate, 140, 1, // 1144: check predicate 140
12172 OPC_Decode, 233, 107, 56, // 1147: decode to AIF_AMOCMPSWAPG_W using decoder 56
12173 // 1147: }
12174 3, 0, // 1151: case 0x3: {
12175 OPC_CheckPredicate, 140, 1, // 1153: check predicate 140
12176 OPC_Decode, 232, 107, 56, // 1156: decode to AIF_AMOCMPSWAPG_D using decoder 56
12177 // 1156: }
12178 // 1156: } // switch Inst[14:12]
12179 // 1156: }
12180 // 1156: } // switch Inst[31:25]
12181 // 1156: }
12182 63, 45, // 1160: case 0x3f: {
12183 OPC_SwitchField, 12, 3, // 1162: switch Inst[14:12] {
12184 0, 12, // 1165: case 0x0: {
12185 OPC_CheckPredicate, 140, 1, // 1167: check predicate 140
12186 OPC_CheckField, 25, 2, 2, // 1170: check Inst[26:25] == 0x2
12187 OPC_Decode, 141, 108, 186, 1, // 1174: decode to AIF_FADDI_PI using decoder 186
12188 // 1174: }
12189 1, 12, // 1179: case 0x1: {
12190 OPC_CheckPredicate, 140, 1, // 1181: check predicate 140
12191 OPC_CheckField, 25, 2, 2, // 1184: check Inst[26:25] == 0x2
12192 OPC_Decode, 166, 108, 186, 1, // 1188: decode to AIF_FANDI_PI using decoder 186
12193 // 1188: }
12194 2, 0, // 1193: case 0x2: {
12195 OPC_CheckPredicate, 140, 1, // 1195: check predicate 140
12196 OPC_CheckField, 25, 2, 2, // 1198: check Inst[26:25] == 0x2
12197 OPC_Decode, 174, 108, 187, 1, // 1202: decode to AIF_FCMOV_PS using decoder 187
12198 // 1202: }
12199 // 1202: } // switch Inst[14:12]
12200 // 1202: }
12201 91, 43, // 1207: case 0x5b: {
12202 OPC_SwitchField, 25, 2, // 1209: switch Inst[26:25] {
12203 0, 8, // 1212: case 0x0: {
12204 OPC_CheckPredicate, 140, 1, // 1214: check predicate 140
12205 OPC_Decode, 234, 108, 188, 1, // 1217: decode to AIF_FMADD_PS using decoder 188
12206 // 1217: }
12207 1, 8, // 1222: case 0x1: {
12208 OPC_CheckPredicate, 140, 1, // 1224: check predicate 140
12209 OPC_Decode, 241, 108, 188, 1, // 1227: decode to AIF_FMSUB_PS using decoder 188
12210 // 1227: }
12211 2, 8, // 1232: case 0x2: {
12212 OPC_CheckPredicate, 140, 1, // 1234: check predicate 140
12213 OPC_Decode, 249, 108, 188, 1, // 1237: decode to AIF_FNMSUB_PS using decoder 188
12214 // 1237: }
12215 3, 0, // 1242: case 0x3: {
12216 OPC_CheckPredicate, 140, 1, // 1244: check predicate 140
12217 OPC_Decode, 248, 108, 188, 1, // 1247: decode to AIF_FNMADD_PS using decoder 188
12218 // 1247: }
12219 // 1247: } // switch Inst[26:25]
12220 // 1247: }
12221 95, 8, // 1252: case 0x5f: {
12222 OPC_CheckPredicate, 140, 1, // 1254: check predicate 140
12223 OPC_Decode, 168, 108, 185, 1, // 1257: decode to AIF_FBCI_PI using decoder 185
12224 // 1257: }
12225 119, 16, // 1262: case 0x77: {
12226 OPC_CheckPredicate, 140, 1, // 1264: check predicate 140
12227 OPC_CheckField, 25, 7, 0, // 1267: check Inst[31:25] == 0x0
12228 OPC_CheckField, 12, 3, 0, // 1271: check Inst[14:12] == 0x0
12229 OPC_Decode, 173, 108, 189, 1, // 1275: decode to AIF_FCMOVM_PS using decoder 189
12230 // 1275: }
12231 123, 0, // 1280: case 0x7b: {
12232 OPC_SwitchField, 25, 7, // 1282: switch Inst[31:25] {
12233 0, 8, // 1285: case 0x0: {
12234 OPC_CheckPredicate, 140, 1, // 1287: check predicate 140
12235 OPC_Decode, 143, 108, 190, 1, // 1290: decode to AIF_FADD_PS using decoder 190
12236 // 1290: }
12237 3, 102, // 1295: case 0x3: {
12238 OPC_SwitchField, 12, 3, // 1297: switch Inst[14:12] {
12239 0, 8, // 1300: case 0x0: {
12240 OPC_CheckPredicate, 140, 1, // 1302: check predicate 140
12241 OPC_Decode, 142, 108, 189, 1, // 1305: decode to AIF_FADD_PI using decoder 189
12242 // 1305: }
12243 1, 8, // 1310: case 0x1: {
12244 OPC_CheckPredicate, 140, 1, // 1312: check predicate 140
12245 OPC_Decode, 152, 109, 189, 1, // 1315: decode to AIF_FSLL_PI using decoder 189
12246 // 1315: }
12247 2, 12, // 1320: case 0x2: {
12248 OPC_CheckPredicate, 140, 1, // 1322: check predicate 140
12249 OPC_CheckField, 20, 5, 0, // 1325: check Inst[24:20] == 0x0
12250 OPC_Decode, 250, 108, 191, 1, // 1329: decode to AIF_FNOT_PI using decoder 191
12251 // 1329: }
12252 3, 23, // 1334: case 0x3: {
12253 OPC_SwitchField, 20, 5, // 1336: switch Inst[24:20] {
12254 0, 8, // 1339: case 0x0: {
12255 OPC_CheckPredicate, 140, 1, // 1341: check predicate 140
12256 OPC_Decode, 132, 109, 191, 1, // 1344: decode to AIF_FSAT8_PI using decoder 191
12257 // 1344: }
12258 1, 0, // 1349: case 0x1: {
12259 OPC_CheckPredicate, 140, 1, // 1351: check predicate 140
12260 OPC_Decode, 133, 109, 191, 1, // 1354: decode to AIF_FSATU8_PI using decoder 191
12261 // 1354: }
12262 // 1354: } // switch Inst[24:20]
12263 // 1354: }
12264 4, 8, // 1359: case 0x4: {
12265 OPC_CheckPredicate, 140, 1, // 1361: check predicate 140
12266 OPC_Decode, 165, 109, 189, 1, // 1364: decode to AIF_FXOR_PI using decoder 189
12267 // 1364: }
12268 5, 8, // 1369: case 0x5: {
12269 OPC_CheckPredicate, 140, 1, // 1371: check predicate 140
12270 OPC_Decode, 158, 109, 189, 1, // 1374: decode to AIF_FSRL_PI using decoder 189
12271 // 1374: }
12272 6, 8, // 1379: case 0x6: {
12273 OPC_CheckPredicate, 140, 1, // 1381: check predicate 140
12274 OPC_Decode, 251, 108, 189, 1, // 1384: decode to AIF_FOR_PI using decoder 189
12275 // 1384: }
12276 7, 0, // 1389: case 0x7: {
12277 OPC_CheckPredicate, 140, 1, // 1391: check predicate 140
12278 OPC_Decode, 167, 108, 189, 1, // 1394: decode to AIF_FAND_PI using decoder 189
12279 // 1394: }
12280 // 1394: } // switch Inst[14:12]
12281 // 1394: }
12282 4, 8, // 1399: case 0x4: {
12283 OPC_CheckPredicate, 140, 1, // 1401: check predicate 140
12284 OPC_Decode, 160, 109, 190, 1, // 1404: decode to AIF_FSUB_PS using decoder 190
12285 // 1404: }
12286 7, 23, // 1409: case 0x7: {
12287 OPC_SwitchField, 12, 3, // 1411: switch Inst[14:12] {
12288 0, 8, // 1414: case 0x0: {
12289 OPC_CheckPredicate, 140, 1, // 1416: check predicate 140
12290 OPC_Decode, 159, 109, 189, 1, // 1419: decode to AIF_FSUB_PI using decoder 189
12291 // 1419: }
12292 5, 0, // 1424: case 0x5: {
12293 OPC_CheckPredicate, 140, 1, // 1426: check predicate 140
12294 OPC_Decode, 156, 109, 189, 1, // 1429: decode to AIF_FSRA_PI using decoder 189
12295 // 1429: }
12296 // 1429: } // switch Inst[14:12]
12297 // 1429: }
12298 8, 8, // 1434: case 0x8: {
12299 OPC_CheckPredicate, 140, 1, // 1436: check predicate 140
12300 OPC_Decode, 245, 108, 190, 1, // 1439: decode to AIF_FMUL_PS using decoder 190
12301 // 1439: }
12302 11, 33, // 1444: case 0xb: {
12303 OPC_SwitchField, 12, 3, // 1446: switch Inst[14:12] {
12304 0, 8, // 1449: case 0x0: {
12305 OPC_CheckPredicate, 140, 1, // 1451: check predicate 140
12306 OPC_Decode, 244, 108, 189, 1, // 1454: decode to AIF_FMUL_PI using decoder 189
12307 // 1454: }
12308 1, 8, // 1459: case 0x1: {
12309 OPC_CheckPredicate, 140, 1, // 1461: check predicate 140
12310 OPC_Decode, 243, 108, 189, 1, // 1464: decode to AIF_FMULH_PI using decoder 189
12311 // 1464: }
12312 2, 0, // 1469: case 0x2: {
12313 OPC_CheckPredicate, 140, 1, // 1471: check predicate 140
12314 OPC_Decode, 242, 108, 189, 1, // 1474: decode to AIF_FMULHU_PI using decoder 189
12315 // 1474: }
12316 // 1474: } // switch Inst[14:12]
12317 // 1474: }
12318 12, 8, // 1479: case 0xc: {
12319 OPC_CheckPredicate, 140, 1, // 1481: check predicate 140
12320 OPC_Decode, 203, 108, 190, 1, // 1484: decode to AIF_FDIV_PS using decoder 190
12321 // 1484: }
12322 15, 43, // 1489: case 0xf: {
12323 OPC_SwitchField, 12, 3, // 1491: switch Inst[14:12] {
12324 0, 8, // 1494: case 0x0: {
12325 OPC_CheckPredicate, 140, 1, // 1496: check predicate 140
12326 OPC_Decode, 202, 108, 189, 1, // 1499: decode to AIF_FDIV_PI using decoder 189
12327 // 1499: }
12328 1, 8, // 1504: case 0x1: {
12329 OPC_CheckPredicate, 140, 1, // 1506: check predicate 140
12330 OPC_Decode, 201, 108, 189, 1, // 1509: decode to AIF_FDIVU_PI using decoder 189
12331 // 1509: }
12332 2, 8, // 1514: case 0x2: {
12333 OPC_CheckPredicate, 140, 1, // 1516: check predicate 140
12334 OPC_Decode, 129, 109, 189, 1, // 1519: decode to AIF_FREM_PI using decoder 189
12335 // 1519: }
12336 3, 0, // 1524: case 0x3: {
12337 OPC_CheckPredicate, 140, 1, // 1526: check predicate 140
12338 OPC_Decode, 128, 109, 189, 1, // 1529: decode to AIF_FREMU_PI using decoder 189
12339 // 1529: }
12340 // 1529: } // switch Inst[14:12]
12341 // 1529: }
12342 16, 33, // 1534: case 0x10: {
12343 OPC_SwitchField, 12, 3, // 1536: switch Inst[14:12] {
12344 0, 8, // 1539: case 0x0: {
12345 OPC_CheckPredicate, 140, 1, // 1541: check predicate 140
12346 OPC_Decode, 149, 109, 189, 1, // 1544: decode to AIF_FSGNJ_PS using decoder 189
12347 // 1544: }
12348 1, 8, // 1549: case 0x1: {
12349 OPC_CheckPredicate, 140, 1, // 1551: check predicate 140
12350 OPC_Decode, 147, 109, 189, 1, // 1554: decode to AIF_FSGNJN_PS using decoder 189
12351 // 1554: }
12352 2, 0, // 1559: case 0x2: {
12353 OPC_CheckPredicate, 140, 1, // 1561: check predicate 140
12354 OPC_Decode, 148, 109, 189, 1, // 1564: decode to AIF_FSGNJX_PS using decoder 189
12355 // 1564: }
12356 // 1564: } // switch Inst[14:12]
12357 // 1564: }
12358 19, 31, // 1569: case 0x13: {
12359 OPC_SwitchField, 12, 3, // 1571: switch Inst[14:12] {
12360 0, 12, // 1574: case 0x0: {
12361 OPC_CheckPredicate, 140, 1, // 1576: check predicate 140
12362 OPC_CheckField, 20, 5, 0, // 1579: check Inst[24:20] == 0x0
12363 OPC_Decode, 252, 108, 191, 1, // 1583: decode to AIF_FPACKREPB_PI using decoder 191
12364 // 1583: }
12365 1, 0, // 1588: case 0x1: {
12366 OPC_CheckPredicate, 140, 1, // 1590: check predicate 140
12367 OPC_CheckField, 20, 5, 0, // 1593: check Inst[24:20] == 0x0
12368 OPC_Decode, 253, 108, 191, 1, // 1597: decode to AIF_FPACKREPH_PI using decoder 191
12369 // 1597: }
12370 // 1597: } // switch Inst[14:12]
12371 // 1597: }
12372 20, 23, // 1602: case 0x14: {
12373 OPC_SwitchField, 12, 3, // 1604: switch Inst[14:12] {
12374 0, 8, // 1607: case 0x0: {
12375 OPC_CheckPredicate, 140, 1, // 1609: check predicate 140
12376 OPC_Decode, 240, 108, 189, 1, // 1612: decode to AIF_FMIN_PS using decoder 189
12377 // 1612: }
12378 1, 0, // 1617: case 0x1: {
12379 OPC_CheckPredicate, 140, 1, // 1619: check predicate 140
12380 OPC_Decode, 237, 108, 189, 1, // 1622: decode to AIF_FMAX_PS using decoder 189
12381 // 1622: }
12382 // 1622: } // switch Inst[14:12]
12383 // 1622: }
12384 23, 43, // 1627: case 0x17: {
12385 OPC_SwitchField, 12, 3, // 1629: switch Inst[14:12] {
12386 0, 8, // 1632: case 0x0: {
12387 OPC_CheckPredicate, 140, 1, // 1634: check predicate 140
12388 OPC_Decode, 239, 108, 189, 1, // 1637: decode to AIF_FMIN_PI using decoder 189
12389 // 1637: }
12390 1, 8, // 1642: case 0x1: {
12391 OPC_CheckPredicate, 140, 1, // 1644: check predicate 140
12392 OPC_Decode, 236, 108, 189, 1, // 1647: decode to AIF_FMAX_PI using decoder 189
12393 // 1647: }
12394 2, 8, // 1652: case 0x2: {
12395 OPC_CheckPredicate, 140, 1, // 1654: check predicate 140
12396 OPC_Decode, 238, 108, 189, 1, // 1657: decode to AIF_FMINU_PI using decoder 189
12397 // 1657: }
12398 3, 0, // 1662: case 0x3: {
12399 OPC_CheckPredicate, 140, 1, // 1664: check predicate 140
12400 OPC_Decode, 235, 108, 189, 1, // 1667: decode to AIF_FMAXU_PI using decoder 189
12401 // 1667: }
12402 // 1667: } // switch Inst[14:12]
12403 // 1667: }
12404 24, 12, // 1672: case 0x18: {
12405 OPC_CheckPredicate, 140, 1, // 1674: check predicate 140
12406 OPC_CheckField, 12, 3, 0, // 1677: check Inst[14:12] == 0x0
12407 OPC_Decode, 254, 108, 189, 1, // 1681: decode to AIF_FRCP_FIX_RAST using decoder 189
12408 // 1681: }
12409 31, 12, // 1686: case 0x1f: {
12410 OPC_CheckPredicate, 140, 1, // 1688: check predicate 140
12411 OPC_CheckField, 12, 3, 0, // 1691: check Inst[14:12] == 0x0
12412 OPC_Decode, 226, 108, 192, 1, // 1695: decode to AIF_FLTM_PI using decoder 192
12413 // 1695: }
12414 39, 33, // 1700: case 0x27: {
12415 OPC_SwitchField, 12, 3, // 1702: switch Inst[14:12] {
12416 1, 8, // 1705: case 0x1: {
12417 OPC_CheckPredicate, 140, 1, // 1707: check predicate 140
12418 OPC_Decode, 151, 109, 193, 1, // 1710: decode to AIF_FSLLI_PI using decoder 193
12419 // 1710: }
12420 5, 8, // 1715: case 0x5: {
12421 OPC_CheckPredicate, 140, 1, // 1717: check predicate 140
12422 OPC_Decode, 157, 109, 193, 1, // 1720: decode to AIF_FSRLI_PI using decoder 193
12423 // 1720: }
12424 7, 0, // 1725: case 0x7: {
12425 OPC_CheckPredicate, 140, 1, // 1727: check predicate 140
12426 OPC_Decode, 155, 109, 193, 1, // 1730: decode to AIF_FSRAI_PI using decoder 193
12427 // 1730: }
12428 // 1730: } // switch Inst[14:12]
12429 // 1730: }
12430 41, 16, // 1735: case 0x29: {
12431 OPC_CheckPredicate, 140, 1, // 1737: check predicate 140
12432 OPC_CheckField, 18, 7, 0, // 1740: check Inst[24:18] == 0x0
12433 OPC_CheckField, 12, 3, 0, // 1744: check Inst[14:12] == 0x0
12434 OPC_Decode, 169, 109, 194, 1, // 1748: decode to AIF_MASKPOPC using decoder 194
12435 // 1748: }
12436 42, 16, // 1753: case 0x2a: {
12437 OPC_CheckPredicate, 140, 1, // 1755: check predicate 140
12438 OPC_CheckField, 18, 7, 0, // 1758: check Inst[24:18] == 0x0
12439 OPC_CheckField, 12, 3, 0, // 1762: check Inst[14:12] == 0x0
12440 OPC_Decode, 170, 109, 194, 1, // 1766: decode to AIF_MASKPOPCZ using decoder 194
12441 // 1766: }
12442 43, 12, // 1771: case 0x2b: {
12443 OPC_CheckPredicate, 140, 1, // 1773: check predicate 140
12444 OPC_CheckField, 10, 2, 0, // 1776: check Inst[11:10] == 0x0
12445 OPC_Decode, 175, 109, 195, 1, // 1780: decode to AIF_MOV_M_X using decoder 195
12446 // 1780: }
12447 44, 111, // 1785: case 0x2c: {
12448 OPC_SwitchField, 20, 5, // 1787: switch Inst[24:20] {
12449 0, 12, // 1790: case 0x0: {
12450 OPC_CheckPredicate, 140, 1, // 1792: check predicate 140
12451 OPC_CheckField, 12, 3, 0, // 1795: check Inst[14:12] == 0x0
12452 OPC_Decode, 154, 109, 191, 1, // 1799: decode to AIF_FSQRT_PS using decoder 191
12453 // 1799: }
12454 1, 8, // 1804: case 0x1: {
12455 OPC_CheckPredicate, 140, 1, // 1806: check predicate 140
12456 OPC_Decode, 130, 109, 196, 1, // 1809: decode to AIF_FROUND_PS using decoder 196
12457 // 1809: }
12458 2, 12, // 1814: case 0x2: {
12459 OPC_CheckPredicate, 140, 1, // 1816: check predicate 140
12460 OPC_CheckField, 12, 3, 0, // 1819: check Inst[14:12] == 0x0
12461 OPC_Decode, 208, 108, 191, 1, // 1823: decode to AIF_FFRC_PS using decoder 191
12462 // 1823: }
12463 3, 12, // 1828: case 0x3: {
12464 OPC_CheckPredicate, 140, 1, // 1830: check predicate 140
12465 OPC_CheckField, 12, 3, 0, // 1833: check Inst[14:12] == 0x0
12466 OPC_Decode, 224, 108, 191, 1, // 1837: decode to AIF_FLOG_PS using decoder 191
12467 // 1837: }
12468 4, 12, // 1842: case 0x4: {
12469 OPC_CheckPredicate, 140, 1, // 1844: check predicate 140
12470 OPC_CheckField, 12, 3, 0, // 1847: check Inst[14:12] == 0x0
12471 OPC_Decode, 207, 108, 191, 1, // 1851: decode to AIF_FEXP_PS using decoder 191
12472 // 1851: }
12473 6, 12, // 1856: case 0x6: {
12474 OPC_CheckPredicate, 140, 1, // 1858: check predicate 140
12475 OPC_CheckField, 12, 3, 0, // 1861: check Inst[14:12] == 0x0
12476 OPC_Decode, 150, 109, 191, 1, // 1865: decode to AIF_FSIN_PS using decoder 191
12477 // 1865: }
12478 7, 12, // 1870: case 0x7: {
12479 OPC_CheckPredicate, 140, 1, // 1872: check predicate 140
12480 OPC_CheckField, 12, 3, 0, // 1875: check Inst[14:12] == 0x0
12481 OPC_Decode, 255, 108, 191, 1, // 1879: decode to AIF_FRCP_PS using decoder 191
12482 // 1879: }
12483 8, 0, // 1884: case 0x8: {
12484 OPC_CheckPredicate, 140, 1, // 1886: check predicate 140
12485 OPC_CheckField, 12, 3, 0, // 1889: check Inst[14:12] == 0x0
12486 OPC_Decode, 131, 109, 191, 1, // 1893: decode to AIF_FRSQ_PS using decoder 191
12487 // 1893: }
12488 // 1893: } // switch Inst[24:20]
12489 // 1893: }
12490 47, 12, // 1898: case 0x2f: {
12491 OPC_CheckPredicate, 140, 1, // 1900: check predicate 140
12492 OPC_CheckField, 12, 3, 0, // 1903: check Inst[14:12] == 0x0
12493 OPC_Decode, 171, 109, 197, 1, // 1907: decode to AIF_MASKPOPC_ET_RAST using decoder 197
12494 // 1907: }
12495 51, 71, // 1912: case 0x33: {
12496 OPC_SwitchField, 10, 5, // 1914: switch Inst[14:10] {
12497 8, 12, // 1917: case 0x8: {
12498 OPC_CheckPredicate, 140, 1, // 1919: check predicate 140
12499 OPC_CheckField, 18, 7, 0, // 1922: check Inst[24:18] == 0x0
12500 OPC_Decode, 167, 109, 198, 1, // 1926: decode to AIF_MASKNOT using decoder 198
12501 // 1926: }
12502 16, 16, // 1931: case 0x10: {
12503 OPC_CheckPredicate, 140, 1, // 1933: check predicate 140
12504 OPC_CheckField, 23, 2, 0, // 1936: check Inst[24:23] == 0x0
12505 OPC_CheckField, 18, 2, 0, // 1940: check Inst[19:18] == 0x0
12506 OPC_Decode, 172, 109, 199, 1, // 1944: decode to AIF_MASKXOR using decoder 199
12507 // 1944: }
12508 24, 16, // 1949: case 0x18: {
12509 OPC_CheckPredicate, 140, 1, // 1951: check predicate 140
12510 OPC_CheckField, 23, 2, 0, // 1954: check Inst[24:23] == 0x0
12511 OPC_CheckField, 18, 2, 0, // 1958: check Inst[19:18] == 0x0
12512 OPC_Decode, 168, 109, 199, 1, // 1962: decode to AIF_MASKOR using decoder 199
12513 // 1962: }
12514 28, 0, // 1967: case 0x1c: {
12515 OPC_CheckPredicate, 140, 1, // 1969: check predicate 140
12516 OPC_CheckField, 23, 2, 0, // 1972: check Inst[24:23] == 0x0
12517 OPC_CheckField, 18, 2, 0, // 1976: check Inst[19:18] == 0x0
12518 OPC_Decode, 166, 109, 199, 1, // 1980: decode to AIF_MASKAND using decoder 199
12519 // 1980: }
12520 // 1980: } // switch Inst[14:10]
12521 // 1980: }
12522 68, 43, // 1985: case 0x44: {
12523 OPC_SwitchField, 12, 3, // 1987: switch Inst[14:12] {
12524 0, 8, // 1990: case 0x0: {
12525 OPC_CheckPredicate, 140, 1, // 1992: check predicate 140
12526 OPC_Decode, 138, 108, 189, 1, // 1995: decode to AIF_CUBEFACE_PS using decoder 189
12527 // 1995: }
12528 1, 8, // 2000: case 0x1: {
12529 OPC_CheckPredicate, 140, 1, // 2002: check predicate 140
12530 OPC_Decode, 137, 108, 189, 1, // 2005: decode to AIF_CUBEFACEIDX_PS using decoder 189
12531 // 2005: }
12532 2, 8, // 2010: case 0x2: {
12533 OPC_CheckPredicate, 140, 1, // 2012: check predicate 140
12534 OPC_Decode, 139, 108, 189, 1, // 2015: decode to AIF_CUBESGNSC_PS using decoder 189
12535 // 2015: }
12536 3, 0, // 2020: case 0x3: {
12537 OPC_CheckPredicate, 140, 1, // 2022: check predicate 140
12538 OPC_Decode, 140, 108, 189, 1, // 2025: decode to AIF_CUBESGNTC_PS using decoder 189
12539 // 2025: }
12540 // 2025: } // switch Inst[14:12]
12541 // 2025: }
12542 80, 63, // 2030: case 0x50: {
12543 OPC_SwitchField, 12, 3, // 2032: switch Inst[14:12] {
12544 0, 8, // 2035: case 0x0: {
12545 OPC_CheckPredicate, 140, 1, // 2037: check predicate 140
12546 OPC_Decode, 223, 108, 189, 1, // 2040: decode to AIF_FLE_PS using decoder 189
12547 // 2040: }
12548 1, 8, // 2045: case 0x1: {
12549 OPC_CheckPredicate, 140, 1, // 2047: check predicate 140
12550 OPC_Decode, 230, 108, 189, 1, // 2050: decode to AIF_FLT_PS using decoder 189
12551 // 2050: }
12552 2, 8, // 2055: case 0x2: {
12553 OPC_CheckPredicate, 140, 1, // 2057: check predicate 140
12554 OPC_Decode, 206, 108, 189, 1, // 2060: decode to AIF_FEQ_PS using decoder 189
12555 // 2060: }
12556 4, 8, // 2065: case 0x4: {
12557 OPC_CheckPredicate, 140, 1, // 2067: check predicate 140
12558 OPC_Decode, 221, 108, 192, 1, // 2070: decode to AIF_FLEM_PS using decoder 192
12559 // 2070: }
12560 5, 8, // 2075: case 0x5: {
12561 OPC_CheckPredicate, 140, 1, // 2077: check predicate 140
12562 OPC_Decode, 227, 108, 192, 1, // 2080: decode to AIF_FLTM_PS using decoder 192
12563 // 2080: }
12564 6, 0, // 2085: case 0x6: {
12565 OPC_CheckPredicate, 140, 1, // 2087: check predicate 140
12566 OPC_Decode, 204, 108, 192, 1, // 2090: decode to AIF_FEQM_PS using decoder 192
12567 // 2090: }
12568 // 2090: } // switch Inst[14:12]
12569 // 2090: }
12570 83, 57, // 2095: case 0x53: {
12571 OPC_SwitchField, 12, 3, // 2097: switch Inst[14:12] {
12572 0, 8, // 2100: case 0x0: {
12573 OPC_CheckPredicate, 140, 1, // 2102: check predicate 140
12574 OPC_Decode, 222, 108, 189, 1, // 2105: decode to AIF_FLE_PI using decoder 189
12575 // 2105: }
12576 1, 8, // 2110: case 0x1: {
12577 OPC_CheckPredicate, 140, 1, // 2112: check predicate 140
12578 OPC_Decode, 229, 108, 189, 1, // 2115: decode to AIF_FLT_PI using decoder 189
12579 // 2115: }
12580 2, 8, // 2120: case 0x2: {
12581 OPC_CheckPredicate, 140, 1, // 2122: check predicate 140
12582 OPC_Decode, 205, 108, 189, 1, // 2125: decode to AIF_FEQ_PI using decoder 189
12583 // 2125: }
12584 3, 8, // 2130: case 0x3: {
12585 OPC_CheckPredicate, 140, 1, // 2132: check predicate 140
12586 OPC_Decode, 228, 108, 189, 1, // 2135: decode to AIF_FLTU_PI using decoder 189
12587 // 2135: }
12588 4, 0, // 2140: case 0x4: {
12589 OPC_CheckPredicate, 140, 1, // 2142: check predicate 140
12590 OPC_CheckField, 20, 5, 0, // 2145: check Inst[24:20] == 0x0
12591 OPC_Decode, 146, 109, 200, 1, // 2149: decode to AIF_FSETM_PI using decoder 200
12592 // 2149: }
12593 // 2149: } // switch Inst[14:12]
12594 // 2149: }
12595 96, 37, // 2154: case 0x60: {
12596 OPC_SwitchField, 20, 5, // 2156: switch Inst[24:20] {
12597 0, 8, // 2159: case 0x0: {
12598 OPC_CheckPredicate, 140, 1, // 2161: check predicate 140
12599 OPC_Decode, 192, 108, 196, 1, // 2164: decode to AIF_FCVT_PW_PS using decoder 196
12600 // 2164: }
12601 1, 8, // 2169: case 0x1: {
12602 OPC_CheckPredicate, 140, 1, // 2171: check predicate 140
12603 OPC_Decode, 191, 108, 196, 1, // 2174: decode to AIF_FCVT_PWU_PS using decoder 196
12604 // 2174: }
12605 2, 0, // 2179: case 0x2: {
12606 OPC_CheckPredicate, 140, 1, // 2181: check predicate 140
12607 OPC_CheckField, 12, 3, 0, // 2184: check Inst[14:12] == 0x0
12608 OPC_Decode, 193, 108, 191, 1, // 2188: decode to AIF_FCVT_RAST_PS using decoder 191
12609 // 2188: }
12610 // 2188: } // switch Inst[24:20]
12611 // 2188: }
12612 104, 177, 1, // 2193: case 0x68: {
12613 OPC_SwitchField, 20, 5, // 2196: switch Inst[24:20] {
12614 0, 8, // 2199: case 0x0: {
12615 OPC_CheckPredicate, 140, 1, // 2201: check predicate 140
12616 OPC_Decode, 181, 108, 196, 1, // 2204: decode to AIF_FCVT_PS_PW using decoder 196
12617 // 2204: }
12618 1, 8, // 2209: case 0x1: {
12619 OPC_CheckPredicate, 140, 1, // 2211: check predicate 140
12620 OPC_Decode, 182, 108, 196, 1, // 2214: decode to AIF_FCVT_PS_PWU using decoder 196
12621 // 2214: }
12622 2, 12, // 2219: case 0x2: {
12623 OPC_CheckPredicate, 140, 1, // 2221: check predicate 140
12624 OPC_CheckField, 12, 3, 0, // 2224: check Inst[14:12] == 0x0
12625 OPC_Decode, 183, 108, 191, 1, // 2228: decode to AIF_FCVT_PS_RAST using decoder 191
12626 // 2228: }
12627 8, 12, // 2233: case 0x8: {
12628 OPC_CheckPredicate, 140, 1, // 2235: check predicate 140
12629 OPC_CheckField, 12, 3, 0, // 2238: check Inst[14:12] == 0x0
12630 OPC_Decode, 178, 108, 191, 1, // 2242: decode to AIF_FCVT_PS_F10 using decoder 191
12631 // 2242: }
12632 9, 12, // 2247: case 0x9: {
12633 OPC_CheckPredicate, 140, 1, // 2249: check predicate 140
12634 OPC_CheckField, 12, 3, 0, // 2252: check Inst[14:12] == 0x0
12635 OPC_Decode, 179, 108, 191, 1, // 2256: decode to AIF_FCVT_PS_F11 using decoder 191
12636 // 2256: }
12637 10, 12, // 2261: case 0xa: {
12638 OPC_CheckPredicate, 140, 1, // 2263: check predicate 140
12639 OPC_CheckField, 12, 3, 0, // 2266: check Inst[14:12] == 0x0
12640 OPC_Decode, 180, 108, 191, 1, // 2270: decode to AIF_FCVT_PS_F16 using decoder 191
12641 // 2270: }
12642 16, 12, // 2275: case 0x10: {
12643 OPC_CheckPredicate, 140, 1, // 2277: check predicate 140
12644 OPC_CheckField, 12, 3, 0, // 2280: check Inst[14:12] == 0x0
12645 OPC_Decode, 189, 108, 191, 1, // 2284: decode to AIF_FCVT_PS_UN24 using decoder 191
12646 // 2284: }
12647 17, 12, // 2289: case 0x11: {
12648 OPC_CheckPredicate, 140, 1, // 2291: check predicate 140
12649 OPC_CheckField, 12, 3, 0, // 2294: check Inst[14:12] == 0x0
12650 OPC_Decode, 187, 108, 191, 1, // 2298: decode to AIF_FCVT_PS_UN16 using decoder 191
12651 // 2298: }
12652 18, 12, // 2303: case 0x12: {
12653 OPC_CheckPredicate, 140, 1, // 2305: check predicate 140
12654 OPC_CheckField, 12, 3, 0, // 2308: check Inst[14:12] == 0x0
12655 OPC_Decode, 186, 108, 191, 1, // 2312: decode to AIF_FCVT_PS_UN10 using decoder 191
12656 // 2312: }
12657 19, 12, // 2317: case 0x13: {
12658 OPC_CheckPredicate, 140, 1, // 2319: check predicate 140
12659 OPC_CheckField, 12, 3, 0, // 2322: check Inst[14:12] == 0x0
12660 OPC_Decode, 190, 108, 191, 1, // 2326: decode to AIF_FCVT_PS_UN8 using decoder 191
12661 // 2326: }
12662 23, 12, // 2331: case 0x17: {
12663 OPC_CheckPredicate, 140, 1, // 2333: check predicate 140
12664 OPC_CheckField, 12, 3, 0, // 2336: check Inst[14:12] == 0x0
12665 OPC_Decode, 188, 108, 191, 1, // 2340: decode to AIF_FCVT_PS_UN2 using decoder 191
12666 // 2340: }
12667 25, 12, // 2345: case 0x19: {
12668 OPC_CheckPredicate, 140, 1, // 2347: check predicate 140
12669 OPC_CheckField, 12, 3, 0, // 2350: check Inst[14:12] == 0x0
12670 OPC_Decode, 184, 108, 191, 1, // 2354: decode to AIF_FCVT_PS_SN16 using decoder 191
12671 // 2354: }
12672 27, 0, // 2359: case 0x1b: {
12673 OPC_CheckPredicate, 140, 1, // 2361: check predicate 140
12674 OPC_CheckField, 12, 3, 0, // 2364: check Inst[14:12] == 0x0
12675 OPC_Decode, 185, 108, 191, 1, // 2368: decode to AIF_FCVT_PS_SN8 using decoder 191
12676 // 2368: }
12677 // 2368: } // switch Inst[24:20]
12678 // 2368: }
12679 107, 34, // 2373: case 0x6b: {
12680 OPC_SwitchField, 12, 3, // 2375: switch Inst[14:12] {
12681 0, 12, // 2378: case 0x0: {
12682 OPC_CheckPredicate, 140, 1, // 2380: check predicate 140
12683 OPC_CheckField, 15, 10, 0, // 2383: check Inst[24:15] == 0x0
12684 OPC_Decode, 174, 109, 201, 1, // 2387: decode to AIF_MOVA_X_M using decoder 201
12685 // 2387: }
12686 1, 0, // 2392: case 0x1: {
12687 OPC_CheckPredicate, 140, 1, // 2394: check predicate 140
12688 OPC_CheckField, 20, 5, 0, // 2397: check Inst[24:20] == 0x0
12689 OPC_CheckField, 7, 5, 0, // 2401: check Inst[11:7] == 0x0
12690 OPC_Decode, 173, 109, 15, // 2405: decode to AIF_MOVA_M_X using decoder 15
12691 // 2405: }
12692 // 2405: } // switch Inst[14:12]
12693 // 2405: }
12694 108, 143, 1, // 2409: case 0x6c: {
12695 OPC_SwitchField, 20, 5, // 2412: switch Inst[24:20] {
12696 8, 12, // 2415: case 0x8: {
12697 OPC_CheckPredicate, 140, 1, // 2417: check predicate 140
12698 OPC_CheckField, 12, 3, 0, // 2420: check Inst[14:12] == 0x0
12699 OPC_Decode, 176, 108, 191, 1, // 2424: decode to AIF_FCVT_F11_PS using decoder 191
12700 // 2424: }
12701 9, 12, // 2429: case 0x9: {
12702 OPC_CheckPredicate, 140, 1, // 2431: check predicate 140
12703 OPC_CheckField, 12, 3, 0, // 2434: check Inst[14:12] == 0x0
12704 OPC_Decode, 177, 108, 191, 1, // 2438: decode to AIF_FCVT_F16_PS using decoder 191
12705 // 2438: }
12706 11, 12, // 2443: case 0xb: {
12707 OPC_CheckPredicate, 140, 1, // 2445: check predicate 140
12708 OPC_CheckField, 12, 3, 0, // 2448: check Inst[14:12] == 0x0
12709 OPC_Decode, 175, 108, 191, 1, // 2452: decode to AIF_FCVT_F10_PS using decoder 191
12710 // 2452: }
12711 16, 12, // 2457: case 0x10: {
12712 OPC_CheckPredicate, 140, 1, // 2459: check predicate 140
12713 OPC_CheckField, 12, 3, 0, // 2462: check Inst[14:12] == 0x0
12714 OPC_Decode, 198, 108, 191, 1, // 2466: decode to AIF_FCVT_UN24_PS using decoder 191
12715 // 2466: }
12716 17, 12, // 2471: case 0x11: {
12717 OPC_CheckPredicate, 140, 1, // 2473: check predicate 140
12718 OPC_CheckField, 12, 3, 0, // 2476: check Inst[14:12] == 0x0
12719 OPC_Decode, 197, 108, 191, 1, // 2480: decode to AIF_FCVT_UN16_PS using decoder 191
12720 // 2480: }
12721 18, 12, // 2485: case 0x12: {
12722 OPC_CheckPredicate, 140, 1, // 2487: check predicate 140
12723 OPC_CheckField, 12, 3, 0, // 2490: check Inst[14:12] == 0x0
12724 OPC_Decode, 196, 108, 191, 1, // 2494: decode to AIF_FCVT_UN10_PS using decoder 191
12725 // 2494: }
12726 19, 12, // 2499: case 0x13: {
12727 OPC_CheckPredicate, 140, 1, // 2501: check predicate 140
12728 OPC_CheckField, 12, 3, 0, // 2504: check Inst[14:12] == 0x0
12729 OPC_Decode, 200, 108, 191, 1, // 2508: decode to AIF_FCVT_UN8_PS using decoder 191
12730 // 2508: }
12731 23, 12, // 2513: case 0x17: {
12732 OPC_CheckPredicate, 140, 1, // 2515: check predicate 140
12733 OPC_CheckField, 12, 3, 0, // 2518: check Inst[14:12] == 0x0
12734 OPC_Decode, 199, 108, 191, 1, // 2522: decode to AIF_FCVT_UN2_PS using decoder 191
12735 // 2522: }
12736 25, 12, // 2527: case 0x19: {
12737 OPC_CheckPredicate, 140, 1, // 2529: check predicate 140
12738 OPC_CheckField, 12, 3, 0, // 2532: check Inst[14:12] == 0x0
12739 OPC_Decode, 194, 108, 191, 1, // 2536: decode to AIF_FCVT_SN16_PS using decoder 191
12740 // 2536: }
12741 27, 0, // 2541: case 0x1b: {
12742 OPC_CheckPredicate, 140, 1, // 2543: check predicate 140
12743 OPC_CheckField, 12, 3, 0, // 2546: check Inst[14:12] == 0x0
12744 OPC_Decode, 195, 108, 191, 1, // 2550: decode to AIF_FCVT_SN8_PS using decoder 191
12745 // 2550: }
12746 // 2550: } // switch Inst[24:20]
12747 // 2550: }
12748 112, 45, // 2555: case 0x70: {
12749 OPC_SwitchField, 12, 3, // 2557: switch Inst[14:12] {
12750 0, 12, // 2560: case 0x0: {
12751 OPC_CheckPredicate, 140, 1, // 2562: check predicate 140
12752 OPC_CheckField, 23, 2, 0, // 2565: check Inst[24:23] == 0x0
12753 OPC_Decode, 247, 108, 202, 1, // 2569: decode to AIF_FMVZ_X_PS using decoder 202
12754 // 2569: }
12755 1, 12, // 2574: case 0x1: {
12756 OPC_CheckPredicate, 140, 1, // 2576: check predicate 140
12757 OPC_CheckField, 20, 5, 0, // 2579: check Inst[24:20] == 0x0
12758 OPC_Decode, 172, 108, 191, 1, // 2583: decode to AIF_FCLASS_PS using decoder 191
12759 // 2583: }
12760 2, 0, // 2588: case 0x2: {
12761 OPC_CheckPredicate, 140, 1, // 2590: check predicate 140
12762 OPC_CheckField, 23, 2, 0, // 2593: check Inst[24:23] == 0x0
12763 OPC_Decode, 246, 108, 202, 1, // 2597: decode to AIF_FMVS_X_PS using decoder 202
12764 // 2597: }
12765 // 2597: } // switch Inst[14:12]
12766 // 2597: }
12767 115, 0, // 2602: case 0x73: {
12768 OPC_CheckPredicate, 140, 1, // 2604: check predicate 140
12769 OPC_Decode, 162, 109, 203, 1, // 2607: decode to AIF_FSWIZZ_PS using decoder 203
12770 // 2607: }
12771 // 2607: } // switch Inst[31:25]
12772 // 2607: }
12773 // 2607: } // switch Inst[6:0]
12774};
12775static const uint8_t DecoderTableXAndes32[612] = {
12776 32, // 0: BitWidth 32
12777 OPC_SwitchField, 12, 2, // 1: switch Inst[13:12] {
12778 0, 150, 3, // 4: case 0x0: {
12779 OPC_SwitchField, 0, 7, // 7: switch Inst[6:0] {
12780 11, 8, // 10: case 0xb: {
12781 OPC_CheckPredicate, 141, 1, // 12: check predicate 141
12782 OPC_Decode, 172, 118, 204, 1, // 15: decode to NDS_LBGP using decoder 204
12783 // 15: }
12784 43, 23, // 20: case 0x2b: {
12785 OPC_SwitchField, 14, 1, // 22: switch Inst[14] {
12786 0, 8, // 25: case 0x0: {
12787 OPC_CheckPredicate, 141, 1, // 27: check predicate 141
12788 OPC_Decode, 188, 118, 205, 1, // 30: decode to NDS_SHGP using decoder 205
12789 // 30: }
12790 1, 0, // 35: case 0x1: {
12791 OPC_CheckPredicate, 141, 1, // 37: check predicate 141
12792 OPC_Decode, 189, 118, 206, 1, // 40: decode to NDS_SWGP using decoder 206
12793 // 40: }
12794 // 40: } // switch Inst[14]
12795 // 40: }
12796 91, 0, // 45: case 0x5b: {
12797 OPC_SwitchField, 26, 6, // 47: switch Inst[31:26] {
12798 0, 95, // 50: case 0x0: {
12799 OPC_SwitchField, 14, 6, // 52: switch Inst[19:14] {
12800 1, 12, // 55: case 0x1: {
12801 OPC_CheckPredicate, 142, 1, // 57: check predicate 142
12802 OPC_CheckField, 25, 1, 0, // 60: check Inst[25] == 0x0
12803 OPC_Decode, 200, 118, 135, 1, // 64: decode to NDS_VFWCVT_S_BF16 using decoder 135
12804 // 64: }
12805 3, 12, // 69: case 0x3: {
12806 OPC_CheckPredicate, 142, 1, // 71: check predicate 142
12807 OPC_CheckField, 25, 1, 0, // 74: check Inst[25] == 0x0
12808 OPC_Decode, 193, 118, 135, 1, // 78: decode to NDS_VFNCVT_BF16_S using decoder 135
12809 // 78: }
12810 5, 12, // 83: case 0x5: {
12811 OPC_CheckPredicate, 143, 1, // 85: check predicate 143
12812 OPC_CheckField, 25, 1, 0, // 88: check Inst[25] == 0x0
12813 OPC_Decode, 165, 118, 207, 1, // 92: decode to NDS_FCVT_S_BF16 using decoder 207
12814 // 92: }
12815 7, 12, // 97: case 0x7: {
12816 OPC_CheckPredicate, 143, 1, // 99: check predicate 143
12817 OPC_CheckField, 25, 1, 0, // 102: check Inst[25] == 0x0
12818 OPC_Decode, 164, 118, 208, 1, // 106: decode to NDS_FCVT_BF16_S using decoder 208
12819 // 106: }
12820 9, 7, // 111: case 0x9: {
12821 OPC_CheckPredicate, 144, 1, // 113: check predicate 144
12822 OPC_Decode, 198, 118, 124, // 116: decode to NDS_VFWCVT_F_N using decoder 124
12823 // 116: }
12824 11, 7, // 120: case 0xb: {
12825 OPC_CheckPredicate, 144, 1, // 122: check predicate 144
12826 OPC_Decode, 199, 118, 124, // 125: decode to NDS_VFWCVT_F_NU using decoder 124
12827 // 125: }
12828 13, 7, // 129: case 0xd: {
12829 OPC_CheckPredicate, 144, 1, // 131: check predicate 144
12830 OPC_Decode, 196, 118, 124, // 134: decode to NDS_VFWCVT_F_B using decoder 124
12831 // 134: }
12832 15, 0, // 138: case 0xf: {
12833 OPC_CheckPredicate, 144, 1, // 140: check predicate 144
12834 OPC_Decode, 197, 118, 124, // 143: decode to NDS_VFWCVT_F_BU using decoder 124
12835 // 143: }
12836 // 143: } // switch Inst[19:14]
12837 // 143: }
12838 1, 46, // 147: case 0x1: {
12839 OPC_SwitchField, 20, 5, // 149: switch Inst[24:20] {
12840 0, 15, // 152: case 0x0: {
12841 OPC_CheckPredicate, 145, 1, // 154: check predicate 145
12842 OPC_CheckField, 25, 1, 1, // 157: check Inst[25] == 0x1
12843 OPC_CheckField, 14, 1, 1, // 161: check Inst[14] == 0x1
12844 OPC_Decode, 201, 118, 2, // 165: decode to NDS_VLE4_V using decoder 2
12845 // 165: }
12846 2, 11, // 169: case 0x2: {
12847 OPC_CheckPredicate, 146, 1, // 171: check predicate 146
12848 OPC_CheckField, 14, 1, 1, // 174: check Inst[14] == 0x1
12849 OPC_Decode, 202, 118, 1, // 178: decode to NDS_VLN8_V using decoder 1
12850 // 178: }
12851 3, 0, // 182: case 0x3: {
12852 OPC_CheckPredicate, 146, 1, // 184: check predicate 146
12853 OPC_CheckField, 14, 1, 1, // 187: check Inst[14] == 0x1
12854 OPC_Decode, 203, 118, 1, // 191: decode to NDS_VLNU8_V using decoder 1
12855 // 191: }
12856 // 191: } // switch Inst[24:20]
12857 // 191: }
12858 2, 26, // 195: case 0x2: {
12859 OPC_SwitchField, 14, 1, // 197: switch Inst[14] {
12860 0, 11, // 200: case 0x0: {
12861 OPC_CheckPredicate, 141, 1, // 202: check predicate 141
12862 OPC_CheckField, 25, 1, 1, // 205: check Inst[25] == 0x1
12863 OPC_Decode, 178, 118, 56, // 209: decode to NDS_LEA_H using decoder 56
12864 // 209: }
12865 1, 0, // 213: case 0x1: {
12866 OPC_CheckPredicate, 147, 1, // 215: check predicate 147
12867 OPC_Decode, 195, 118, 143, 1, // 218: decode to NDS_VFPMADT_VF using decoder 143
12868 // 218: }
12869 // 218: } // switch Inst[14]
12870 // 218: }
12871 3, 36, // 223: case 0x3: {
12872 OPC_SwitchField, 14, 1, // 225: switch Inst[14] {
12873 0, 21, // 228: case 0x0: {
12874 OPC_SwitchField, 25, 1, // 230: switch Inst[25] {
12875 0, 7, // 233: case 0x0: {
12876 OPC_CheckPredicate, 141, 1, // 235: check predicate 141
12877 OPC_Decode, 180, 118, 56, // 238: decode to NDS_LEA_W using decoder 56
12878 // 238: }
12879 1, 0, // 242: case 0x1: {
12880 OPC_CheckPredicate, 141, 1, // 244: check predicate 141
12881 OPC_Decode, 176, 118, 56, // 247: decode to NDS_LEA_D using decoder 56
12882 // 247: }
12883 // 247: } // switch Inst[25]
12884 // 247: }
12885 1, 0, // 251: case 0x1: {
12886 OPC_CheckPredicate, 147, 1, // 253: check predicate 147
12887 OPC_Decode, 194, 118, 143, 1, // 256: decode to NDS_VFPMADB_VF using decoder 143
12888 // 256: }
12889 // 256: } // switch Inst[14]
12890 // 256: }
12891 4, 36, // 261: case 0x4: {
12892 OPC_SwitchField, 14, 1, // 263: switch Inst[14] {
12893 0, 21, // 266: case 0x0: {
12894 OPC_SwitchField, 25, 1, // 268: switch Inst[25] {
12895 0, 7, // 271: case 0x0: {
12896 OPC_CheckPredicate, 148, 1, // 273: check predicate 148
12897 OPC_Decode, 175, 118, 56, // 276: decode to NDS_LEA_B_ZE using decoder 56
12898 // 276: }
12899 1, 0, // 280: case 0x1: {
12900 OPC_CheckPredicate, 148, 1, // 282: check predicate 148
12901 OPC_Decode, 179, 118, 56, // 285: decode to NDS_LEA_H_ZE using decoder 56
12902 // 285: }
12903 // 285: } // switch Inst[25]
12904 // 285: }
12905 1, 0, // 289: case 0x1: {
12906 OPC_CheckPredicate, 149, 1, // 291: check predicate 149
12907 OPC_Decode, 191, 118, 209, 1, // 294: decode to NDS_VD4DOTS_VV using decoder 209
12908 // 294: }
12909 // 294: } // switch Inst[14]
12910 // 294: }
12911 5, 36, // 299: case 0x5: {
12912 OPC_SwitchField, 14, 1, // 301: switch Inst[14] {
12913 0, 21, // 304: case 0x0: {
12914 OPC_SwitchField, 25, 1, // 306: switch Inst[25] {
12915 0, 7, // 309: case 0x0: {
12916 OPC_CheckPredicate, 148, 1, // 311: check predicate 148
12917 OPC_Decode, 181, 118, 56, // 314: decode to NDS_LEA_W_ZE using decoder 56
12918 // 314: }
12919 1, 0, // 318: case 0x1: {
12920 OPC_CheckPredicate, 148, 1, // 320: check predicate 148
12921 OPC_Decode, 177, 118, 56, // 323: decode to NDS_LEA_D_ZE using decoder 56
12922 // 323: }
12923 // 323: } // switch Inst[25]
12924 // 323: }
12925 1, 0, // 327: case 0x1: {
12926 OPC_CheckPredicate, 149, 1, // 329: check predicate 149
12927 OPC_Decode, 190, 118, 209, 1, // 332: decode to NDS_VD4DOTSU_VV using decoder 209
12928 // 332: }
12929 // 332: } // switch Inst[14]
12930 // 332: }
12931 7, 12, // 337: case 0x7: {
12932 OPC_CheckPredicate, 149, 1, // 339: check predicate 149
12933 OPC_CheckField, 14, 1, 1, // 342: check Inst[14] == 0x1
12934 OPC_Decode, 192, 118, 209, 1, // 346: decode to NDS_VD4DOTU_VV using decoder 209
12935 // 346: }
12936 8, 29, // 351: case 0x8: {
12937 OPC_SwitchField, 25, 1, // 353: switch Inst[25] {
12938 0, 11, // 356: case 0x0: {
12939 OPC_CheckPredicate, 141, 1, // 358: check predicate 141
12940 OPC_CheckField, 14, 1, 0, // 361: check Inst[14] == 0x0
12941 OPC_Decode, 166, 118, 31, // 365: decode to NDS_FFB using decoder 31
12942 // 365: }
12943 1, 0, // 369: case 0x1: {
12944 OPC_CheckPredicate, 141, 1, // 371: check predicate 141
12945 OPC_CheckField, 14, 1, 0, // 374: check Inst[14] == 0x0
12946 OPC_Decode, 168, 118, 31, // 378: decode to NDS_FFZMISM using decoder 31
12947 // 378: }
12948 // 378: } // switch Inst[25]
12949 // 378: }
12950 9, 0, // 382: case 0x9: {
12951 OPC_SwitchField, 25, 1, // 384: switch Inst[25] {
12952 0, 11, // 387: case 0x0: {
12953 OPC_CheckPredicate, 141, 1, // 389: check predicate 141
12954 OPC_CheckField, 14, 1, 0, // 392: check Inst[14] == 0x0
12955 OPC_Decode, 167, 118, 31, // 396: decode to NDS_FFMISM using decoder 31
12956 // 396: }
12957 1, 0, // 400: case 0x1: {
12958 OPC_CheckPredicate, 141, 1, // 402: check predicate 141
12959 OPC_CheckField, 14, 1, 0, // 405: check Inst[14] == 0x0
12960 OPC_Decode, 169, 118, 31, // 409: decode to NDS_FLMISM using decoder 31
12961 // 409: }
12962 // 409: } // switch Inst[25]
12963 // 409: }
12964 // 409: } // switch Inst[31:26]
12965 // 409: }
12966 // 409: } // switch Inst[6:0]
12967 // 409: }
12968 1, 52, // 413: case 0x1: {
12969 OPC_SwitchField, 0, 7, // 415: switch Inst[6:0] {
12970 11, 8, // 418: case 0xb: {
12971 OPC_CheckPredicate, 141, 1, // 420: check predicate 141
12972 OPC_Decode, 157, 118, 204, 1, // 423: decode to NDS_ADDIGP using decoder 204
12973 // 423: }
12974 43, 23, // 428: case 0x2b: {
12975 OPC_SwitchField, 14, 1, // 430: switch Inst[14] {
12976 0, 8, // 433: case 0x0: {
12977 OPC_CheckPredicate, 141, 1, // 435: check predicate 141
12978 OPC_Decode, 182, 118, 210, 1, // 438: decode to NDS_LHGP using decoder 210
12979 // 438: }
12980 1, 0, // 443: case 0x1: {
12981 OPC_CheckPredicate, 141, 1, // 445: check predicate 141
12982 OPC_Decode, 183, 118, 210, 1, // 448: decode to NDS_LHUGP using decoder 210
12983 // 448: }
12984 // 448: } // switch Inst[14]
12985 // 448: }
12986 91, 0, // 453: case 0x5b: {
12987 OPC_CheckPredicate, 141, 1, // 455: check predicate 141
12988 OPC_CheckField, 14, 1, 1, // 458: check Inst[14] == 0x1
12989 OPC_Decode, 160, 118, 211, 1, // 462: decode to NDS_BEQC using decoder 211
12990 // 462: }
12991 // 462: } // switch Inst[6:0]
12992 // 462: }
12993 2, 63, // 467: case 0x2: {
12994 OPC_SwitchField, 0, 7, // 469: switch Inst[6:0] {
12995 11, 8, // 472: case 0xb: {
12996 OPC_CheckPredicate, 141, 1, // 474: check predicate 141
12997 OPC_Decode, 173, 118, 204, 1, // 477: decode to NDS_LBUGP using decoder 204
12998 // 477: }
12999 43, 23, // 482: case 0x2b: {
13000 OPC_SwitchField, 14, 1, // 484: switch Inst[14] {
13001 0, 8, // 487: case 0x0: {
13002 OPC_CheckPredicate, 141, 1, // 489: check predicate 141
13003 OPC_Decode, 184, 118, 212, 1, // 492: decode to NDS_LWGP using decoder 212
13004 // 492: }
13005 1, 0, // 497: case 0x1: {
13006 OPC_CheckPredicate, 148, 1, // 499: check predicate 148
13007 OPC_Decode, 185, 118, 212, 1, // 502: decode to NDS_LWUGP using decoder 212
13008 // 502: }
13009 // 502: } // switch Inst[14]
13010 // 502: }
13011 91, 0, // 507: case 0x5b: {
13012 OPC_SwitchField, 14, 1, // 509: switch Inst[14] {
13013 0, 8, // 512: case 0x0: {
13014 OPC_CheckPredicate, 141, 1, // 514: check predicate 141
13015 OPC_Decode, 162, 118, 213, 1, // 517: decode to NDS_BFOZ using decoder 213
13016 // 517: }
13017 1, 0, // 522: case 0x1: {
13018 OPC_CheckPredicate, 141, 1, // 524: check predicate 141
13019 OPC_Decode, 163, 118, 211, 1, // 527: decode to NDS_BNEC using decoder 211
13020 // 527: }
13021 // 527: } // switch Inst[14]
13022 // 527: }
13023 // 527: } // switch Inst[6:0]
13024 // 527: }
13025 3, 0, // 532: case 0x3: {
13026 OPC_SwitchField, 0, 7, // 534: switch Inst[6:0] {
13027 11, 8, // 537: case 0xb: {
13028 OPC_CheckPredicate, 141, 1, // 539: check predicate 141
13029 OPC_Decode, 186, 118, 214, 1, // 542: decode to NDS_SBGP using decoder 214
13030 // 542: }
13031 43, 23, // 547: case 0x2b: {
13032 OPC_SwitchField, 14, 1, // 549: switch Inst[14] {
13033 0, 8, // 552: case 0x0: {
13034 OPC_CheckPredicate, 148, 1, // 554: check predicate 148
13035 OPC_Decode, 174, 118, 215, 1, // 557: decode to NDS_LDGP using decoder 215
13036 // 557: }
13037 1, 0, // 562: case 0x1: {
13038 OPC_CheckPredicate, 148, 1, // 564: check predicate 148
13039 OPC_Decode, 187, 118, 216, 1, // 567: decode to NDS_SDGP using decoder 216
13040 // 567: }
13041 // 567: } // switch Inst[14]
13042 // 567: }
13043 91, 0, // 572: case 0x5b: {
13044 OPC_SwitchField, 14, 1, // 574: switch Inst[14] {
13045 0, 8, // 577: case 0x0: {
13046 OPC_CheckPredicate, 141, 1, // 579: check predicate 141
13047 OPC_Decode, 161, 118, 213, 1, // 582: decode to NDS_BFOS using decoder 213
13048 // 582: }
13049 1, 0, // 587: case 0x1: {
13050 OPC_SwitchField, 30, 1, // 589: switch Inst[30] {
13051 0, 8, // 592: case 0x0: {
13052 OPC_CheckPredicate, 141, 1, // 594: check predicate 141
13053 OPC_Decode, 158, 118, 217, 1, // 597: decode to NDS_BBC using decoder 217
13054 // 597: }
13055 1, 0, // 602: case 0x1: {
13056 OPC_CheckPredicate, 141, 1, // 604: check predicate 141
13057 OPC_Decode, 159, 118, 217, 1, // 607: decode to NDS_BBS using decoder 217
13058 // 607: }
13059 // 607: } // switch Inst[30]
13060 // 607: }
13061 // 607: } // switch Inst[14]
13062 // 607: }
13063 // 607: } // switch Inst[6:0]
13064 // 607: }
13065 // 607: } // switch Inst[13:12]
13066};
13067static const uint8_t DecoderTableXCV32[3680] = {
13068 32, // 0: BitWidth 32
13069 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
13070 0, 190, 4, // 4: case 0x0: {
13071 OPC_SwitchField, 0, 7, // 7: switch Inst[6:0] {
13072 11, 8, // 10: case 0xb: {
13073 OPC_CheckPredicate, 150, 1, // 12: check predicate 150
13074 OPC_Decode, 177, 112, 218, 1, // 15: decode to CV_LB_ri_inc using decoder 218
13075 // 15: }
13076 43, 8, // 20: case 0x2b: {
13077 OPC_CheckPredicate, 150, 1, // 22: check predicate 150
13078 OPC_Decode, 246, 112, 219, 1, // 25: decode to CV_SB_ri_inc using decoder 219
13079 // 25: }
13080 91, 33, // 30: case 0x5b: {
13081 OPC_SwitchField, 30, 2, // 32: switch Inst[31:30] {
13082 0, 8, // 35: case 0x0: {
13083 OPC_CheckPredicate, 151, 1, // 37: check predicate 151
13084 OPC_Decode, 160, 112, 220, 1, // 40: decode to CV_EXTRACT using decoder 220
13085 // 40: }
13086 1, 8, // 45: case 0x1: {
13087 OPC_CheckPredicate, 151, 1, // 47: check predicate 151
13088 OPC_Decode, 162, 112, 220, 1, // 50: decode to CV_EXTRACTU using decoder 220
13089 // 50: }
13090 2, 0, // 55: case 0x2: {
13091 OPC_CheckPredicate, 151, 1, // 57: check predicate 151
13092 OPC_Decode, 170, 112, 221, 1, // 60: decode to CV_INSERT using decoder 221
13093 // 60: }
13094 // 60: } // switch Inst[31:30]
13095 // 60: }
13096 123, 0, // 65: case 0x7b: {
13097 OPC_SwitchField, 26, 6, // 67: switch Inst[31:26] {
13098 0, 11, // 70: case 0x0: {
13099 OPC_CheckPredicate, 152, 1, // 72: check predicate 152
13100 OPC_CheckField, 25, 1, 0, // 75: check Inst[25] == 0x0
13101 OPC_Decode, 160, 111, 31, // 79: decode to CV_ADD_H using decoder 31
13102 // 79: }
13103 1, 11, // 83: case 0x1: {
13104 OPC_CheckPredicate, 152, 1, // 85: check predicate 152
13105 OPC_CheckField, 25, 1, 0, // 88: check Inst[25] == 0x0
13106 OPC_Decode, 196, 111, 31, // 92: decode to CV_CMPEQ_H using decoder 31
13107 // 92: }
13108 2, 11, // 96: case 0x2: {
13109 OPC_CheckPredicate, 152, 1, // 98: check predicate 152
13110 OPC_CheckField, 25, 1, 0, // 101: check Inst[25] == 0x0
13111 OPC_Decode, 187, 113, 31, // 105: decode to CV_SUB_H using decoder 31
13112 // 105: }
13113 3, 11, // 109: case 0x3: {
13114 OPC_CheckPredicate, 152, 1, // 111: check predicate 152
13115 OPC_CheckField, 25, 1, 0, // 114: check Inst[25] == 0x0
13116 OPC_Decode, 250, 111, 31, // 118: decode to CV_CMPNE_H using decoder 31
13117 // 118: }
13118 4, 11, // 122: case 0x4: {
13119 OPC_CheckPredicate, 152, 1, // 124: check predicate 152
13120 OPC_CheckField, 25, 1, 0, // 127: check Inst[25] == 0x0
13121 OPC_Decode, 178, 111, 31, // 131: decode to CV_AVG_H using decoder 31
13122 // 131: }
13123 5, 11, // 135: case 0x5: {
13124 OPC_CheckPredicate, 152, 1, // 137: check predicate 152
13125 OPC_CheckField, 25, 1, 0, // 140: check Inst[25] == 0x0
13126 OPC_Decode, 220, 111, 31, // 144: decode to CV_CMPGT_H using decoder 31
13127 // 144: }
13128 6, 11, // 148: case 0x6: {
13129 OPC_CheckPredicate, 152, 1, // 150: check predicate 152
13130 OPC_CheckField, 25, 1, 0, // 153: check Inst[25] == 0x0
13131 OPC_Decode, 172, 111, 31, // 157: decode to CV_AVGU_H using decoder 31
13132 // 157: }
13133 7, 11, // 161: case 0x7: {
13134 OPC_CheckPredicate, 152, 1, // 163: check predicate 152
13135 OPC_CheckField, 25, 1, 0, // 166: check Inst[25] == 0x0
13136 OPC_Decode, 208, 111, 31, // 170: decode to CV_CMPGE_H using decoder 31
13137 // 170: }
13138 8, 11, // 174: case 0x8: {
13139 OPC_CheckPredicate, 152, 1, // 176: check predicate 152
13140 OPC_CheckField, 25, 1, 0, // 179: check Inst[25] == 0x0
13141 OPC_Decode, 221, 112, 31, // 183: decode to CV_MIN_H using decoder 31
13142 // 183: }
13143 9, 11, // 187: case 0x9: {
13144 OPC_CheckPredicate, 152, 1, // 189: check predicate 152
13145 OPC_CheckField, 25, 1, 0, // 192: check Inst[25] == 0x0
13146 OPC_Decode, 244, 111, 31, // 196: decode to CV_CMPLT_H using decoder 31
13147 // 196: }
13148 10, 11, // 200: case 0xa: {
13149 OPC_CheckPredicate, 152, 1, // 202: check predicate 152
13150 OPC_CheckField, 25, 1, 0, // 205: check Inst[25] == 0x0
13151 OPC_Decode, 215, 112, 31, // 209: decode to CV_MINU_H using decoder 31
13152 // 209: }
13153 11, 11, // 213: case 0xb: {
13154 OPC_CheckPredicate, 152, 1, // 215: check predicate 152
13155 OPC_CheckField, 25, 1, 0, // 218: check Inst[25] == 0x0
13156 OPC_Decode, 232, 111, 31, // 222: decode to CV_CMPLE_H using decoder 31
13157 // 222: }
13158 12, 11, // 226: case 0xc: {
13159 OPC_CheckPredicate, 152, 1, // 228: check predicate 152
13160 OPC_CheckField, 25, 1, 0, // 231: check Inst[25] == 0x0
13161 OPC_Decode, 207, 112, 31, // 235: decode to CV_MAX_H using decoder 31
13162 // 235: }
13163 13, 11, // 239: case 0xd: {
13164 OPC_CheckPredicate, 152, 1, // 241: check predicate 152
13165 OPC_CheckField, 25, 1, 0, // 244: check Inst[25] == 0x0
13166 OPC_Decode, 214, 111, 31, // 248: decode to CV_CMPGTU_H using decoder 31
13167 // 248: }
13168 14, 11, // 252: case 0xe: {
13169 OPC_CheckPredicate, 152, 1, // 254: check predicate 152
13170 OPC_CheckField, 25, 1, 0, // 257: check Inst[25] == 0x0
13171 OPC_Decode, 201, 112, 31, // 261: decode to CV_MAXU_H using decoder 31
13172 // 261: }
13173 15, 11, // 265: case 0xf: {
13174 OPC_CheckPredicate, 152, 1, // 267: check predicate 152
13175 OPC_CheckField, 25, 1, 0, // 270: check Inst[25] == 0x0
13176 OPC_Decode, 202, 111, 31, // 274: decode to CV_CMPGEU_H using decoder 31
13177 // 274: }
13178 16, 11, // 278: case 0x10: {
13179 OPC_CheckPredicate, 152, 1, // 280: check predicate 152
13180 OPC_CheckField, 25, 1, 0, // 283: check Inst[25] == 0x0
13181 OPC_Decode, 166, 113, 31, // 287: decode to CV_SRL_H using decoder 31
13182 // 287: }
13183 17, 11, // 291: case 0x11: {
13184 OPC_CheckPredicate, 152, 1, // 293: check predicate 152
13185 OPC_CheckField, 25, 1, 0, // 296: check Inst[25] == 0x0
13186 OPC_Decode, 238, 111, 31, // 300: decode to CV_CMPLTU_H using decoder 31
13187 // 300: }
13188 18, 11, // 304: case 0x12: {
13189 OPC_CheckPredicate, 152, 1, // 306: check predicate 152
13190 OPC_CheckField, 25, 1, 0, // 309: check Inst[25] == 0x0
13191 OPC_Decode, 160, 113, 31, // 313: decode to CV_SRA_H using decoder 31
13192 // 313: }
13193 19, 11, // 317: case 0x13: {
13194 OPC_CheckPredicate, 152, 1, // 319: check predicate 152
13195 OPC_CheckField, 25, 1, 0, // 322: check Inst[25] == 0x0
13196 OPC_Decode, 226, 111, 31, // 326: decode to CV_CMPLEU_H using decoder 31
13197 // 326: }
13198 20, 11, // 330: case 0x14: {
13199 OPC_CheckPredicate, 152, 1, // 332: check predicate 152
13200 OPC_CheckField, 25, 1, 0, // 335: check Inst[25] == 0x0
13201 OPC_Decode, 154, 113, 31, // 339: decode to CV_SLL_H using decoder 31
13202 // 339: }
13203 21, 21, // 343: case 0x15: {
13204 OPC_SwitchField, 25, 1, // 345: switch Inst[25] {
13205 0, 7, // 348: case 0x0: {
13206 OPC_CheckPredicate, 152, 1, // 350: check predicate 152
13207 OPC_Decode, 133, 112, 61, // 353: decode to CV_CPLXMUL_R using decoder 61
13208 // 353: }
13209 1, 0, // 357: case 0x1: {
13210 OPC_CheckPredicate, 152, 1, // 359: check predicate 152
13211 OPC_Decode, 129, 112, 61, // 362: decode to CV_CPLXMUL_I using decoder 61
13212 // 362: }
13213 // 362: } // switch Inst[25]
13214 // 362: }
13215 22, 11, // 366: case 0x16: {
13216 OPC_CheckPredicate, 152, 1, // 368: check predicate 152
13217 OPC_CheckField, 25, 1, 0, // 371: check Inst[25] == 0x0
13218 OPC_Decode, 236, 112, 31, // 375: decode to CV_OR_H using decoder 31
13219 // 375: }
13220 23, 11, // 379: case 0x17: {
13221 OPC_CheckPredicate, 152, 1, // 381: check predicate 152
13222 OPC_CheckField, 20, 6, 0, // 384: check Inst[25:20] == 0x0
13223 OPC_Decode, 128, 112, 17, // 388: decode to CV_CPLXCONJ using decoder 17
13224 // 388: }
13225 24, 11, // 392: case 0x18: {
13226 OPC_CheckPredicate, 152, 1, // 394: check predicate 152
13227 OPC_CheckField, 25, 1, 0, // 397: check Inst[25] == 0x0
13228 OPC_Decode, 196, 113, 31, // 401: decode to CV_XOR_H using decoder 31
13229 // 401: }
13230 25, 11, // 405: case 0x19: {
13231 OPC_CheckPredicate, 152, 1, // 407: check predicate 152
13232 OPC_CheckField, 25, 1, 0, // 410: check Inst[25] == 0x0
13233 OPC_Decode, 175, 113, 31, // 414: decode to CV_SUBROTMJ using decoder 31
13234 // 414: }
13235 26, 11, // 418: case 0x1a: {
13236 OPC_CheckPredicate, 152, 1, // 420: check predicate 152
13237 OPC_CheckField, 25, 1, 0, // 423: check Inst[25] == 0x0
13238 OPC_Decode, 166, 111, 31, // 427: decode to CV_AND_H using decoder 31
13239 // 427: }
13240 28, 11, // 431: case 0x1c: {
13241 OPC_CheckPredicate, 152, 1, // 433: check predicate 152
13242 OPC_CheckField, 20, 6, 0, // 436: check Inst[25:20] == 0x0
13243 OPC_Decode, 147, 111, 17, // 440: decode to CV_ABS_H using decoder 17
13244 // 440: }
13245 32, 11, // 444: case 0x20: {
13246 OPC_CheckPredicate, 152, 1, // 446: check predicate 152
13247 OPC_CheckField, 25, 1, 0, // 449: check Inst[25] == 0x0
13248 OPC_Decode, 144, 112, 31, // 453: decode to CV_DOTUP_H using decoder 31
13249 // 453: }
13250 34, 11, // 457: case 0x22: {
13251 OPC_CheckPredicate, 152, 1, // 459: check predicate 152
13252 OPC_CheckField, 25, 1, 0, // 462: check Inst[25] == 0x0
13253 OPC_Decode, 150, 112, 31, // 466: decode to CV_DOTUSP_H using decoder 31
13254 // 466: }
13255 36, 11, // 470: case 0x24: {
13256 OPC_CheckPredicate, 152, 1, // 472: check predicate 152
13257 OPC_CheckField, 25, 1, 0, // 475: check Inst[25] == 0x0
13258 OPC_Decode, 138, 112, 31, // 479: decode to CV_DOTSP_H using decoder 31
13259 // 479: }
13260 38, 11, // 483: case 0x26: {
13261 OPC_CheckPredicate, 152, 1, // 485: check predicate 152
13262 OPC_CheckField, 25, 1, 0, // 488: check Inst[25] == 0x0
13263 OPC_Decode, 128, 113, 61, // 492: decode to CV_SDOTUP_H using decoder 61
13264 // 492: }
13265 40, 11, // 496: case 0x28: {
13266 OPC_CheckPredicate, 152, 1, // 498: check predicate 152
13267 OPC_CheckField, 25, 1, 0, // 501: check Inst[25] == 0x0
13268 OPC_Decode, 134, 113, 61, // 505: decode to CV_SDOTUSP_H using decoder 61
13269 // 505: }
13270 42, 11, // 509: case 0x2a: {
13271 OPC_CheckPredicate, 152, 1, // 511: check predicate 152
13272 OPC_CheckField, 25, 1, 0, // 514: check Inst[25] == 0x0
13273 OPC_Decode, 250, 112, 61, // 518: decode to CV_SDOTSP_H using decoder 61
13274 // 518: }
13275 46, 8, // 522: case 0x2e: {
13276 OPC_CheckPredicate, 152, 1, // 524: check predicate 152
13277 OPC_Decode, 167, 112, 222, 1, // 527: decode to CV_EXTRACT_H using decoder 222
13278 // 527: }
13279 48, 11, // 532: case 0x30: {
13280 OPC_CheckPredicate, 152, 1, // 534: check predicate 152
13281 OPC_CheckField, 25, 1, 0, // 537: check Inst[25] == 0x0
13282 OPC_Decode, 146, 113, 31, // 541: decode to CV_SHUFFLE_H using decoder 31
13283 // 541: }
13284 56, 11, // 545: case 0x38: {
13285 OPC_CheckPredicate, 152, 1, // 547: check predicate 152
13286 OPC_CheckField, 25, 1, 0, // 550: check Inst[25] == 0x0
13287 OPC_Decode, 140, 113, 61, // 554: decode to CV_SHUFFLE2_H using decoder 61
13288 // 554: }
13289 60, 0, // 558: case 0x3c: {
13290 OPC_SwitchField, 25, 1, // 560: switch Inst[25] {
13291 0, 7, // 563: case 0x0: {
13292 OPC_CheckPredicate, 152, 1, // 565: check predicate 152
13293 OPC_Decode, 241, 112, 31, // 568: decode to CV_PACK using decoder 31
13294 // 568: }
13295 1, 0, // 572: case 0x1: {
13296 OPC_CheckPredicate, 152, 1, // 574: check predicate 152
13297 OPC_Decode, 244, 112, 31, // 577: decode to CV_PACK_H using decoder 31
13298 // 577: }
13299 // 577: } // switch Inst[25]
13300 // 577: }
13301 // 577: } // switch Inst[31:26]
13302 // 577: }
13303 // 577: } // switch Inst[6:0]
13304 // 577: }
13305 1, 141, 4, // 581: case 0x1: {
13306 OPC_SwitchField, 0, 7, // 584: switch Inst[6:0] {
13307 11, 8, // 587: case 0xb: {
13308 OPC_CheckPredicate, 150, 1, // 589: check predicate 150
13309 OPC_Decode, 183, 112, 218, 1, // 592: decode to CV_LH_ri_inc using decoder 218
13310 // 592: }
13311 43, 8, // 597: case 0x2b: {
13312 OPC_CheckPredicate, 150, 1, // 599: check predicate 150
13313 OPC_Decode, 148, 113, 219, 1, // 602: decode to CV_SH_ri_inc using decoder 219
13314 // 602: }
13315 91, 33, // 607: case 0x5b: {
13316 OPC_SwitchField, 30, 2, // 609: switch Inst[31:30] {
13317 0, 8, // 612: case 0x0: {
13318 OPC_CheckPredicate, 151, 1, // 614: check predicate 151
13319 OPC_Decode, 183, 111, 220, 1, // 617: decode to CV_BCLR using decoder 220
13320 // 617: }
13321 1, 8, // 622: case 0x1: {
13322 OPC_CheckPredicate, 151, 1, // 624: check predicate 151
13323 OPC_Decode, 188, 111, 220, 1, // 627: decode to CV_BSET using decoder 220
13324 // 627: }
13325 3, 0, // 632: case 0x3: {
13326 OPC_CheckPredicate, 151, 1, // 634: check predicate 151
13327 OPC_Decode, 186, 111, 223, 1, // 637: decode to CV_BITREV using decoder 223
13328 // 637: }
13329 // 637: } // switch Inst[31:30]
13330 // 637: }
13331 123, 0, // 642: case 0x7b: {
13332 OPC_SwitchField, 26, 6, // 644: switch Inst[31:26] {
13333 0, 11, // 647: case 0x0: {
13334 OPC_CheckPredicate, 152, 1, // 649: check predicate 152
13335 OPC_CheckField, 25, 1, 0, // 652: check Inst[25] == 0x0
13336 OPC_Decode, 156, 111, 31, // 656: decode to CV_ADD_B using decoder 31
13337 // 656: }
13338 1, 11, // 660: case 0x1: {
13339 OPC_CheckPredicate, 152, 1, // 662: check predicate 152
13340 OPC_CheckField, 25, 1, 0, // 665: check Inst[25] == 0x0
13341 OPC_Decode, 195, 111, 31, // 669: decode to CV_CMPEQ_B using decoder 31
13342 // 669: }
13343 2, 11, // 673: case 0x2: {
13344 OPC_CheckPredicate, 152, 1, // 675: check predicate 152
13345 OPC_CheckField, 25, 1, 0, // 678: check Inst[25] == 0x0
13346 OPC_Decode, 183, 113, 31, // 682: decode to CV_SUB_B using decoder 31
13347 // 682: }
13348 3, 11, // 686: case 0x3: {
13349 OPC_CheckPredicate, 152, 1, // 688: check predicate 152
13350 OPC_CheckField, 25, 1, 0, // 691: check Inst[25] == 0x0
13351 OPC_Decode, 249, 111, 31, // 695: decode to CV_CMPNE_B using decoder 31
13352 // 695: }
13353 4, 11, // 699: case 0x4: {
13354 OPC_CheckPredicate, 152, 1, // 701: check predicate 152
13355 OPC_CheckField, 25, 1, 0, // 704: check Inst[25] == 0x0
13356 OPC_Decode, 177, 111, 31, // 708: decode to CV_AVG_B using decoder 31
13357 // 708: }
13358 5, 11, // 712: case 0x5: {
13359 OPC_CheckPredicate, 152, 1, // 714: check predicate 152
13360 OPC_CheckField, 25, 1, 0, // 717: check Inst[25] == 0x0
13361 OPC_Decode, 219, 111, 31, // 721: decode to CV_CMPGT_B using decoder 31
13362 // 721: }
13363 6, 11, // 725: case 0x6: {
13364 OPC_CheckPredicate, 152, 1, // 727: check predicate 152
13365 OPC_CheckField, 25, 1, 0, // 730: check Inst[25] == 0x0
13366 OPC_Decode, 171, 111, 31, // 734: decode to CV_AVGU_B using decoder 31
13367 // 734: }
13368 7, 11, // 738: case 0x7: {
13369 OPC_CheckPredicate, 152, 1, // 740: check predicate 152
13370 OPC_CheckField, 25, 1, 0, // 743: check Inst[25] == 0x0
13371 OPC_Decode, 207, 111, 31, // 747: decode to CV_CMPGE_B using decoder 31
13372 // 747: }
13373 8, 11, // 751: case 0x8: {
13374 OPC_CheckPredicate, 152, 1, // 753: check predicate 152
13375 OPC_CheckField, 25, 1, 0, // 756: check Inst[25] == 0x0
13376 OPC_Decode, 220, 112, 31, // 760: decode to CV_MIN_B using decoder 31
13377 // 760: }
13378 9, 11, // 764: case 0x9: {
13379 OPC_CheckPredicate, 152, 1, // 766: check predicate 152
13380 OPC_CheckField, 25, 1, 0, // 769: check Inst[25] == 0x0
13381 OPC_Decode, 243, 111, 31, // 773: decode to CV_CMPLT_B using decoder 31
13382 // 773: }
13383 10, 11, // 777: case 0xa: {
13384 OPC_CheckPredicate, 152, 1, // 779: check predicate 152
13385 OPC_CheckField, 25, 1, 0, // 782: check Inst[25] == 0x0
13386 OPC_Decode, 214, 112, 31, // 786: decode to CV_MINU_B using decoder 31
13387 // 786: }
13388 11, 11, // 790: case 0xb: {
13389 OPC_CheckPredicate, 152, 1, // 792: check predicate 152
13390 OPC_CheckField, 25, 1, 0, // 795: check Inst[25] == 0x0
13391 OPC_Decode, 231, 111, 31, // 799: decode to CV_CMPLE_B using decoder 31
13392 // 799: }
13393 12, 11, // 803: case 0xc: {
13394 OPC_CheckPredicate, 152, 1, // 805: check predicate 152
13395 OPC_CheckField, 25, 1, 0, // 808: check Inst[25] == 0x0
13396 OPC_Decode, 206, 112, 31, // 812: decode to CV_MAX_B using decoder 31
13397 // 812: }
13398 13, 11, // 816: case 0xd: {
13399 OPC_CheckPredicate, 152, 1, // 818: check predicate 152
13400 OPC_CheckField, 25, 1, 0, // 821: check Inst[25] == 0x0
13401 OPC_Decode, 213, 111, 31, // 825: decode to CV_CMPGTU_B using decoder 31
13402 // 825: }
13403 14, 11, // 829: case 0xe: {
13404 OPC_CheckPredicate, 152, 1, // 831: check predicate 152
13405 OPC_CheckField, 25, 1, 0, // 834: check Inst[25] == 0x0
13406 OPC_Decode, 200, 112, 31, // 838: decode to CV_MAXU_B using decoder 31
13407 // 838: }
13408 15, 11, // 842: case 0xf: {
13409 OPC_CheckPredicate, 152, 1, // 844: check predicate 152
13410 OPC_CheckField, 25, 1, 0, // 847: check Inst[25] == 0x0
13411 OPC_Decode, 201, 111, 31, // 851: decode to CV_CMPGEU_B using decoder 31
13412 // 851: }
13413 16, 11, // 855: case 0x10: {
13414 OPC_CheckPredicate, 152, 1, // 857: check predicate 152
13415 OPC_CheckField, 25, 1, 0, // 860: check Inst[25] == 0x0
13416 OPC_Decode, 165, 113, 31, // 864: decode to CV_SRL_B using decoder 31
13417 // 864: }
13418 17, 11, // 868: case 0x11: {
13419 OPC_CheckPredicate, 152, 1, // 870: check predicate 152
13420 OPC_CheckField, 25, 1, 0, // 873: check Inst[25] == 0x0
13421 OPC_Decode, 237, 111, 31, // 877: decode to CV_CMPLTU_B using decoder 31
13422 // 877: }
13423 18, 11, // 881: case 0x12: {
13424 OPC_CheckPredicate, 152, 1, // 883: check predicate 152
13425 OPC_CheckField, 25, 1, 0, // 886: check Inst[25] == 0x0
13426 OPC_Decode, 159, 113, 31, // 890: decode to CV_SRA_B using decoder 31
13427 // 890: }
13428 19, 11, // 894: case 0x13: {
13429 OPC_CheckPredicate, 152, 1, // 896: check predicate 152
13430 OPC_CheckField, 25, 1, 0, // 899: check Inst[25] == 0x0
13431 OPC_Decode, 225, 111, 31, // 903: decode to CV_CMPLEU_B using decoder 31
13432 // 903: }
13433 20, 11, // 907: case 0x14: {
13434 OPC_CheckPredicate, 152, 1, // 909: check predicate 152
13435 OPC_CheckField, 25, 1, 0, // 912: check Inst[25] == 0x0
13436 OPC_Decode, 153, 113, 31, // 916: decode to CV_SLL_B using decoder 31
13437 // 916: }
13438 22, 11, // 920: case 0x16: {
13439 OPC_CheckPredicate, 152, 1, // 922: check predicate 152
13440 OPC_CheckField, 25, 1, 0, // 925: check Inst[25] == 0x0
13441 OPC_Decode, 235, 112, 31, // 929: decode to CV_OR_B using decoder 31
13442 // 929: }
13443 24, 11, // 933: case 0x18: {
13444 OPC_CheckPredicate, 152, 1, // 935: check predicate 152
13445 OPC_CheckField, 25, 1, 0, // 938: check Inst[25] == 0x0
13446 OPC_Decode, 195, 113, 31, // 942: decode to CV_XOR_B using decoder 31
13447 // 942: }
13448 26, 11, // 946: case 0x1a: {
13449 OPC_CheckPredicate, 152, 1, // 948: check predicate 152
13450 OPC_CheckField, 25, 1, 0, // 951: check Inst[25] == 0x0
13451 OPC_Decode, 165, 111, 31, // 955: decode to CV_AND_B using decoder 31
13452 // 955: }
13453 28, 11, // 959: case 0x1c: {
13454 OPC_CheckPredicate, 152, 1, // 961: check predicate 152
13455 OPC_CheckField, 20, 6, 0, // 964: check Inst[25:20] == 0x0
13456 OPC_Decode, 146, 111, 17, // 968: decode to CV_ABS_B using decoder 17
13457 // 968: }
13458 32, 11, // 972: case 0x20: {
13459 OPC_CheckPredicate, 152, 1, // 974: check predicate 152
13460 OPC_CheckField, 25, 1, 0, // 977: check Inst[25] == 0x0
13461 OPC_Decode, 143, 112, 31, // 981: decode to CV_DOTUP_B using decoder 31
13462 // 981: }
13463 34, 11, // 985: case 0x22: {
13464 OPC_CheckPredicate, 152, 1, // 987: check predicate 152
13465 OPC_CheckField, 25, 1, 0, // 990: check Inst[25] == 0x0
13466 OPC_Decode, 149, 112, 31, // 994: decode to CV_DOTUSP_B using decoder 31
13467 // 994: }
13468 36, 11, // 998: case 0x24: {
13469 OPC_CheckPredicate, 152, 1, // 1000: check predicate 152
13470 OPC_CheckField, 25, 1, 0, // 1003: check Inst[25] == 0x0
13471 OPC_Decode, 137, 112, 31, // 1007: decode to CV_DOTSP_B using decoder 31
13472 // 1007: }
13473 38, 11, // 1011: case 0x26: {
13474 OPC_CheckPredicate, 152, 1, // 1013: check predicate 152
13475 OPC_CheckField, 25, 1, 0, // 1016: check Inst[25] == 0x0
13476 OPC_Decode, 255, 112, 61, // 1020: decode to CV_SDOTUP_B using decoder 61
13477 // 1020: }
13478 40, 11, // 1024: case 0x28: {
13479 OPC_CheckPredicate, 152, 1, // 1026: check predicate 152
13480 OPC_CheckField, 25, 1, 0, // 1029: check Inst[25] == 0x0
13481 OPC_Decode, 133, 113, 61, // 1033: decode to CV_SDOTUSP_B using decoder 61
13482 // 1033: }
13483 42, 11, // 1037: case 0x2a: {
13484 OPC_CheckPredicate, 152, 1, // 1039: check predicate 152
13485 OPC_CheckField, 25, 1, 0, // 1042: check Inst[25] == 0x0
13486 OPC_Decode, 249, 112, 61, // 1046: decode to CV_SDOTSP_B using decoder 61
13487 // 1046: }
13488 46, 8, // 1050: case 0x2e: {
13489 OPC_CheckPredicate, 152, 1, // 1052: check predicate 152
13490 OPC_Decode, 166, 112, 224, 1, // 1055: decode to CV_EXTRACT_B using decoder 224
13491 // 1055: }
13492 48, 11, // 1060: case 0x30: {
13493 OPC_CheckPredicate, 152, 1, // 1062: check predicate 152
13494 OPC_CheckField, 25, 1, 0, // 1065: check Inst[25] == 0x0
13495 OPC_Decode, 145, 113, 31, // 1069: decode to CV_SHUFFLE_B using decoder 31
13496 // 1069: }
13497 56, 11, // 1073: case 0x38: {
13498 OPC_CheckPredicate, 152, 1, // 1075: check predicate 152
13499 OPC_CheckField, 25, 1, 0, // 1078: check Inst[25] == 0x0
13500 OPC_Decode, 139, 113, 61, // 1082: decode to CV_SHUFFLE2_B using decoder 61
13501 // 1082: }
13502 62, 0, // 1086: case 0x3e: {
13503 OPC_SwitchField, 25, 1, // 1088: switch Inst[25] {
13504 0, 7, // 1091: case 0x0: {
13505 OPC_CheckPredicate, 152, 1, // 1093: check predicate 152
13506 OPC_Decode, 243, 112, 61, // 1096: decode to CV_PACKLO_B using decoder 61
13507 // 1096: }
13508 1, 0, // 1100: case 0x1: {
13509 OPC_CheckPredicate, 152, 1, // 1102: check predicate 152
13510 OPC_Decode, 242, 112, 61, // 1105: decode to CV_PACKHI_B using decoder 61
13511 // 1105: }
13512 // 1105: } // switch Inst[25]
13513 // 1105: }
13514 // 1105: } // switch Inst[31:26]
13515 // 1105: }
13516 // 1105: } // switch Inst[6:0]
13517 // 1105: }
13518 2, 145, 1, // 1109: case 0x2: {
13519 OPC_SwitchField, 0, 7, // 1112: switch Inst[6:0] {
13520 11, 8, // 1115: case 0xb: {
13521 OPC_CheckPredicate, 150, 1, // 1117: check predicate 150
13522 OPC_Decode, 186, 112, 218, 1, // 1120: decode to CV_LW_ri_inc using decoder 218
13523 // 1120: }
13524 43, 8, // 1125: case 0x2b: {
13525 OPC_CheckPredicate, 150, 1, // 1127: check predicate 150
13526 OPC_Decode, 192, 113, 219, 1, // 1130: decode to CV_SW_ri_inc using decoder 219
13527 // 1130: }
13528 91, 43, // 1135: case 0x5b: {
13529 OPC_SwitchField, 30, 2, // 1137: switch Inst[31:30] {
13530 0, 8, // 1140: case 0x0: {
13531 OPC_CheckPredicate, 153, 1, // 1142: check predicate 153
13532 OPC_Decode, 148, 111, 225, 1, // 1145: decode to CV_ADDN using decoder 225
13533 // 1145: }
13534 1, 8, // 1150: case 0x1: {
13535 OPC_CheckPredicate, 153, 1, // 1152: check predicate 153
13536 OPC_Decode, 152, 111, 225, 1, // 1155: decode to CV_ADDUN using decoder 225
13537 // 1155: }
13538 2, 8, // 1160: case 0x2: {
13539 OPC_CheckPredicate, 153, 1, // 1162: check predicate 153
13540 OPC_Decode, 150, 111, 225, 1, // 1165: decode to CV_ADDRN using decoder 225
13541 // 1165: }
13542 3, 0, // 1170: case 0x3: {
13543 OPC_CheckPredicate, 153, 1, // 1172: check predicate 153
13544 OPC_Decode, 154, 111, 225, 1, // 1175: decode to CV_ADDURN using decoder 225
13545 // 1175: }
13546 // 1175: } // switch Inst[31:30]
13547 // 1175: }
13548 123, 0, // 1180: case 0x7b: {
13549 OPC_SwitchField, 26, 6, // 1182: switch Inst[31:26] {
13550 21, 21, // 1185: case 0x15: {
13551 OPC_SwitchField, 25, 1, // 1187: switch Inst[25] {
13552 0, 7, // 1190: case 0x0: {
13553 OPC_CheckPredicate, 152, 1, // 1192: check predicate 152
13554 OPC_Decode, 134, 112, 61, // 1195: decode to CV_CPLXMUL_R_DIV2 using decoder 61
13555 // 1195: }
13556 1, 0, // 1199: case 0x1: {
13557 OPC_CheckPredicate, 152, 1, // 1201: check predicate 152
13558 OPC_Decode, 130, 112, 61, // 1204: decode to CV_CPLXMUL_I_DIV2 using decoder 61
13559 // 1204: }
13560 // 1204: } // switch Inst[25]
13561 // 1204: }
13562 25, 11, // 1208: case 0x19: {
13563 OPC_CheckPredicate, 152, 1, // 1210: check predicate 152
13564 OPC_CheckField, 25, 1, 0, // 1213: check Inst[25] == 0x0
13565 OPC_Decode, 176, 113, 31, // 1217: decode to CV_SUBROTMJ_DIV2 using decoder 31
13566 // 1217: }
13567 27, 11, // 1221: case 0x1b: {
13568 OPC_CheckPredicate, 152, 1, // 1223: check predicate 152
13569 OPC_CheckField, 25, 1, 0, // 1226: check Inst[25] == 0x0
13570 OPC_Decode, 157, 111, 31, // 1230: decode to CV_ADD_DIV2 using decoder 31
13571 // 1230: }
13572 29, 11, // 1234: case 0x1d: {
13573 OPC_CheckPredicate, 152, 1, // 1236: check predicate 152
13574 OPC_CheckField, 25, 1, 0, // 1239: check Inst[25] == 0x0
13575 OPC_Decode, 184, 113, 31, // 1243: decode to CV_SUB_DIV2 using decoder 31
13576 // 1243: }
13577 46, 0, // 1247: case 0x2e: {
13578 OPC_CheckPredicate, 152, 1, // 1249: check predicate 152
13579 OPC_Decode, 165, 112, 222, 1, // 1252: decode to CV_EXTRACTU_H using decoder 222
13580 // 1252: }
13581 // 1252: } // switch Inst[31:26]
13582 // 1252: }
13583 // 1252: } // switch Inst[6:0]
13584 // 1252: }
13585 3, 199, 4, // 1257: case 0x3: {
13586 OPC_SwitchField, 0, 7, // 1260: switch Inst[6:0] {
13587 11, 7, // 1263: case 0xb: {
13588 OPC_CheckPredicate, 154, 1, // 1265: check predicate 154
13589 OPC_Decode, 155, 112, 0, // 1268: decode to CV_ELW using decoder 0
13590 // 1268: }
13591 43, 253, 3, // 1272: case 0x2b: {
13592 OPC_SwitchField, 25, 7, // 1275: switch Inst[31:25] {
13593 0, 8, // 1278: case 0x0: {
13594 OPC_CheckPredicate, 150, 1, // 1280: check predicate 150
13595 OPC_Decode, 179, 112, 226, 1, // 1283: decode to CV_LB_rr_inc using decoder 226
13596 // 1283: }
13597 1, 8, // 1288: case 0x1: {
13598 OPC_CheckPredicate, 150, 1, // 1290: check predicate 150
13599 OPC_Decode, 185, 112, 226, 1, // 1293: decode to CV_LH_rr_inc using decoder 226
13600 // 1293: }
13601 2, 8, // 1298: case 0x2: {
13602 OPC_CheckPredicate, 150, 1, // 1300: check predicate 150
13603 OPC_Decode, 188, 112, 226, 1, // 1303: decode to CV_LW_rr_inc using decoder 226
13604 // 1303: }
13605 4, 7, // 1308: case 0x4: {
13606 OPC_CheckPredicate, 150, 1, // 1310: check predicate 150
13607 OPC_Decode, 178, 112, 31, // 1313: decode to CV_LB_rr using decoder 31
13608 // 1313: }
13609 5, 7, // 1317: case 0x5: {
13610 OPC_CheckPredicate, 150, 1, // 1319: check predicate 150
13611 OPC_Decode, 184, 112, 31, // 1322: decode to CV_LH_rr using decoder 31
13612 // 1322: }
13613 6, 7, // 1326: case 0x6: {
13614 OPC_CheckPredicate, 150, 1, // 1328: check predicate 150
13615 OPC_Decode, 187, 112, 31, // 1331: decode to CV_LW_rr using decoder 31
13616 // 1331: }
13617 8, 8, // 1335: case 0x8: {
13618 OPC_CheckPredicate, 150, 1, // 1337: check predicate 150
13619 OPC_Decode, 176, 112, 226, 1, // 1340: decode to CV_LBU_rr_inc using decoder 226
13620 // 1340: }
13621 9, 8, // 1345: case 0x9: {
13622 OPC_CheckPredicate, 150, 1, // 1347: check predicate 150
13623 OPC_Decode, 182, 112, 226, 1, // 1350: decode to CV_LHU_rr_inc using decoder 226
13624 // 1350: }
13625 12, 7, // 1355: case 0xc: {
13626 OPC_CheckPredicate, 150, 1, // 1357: check predicate 150
13627 OPC_Decode, 175, 112, 31, // 1360: decode to CV_LBU_rr using decoder 31
13628 // 1360: }
13629 13, 7, // 1364: case 0xd: {
13630 OPC_CheckPredicate, 150, 1, // 1366: check predicate 150
13631 OPC_Decode, 181, 112, 31, // 1369: decode to CV_LHU_rr using decoder 31
13632 // 1369: }
13633 16, 8, // 1373: case 0x10: {
13634 OPC_CheckPredicate, 150, 1, // 1375: check predicate 150
13635 OPC_Decode, 248, 112, 227, 1, // 1378: decode to CV_SB_rr_inc using decoder 227
13636 // 1378: }
13637 17, 8, // 1383: case 0x11: {
13638 OPC_CheckPredicate, 150, 1, // 1385: check predicate 150
13639 OPC_Decode, 150, 113, 227, 1, // 1388: decode to CV_SH_rr_inc using decoder 227
13640 // 1388: }
13641 18, 8, // 1393: case 0x12: {
13642 OPC_CheckPredicate, 150, 1, // 1395: check predicate 150
13643 OPC_Decode, 194, 113, 227, 1, // 1398: decode to CV_SW_rr_inc using decoder 227
13644 // 1398: }
13645 20, 8, // 1403: case 0x14: {
13646 OPC_CheckPredicate, 150, 1, // 1405: check predicate 150
13647 OPC_Decode, 247, 112, 228, 1, // 1408: decode to CV_SB_rr using decoder 228
13648 // 1408: }
13649 21, 8, // 1413: case 0x15: {
13650 OPC_CheckPredicate, 150, 1, // 1415: check predicate 150
13651 OPC_Decode, 149, 113, 228, 1, // 1418: decode to CV_SH_rr using decoder 228
13652 // 1418: }
13653 22, 8, // 1423: case 0x16: {
13654 OPC_CheckPredicate, 150, 1, // 1425: check predicate 150
13655 OPC_Decode, 193, 113, 228, 1, // 1428: decode to CV_SW_rr using decoder 228
13656 // 1428: }
13657 24, 7, // 1433: case 0x18: {
13658 OPC_CheckPredicate, 151, 1, // 1435: check predicate 151
13659 OPC_Decode, 161, 112, 31, // 1438: decode to CV_EXTRACTR using decoder 31
13660 // 1438: }
13661 25, 7, // 1442: case 0x19: {
13662 OPC_CheckPredicate, 151, 1, // 1444: check predicate 151
13663 OPC_Decode, 163, 112, 31, // 1447: decode to CV_EXTRACTUR using decoder 31
13664 // 1447: }
13665 26, 7, // 1451: case 0x1a: {
13666 OPC_CheckPredicate, 151, 1, // 1453: check predicate 151
13667 OPC_Decode, 171, 112, 61, // 1456: decode to CV_INSERTR using decoder 61
13668 // 1456: }
13669 28, 7, // 1460: case 0x1c: {
13670 OPC_CheckPredicate, 151, 1, // 1462: check predicate 151
13671 OPC_Decode, 184, 111, 31, // 1465: decode to CV_BCLRR using decoder 31
13672 // 1465: }
13673 29, 7, // 1469: case 0x1d: {
13674 OPC_CheckPredicate, 151, 1, // 1471: check predicate 151
13675 OPC_Decode, 189, 111, 31, // 1474: decode to CV_BSETR using decoder 31
13676 // 1474: }
13677 32, 7, // 1478: case 0x20: {
13678 OPC_CheckPredicate, 151, 1, // 1480: check predicate 151
13679 OPC_Decode, 245, 112, 31, // 1483: decode to CV_ROR using decoder 31
13680 // 1483: }
13681 33, 11, // 1487: case 0x21: {
13682 OPC_CheckPredicate, 151, 1, // 1489: check predicate 151
13683 OPC_CheckField, 20, 5, 0, // 1492: check Inst[24:20] == 0x0
13684 OPC_Decode, 168, 112, 17, // 1496: decode to CV_FF1 using decoder 17
13685 // 1496: }
13686 34, 11, // 1500: case 0x22: {
13687 OPC_CheckPredicate, 151, 1, // 1502: check predicate 151
13688 OPC_CheckField, 20, 5, 0, // 1505: check Inst[24:20] == 0x0
13689 OPC_Decode, 169, 112, 17, // 1509: decode to CV_FL1 using decoder 17
13690 // 1509: }
13691 35, 11, // 1513: case 0x23: {
13692 OPC_CheckPredicate, 151, 1, // 1515: check predicate 151
13693 OPC_CheckField, 20, 5, 0, // 1518: check Inst[24:20] == 0x0
13694 OPC_Decode, 190, 111, 17, // 1522: decode to CV_CLB using decoder 17
13695 // 1522: }
13696 36, 11, // 1526: case 0x24: {
13697 OPC_CheckPredicate, 151, 1, // 1528: check predicate 151
13698 OPC_CheckField, 20, 5, 0, // 1531: check Inst[24:20] == 0x0
13699 OPC_Decode, 255, 111, 17, // 1535: decode to CV_CNT using decoder 17
13700 // 1535: }
13701 40, 11, // 1539: case 0x28: {
13702 OPC_CheckPredicate, 153, 1, // 1541: check predicate 153
13703 OPC_CheckField, 20, 5, 0, // 1544: check Inst[24:20] == 0x0
13704 OPC_Decode, 145, 111, 17, // 1548: decode to CV_ABS using decoder 17
13705 // 1548: }
13706 41, 7, // 1552: case 0x29: {
13707 OPC_CheckPredicate, 153, 1, // 1554: check predicate 153
13708 OPC_Decode, 151, 113, 31, // 1557: decode to CV_SLE using decoder 31
13709 // 1557: }
13710 42, 7, // 1561: case 0x2a: {
13711 OPC_CheckPredicate, 153, 1, // 1563: check predicate 153
13712 OPC_Decode, 152, 113, 31, // 1566: decode to CV_SLEU using decoder 31
13713 // 1566: }
13714 43, 7, // 1570: case 0x2b: {
13715 OPC_CheckPredicate, 153, 1, // 1572: check predicate 153
13716 OPC_Decode, 212, 112, 31, // 1575: decode to CV_MIN using decoder 31
13717 // 1575: }
13718 44, 7, // 1579: case 0x2c: {
13719 OPC_CheckPredicate, 153, 1, // 1581: check predicate 153
13720 OPC_Decode, 213, 112, 31, // 1584: decode to CV_MINU using decoder 31
13721 // 1584: }
13722 45, 7, // 1588: case 0x2d: {
13723 OPC_CheckPredicate, 153, 1, // 1590: check predicate 153
13724 OPC_Decode, 198, 112, 31, // 1593: decode to CV_MAX using decoder 31
13725 // 1593: }
13726 46, 7, // 1597: case 0x2e: {
13727 OPC_CheckPredicate, 153, 1, // 1599: check predicate 153
13728 OPC_Decode, 199, 112, 31, // 1602: decode to CV_MAXU using decoder 31
13729 // 1602: }
13730 48, 11, // 1606: case 0x30: {
13731 OPC_CheckPredicate, 153, 1, // 1608: check predicate 153
13732 OPC_CheckField, 20, 5, 0, // 1611: check Inst[24:20] == 0x0
13733 OPC_Decode, 158, 112, 17, // 1615: decode to CV_EXTHS using decoder 17
13734 // 1615: }
13735 49, 11, // 1619: case 0x31: {
13736 OPC_CheckPredicate, 153, 1, // 1621: check predicate 153
13737 OPC_CheckField, 20, 5, 0, // 1624: check Inst[24:20] == 0x0
13738 OPC_Decode, 159, 112, 17, // 1628: decode to CV_EXTHZ using decoder 17
13739 // 1628: }
13740 50, 11, // 1632: case 0x32: {
13741 OPC_CheckPredicate, 153, 1, // 1634: check predicate 153
13742 OPC_CheckField, 20, 5, 0, // 1637: check Inst[24:20] == 0x0
13743 OPC_Decode, 156, 112, 17, // 1641: decode to CV_EXTBS using decoder 17
13744 // 1641: }
13745 51, 11, // 1645: case 0x33: {
13746 OPC_CheckPredicate, 153, 1, // 1647: check predicate 153
13747 OPC_CheckField, 20, 5, 0, // 1650: check Inst[24:20] == 0x0
13748 OPC_Decode, 157, 112, 17, // 1654: decode to CV_EXTBZ using decoder 17
13749 // 1654: }
13750 56, 7, // 1658: case 0x38: {
13751 OPC_CheckPredicate, 153, 1, // 1660: check predicate 153
13752 OPC_Decode, 191, 111, 21, // 1663: decode to CV_CLIP using decoder 21
13753 // 1663: }
13754 57, 7, // 1667: case 0x39: {
13755 OPC_CheckPredicate, 153, 1, // 1669: check predicate 153
13756 OPC_Decode, 193, 111, 21, // 1672: decode to CV_CLIPU using decoder 21
13757 // 1672: }
13758 58, 7, // 1676: case 0x3a: {
13759 OPC_CheckPredicate, 153, 1, // 1678: check predicate 153
13760 OPC_Decode, 192, 111, 31, // 1681: decode to CV_CLIPR using decoder 31
13761 // 1681: }
13762 59, 7, // 1685: case 0x3b: {
13763 OPC_CheckPredicate, 153, 1, // 1687: check predicate 153
13764 OPC_Decode, 194, 111, 31, // 1690: decode to CV_CLIPUR using decoder 31
13765 // 1690: }
13766 64, 7, // 1694: case 0x40: {
13767 OPC_CheckPredicate, 153, 1, // 1696: check predicate 153
13768 OPC_Decode, 149, 111, 61, // 1699: decode to CV_ADDNR using decoder 61
13769 // 1699: }
13770 65, 7, // 1703: case 0x41: {
13771 OPC_CheckPredicate, 153, 1, // 1705: check predicate 153
13772 OPC_Decode, 153, 111, 61, // 1708: decode to CV_ADDUNR using decoder 61
13773 // 1708: }
13774 66, 7, // 1712: case 0x42: {
13775 OPC_CheckPredicate, 153, 1, // 1714: check predicate 153
13776 OPC_Decode, 151, 111, 61, // 1717: decode to CV_ADDRNR using decoder 61
13777 // 1717: }
13778 67, 7, // 1721: case 0x43: {
13779 OPC_CheckPredicate, 153, 1, // 1723: check predicate 153
13780 OPC_Decode, 155, 111, 61, // 1726: decode to CV_ADDURNR using decoder 61
13781 // 1726: }
13782 68, 7, // 1730: case 0x44: {
13783 OPC_CheckPredicate, 153, 1, // 1732: check predicate 153
13784 OPC_Decode, 172, 113, 61, // 1735: decode to CV_SUBNR using decoder 61
13785 // 1735: }
13786 69, 7, // 1739: case 0x45: {
13787 OPC_CheckPredicate, 153, 1, // 1741: check predicate 153
13788 OPC_Decode, 180, 113, 61, // 1744: decode to CV_SUBUNR using decoder 61
13789 // 1744: }
13790 70, 7, // 1748: case 0x46: {
13791 OPC_CheckPredicate, 153, 1, // 1750: check predicate 153
13792 OPC_Decode, 174, 113, 61, // 1753: decode to CV_SUBRNR using decoder 61
13793 // 1753: }
13794 71, 7, // 1757: case 0x47: {
13795 OPC_CheckPredicate, 153, 1, // 1759: check predicate 153
13796 OPC_Decode, 182, 113, 61, // 1762: decode to CV_SUBURNR using decoder 61
13797 // 1762: }
13798 72, 7, // 1766: case 0x48: {
13799 OPC_CheckPredicate, 155, 1, // 1768: check predicate 155
13800 OPC_Decode, 189, 112, 61, // 1771: decode to CV_MAC using decoder 61
13801 // 1771: }
13802 73, 0, // 1775: case 0x49: {
13803 OPC_CheckPredicate, 155, 1, // 1777: check predicate 155
13804 OPC_Decode, 226, 112, 61, // 1780: decode to CV_MSU using decoder 61
13805 // 1780: }
13806 // 1780: } // switch Inst[31:25]
13807 // 1780: }
13808 91, 43, // 1784: case 0x5b: {
13809 OPC_SwitchField, 30, 2, // 1786: switch Inst[31:30] {
13810 0, 8, // 1789: case 0x0: {
13811 OPC_CheckPredicate, 153, 1, // 1791: check predicate 153
13812 OPC_Decode, 171, 113, 225, 1, // 1794: decode to CV_SUBN using decoder 225
13813 // 1794: }
13814 1, 8, // 1799: case 0x1: {
13815 OPC_CheckPredicate, 153, 1, // 1801: check predicate 153
13816 OPC_Decode, 179, 113, 225, 1, // 1804: decode to CV_SUBUN using decoder 225
13817 // 1804: }
13818 2, 8, // 1809: case 0x2: {
13819 OPC_CheckPredicate, 153, 1, // 1811: check predicate 153
13820 OPC_Decode, 173, 113, 225, 1, // 1814: decode to CV_SUBRN using decoder 225
13821 // 1814: }
13822 3, 0, // 1819: case 0x3: {
13823 OPC_CheckPredicate, 153, 1, // 1821: check predicate 153
13824 OPC_Decode, 181, 113, 225, 1, // 1824: decode to CV_SUBURN using decoder 225
13825 // 1824: }
13826 // 1824: } // switch Inst[31:30]
13827 // 1824: }
13828 123, 0, // 1829: case 0x7b: {
13829 OPC_CheckPredicate, 152, 1, // 1831: check predicate 152
13830 OPC_CheckField, 26, 6, 46, // 1834: check Inst[31:26] == 0x2e
13831 OPC_Decode, 164, 112, 224, 1, // 1838: decode to CV_EXTRACTU_B using decoder 224
13832 // 1838: }
13833 // 1838: } // switch Inst[6:0]
13834 // 1838: }
13835 4, 141, 4, // 1843: case 0x4: {
13836 OPC_SwitchField, 0, 7, // 1846: switch Inst[6:0] {
13837 11, 8, // 1849: case 0xb: {
13838 OPC_CheckPredicate, 150, 1, // 1851: check predicate 150
13839 OPC_Decode, 174, 112, 218, 1, // 1854: decode to CV_LBU_ri_inc using decoder 218
13840 // 1854: }
13841 91, 43, // 1859: case 0x5b: {
13842 OPC_SwitchField, 30, 2, // 1861: switch Inst[31:30] {
13843 0, 8, // 1864: case 0x0: {
13844 OPC_CheckPredicate, 155, 1, // 1866: check predicate 155
13845 OPC_Decode, 231, 112, 225, 1, // 1869: decode to CV_MULSN using decoder 225
13846 // 1869: }
13847 1, 8, // 1874: case 0x1: {
13848 OPC_CheckPredicate, 155, 1, // 1876: check predicate 155
13849 OPC_Decode, 227, 112, 225, 1, // 1879: decode to CV_MULHHSN using decoder 225
13850 // 1879: }
13851 2, 8, // 1884: case 0x2: {
13852 OPC_CheckPredicate, 155, 1, // 1886: check predicate 155
13853 OPC_Decode, 232, 112, 225, 1, // 1889: decode to CV_MULSRN using decoder 225
13854 // 1889: }
13855 3, 0, // 1894: case 0x3: {
13856 OPC_CheckPredicate, 155, 1, // 1896: check predicate 155
13857 OPC_Decode, 228, 112, 225, 1, // 1899: decode to CV_MULHHSRN using decoder 225
13858 // 1899: }
13859 // 1899: } // switch Inst[31:30]
13860 // 1899: }
13861 123, 0, // 1904: case 0x7b: {
13862 OPC_SwitchField, 26, 6, // 1906: switch Inst[31:26] {
13863 0, 11, // 1909: case 0x0: {
13864 OPC_CheckPredicate, 152, 1, // 1911: check predicate 152
13865 OPC_CheckField, 25, 1, 0, // 1914: check Inst[25] == 0x0
13866 OPC_Decode, 164, 111, 31, // 1918: decode to CV_ADD_SC_H using decoder 31
13867 // 1918: }
13868 1, 11, // 1922: case 0x1: {
13869 OPC_CheckPredicate, 152, 1, // 1924: check predicate 152
13870 OPC_CheckField, 25, 1, 0, // 1927: check Inst[25] == 0x0
13871 OPC_Decode, 200, 111, 31, // 1931: decode to CV_CMPEQ_SC_H using decoder 31
13872 // 1931: }
13873 2, 11, // 1935: case 0x2: {
13874 OPC_CheckPredicate, 152, 1, // 1937: check predicate 152
13875 OPC_CheckField, 25, 1, 0, // 1940: check Inst[25] == 0x0
13876 OPC_Decode, 191, 113, 31, // 1944: decode to CV_SUB_SC_H using decoder 31
13877 // 1944: }
13878 3, 11, // 1948: case 0x3: {
13879 OPC_CheckPredicate, 152, 1, // 1950: check predicate 152
13880 OPC_CheckField, 25, 1, 0, // 1953: check Inst[25] == 0x0
13881 OPC_Decode, 254, 111, 31, // 1957: decode to CV_CMPNE_SC_H using decoder 31
13882 // 1957: }
13883 4, 11, // 1961: case 0x4: {
13884 OPC_CheckPredicate, 152, 1, // 1963: check predicate 152
13885 OPC_CheckField, 25, 1, 0, // 1966: check Inst[25] == 0x0
13886 OPC_Decode, 182, 111, 31, // 1970: decode to CV_AVG_SC_H using decoder 31
13887 // 1970: }
13888 5, 11, // 1974: case 0x5: {
13889 OPC_CheckPredicate, 152, 1, // 1976: check predicate 152
13890 OPC_CheckField, 25, 1, 0, // 1979: check Inst[25] == 0x0
13891 OPC_Decode, 224, 111, 31, // 1983: decode to CV_CMPGT_SC_H using decoder 31
13892 // 1983: }
13893 6, 11, // 1987: case 0x6: {
13894 OPC_CheckPredicate, 152, 1, // 1989: check predicate 152
13895 OPC_CheckField, 25, 1, 0, // 1992: check Inst[25] == 0x0
13896 OPC_Decode, 176, 111, 31, // 1996: decode to CV_AVGU_SC_H using decoder 31
13897 // 1996: }
13898 7, 11, // 2000: case 0x7: {
13899 OPC_CheckPredicate, 152, 1, // 2002: check predicate 152
13900 OPC_CheckField, 25, 1, 0, // 2005: check Inst[25] == 0x0
13901 OPC_Decode, 212, 111, 31, // 2009: decode to CV_CMPGE_SC_H using decoder 31
13902 // 2009: }
13903 8, 11, // 2013: case 0x8: {
13904 OPC_CheckPredicate, 152, 1, // 2015: check predicate 152
13905 OPC_CheckField, 25, 1, 0, // 2018: check Inst[25] == 0x0
13906 OPC_Decode, 225, 112, 31, // 2022: decode to CV_MIN_SC_H using decoder 31
13907 // 2022: }
13908 9, 11, // 2026: case 0x9: {
13909 OPC_CheckPredicate, 152, 1, // 2028: check predicate 152
13910 OPC_CheckField, 25, 1, 0, // 2031: check Inst[25] == 0x0
13911 OPC_Decode, 248, 111, 31, // 2035: decode to CV_CMPLT_SC_H using decoder 31
13912 // 2035: }
13913 10, 11, // 2039: case 0xa: {
13914 OPC_CheckPredicate, 152, 1, // 2041: check predicate 152
13915 OPC_CheckField, 25, 1, 0, // 2044: check Inst[25] == 0x0
13916 OPC_Decode, 219, 112, 31, // 2048: decode to CV_MINU_SC_H using decoder 31
13917 // 2048: }
13918 11, 11, // 2052: case 0xb: {
13919 OPC_CheckPredicate, 152, 1, // 2054: check predicate 152
13920 OPC_CheckField, 25, 1, 0, // 2057: check Inst[25] == 0x0
13921 OPC_Decode, 236, 111, 31, // 2061: decode to CV_CMPLE_SC_H using decoder 31
13922 // 2061: }
13923 12, 11, // 2065: case 0xc: {
13924 OPC_CheckPredicate, 152, 1, // 2067: check predicate 152
13925 OPC_CheckField, 25, 1, 0, // 2070: check Inst[25] == 0x0
13926 OPC_Decode, 211, 112, 31, // 2074: decode to CV_MAX_SC_H using decoder 31
13927 // 2074: }
13928 13, 11, // 2078: case 0xd: {
13929 OPC_CheckPredicate, 152, 1, // 2080: check predicate 152
13930 OPC_CheckField, 25, 1, 0, // 2083: check Inst[25] == 0x0
13931 OPC_Decode, 218, 111, 31, // 2087: decode to CV_CMPGTU_SC_H using decoder 31
13932 // 2087: }
13933 14, 11, // 2091: case 0xe: {
13934 OPC_CheckPredicate, 152, 1, // 2093: check predicate 152
13935 OPC_CheckField, 25, 1, 0, // 2096: check Inst[25] == 0x0
13936 OPC_Decode, 205, 112, 31, // 2100: decode to CV_MAXU_SC_H using decoder 31
13937 // 2100: }
13938 15, 11, // 2104: case 0xf: {
13939 OPC_CheckPredicate, 152, 1, // 2106: check predicate 152
13940 OPC_CheckField, 25, 1, 0, // 2109: check Inst[25] == 0x0
13941 OPC_Decode, 206, 111, 31, // 2113: decode to CV_CMPGEU_SC_H using decoder 31
13942 // 2113: }
13943 16, 11, // 2117: case 0x10: {
13944 OPC_CheckPredicate, 152, 1, // 2119: check predicate 152
13945 OPC_CheckField, 25, 1, 0, // 2122: check Inst[25] == 0x0
13946 OPC_Decode, 170, 113, 31, // 2126: decode to CV_SRL_SC_H using decoder 31
13947 // 2126: }
13948 17, 11, // 2130: case 0x11: {
13949 OPC_CheckPredicate, 152, 1, // 2132: check predicate 152
13950 OPC_CheckField, 25, 1, 0, // 2135: check Inst[25] == 0x0
13951 OPC_Decode, 242, 111, 31, // 2139: decode to CV_CMPLTU_SC_H using decoder 31
13952 // 2139: }
13953 18, 11, // 2143: case 0x12: {
13954 OPC_CheckPredicate, 152, 1, // 2145: check predicate 152
13955 OPC_CheckField, 25, 1, 0, // 2148: check Inst[25] == 0x0
13956 OPC_Decode, 164, 113, 31, // 2152: decode to CV_SRA_SC_H using decoder 31
13957 // 2152: }
13958 19, 11, // 2156: case 0x13: {
13959 OPC_CheckPredicate, 152, 1, // 2158: check predicate 152
13960 OPC_CheckField, 25, 1, 0, // 2161: check Inst[25] == 0x0
13961 OPC_Decode, 230, 111, 31, // 2165: decode to CV_CMPLEU_SC_H using decoder 31
13962 // 2165: }
13963 20, 11, // 2169: case 0x14: {
13964 OPC_CheckPredicate, 152, 1, // 2171: check predicate 152
13965 OPC_CheckField, 25, 1, 0, // 2174: check Inst[25] == 0x0
13966 OPC_Decode, 158, 113, 31, // 2178: decode to CV_SLL_SC_H using decoder 31
13967 // 2178: }
13968 21, 21, // 2182: case 0x15: {
13969 OPC_SwitchField, 25, 1, // 2184: switch Inst[25] {
13970 0, 7, // 2187: case 0x0: {
13971 OPC_CheckPredicate, 152, 1, // 2189: check predicate 152
13972 OPC_Decode, 135, 112, 61, // 2192: decode to CV_CPLXMUL_R_DIV4 using decoder 61
13973 // 2192: }
13974 1, 0, // 2196: case 0x1: {
13975 OPC_CheckPredicate, 152, 1, // 2198: check predicate 152
13976 OPC_Decode, 131, 112, 61, // 2201: decode to CV_CPLXMUL_I_DIV4 using decoder 61
13977 // 2201: }
13978 // 2201: } // switch Inst[25]
13979 // 2201: }
13980 22, 11, // 2205: case 0x16: {
13981 OPC_CheckPredicate, 152, 1, // 2207: check predicate 152
13982 OPC_CheckField, 25, 1, 0, // 2210: check Inst[25] == 0x0
13983 OPC_Decode, 240, 112, 31, // 2214: decode to CV_OR_SC_H using decoder 31
13984 // 2214: }
13985 24, 11, // 2218: case 0x18: {
13986 OPC_CheckPredicate, 152, 1, // 2220: check predicate 152
13987 OPC_CheckField, 25, 1, 0, // 2223: check Inst[25] == 0x0
13988 OPC_Decode, 200, 113, 31, // 2227: decode to CV_XOR_SC_H using decoder 31
13989 // 2227: }
13990 25, 11, // 2231: case 0x19: {
13991 OPC_CheckPredicate, 152, 1, // 2233: check predicate 152
13992 OPC_CheckField, 25, 1, 0, // 2236: check Inst[25] == 0x0
13993 OPC_Decode, 177, 113, 31, // 2240: decode to CV_SUBROTMJ_DIV4 using decoder 31
13994 // 2240: }
13995 26, 11, // 2244: case 0x1a: {
13996 OPC_CheckPredicate, 152, 1, // 2246: check predicate 152
13997 OPC_CheckField, 25, 1, 0, // 2249: check Inst[25] == 0x0
13998 OPC_Decode, 170, 111, 31, // 2253: decode to CV_AND_SC_H using decoder 31
13999 // 2253: }
14000 27, 11, // 2257: case 0x1b: {
14001 OPC_CheckPredicate, 152, 1, // 2259: check predicate 152
14002 OPC_CheckField, 25, 1, 0, // 2262: check Inst[25] == 0x0
14003 OPC_Decode, 158, 111, 31, // 2266: decode to CV_ADD_DIV4 using decoder 31
14004 // 2266: }
14005 29, 11, // 2270: case 0x1d: {
14006 OPC_CheckPredicate, 152, 1, // 2272: check predicate 152
14007 OPC_CheckField, 25, 1, 0, // 2275: check Inst[25] == 0x0
14008 OPC_Decode, 185, 113, 31, // 2279: decode to CV_SUB_DIV4 using decoder 31
14009 // 2279: }
14010 32, 11, // 2283: case 0x20: {
14011 OPC_CheckPredicate, 152, 1, // 2285: check predicate 152
14012 OPC_CheckField, 25, 1, 0, // 2288: check Inst[25] == 0x0
14013 OPC_Decode, 148, 112, 31, // 2292: decode to CV_DOTUP_SC_H using decoder 31
14014 // 2292: }
14015 34, 11, // 2296: case 0x22: {
14016 OPC_CheckPredicate, 152, 1, // 2298: check predicate 152
14017 OPC_CheckField, 25, 1, 0, // 2301: check Inst[25] == 0x0
14018 OPC_Decode, 154, 112, 31, // 2305: decode to CV_DOTUSP_SC_H using decoder 31
14019 // 2305: }
14020 36, 11, // 2309: case 0x24: {
14021 OPC_CheckPredicate, 152, 1, // 2311: check predicate 152
14022 OPC_CheckField, 25, 1, 0, // 2314: check Inst[25] == 0x0
14023 OPC_Decode, 142, 112, 31, // 2318: decode to CV_DOTSP_SC_H using decoder 31
14024 // 2318: }
14025 38, 11, // 2322: case 0x26: {
14026 OPC_CheckPredicate, 152, 1, // 2324: check predicate 152
14027 OPC_CheckField, 25, 1, 0, // 2327: check Inst[25] == 0x0
14028 OPC_Decode, 132, 113, 61, // 2331: decode to CV_SDOTUP_SC_H using decoder 61
14029 // 2331: }
14030 40, 11, // 2335: case 0x28: {
14031 OPC_CheckPredicate, 152, 1, // 2337: check predicate 152
14032 OPC_CheckField, 25, 1, 0, // 2340: check Inst[25] == 0x0
14033 OPC_Decode, 138, 113, 61, // 2344: decode to CV_SDOTUSP_SC_H using decoder 61
14034 // 2344: }
14035 42, 11, // 2348: case 0x2a: {
14036 OPC_CheckPredicate, 152, 1, // 2350: check predicate 152
14037 OPC_CheckField, 25, 1, 0, // 2353: check Inst[25] == 0x0
14038 OPC_Decode, 254, 112, 61, // 2357: decode to CV_SDOTSP_SC_H using decoder 61
14039 // 2357: }
14040 46, 0, // 2361: case 0x2e: {
14041 OPC_CheckPredicate, 152, 1, // 2363: check predicate 152
14042 OPC_Decode, 173, 112, 229, 1, // 2366: decode to CV_INSERT_H using decoder 229
14043 // 2366: }
14044 // 2366: } // switch Inst[31:26]
14045 // 2366: }
14046 // 2366: } // switch Inst[6:0]
14047 // 2366: }
14048 5, 207, 3, // 2371: case 0x5: {
14049 OPC_SwitchField, 0, 7, // 2374: switch Inst[6:0] {
14050 11, 8, // 2377: case 0xb: {
14051 OPC_CheckPredicate, 150, 1, // 2379: check predicate 150
14052 OPC_Decode, 180, 112, 218, 1, // 2382: decode to CV_LHU_ri_inc using decoder 218
14053 // 2382: }
14054 91, 43, // 2387: case 0x5b: {
14055 OPC_SwitchField, 30, 2, // 2389: switch Inst[31:30] {
14056 0, 8, // 2392: case 0x0: {
14057 OPC_CheckPredicate, 155, 1, // 2394: check predicate 155
14058 OPC_Decode, 233, 112, 225, 1, // 2397: decode to CV_MULUN using decoder 225
14059 // 2397: }
14060 1, 8, // 2402: case 0x1: {
14061 OPC_CheckPredicate, 155, 1, // 2404: check predicate 155
14062 OPC_Decode, 229, 112, 225, 1, // 2407: decode to CV_MULHHUN using decoder 225
14063 // 2407: }
14064 2, 8, // 2412: case 0x2: {
14065 OPC_CheckPredicate, 155, 1, // 2414: check predicate 155
14066 OPC_Decode, 234, 112, 225, 1, // 2417: decode to CV_MULURN using decoder 225
14067 // 2417: }
14068 3, 0, // 2422: case 0x3: {
14069 OPC_CheckPredicate, 155, 1, // 2424: check predicate 155
14070 OPC_Decode, 230, 112, 225, 1, // 2427: decode to CV_MULHHURN using decoder 225
14071 // 2427: }
14072 // 2427: } // switch Inst[31:30]
14073 // 2427: }
14074 123, 0, // 2432: case 0x7b: {
14075 OPC_SwitchField, 26, 6, // 2434: switch Inst[31:26] {
14076 0, 11, // 2437: case 0x0: {
14077 OPC_CheckPredicate, 152, 1, // 2439: check predicate 152
14078 OPC_CheckField, 25, 1, 0, // 2442: check Inst[25] == 0x0
14079 OPC_Decode, 163, 111, 31, // 2446: decode to CV_ADD_SC_B using decoder 31
14080 // 2446: }
14081 1, 11, // 2450: case 0x1: {
14082 OPC_CheckPredicate, 152, 1, // 2452: check predicate 152
14083 OPC_CheckField, 25, 1, 0, // 2455: check Inst[25] == 0x0
14084 OPC_Decode, 199, 111, 31, // 2459: decode to CV_CMPEQ_SC_B using decoder 31
14085 // 2459: }
14086 2, 11, // 2463: case 0x2: {
14087 OPC_CheckPredicate, 152, 1, // 2465: check predicate 152
14088 OPC_CheckField, 25, 1, 0, // 2468: check Inst[25] == 0x0
14089 OPC_Decode, 190, 113, 31, // 2472: decode to CV_SUB_SC_B using decoder 31
14090 // 2472: }
14091 3, 11, // 2476: case 0x3: {
14092 OPC_CheckPredicate, 152, 1, // 2478: check predicate 152
14093 OPC_CheckField, 25, 1, 0, // 2481: check Inst[25] == 0x0
14094 OPC_Decode, 253, 111, 31, // 2485: decode to CV_CMPNE_SC_B using decoder 31
14095 // 2485: }
14096 4, 11, // 2489: case 0x4: {
14097 OPC_CheckPredicate, 152, 1, // 2491: check predicate 152
14098 OPC_CheckField, 25, 1, 0, // 2494: check Inst[25] == 0x0
14099 OPC_Decode, 181, 111, 31, // 2498: decode to CV_AVG_SC_B using decoder 31
14100 // 2498: }
14101 5, 11, // 2502: case 0x5: {
14102 OPC_CheckPredicate, 152, 1, // 2504: check predicate 152
14103 OPC_CheckField, 25, 1, 0, // 2507: check Inst[25] == 0x0
14104 OPC_Decode, 223, 111, 31, // 2511: decode to CV_CMPGT_SC_B using decoder 31
14105 // 2511: }
14106 6, 11, // 2515: case 0x6: {
14107 OPC_CheckPredicate, 152, 1, // 2517: check predicate 152
14108 OPC_CheckField, 25, 1, 0, // 2520: check Inst[25] == 0x0
14109 OPC_Decode, 175, 111, 31, // 2524: decode to CV_AVGU_SC_B using decoder 31
14110 // 2524: }
14111 7, 11, // 2528: case 0x7: {
14112 OPC_CheckPredicate, 152, 1, // 2530: check predicate 152
14113 OPC_CheckField, 25, 1, 0, // 2533: check Inst[25] == 0x0
14114 OPC_Decode, 211, 111, 31, // 2537: decode to CV_CMPGE_SC_B using decoder 31
14115 // 2537: }
14116 8, 11, // 2541: case 0x8: {
14117 OPC_CheckPredicate, 152, 1, // 2543: check predicate 152
14118 OPC_CheckField, 25, 1, 0, // 2546: check Inst[25] == 0x0
14119 OPC_Decode, 224, 112, 31, // 2550: decode to CV_MIN_SC_B using decoder 31
14120 // 2550: }
14121 9, 11, // 2554: case 0x9: {
14122 OPC_CheckPredicate, 152, 1, // 2556: check predicate 152
14123 OPC_CheckField, 25, 1, 0, // 2559: check Inst[25] == 0x0
14124 OPC_Decode, 247, 111, 31, // 2563: decode to CV_CMPLT_SC_B using decoder 31
14125 // 2563: }
14126 10, 11, // 2567: case 0xa: {
14127 OPC_CheckPredicate, 152, 1, // 2569: check predicate 152
14128 OPC_CheckField, 25, 1, 0, // 2572: check Inst[25] == 0x0
14129 OPC_Decode, 218, 112, 31, // 2576: decode to CV_MINU_SC_B using decoder 31
14130 // 2576: }
14131 11, 11, // 2580: case 0xb: {
14132 OPC_CheckPredicate, 152, 1, // 2582: check predicate 152
14133 OPC_CheckField, 25, 1, 0, // 2585: check Inst[25] == 0x0
14134 OPC_Decode, 235, 111, 31, // 2589: decode to CV_CMPLE_SC_B using decoder 31
14135 // 2589: }
14136 12, 11, // 2593: case 0xc: {
14137 OPC_CheckPredicate, 152, 1, // 2595: check predicate 152
14138 OPC_CheckField, 25, 1, 0, // 2598: check Inst[25] == 0x0
14139 OPC_Decode, 210, 112, 31, // 2602: decode to CV_MAX_SC_B using decoder 31
14140 // 2602: }
14141 13, 11, // 2606: case 0xd: {
14142 OPC_CheckPredicate, 152, 1, // 2608: check predicate 152
14143 OPC_CheckField, 25, 1, 0, // 2611: check Inst[25] == 0x0
14144 OPC_Decode, 217, 111, 31, // 2615: decode to CV_CMPGTU_SC_B using decoder 31
14145 // 2615: }
14146 14, 11, // 2619: case 0xe: {
14147 OPC_CheckPredicate, 152, 1, // 2621: check predicate 152
14148 OPC_CheckField, 25, 1, 0, // 2624: check Inst[25] == 0x0
14149 OPC_Decode, 204, 112, 31, // 2628: decode to CV_MAXU_SC_B using decoder 31
14150 // 2628: }
14151 15, 11, // 2632: case 0xf: {
14152 OPC_CheckPredicate, 152, 1, // 2634: check predicate 152
14153 OPC_CheckField, 25, 1, 0, // 2637: check Inst[25] == 0x0
14154 OPC_Decode, 205, 111, 31, // 2641: decode to CV_CMPGEU_SC_B using decoder 31
14155 // 2641: }
14156 16, 11, // 2645: case 0x10: {
14157 OPC_CheckPredicate, 152, 1, // 2647: check predicate 152
14158 OPC_CheckField, 25, 1, 0, // 2650: check Inst[25] == 0x0
14159 OPC_Decode, 169, 113, 31, // 2654: decode to CV_SRL_SC_B using decoder 31
14160 // 2654: }
14161 17, 11, // 2658: case 0x11: {
14162 OPC_CheckPredicate, 152, 1, // 2660: check predicate 152
14163 OPC_CheckField, 25, 1, 0, // 2663: check Inst[25] == 0x0
14164 OPC_Decode, 241, 111, 31, // 2667: decode to CV_CMPLTU_SC_B using decoder 31
14165 // 2667: }
14166 18, 11, // 2671: case 0x12: {
14167 OPC_CheckPredicate, 152, 1, // 2673: check predicate 152
14168 OPC_CheckField, 25, 1, 0, // 2676: check Inst[25] == 0x0
14169 OPC_Decode, 163, 113, 31, // 2680: decode to CV_SRA_SC_B using decoder 31
14170 // 2680: }
14171 19, 11, // 2684: case 0x13: {
14172 OPC_CheckPredicate, 152, 1, // 2686: check predicate 152
14173 OPC_CheckField, 25, 1, 0, // 2689: check Inst[25] == 0x0
14174 OPC_Decode, 229, 111, 31, // 2693: decode to CV_CMPLEU_SC_B using decoder 31
14175 // 2693: }
14176 20, 11, // 2697: case 0x14: {
14177 OPC_CheckPredicate, 152, 1, // 2699: check predicate 152
14178 OPC_CheckField, 25, 1, 0, // 2702: check Inst[25] == 0x0
14179 OPC_Decode, 157, 113, 31, // 2706: decode to CV_SLL_SC_B using decoder 31
14180 // 2706: }
14181 22, 11, // 2710: case 0x16: {
14182 OPC_CheckPredicate, 152, 1, // 2712: check predicate 152
14183 OPC_CheckField, 25, 1, 0, // 2715: check Inst[25] == 0x0
14184 OPC_Decode, 239, 112, 31, // 2719: decode to CV_OR_SC_B using decoder 31
14185 // 2719: }
14186 24, 11, // 2723: case 0x18: {
14187 OPC_CheckPredicate, 152, 1, // 2725: check predicate 152
14188 OPC_CheckField, 25, 1, 0, // 2728: check Inst[25] == 0x0
14189 OPC_Decode, 199, 113, 31, // 2732: decode to CV_XOR_SC_B using decoder 31
14190 // 2732: }
14191 26, 11, // 2736: case 0x1a: {
14192 OPC_CheckPredicate, 152, 1, // 2738: check predicate 152
14193 OPC_CheckField, 25, 1, 0, // 2741: check Inst[25] == 0x0
14194 OPC_Decode, 169, 111, 31, // 2745: decode to CV_AND_SC_B using decoder 31
14195 // 2745: }
14196 32, 11, // 2749: case 0x20: {
14197 OPC_CheckPredicate, 152, 1, // 2751: check predicate 152
14198 OPC_CheckField, 25, 1, 0, // 2754: check Inst[25] == 0x0
14199 OPC_Decode, 147, 112, 31, // 2758: decode to CV_DOTUP_SC_B using decoder 31
14200 // 2758: }
14201 34, 11, // 2762: case 0x22: {
14202 OPC_CheckPredicate, 152, 1, // 2764: check predicate 152
14203 OPC_CheckField, 25, 1, 0, // 2767: check Inst[25] == 0x0
14204 OPC_Decode, 153, 112, 31, // 2771: decode to CV_DOTUSP_SC_B using decoder 31
14205 // 2771: }
14206 36, 11, // 2775: case 0x24: {
14207 OPC_CheckPredicate, 152, 1, // 2777: check predicate 152
14208 OPC_CheckField, 25, 1, 0, // 2780: check Inst[25] == 0x0
14209 OPC_Decode, 141, 112, 31, // 2784: decode to CV_DOTSP_SC_B using decoder 31
14210 // 2784: }
14211 38, 11, // 2788: case 0x26: {
14212 OPC_CheckPredicate, 152, 1, // 2790: check predicate 152
14213 OPC_CheckField, 25, 1, 0, // 2793: check Inst[25] == 0x0
14214 OPC_Decode, 131, 113, 61, // 2797: decode to CV_SDOTUP_SC_B using decoder 61
14215 // 2797: }
14216 40, 11, // 2801: case 0x28: {
14217 OPC_CheckPredicate, 152, 1, // 2803: check predicate 152
14218 OPC_CheckField, 25, 1, 0, // 2806: check Inst[25] == 0x0
14219 OPC_Decode, 137, 113, 61, // 2810: decode to CV_SDOTUSP_SC_B using decoder 61
14220 // 2810: }
14221 42, 11, // 2814: case 0x2a: {
14222 OPC_CheckPredicate, 152, 1, // 2816: check predicate 152
14223 OPC_CheckField, 25, 1, 0, // 2819: check Inst[25] == 0x0
14224 OPC_Decode, 253, 112, 61, // 2823: decode to CV_SDOTSP_SC_B using decoder 61
14225 // 2823: }
14226 46, 0, // 2827: case 0x2e: {
14227 OPC_CheckPredicate, 152, 1, // 2829: check predicate 152
14228 OPC_Decode, 172, 112, 230, 1, // 2832: decode to CV_INSERT_B using decoder 230
14229 // 2832: }
14230 // 2832: } // switch Inst[31:26]
14231 // 2832: }
14232 // 2832: } // switch Inst[6:0]
14233 // 2832: }
14234 6, 179, 3, // 2837: case 0x6: {
14235 OPC_SwitchField, 0, 7, // 2840: switch Inst[6:0] {
14236 11, 8, // 2843: case 0xb: {
14237 OPC_CheckPredicate, 156, 1, // 2845: check predicate 156
14238 OPC_Decode, 185, 111, 231, 1, // 2848: decode to CV_BEQIMM using decoder 231
14239 // 2848: }
14240 91, 43, // 2853: case 0x5b: {
14241 OPC_SwitchField, 30, 2, // 2855: switch Inst[31:30] {
14242 0, 8, // 2858: case 0x0: {
14243 OPC_CheckPredicate, 155, 1, // 2860: check predicate 155
14244 OPC_Decode, 194, 112, 232, 1, // 2863: decode to CV_MACSN using decoder 232
14245 // 2863: }
14246 1, 8, // 2868: case 0x1: {
14247 OPC_CheckPredicate, 155, 1, // 2870: check predicate 155
14248 OPC_Decode, 190, 112, 232, 1, // 2873: decode to CV_MACHHSN using decoder 232
14249 // 2873: }
14250 2, 8, // 2878: case 0x2: {
14251 OPC_CheckPredicate, 155, 1, // 2880: check predicate 155
14252 OPC_Decode, 195, 112, 232, 1, // 2883: decode to CV_MACSRN using decoder 232
14253 // 2883: }
14254 3, 0, // 2888: case 0x3: {
14255 OPC_CheckPredicate, 155, 1, // 2890: check predicate 155
14256 OPC_Decode, 191, 112, 232, 1, // 2893: decode to CV_MACHHSRN using decoder 232
14257 // 2893: }
14258 // 2893: } // switch Inst[31:30]
14259 // 2893: }
14260 123, 0, // 2898: case 0x7b: {
14261 OPC_SwitchField, 26, 6, // 2900: switch Inst[31:26] {
14262 0, 8, // 2903: case 0x0: {
14263 OPC_CheckPredicate, 152, 1, // 2905: check predicate 152
14264 OPC_Decode, 162, 111, 233, 1, // 2908: decode to CV_ADD_SCI_H using decoder 233
14265 // 2908: }
14266 1, 8, // 2913: case 0x1: {
14267 OPC_CheckPredicate, 152, 1, // 2915: check predicate 152
14268 OPC_Decode, 198, 111, 233, 1, // 2918: decode to CV_CMPEQ_SCI_H using decoder 233
14269 // 2918: }
14270 2, 8, // 2923: case 0x2: {
14271 OPC_CheckPredicate, 152, 1, // 2925: check predicate 152
14272 OPC_Decode, 189, 113, 233, 1, // 2928: decode to CV_SUB_SCI_H using decoder 233
14273 // 2928: }
14274 3, 8, // 2933: case 0x3: {
14275 OPC_CheckPredicate, 152, 1, // 2935: check predicate 152
14276 OPC_Decode, 252, 111, 233, 1, // 2938: decode to CV_CMPNE_SCI_H using decoder 233
14277 // 2938: }
14278 4, 8, // 2943: case 0x4: {
14279 OPC_CheckPredicate, 152, 1, // 2945: check predicate 152
14280 OPC_Decode, 180, 111, 233, 1, // 2948: decode to CV_AVG_SCI_H using decoder 233
14281 // 2948: }
14282 5, 8, // 2953: case 0x5: {
14283 OPC_CheckPredicate, 152, 1, // 2955: check predicate 152
14284 OPC_Decode, 222, 111, 233, 1, // 2958: decode to CV_CMPGT_SCI_H using decoder 233
14285 // 2958: }
14286 6, 8, // 2963: case 0x6: {
14287 OPC_CheckPredicate, 152, 1, // 2965: check predicate 152
14288 OPC_Decode, 174, 111, 234, 1, // 2968: decode to CV_AVGU_SCI_H using decoder 234
14289 // 2968: }
14290 7, 8, // 2973: case 0x7: {
14291 OPC_CheckPredicate, 152, 1, // 2975: check predicate 152
14292 OPC_Decode, 210, 111, 233, 1, // 2978: decode to CV_CMPGE_SCI_H using decoder 233
14293 // 2978: }
14294 8, 8, // 2983: case 0x8: {
14295 OPC_CheckPredicate, 152, 1, // 2985: check predicate 152
14296 OPC_Decode, 223, 112, 233, 1, // 2988: decode to CV_MIN_SCI_H using decoder 233
14297 // 2988: }
14298 9, 8, // 2993: case 0x9: {
14299 OPC_CheckPredicate, 152, 1, // 2995: check predicate 152
14300 OPC_Decode, 246, 111, 233, 1, // 2998: decode to CV_CMPLT_SCI_H using decoder 233
14301 // 2998: }
14302 10, 8, // 3003: case 0xa: {
14303 OPC_CheckPredicate, 152, 1, // 3005: check predicate 152
14304 OPC_Decode, 217, 112, 234, 1, // 3008: decode to CV_MINU_SCI_H using decoder 234
14305 // 3008: }
14306 11, 8, // 3013: case 0xb: {
14307 OPC_CheckPredicate, 152, 1, // 3015: check predicate 152
14308 OPC_Decode, 234, 111, 233, 1, // 3018: decode to CV_CMPLE_SCI_H using decoder 233
14309 // 3018: }
14310 12, 8, // 3023: case 0xc: {
14311 OPC_CheckPredicate, 152, 1, // 3025: check predicate 152
14312 OPC_Decode, 209, 112, 233, 1, // 3028: decode to CV_MAX_SCI_H using decoder 233
14313 // 3028: }
14314 13, 8, // 3033: case 0xd: {
14315 OPC_CheckPredicate, 152, 1, // 3035: check predicate 152
14316 OPC_Decode, 216, 111, 234, 1, // 3038: decode to CV_CMPGTU_SCI_H using decoder 234
14317 // 3038: }
14318 14, 8, // 3043: case 0xe: {
14319 OPC_CheckPredicate, 152, 1, // 3045: check predicate 152
14320 OPC_Decode, 203, 112, 234, 1, // 3048: decode to CV_MAXU_SCI_H using decoder 234
14321 // 3048: }
14322 15, 8, // 3053: case 0xf: {
14323 OPC_CheckPredicate, 152, 1, // 3055: check predicate 152
14324 OPC_Decode, 204, 111, 234, 1, // 3058: decode to CV_CMPGEU_SCI_H using decoder 234
14325 // 3058: }
14326 16, 8, // 3063: case 0x10: {
14327 OPC_CheckPredicate, 152, 1, // 3065: check predicate 152
14328 OPC_Decode, 168, 113, 235, 1, // 3068: decode to CV_SRL_SCI_H using decoder 235
14329 // 3068: }
14330 17, 8, // 3073: case 0x11: {
14331 OPC_CheckPredicate, 152, 1, // 3075: check predicate 152
14332 OPC_Decode, 240, 111, 234, 1, // 3078: decode to CV_CMPLTU_SCI_H using decoder 234
14333 // 3078: }
14334 18, 8, // 3083: case 0x12: {
14335 OPC_CheckPredicate, 152, 1, // 3085: check predicate 152
14336 OPC_Decode, 162, 113, 235, 1, // 3088: decode to CV_SRA_SCI_H using decoder 235
14337 // 3088: }
14338 19, 8, // 3093: case 0x13: {
14339 OPC_CheckPredicate, 152, 1, // 3095: check predicate 152
14340 OPC_Decode, 228, 111, 234, 1, // 3098: decode to CV_CMPLEU_SCI_H using decoder 234
14341 // 3098: }
14342 20, 8, // 3103: case 0x14: {
14343 OPC_CheckPredicate, 152, 1, // 3105: check predicate 152
14344 OPC_Decode, 156, 113, 235, 1, // 3108: decode to CV_SLL_SCI_H using decoder 235
14345 // 3108: }
14346 21, 21, // 3113: case 0x15: {
14347 OPC_SwitchField, 25, 1, // 3115: switch Inst[25] {
14348 0, 7, // 3118: case 0x0: {
14349 OPC_CheckPredicate, 152, 1, // 3120: check predicate 152
14350 OPC_Decode, 136, 112, 61, // 3123: decode to CV_CPLXMUL_R_DIV8 using decoder 61
14351 // 3123: }
14352 1, 0, // 3127: case 0x1: {
14353 OPC_CheckPredicate, 152, 1, // 3129: check predicate 152
14354 OPC_Decode, 132, 112, 61, // 3132: decode to CV_CPLXMUL_I_DIV8 using decoder 61
14355 // 3132: }
14356 // 3132: } // switch Inst[25]
14357 // 3132: }
14358 22, 8, // 3136: case 0x16: {
14359 OPC_CheckPredicate, 152, 1, // 3138: check predicate 152
14360 OPC_Decode, 238, 112, 233, 1, // 3141: decode to CV_OR_SCI_H using decoder 233
14361 // 3141: }
14362 24, 8, // 3146: case 0x18: {
14363 OPC_CheckPredicate, 152, 1, // 3148: check predicate 152
14364 OPC_Decode, 198, 113, 233, 1, // 3151: decode to CV_XOR_SCI_H using decoder 233
14365 // 3151: }
14366 25, 11, // 3156: case 0x19: {
14367 OPC_CheckPredicate, 152, 1, // 3158: check predicate 152
14368 OPC_CheckField, 25, 1, 0, // 3161: check Inst[25] == 0x0
14369 OPC_Decode, 178, 113, 31, // 3165: decode to CV_SUBROTMJ_DIV8 using decoder 31
14370 // 3165: }
14371 26, 8, // 3169: case 0x1a: {
14372 OPC_CheckPredicate, 152, 1, // 3171: check predicate 152
14373 OPC_Decode, 168, 111, 233, 1, // 3174: decode to CV_AND_SCI_H using decoder 233
14374 // 3174: }
14375 27, 11, // 3179: case 0x1b: {
14376 OPC_CheckPredicate, 152, 1, // 3181: check predicate 152
14377 OPC_CheckField, 25, 1, 0, // 3184: check Inst[25] == 0x0
14378 OPC_Decode, 159, 111, 31, // 3188: decode to CV_ADD_DIV8 using decoder 31
14379 // 3188: }
14380 29, 11, // 3192: case 0x1d: {
14381 OPC_CheckPredicate, 152, 1, // 3194: check predicate 152
14382 OPC_CheckField, 25, 1, 0, // 3197: check Inst[25] == 0x0
14383 OPC_Decode, 186, 113, 31, // 3201: decode to CV_SUB_DIV8 using decoder 31
14384 // 3201: }
14385 32, 8, // 3205: case 0x20: {
14386 OPC_CheckPredicate, 152, 1, // 3207: check predicate 152
14387 OPC_Decode, 146, 112, 234, 1, // 3210: decode to CV_DOTUP_SCI_H using decoder 234
14388 // 3210: }
14389 34, 8, // 3215: case 0x22: {
14390 OPC_CheckPredicate, 152, 1, // 3217: check predicate 152
14391 OPC_Decode, 152, 112, 233, 1, // 3220: decode to CV_DOTUSP_SCI_H using decoder 233
14392 // 3220: }
14393 36, 8, // 3225: case 0x24: {
14394 OPC_CheckPredicate, 152, 1, // 3227: check predicate 152
14395 OPC_Decode, 140, 112, 233, 1, // 3230: decode to CV_DOTSP_SCI_H using decoder 233
14396 // 3230: }
14397 38, 8, // 3235: case 0x26: {
14398 OPC_CheckPredicate, 152, 1, // 3237: check predicate 152
14399 OPC_Decode, 130, 113, 236, 1, // 3240: decode to CV_SDOTUP_SCI_H using decoder 236
14400 // 3240: }
14401 40, 8, // 3245: case 0x28: {
14402 OPC_CheckPredicate, 152, 1, // 3247: check predicate 152
14403 OPC_Decode, 136, 113, 237, 1, // 3250: decode to CV_SDOTUSP_SCI_H using decoder 237
14404 // 3250: }
14405 42, 8, // 3255: case 0x2a: {
14406 OPC_CheckPredicate, 152, 1, // 3257: check predicate 152
14407 OPC_Decode, 252, 112, 237, 1, // 3260: decode to CV_SDOTSP_SCI_H using decoder 237
14408 // 3260: }
14409 48, 0, // 3265: case 0x30: {
14410 OPC_CheckPredicate, 152, 1, // 3267: check predicate 152
14411 OPC_Decode, 147, 113, 224, 1, // 3270: decode to CV_SHUFFLE_SCI_H using decoder 224
14412 // 3270: }
14413 // 3270: } // switch Inst[31:26]
14414 // 3270: }
14415 // 3270: } // switch Inst[6:0]
14416 // 3270: }
14417 7, 0, // 3275: case 0x7: {
14418 OPC_SwitchField, 0, 7, // 3277: switch Inst[6:0] {
14419 11, 8, // 3280: case 0xb: {
14420 OPC_CheckPredicate, 156, 1, // 3282: check predicate 156
14421 OPC_Decode, 187, 111, 231, 1, // 3285: decode to CV_BNEIMM using decoder 231
14422 // 3285: }
14423 91, 43, // 3290: case 0x5b: {
14424 OPC_SwitchField, 30, 2, // 3292: switch Inst[31:30] {
14425 0, 8, // 3295: case 0x0: {
14426 OPC_CheckPredicate, 155, 1, // 3297: check predicate 155
14427 OPC_Decode, 196, 112, 232, 1, // 3300: decode to CV_MACUN using decoder 232
14428 // 3300: }
14429 1, 8, // 3305: case 0x1: {
14430 OPC_CheckPredicate, 155, 1, // 3307: check predicate 155
14431 OPC_Decode, 192, 112, 232, 1, // 3310: decode to CV_MACHHUN using decoder 232
14432 // 3310: }
14433 2, 8, // 3315: case 0x2: {
14434 OPC_CheckPredicate, 155, 1, // 3317: check predicate 155
14435 OPC_Decode, 197, 112, 232, 1, // 3320: decode to CV_MACURN using decoder 232
14436 // 3320: }
14437 3, 0, // 3325: case 0x3: {
14438 OPC_CheckPredicate, 155, 1, // 3327: check predicate 155
14439 OPC_Decode, 193, 112, 232, 1, // 3330: decode to CV_MACHHURN using decoder 232
14440 // 3330: }
14441 // 3330: } // switch Inst[31:30]
14442 // 3330: }
14443 123, 0, // 3335: case 0x7b: {
14444 OPC_SwitchField, 26, 6, // 3337: switch Inst[31:26] {
14445 0, 8, // 3340: case 0x0: {
14446 OPC_CheckPredicate, 152, 1, // 3342: check predicate 152
14447 OPC_Decode, 161, 111, 233, 1, // 3345: decode to CV_ADD_SCI_B using decoder 233
14448 // 3345: }
14449 1, 8, // 3350: case 0x1: {
14450 OPC_CheckPredicate, 152, 1, // 3352: check predicate 152
14451 OPC_Decode, 197, 111, 233, 1, // 3355: decode to CV_CMPEQ_SCI_B using decoder 233
14452 // 3355: }
14453 2, 8, // 3360: case 0x2: {
14454 OPC_CheckPredicate, 152, 1, // 3362: check predicate 152
14455 OPC_Decode, 188, 113, 233, 1, // 3365: decode to CV_SUB_SCI_B using decoder 233
14456 // 3365: }
14457 3, 8, // 3370: case 0x3: {
14458 OPC_CheckPredicate, 152, 1, // 3372: check predicate 152
14459 OPC_Decode, 251, 111, 233, 1, // 3375: decode to CV_CMPNE_SCI_B using decoder 233
14460 // 3375: }
14461 4, 8, // 3380: case 0x4: {
14462 OPC_CheckPredicate, 152, 1, // 3382: check predicate 152
14463 OPC_Decode, 179, 111, 233, 1, // 3385: decode to CV_AVG_SCI_B using decoder 233
14464 // 3385: }
14465 5, 8, // 3390: case 0x5: {
14466 OPC_CheckPredicate, 152, 1, // 3392: check predicate 152
14467 OPC_Decode, 221, 111, 233, 1, // 3395: decode to CV_CMPGT_SCI_B using decoder 233
14468 // 3395: }
14469 6, 8, // 3400: case 0x6: {
14470 OPC_CheckPredicate, 152, 1, // 3402: check predicate 152
14471 OPC_Decode, 173, 111, 234, 1, // 3405: decode to CV_AVGU_SCI_B using decoder 234
14472 // 3405: }
14473 7, 8, // 3410: case 0x7: {
14474 OPC_CheckPredicate, 152, 1, // 3412: check predicate 152
14475 OPC_Decode, 209, 111, 233, 1, // 3415: decode to CV_CMPGE_SCI_B using decoder 233
14476 // 3415: }
14477 8, 8, // 3420: case 0x8: {
14478 OPC_CheckPredicate, 152, 1, // 3422: check predicate 152
14479 OPC_Decode, 222, 112, 233, 1, // 3425: decode to CV_MIN_SCI_B using decoder 233
14480 // 3425: }
14481 9, 8, // 3430: case 0x9: {
14482 OPC_CheckPredicate, 152, 1, // 3432: check predicate 152
14483 OPC_Decode, 245, 111, 233, 1, // 3435: decode to CV_CMPLT_SCI_B using decoder 233
14484 // 3435: }
14485 10, 8, // 3440: case 0xa: {
14486 OPC_CheckPredicate, 152, 1, // 3442: check predicate 152
14487 OPC_Decode, 216, 112, 234, 1, // 3445: decode to CV_MINU_SCI_B using decoder 234
14488 // 3445: }
14489 11, 8, // 3450: case 0xb: {
14490 OPC_CheckPredicate, 152, 1, // 3452: check predicate 152
14491 OPC_Decode, 233, 111, 233, 1, // 3455: decode to CV_CMPLE_SCI_B using decoder 233
14492 // 3455: }
14493 12, 8, // 3460: case 0xc: {
14494 OPC_CheckPredicate, 152, 1, // 3462: check predicate 152
14495 OPC_Decode, 208, 112, 233, 1, // 3465: decode to CV_MAX_SCI_B using decoder 233
14496 // 3465: }
14497 13, 8, // 3470: case 0xd: {
14498 OPC_CheckPredicate, 152, 1, // 3472: check predicate 152
14499 OPC_Decode, 215, 111, 234, 1, // 3475: decode to CV_CMPGTU_SCI_B using decoder 234
14500 // 3475: }
14501 14, 8, // 3480: case 0xe: {
14502 OPC_CheckPredicate, 152, 1, // 3482: check predicate 152
14503 OPC_Decode, 202, 112, 234, 1, // 3485: decode to CV_MAXU_SCI_B using decoder 234
14504 // 3485: }
14505 15, 8, // 3490: case 0xf: {
14506 OPC_CheckPredicate, 152, 1, // 3492: check predicate 152
14507 OPC_Decode, 203, 111, 234, 1, // 3495: decode to CV_CMPGEU_SCI_B using decoder 234
14508 // 3495: }
14509 16, 8, // 3500: case 0x10: {
14510 OPC_CheckPredicate, 152, 1, // 3502: check predicate 152
14511 OPC_Decode, 167, 113, 238, 1, // 3505: decode to CV_SRL_SCI_B using decoder 238
14512 // 3505: }
14513 17, 8, // 3510: case 0x11: {
14514 OPC_CheckPredicate, 152, 1, // 3512: check predicate 152
14515 OPC_Decode, 239, 111, 234, 1, // 3515: decode to CV_CMPLTU_SCI_B using decoder 234
14516 // 3515: }
14517 18, 8, // 3520: case 0x12: {
14518 OPC_CheckPredicate, 152, 1, // 3522: check predicate 152
14519 OPC_Decode, 161, 113, 238, 1, // 3525: decode to CV_SRA_SCI_B using decoder 238
14520 // 3525: }
14521 19, 8, // 3530: case 0x13: {
14522 OPC_CheckPredicate, 152, 1, // 3532: check predicate 152
14523 OPC_Decode, 227, 111, 234, 1, // 3535: decode to CV_CMPLEU_SCI_B using decoder 234
14524 // 3535: }
14525 20, 8, // 3540: case 0x14: {
14526 OPC_CheckPredicate, 152, 1, // 3542: check predicate 152
14527 OPC_Decode, 155, 113, 238, 1, // 3545: decode to CV_SLL_SCI_B using decoder 238
14528 // 3545: }
14529 22, 8, // 3550: case 0x16: {
14530 OPC_CheckPredicate, 152, 1, // 3552: check predicate 152
14531 OPC_Decode, 237, 112, 233, 1, // 3555: decode to CV_OR_SCI_B using decoder 233
14532 // 3555: }
14533 24, 8, // 3560: case 0x18: {
14534 OPC_CheckPredicate, 152, 1, // 3562: check predicate 152
14535 OPC_Decode, 197, 113, 233, 1, // 3565: decode to CV_XOR_SCI_B using decoder 233
14536 // 3565: }
14537 26, 8, // 3570: case 0x1a: {
14538 OPC_CheckPredicate, 152, 1, // 3572: check predicate 152
14539 OPC_Decode, 167, 111, 233, 1, // 3575: decode to CV_AND_SCI_B using decoder 233
14540 // 3575: }
14541 32, 8, // 3580: case 0x20: {
14542 OPC_CheckPredicate, 152, 1, // 3582: check predicate 152
14543 OPC_Decode, 145, 112, 234, 1, // 3585: decode to CV_DOTUP_SCI_B using decoder 234
14544 // 3585: }
14545 34, 8, // 3590: case 0x22: {
14546 OPC_CheckPredicate, 152, 1, // 3592: check predicate 152
14547 OPC_Decode, 151, 112, 233, 1, // 3595: decode to CV_DOTUSP_SCI_B using decoder 233
14548 // 3595: }
14549 36, 8, // 3600: case 0x24: {
14550 OPC_CheckPredicate, 152, 1, // 3602: check predicate 152
14551 OPC_Decode, 139, 112, 233, 1, // 3605: decode to CV_DOTSP_SCI_B using decoder 233
14552 // 3605: }
14553 38, 8, // 3610: case 0x26: {
14554 OPC_CheckPredicate, 152, 1, // 3612: check predicate 152
14555 OPC_Decode, 129, 113, 236, 1, // 3615: decode to CV_SDOTUP_SCI_B using decoder 236
14556 // 3615: }
14557 40, 8, // 3620: case 0x28: {
14558 OPC_CheckPredicate, 152, 1, // 3622: check predicate 152
14559 OPC_Decode, 135, 113, 237, 1, // 3625: decode to CV_SDOTUSP_SCI_B using decoder 237
14560 // 3625: }
14561 42, 8, // 3630: case 0x2a: {
14562 OPC_CheckPredicate, 152, 1, // 3632: check predicate 152
14563 OPC_Decode, 251, 112, 237, 1, // 3635: decode to CV_SDOTSP_SCI_B using decoder 237
14564 // 3635: }
14565 48, 8, // 3640: case 0x30: {
14566 OPC_CheckPredicate, 152, 1, // 3642: check predicate 152
14567 OPC_Decode, 141, 113, 234, 1, // 3645: decode to CV_SHUFFLEI0_SCI_B using decoder 234
14568 // 3645: }
14569 50, 8, // 3650: case 0x32: {
14570 OPC_CheckPredicate, 152, 1, // 3652: check predicate 152
14571 OPC_Decode, 142, 113, 234, 1, // 3655: decode to CV_SHUFFLEI1_SCI_B using decoder 234
14572 // 3655: }
14573 52, 8, // 3660: case 0x34: {
14574 OPC_CheckPredicate, 152, 1, // 3662: check predicate 152
14575 OPC_Decode, 143, 113, 234, 1, // 3665: decode to CV_SHUFFLEI2_SCI_B using decoder 234
14576 // 3665: }
14577 54, 0, // 3670: case 0x36: {
14578 OPC_CheckPredicate, 152, 1, // 3672: check predicate 152
14579 OPC_Decode, 144, 113, 234, 1, // 3675: decode to CV_SHUFFLEI3_SCI_B using decoder 234
14580 // 3675: }
14581 // 3675: } // switch Inst[31:26]
14582 // 3675: }
14583 // 3675: } // switch Inst[6:0]
14584 // 3675: }
14585 // 3675: } // switch Inst[14:12]
14586};
14587static const uint8_t DecoderTableXMIPS32[152] = {
14588 32, // 0: BitWidth 32
14589 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
14590 0, 16, // 4: case 0x0: {
14591 OPC_CheckPredicate, 157, 1, // 6: check predicate 157
14592 OPC_CheckField, 29, 3, 0, // 9: check Inst[31:29] == 0x0
14593 OPC_CheckField, 0, 7, 11, // 13: check Inst[6:0] == 0xb
14594 OPC_Decode, 183, 117, 239, 1, // 17: decode to MIPS_PREF using decoder 239
14595 // 17: }
14596 1, 43, // 22: case 0x1: {
14597 OPC_SwitchField, 15, 17, // 24: switch Inst[31:15] {
14598 32, 11, // 27: case 0x20: {
14599 OPC_CheckPredicate, 158, 1, // 29: check predicate 158
14600 OPC_CheckField, 0, 12, 19, // 32: check Inst[11:0] == 0x13
14601 OPC_Decode, 179, 117, 14, // 36: decode to MIPS_IHB using decoder 14
14602 // 36: }
14603 96, 11, // 40: case 0x60: {
14604 OPC_CheckPredicate, 158, 1, // 42: check predicate 158
14605 OPC_CheckField, 0, 12, 19, // 45: check Inst[11:0] == 0x13
14606 OPC_Decode, 178, 117, 14, // 49: decode to MIPS_EHB using decoder 14
14607 // 49: }
14608 160, 1, 0, // 53: case 0xa0: {
14609 OPC_CheckPredicate, 158, 1, // 56: check predicate 158
14610 OPC_CheckField, 0, 12, 19, // 59: check Inst[11:0] == 0x13
14611 OPC_Decode, 182, 117, 14, // 63: decode to MIPS_PAUSE using decoder 14
14612 // 63: }
14613 // 63: } // switch Inst[31:15]
14614 // 63: }
14615 3, 16, // 67: case 0x3: {
14616 OPC_CheckPredicate, 159, 1, // 69: check predicate 159
14617 OPC_CheckField, 25, 2, 3, // 72: check Inst[26:25] == 0x3
14618 OPC_CheckField, 0, 7, 11, // 76: check Inst[6:0] == 0xb
14619 OPC_Decode, 177, 117, 240, 1, // 80: decode to MIPS_CCMOV using decoder 240
14620 // 80: }
14621 4, 35, // 85: case 0x4: {
14622 OPC_SwitchField, 20, 2, // 87: switch Inst[21:20] {
14623 0, 16, // 90: case 0x0: {
14624 OPC_CheckPredicate, 160, 1, // 92: check predicate 160
14625 OPC_CheckField, 22, 1, 0, // 95: check Inst[22] == 0x0
14626 OPC_CheckField, 0, 7, 11, // 99: check Inst[6:0] == 0xb
14627 OPC_Decode, 180, 117, 241, 1, // 103: decode to MIPS_LDP using decoder 241
14628 // 103: }
14629 1, 0, // 108: case 0x1: {
14630 OPC_CheckPredicate, 161, 1, // 110: check predicate 161
14631 OPC_CheckField, 0, 7, 11, // 113: check Inst[6:0] == 0xb
14632 OPC_Decode, 181, 117, 242, 1, // 117: decode to MIPS_LWP using decoder 242
14633 // 117: }
14634 // 117: } // switch Inst[21:20]
14635 // 117: }
14636 5, 0, // 122: case 0x5: {
14637 OPC_SwitchField, 0, 9, // 124: switch Inst[8:0] {
14638 11, 12, // 127: case 0xb: {
14639 OPC_CheckPredicate, 160, 1, // 129: check predicate 160
14640 OPC_CheckField, 9, 1, 0, // 132: check Inst[9] == 0x0
14641 OPC_Decode, 184, 117, 243, 1, // 136: decode to MIPS_SDP using decoder 243
14642 // 136: }
14643 139, 1, 0, // 141: case 0x8b: {
14644 OPC_CheckPredicate, 161, 1, // 144: check predicate 161
14645 OPC_Decode, 185, 117, 244, 1, // 147: decode to MIPS_SWP using decoder 244
14646 // 147: }
14647 // 147: } // switch Inst[8:0]
14648 // 147: }
14649 // 147: } // switch Inst[14:12]
14650};
14651static const uint8_t DecoderTableXSMT32[964] = {
14652 32, // 0: BitWidth 32
14653 OPC_SwitchField, 26, 3, // 1: switch Inst[28:26] {
14654 0, 224, 1, // 4: case 0x0: {
14655 OPC_SwitchField, 14, 1, // 7: switch Inst[14] {
14656 0, 177, 1, // 10: case 0x0: {
14657 OPC_SwitchField, 31, 1, // 13: switch Inst[31] {
14658 0, 39, // 16: case 0x0: {
14659 OPC_SwitchField, 29, 2, // 18: switch Inst[30:29] {
14660 2, 16, // 21: case 0x2: {
14661 OPC_CheckPredicate, 162, 1, // 23: check predicate 162
14662 OPC_CheckField, 25, 1, 1, // 26: check Inst[25] == 0x1
14663 OPC_CheckField, 0, 7, 43, // 30: check Inst[6:0] == 0x2b
14664 OPC_Decode, 147, 125, 245, 1, // 34: decode to SMT_VNPACK4_VV using decoder 245
14665 // 34: }
14666 3, 0, // 39: case 0x3: {
14667 OPC_CheckPredicate, 162, 1, // 41: check predicate 162
14668 OPC_CheckField, 25, 1, 1, // 44: check Inst[25] == 0x1
14669 OPC_CheckField, 0, 7, 43, // 48: check Inst[6:0] == 0x2b
14670 OPC_Decode, 148, 125, 245, 1, // 52: decode to SMT_VNPACK_VV using decoder 245
14671 // 52: }
14672 // 52: } // switch Inst[30:29]
14673 // 52: }
14674 1, 0, // 57: case 0x1: {
14675 OPC_SwitchField, 12, 2, // 59: switch Inst[13:12] {
14676 0, 30, // 62: case 0x0: {
14677 OPC_CheckField, 0, 7, 43, // 64: check Inst[6:0] == 0x2b
14678 OPC_CheckField, 25, 1, 1, // 68: check Inst[25] == 0x1
14679 OPC_Scope, 12, // 72: try {
14680 OPC_CheckField, 29, 2, 3, // 74: check Inst[30:29] == 0x3
14681 OPC_CheckPredicate, 163, 1, // 78: check predicate 163
14682 OPC_Decode, 136, 125, 246, 1, // 81: decode to SMT_VMADOTU using decoder 246
14683 // 81: } else try {
14684 OPC_CheckPredicate, 162, 1, // 86: check predicate 162
14685 OPC_Decode, 143, 125, 247, 1, // 89: decode to SMT_VMADOTUvtype using decoder 247
14686 // 89: }
14687 // 89: }
14688 1, 30, // 94: case 0x1: {
14689 OPC_CheckField, 0, 7, 43, // 96: check Inst[6:0] == 0x2b
14690 OPC_CheckField, 25, 1, 1, // 100: check Inst[25] == 0x1
14691 OPC_Scope, 12, // 104: try {
14692 OPC_CheckField, 29, 2, 3, // 106: check Inst[30:29] == 0x3
14693 OPC_CheckPredicate, 163, 1, // 110: check predicate 163
14694 OPC_Decode, 137, 125, 246, 1, // 113: decode to SMT_VMADOTUS using decoder 246
14695 // 113: } else try {
14696 OPC_CheckPredicate, 162, 1, // 118: check predicate 162
14697 OPC_Decode, 140, 125, 247, 1, // 121: decode to SMT_VMADOTUSvtype using decoder 247
14698 // 121: }
14699 // 121: }
14700 2, 30, // 126: case 0x2: {
14701 OPC_CheckField, 0, 7, 43, // 128: check Inst[6:0] == 0x2b
14702 OPC_CheckField, 25, 1, 1, // 132: check Inst[25] == 0x1
14703 OPC_Scope, 12, // 136: try {
14704 OPC_CheckField, 29, 2, 3, // 138: check Inst[30:29] == 0x3
14705 OPC_CheckPredicate, 163, 1, // 142: check predicate 163
14706 OPC_Decode, 132, 125, 246, 1, // 145: decode to SMT_VMADOTSU using decoder 246
14707 // 145: } else try {
14708 OPC_CheckPredicate, 162, 1, // 150: check predicate 162
14709 OPC_Decode, 135, 125, 247, 1, // 153: decode to SMT_VMADOTSUvtype using decoder 247
14710 // 153: }
14711 // 153: }
14712 3, 0, // 158: case 0x3: {
14713 OPC_CheckField, 0, 7, 43, // 160: check Inst[6:0] == 0x2b
14714 OPC_CheckField, 25, 1, 1, // 164: check Inst[25] == 0x1
14715 OPC_Scope, 12, // 168: try {
14716 OPC_CheckField, 29, 2, 3, // 170: check Inst[30:29] == 0x3
14717 OPC_CheckPredicate, 163, 1, // 174: check predicate 163
14718 OPC_Decode, 235, 124, 246, 1, // 177: decode to SMT_VMADOT using decoder 246
14719 // 177: } else try {
14720 OPC_CheckPredicate, 162, 1, // 182: check predicate 162
14721 OPC_Decode, 146, 125, 247, 1, // 185: decode to SMT_VMADOTvtype using decoder 247
14722 // 185: }
14723 // 185: }
14724 // 185: } // switch Inst[13:12]
14725 // 185: }
14726 // 185: } // switch Inst[31]
14727 // 185: }
14728 1, 0, // 190: case 0x1: {
14729 OPC_SwitchField, 29, 3, // 192: switch Inst[31:29] {
14730 2, 16, // 195: case 0x2: {
14731 OPC_CheckPredicate, 162, 1, // 197: check predicate 162
14732 OPC_CheckField, 25, 1, 1, // 200: check Inst[25] == 0x1
14733 OPC_CheckField, 0, 7, 43, // 204: check Inst[6:0] == 0x2b
14734 OPC_Decode, 149, 125, 245, 1, // 208: decode to SMT_VNSPACK4_VV using decoder 245
14735 // 208: }
14736 3, 0, // 213: case 0x3: {
14737 OPC_CheckPredicate, 162, 1, // 215: check predicate 162
14738 OPC_CheckField, 25, 1, 1, // 218: check Inst[25] == 0x1
14739 OPC_CheckField, 0, 7, 43, // 222: check Inst[6:0] == 0x2b
14740 OPC_Decode, 150, 125, 245, 1, // 226: decode to SMT_VNSPACK_VV using decoder 245
14741 // 226: }
14742 // 226: } // switch Inst[31:29]
14743 // 226: }
14744 // 226: } // switch Inst[14]
14745 // 226: }
14746 1, 232, 3, // 231: case 0x1: {
14747 OPC_SwitchField, 14, 1, // 234: switch Inst[14] {
14748 0, 178, 2, // 237: case 0x0: {
14749 OPC_SwitchField, 31, 1, // 240: switch Inst[31] {
14750 0, 20, // 243: case 0x0: {
14751 OPC_CheckPredicate, 162, 1, // 245: check predicate 162
14752 OPC_CheckField, 29, 2, 3, // 248: check Inst[30:29] == 0x3
14753 OPC_CheckField, 25, 1, 1, // 252: check Inst[25] == 0x1
14754 OPC_CheckField, 0, 7, 43, // 256: check Inst[6:0] == 0x2b
14755 OPC_Decode, 151, 125, 248, 1, // 260: decode to SMT_VPACK_VV using decoder 248
14756 // 260: }
14757 1, 0, // 265: case 0x1: {
14758 OPC_SwitchField, 12, 2, // 267: switch Inst[13:12] {
14759 0, 67, // 270: case 0x0: {
14760 OPC_SwitchField, 15, 1, // 272: switch Inst[15] {
14761 0, 30, // 275: case 0x0: {
14762 OPC_CheckField, 0, 7, 43, // 277: check Inst[6:0] == 0x2b
14763 OPC_CheckField, 25, 1, 1, // 281: check Inst[25] == 0x1
14764 OPC_Scope, 12, // 285: try {
14765 OPC_CheckField, 29, 2, 3, // 287: check Inst[30:29] == 0x3
14766 OPC_CheckPredicate, 163, 1, // 291: check predicate 163
14767 OPC_Decode, 239, 124, 249, 1, // 294: decode to SMT_VMADOT1U using decoder 249
14768 // 294: } else try {
14769 OPC_CheckPredicate, 162, 1, // 299: check predicate 162
14770 OPC_Decode, 242, 124, 250, 1, // 302: decode to SMT_VMADOT1Uvtype using decoder 250
14771 // 302: }
14772 // 302: }
14773 1, 0, // 307: case 0x1: {
14774 OPC_CheckField, 0, 7, 43, // 309: check Inst[6:0] == 0x2b
14775 OPC_CheckField, 25, 1, 1, // 313: check Inst[25] == 0x1
14776 OPC_Scope, 12, // 317: try {
14777 OPC_CheckField, 29, 2, 3, // 319: check Inst[30:29] == 0x3
14778 OPC_CheckPredicate, 163, 1, // 323: check predicate 163
14779 OPC_Decode, 255, 124, 249, 1, // 326: decode to SMT_VMADOT3U using decoder 249
14780 // 326: } else try {
14781 OPC_CheckPredicate, 162, 1, // 331: check predicate 162
14782 OPC_Decode, 130, 125, 250, 1, // 334: decode to SMT_VMADOT3Uvtype using decoder 250
14783 // 334: }
14784 // 334: }
14785 // 334: } // switch Inst[15]
14786 // 334: }
14787 1, 67, // 339: case 0x1: {
14788 OPC_SwitchField, 15, 1, // 341: switch Inst[15] {
14789 0, 30, // 344: case 0x0: {
14790 OPC_CheckField, 0, 7, 43, // 346: check Inst[6:0] == 0x2b
14791 OPC_CheckField, 25, 1, 1, // 350: check Inst[25] == 0x1
14792 OPC_Scope, 12, // 354: try {
14793 OPC_CheckField, 29, 2, 3, // 356: check Inst[30:29] == 0x3
14794 OPC_CheckPredicate, 163, 1, // 360: check predicate 163
14795 OPC_Decode, 240, 124, 249, 1, // 363: decode to SMT_VMADOT1US using decoder 249
14796 // 363: } else try {
14797 OPC_CheckPredicate, 162, 1, // 368: check predicate 162
14798 OPC_Decode, 241, 124, 250, 1, // 371: decode to SMT_VMADOT1USvtype using decoder 250
14799 // 371: }
14800 // 371: }
14801 1, 0, // 376: case 0x1: {
14802 OPC_CheckField, 0, 7, 43, // 378: check Inst[6:0] == 0x2b
14803 OPC_CheckField, 25, 1, 1, // 382: check Inst[25] == 0x1
14804 OPC_Scope, 12, // 386: try {
14805 OPC_CheckField, 29, 2, 3, // 388: check Inst[30:29] == 0x3
14806 OPC_CheckPredicate, 163, 1, // 392: check predicate 163
14807 OPC_Decode, 128, 125, 249, 1, // 395: decode to SMT_VMADOT3US using decoder 249
14808 // 395: } else try {
14809 OPC_CheckPredicate, 162, 1, // 400: check predicate 162
14810 OPC_Decode, 129, 125, 250, 1, // 403: decode to SMT_VMADOT3USvtype using decoder 250
14811 // 403: }
14812 // 403: }
14813 // 403: } // switch Inst[15]
14814 // 403: }
14815 2, 67, // 408: case 0x2: {
14816 OPC_SwitchField, 15, 1, // 410: switch Inst[15] {
14817 0, 30, // 413: case 0x0: {
14818 OPC_CheckField, 0, 7, 43, // 415: check Inst[6:0] == 0x2b
14819 OPC_CheckField, 25, 1, 1, // 419: check Inst[25] == 0x1
14820 OPC_Scope, 12, // 423: try {
14821 OPC_CheckField, 29, 2, 3, // 425: check Inst[30:29] == 0x3
14822 OPC_CheckPredicate, 163, 1, // 429: check predicate 163
14823 OPC_Decode, 237, 124, 249, 1, // 432: decode to SMT_VMADOT1SU using decoder 249
14824 // 432: } else try {
14825 OPC_CheckPredicate, 162, 1, // 437: check predicate 162
14826 OPC_Decode, 238, 124, 250, 1, // 440: decode to SMT_VMADOT1SUvtype using decoder 250
14827 // 440: }
14828 // 440: }
14829 1, 0, // 445: case 0x1: {
14830 OPC_CheckField, 0, 7, 43, // 447: check Inst[6:0] == 0x2b
14831 OPC_CheckField, 25, 1, 1, // 451: check Inst[25] == 0x1
14832 OPC_Scope, 12, // 455: try {
14833 OPC_CheckField, 29, 2, 3, // 457: check Inst[30:29] == 0x3
14834 OPC_CheckPredicate, 163, 1, // 461: check predicate 163
14835 OPC_Decode, 253, 124, 249, 1, // 464: decode to SMT_VMADOT3SU using decoder 249
14836 // 464: } else try {
14837 OPC_CheckPredicate, 162, 1, // 469: check predicate 162
14838 OPC_Decode, 254, 124, 250, 1, // 472: decode to SMT_VMADOT3SUvtype using decoder 250
14839 // 472: }
14840 // 472: }
14841 // 472: } // switch Inst[15]
14842 // 472: }
14843 3, 0, // 477: case 0x3: {
14844 OPC_SwitchField, 15, 1, // 479: switch Inst[15] {
14845 0, 30, // 482: case 0x0: {
14846 OPC_CheckField, 0, 7, 43, // 484: check Inst[6:0] == 0x2b
14847 OPC_CheckField, 25, 1, 1, // 488: check Inst[25] == 0x1
14848 OPC_Scope, 12, // 492: try {
14849 OPC_CheckField, 29, 2, 3, // 494: check Inst[30:29] == 0x3
14850 OPC_CheckPredicate, 163, 1, // 498: check predicate 163
14851 OPC_Decode, 236, 124, 249, 1, // 501: decode to SMT_VMADOT1 using decoder 249
14852 // 501: } else try {
14853 OPC_CheckPredicate, 162, 1, // 506: check predicate 162
14854 OPC_Decode, 243, 124, 250, 1, // 509: decode to SMT_VMADOT1vtype using decoder 250
14855 // 509: }
14856 // 509: }
14857 1, 0, // 514: case 0x1: {
14858 OPC_CheckField, 0, 7, 43, // 516: check Inst[6:0] == 0x2b
14859 OPC_CheckField, 25, 1, 1, // 520: check Inst[25] == 0x1
14860 OPC_Scope, 12, // 524: try {
14861 OPC_CheckField, 29, 2, 3, // 526: check Inst[30:29] == 0x3
14862 OPC_CheckPredicate, 163, 1, // 530: check predicate 163
14863 OPC_Decode, 252, 124, 249, 1, // 533: decode to SMT_VMADOT3 using decoder 249
14864 // 533: } else try {
14865 OPC_CheckPredicate, 162, 1, // 538: check predicate 162
14866 OPC_Decode, 131, 125, 250, 1, // 541: decode to SMT_VMADOT3vtype using decoder 250
14867 // 541: }
14868 // 541: }
14869 // 541: } // switch Inst[15]
14870 // 541: }
14871 // 541: } // switch Inst[13:12]
14872 // 541: }
14873 // 541: } // switch Inst[31]
14874 // 541: }
14875 1, 0, // 546: case 0x1: {
14876 OPC_SwitchField, 31, 1, // 548: switch Inst[31] {
14877 0, 20, // 551: case 0x0: {
14878 OPC_CheckPredicate, 162, 1, // 553: check predicate 162
14879 OPC_CheckField, 29, 2, 3, // 556: check Inst[30:29] == 0x3
14880 OPC_CheckField, 25, 1, 1, // 560: check Inst[25] == 0x1
14881 OPC_CheckField, 0, 7, 43, // 564: check Inst[6:0] == 0x2b
14882 OPC_Decode, 152, 125, 248, 1, // 568: decode to SMT_VUPACK_VV using decoder 248
14883 // 568: }
14884 1, 0, // 573: case 0x1: {
14885 OPC_SwitchField, 12, 2, // 575: switch Inst[13:12] {
14886 0, 34, // 578: case 0x0: {
14887 OPC_CheckField, 0, 7, 43, // 580: check Inst[6:0] == 0x2b
14888 OPC_CheckField, 15, 1, 0, // 584: check Inst[15] == 0x0
14889 OPC_CheckField, 25, 1, 1, // 588: check Inst[25] == 0x1
14890 OPC_Scope, 12, // 592: try {
14891 OPC_CheckField, 29, 2, 3, // 594: check Inst[30:29] == 0x3
14892 OPC_CheckPredicate, 163, 1, // 598: check predicate 163
14893 OPC_Decode, 247, 124, 249, 1, // 601: decode to SMT_VMADOT2U using decoder 249
14894 // 601: } else try {
14895 OPC_CheckPredicate, 162, 1, // 606: check predicate 162
14896 OPC_Decode, 250, 124, 250, 1, // 609: decode to SMT_VMADOT2Uvtype using decoder 250
14897 // 609: }
14898 // 609: }
14899 1, 34, // 614: case 0x1: {
14900 OPC_CheckField, 0, 7, 43, // 616: check Inst[6:0] == 0x2b
14901 OPC_CheckField, 15, 1, 0, // 620: check Inst[15] == 0x0
14902 OPC_CheckField, 25, 1, 1, // 624: check Inst[25] == 0x1
14903 OPC_Scope, 12, // 628: try {
14904 OPC_CheckField, 29, 2, 3, // 630: check Inst[30:29] == 0x3
14905 OPC_CheckPredicate, 163, 1, // 634: check predicate 163
14906 OPC_Decode, 248, 124, 249, 1, // 637: decode to SMT_VMADOT2US using decoder 249
14907 // 637: } else try {
14908 OPC_CheckPredicate, 162, 1, // 642: check predicate 162
14909 OPC_Decode, 249, 124, 250, 1, // 645: decode to SMT_VMADOT2USvtype using decoder 250
14910 // 645: }
14911 // 645: }
14912 2, 34, // 650: case 0x2: {
14913 OPC_CheckField, 0, 7, 43, // 652: check Inst[6:0] == 0x2b
14914 OPC_CheckField, 15, 1, 0, // 656: check Inst[15] == 0x0
14915 OPC_CheckField, 25, 1, 1, // 660: check Inst[25] == 0x1
14916 OPC_Scope, 12, // 664: try {
14917 OPC_CheckField, 29, 2, 3, // 666: check Inst[30:29] == 0x3
14918 OPC_CheckPredicate, 163, 1, // 670: check predicate 163
14919 OPC_Decode, 245, 124, 249, 1, // 673: decode to SMT_VMADOT2SU using decoder 249
14920 // 673: } else try {
14921 OPC_CheckPredicate, 162, 1, // 678: check predicate 162
14922 OPC_Decode, 246, 124, 250, 1, // 681: decode to SMT_VMADOT2SUvtype using decoder 250
14923 // 681: }
14924 // 681: }
14925 3, 0, // 686: case 0x3: {
14926 OPC_CheckField, 0, 7, 43, // 688: check Inst[6:0] == 0x2b
14927 OPC_CheckField, 15, 1, 0, // 692: check Inst[15] == 0x0
14928 OPC_CheckField, 25, 1, 1, // 696: check Inst[25] == 0x1
14929 OPC_Scope, 12, // 700: try {
14930 OPC_CheckField, 29, 2, 3, // 702: check Inst[30:29] == 0x3
14931 OPC_CheckPredicate, 163, 1, // 706: check predicate 163
14932 OPC_Decode, 244, 124, 249, 1, // 709: decode to SMT_VMADOT2 using decoder 249
14933 // 709: } else try {
14934 OPC_CheckPredicate, 162, 1, // 714: check predicate 162
14935 OPC_Decode, 251, 124, 250, 1, // 717: decode to SMT_VMADOT2vtype using decoder 250
14936 // 717: }
14937 // 717: }
14938 // 717: } // switch Inst[13:12]
14939 // 717: }
14940 // 717: } // switch Inst[31]
14941 // 717: }
14942 // 717: } // switch Inst[14]
14943 // 717: }
14944 2, 75, // 722: case 0x2: {
14945 OPC_SwitchField, 12, 3, // 724: switch Inst[14:12] {
14946 0, 16, // 727: case 0x0: {
14947 OPC_CheckPredicate, 162, 1, // 729: check predicate 162
14948 OPC_CheckField, 31, 1, 1, // 732: check Inst[31] == 0x1
14949 OPC_CheckField, 0, 7, 43, // 736: check Inst[6:0] == 0x2b
14950 OPC_Decode, 142, 125, 251, 1, // 740: decode to SMT_VMADOTU_SP using decoder 251
14951 // 740: }
14952 1, 16, // 745: case 0x1: {
14953 OPC_CheckPredicate, 162, 1, // 747: check predicate 162
14954 OPC_CheckField, 31, 1, 1, // 750: check Inst[31] == 0x1
14955 OPC_CheckField, 0, 7, 43, // 754: check Inst[6:0] == 0x2b
14956 OPC_Decode, 139, 125, 251, 1, // 758: decode to SMT_VMADOTUS_SP using decoder 251
14957 // 758: }
14958 2, 16, // 763: case 0x2: {
14959 OPC_CheckPredicate, 162, 1, // 765: check predicate 162
14960 OPC_CheckField, 31, 1, 1, // 768: check Inst[31] == 0x1
14961 OPC_CheckField, 0, 7, 43, // 772: check Inst[6:0] == 0x2b
14962 OPC_Decode, 134, 125, 251, 1, // 776: decode to SMT_VMADOTSU_SP using decoder 251
14963 // 776: }
14964 3, 0, // 781: case 0x3: {
14965 OPC_CheckPredicate, 162, 1, // 783: check predicate 162
14966 OPC_CheckField, 31, 1, 1, // 786: check Inst[31] == 0x1
14967 OPC_CheckField, 0, 7, 43, // 790: check Inst[6:0] == 0x2b
14968 OPC_Decode, 145, 125, 251, 1, // 794: decode to SMT_VMADOT_SP using decoder 251
14969 // 794: }
14970 // 794: } // switch Inst[14:12]
14971 // 794: }
14972 3, 16, // 799: case 0x3: {
14973 OPC_CheckPredicate, 162, 1, // 801: check predicate 162
14974 OPC_CheckField, 31, 1, 1, // 804: check Inst[31] == 0x1
14975 OPC_CheckField, 0, 7, 43, // 808: check Inst[6:0] == 0x2b
14976 OPC_Decode, 141, 125, 252, 1, // 812: decode to SMT_VMADOTU_HP using decoder 252
14977 // 812: }
14978 4, 16, // 817: case 0x4: {
14979 OPC_CheckPredicate, 162, 1, // 819: check predicate 162
14980 OPC_CheckField, 31, 1, 1, // 822: check Inst[31] == 0x1
14981 OPC_CheckField, 0, 7, 43, // 826: check Inst[6:0] == 0x2b
14982 OPC_Decode, 144, 125, 252, 1, // 830: decode to SMT_VMADOT_HP using decoder 252
14983 // 830: }
14984 5, 16, // 835: case 0x5: {
14985 OPC_CheckPredicate, 162, 1, // 837: check predicate 162
14986 OPC_CheckField, 31, 1, 1, // 840: check Inst[31] == 0x1
14987 OPC_CheckField, 0, 7, 43, // 844: check Inst[6:0] == 0x2b
14988 OPC_Decode, 133, 125, 252, 1, // 848: decode to SMT_VMADOTSU_HP using decoder 252
14989 // 848: }
14990 6, 16, // 853: case 0x6: {
14991 OPC_CheckPredicate, 162, 1, // 855: check predicate 162
14992 OPC_CheckField, 31, 1, 1, // 858: check Inst[31] == 0x1
14993 OPC_CheckField, 0, 7, 43, // 862: check Inst[6:0] == 0x2b
14994 OPC_Decode, 138, 125, 252, 1, // 866: decode to SMT_VMADOTUS_HP using decoder 252
14995 // 866: }
14996 7, 0, // 871: case 0x7: {
14997 OPC_SwitchField, 12, 3, // 873: switch Inst[14:12] {
14998 4, 20, // 876: case 0x4: {
14999 OPC_CheckPredicate, 162, 1, // 878: check predicate 162
15000 OPC_CheckField, 29, 3, 4, // 881: check Inst[31:29] == 0x4
15001 OPC_CheckField, 25, 1, 1, // 885: check Inst[25] == 0x1
15002 OPC_CheckField, 0, 7, 43, // 889: check Inst[6:0] == 0x2b
15003 OPC_Decode, 231, 124, 246, 1, // 893: decode to SMT_VFWMADOT using decoder 246
15004 // 893: }
15005 5, 20, // 898: case 0x5: {
15006 OPC_CheckPredicate, 162, 1, // 900: check predicate 162
15007 OPC_CheckField, 29, 3, 4, // 903: check Inst[31:29] == 0x4
15008 OPC_CheckField, 25, 1, 1, // 907: check Inst[25] == 0x1
15009 OPC_CheckField, 0, 7, 43, // 911: check Inst[6:0] == 0x2b
15010 OPC_Decode, 232, 124, 253, 1, // 915: decode to SMT_VFWMADOT1 using decoder 253
15011 // 915: }
15012 6, 20, // 920: case 0x6: {
15013 OPC_CheckPredicate, 162, 1, // 922: check predicate 162
15014 OPC_CheckField, 29, 3, 4, // 925: check Inst[31:29] == 0x4
15015 OPC_CheckField, 25, 1, 1, // 929: check Inst[25] == 0x1
15016 OPC_CheckField, 0, 7, 43, // 933: check Inst[6:0] == 0x2b
15017 OPC_Decode, 233, 124, 253, 1, // 937: decode to SMT_VFWMADOT2 using decoder 253
15018 // 937: }
15019 7, 0, // 942: case 0x7: {
15020 OPC_CheckPredicate, 162, 1, // 944: check predicate 162
15021 OPC_CheckField, 29, 3, 4, // 947: check Inst[31:29] == 0x4
15022 OPC_CheckField, 25, 1, 1, // 951: check Inst[25] == 0x1
15023 OPC_CheckField, 0, 7, 43, // 955: check Inst[6:0] == 0x2b
15024 OPC_Decode, 234, 124, 253, 1, // 959: decode to SMT_VFWMADOT3 using decoder 253
15025 // 959: }
15026 // 959: } // switch Inst[14:12]
15027 // 959: }
15028 // 959: } // switch Inst[28:26]
15029};
15030static const uint8_t DecoderTableXSfcease32[16] = {
15031 32, // 0: BitWidth 32
15032 OPC_CheckPredicate, 164, 1, // 1: check predicate 164
15033 OPC_CheckField, 0, 32, 243, 128, 192, 130, 3,
15034 // 4: check Inst[31:0] == 0x30500073
15035 OPC_Decode, 248, 123, 14, // 12: decode to SF_CEASE using decoder 14
15036};
15037static const uint8_t DecoderTableXSfsystem32[32] = {
15038 32, // 0: BitWidth 32
15039 OPC_SwitchField, 20, 12, // 1: switch Inst[31:20] {
15040 192, 31, 11, // 4: case 0xfc0: {
15041 OPC_CheckPredicate, 165, 1, // 7: check predicate 165
15042 OPC_CheckField, 0, 15, 115, // 10: check Inst[14:0] == 0x73
15043 OPC_Decode, 249, 123, 15, // 14: decode to SF_CFLUSH_D_L1 using decoder 15
15044 // 14: }
15045 194, 31, 0, // 18: case 0xfc2: {
15046 OPC_CheckPredicate, 166, 1, // 21: check predicate 166
15047 OPC_CheckField, 0, 15, 115, // 24: check Inst[14:0] == 0x73
15048 OPC_Decode, 247, 123, 15, // 28: decode to SF_CDISCARD_D_L1 using decoder 15
15049 // 28: }
15050 // 28: } // switch Inst[31:20]
15051};
15052static const uint8_t DecoderTableXSfvector32[1129] = {
15053 32, // 0: BitWidth 32
15054 OPC_SwitchField, 28, 4, // 1: switch Inst[31:28] {
15055 0, 69, // 4: case 0x0: {
15056 OPC_SwitchField, 12, 3, // 6: switch Inst[14:12] {
15057 3, 31, // 9: case 0x3: {
15058 OPC_SwitchField, 25, 1, // 11: switch Inst[25] {
15059 0, 12, // 14: case 0x0: {
15060 OPC_CheckPredicate, 167, 1, // 16: check predicate 167
15061 OPC_CheckField, 0, 7, 91, // 19: check Inst[6:0] == 0x5b
15062 OPC_Decode, 144, 124, 254, 1, // 23: decode to SF_VC_V_I using decoder 254
15063 // 23: }
15064 1, 0, // 28: case 0x1: {
15065 OPC_CheckPredicate, 167, 1, // 30: check predicate 167
15066 OPC_CheckField, 0, 7, 91, // 33: check Inst[6:0] == 0x5b
15067 OPC_Decode, 134, 124, 255, 1, // 37: decode to SF_VC_I using decoder 255
15068 // 37: }
15069 // 37: } // switch Inst[25]
15070 // 37: }
15071 4, 0, // 42: case 0x4: {
15072 OPC_SwitchField, 25, 1, // 44: switch Inst[25] {
15073 0, 12, // 47: case 0x0: {
15074 OPC_CheckPredicate, 167, 1, // 49: check predicate 167
15075 OPC_CheckField, 0, 7, 91, // 52: check Inst[6:0] == 0x5b
15076 OPC_Decode, 151, 124, 128, 2, // 56: decode to SF_VC_V_X using decoder 256
15077 // 56: }
15078 1, 0, // 61: case 0x1: {
15079 OPC_CheckPredicate, 167, 1, // 63: check predicate 167
15080 OPC_CheckField, 0, 7, 91, // 66: check Inst[6:0] == 0x5b
15081 OPC_Decode, 155, 124, 129, 2, // 70: decode to SF_VC_X using decoder 257
15082 // 70: }
15083 // 70: } // switch Inst[25]
15084 // 70: }
15085 // 70: } // switch Inst[14:12]
15086 // 70: }
15087 1, 33, // 75: case 0x1: {
15088 OPC_SwitchField, 0, 15, // 77: switch Inst[14:0] {
15089 135, 224, 1, 11, // 80: case 0x7007: {
15090 OPC_CheckPredicate, 168, 1, // 84: check predicate 168
15091 OPC_CheckField, 25, 3, 1, // 87: check Inst[27:25] == 0x1
15092 OPC_Decode, 167, 124, 59, // 91: decode to SF_VLTE8 using decoder 59
15093 // 91: }
15094 167, 224, 1, 0, // 95: case 0x7027: {
15095 OPC_CheckPredicate, 168, 1, // 99: check predicate 168
15096 OPC_CheckField, 25, 3, 1, // 102: check Inst[27:25] == 0x1
15097 OPC_Decode, 182, 124, 59, // 106: decode to SF_VSTE8 using decoder 59
15098 // 106: }
15099 // 106: } // switch Inst[14:0]
15100 // 106: }
15101 2, 143, 1, // 110: case 0x2: {
15102 OPC_SwitchField, 12, 3, // 113: switch Inst[14:12] {
15103 0, 31, // 116: case 0x0: {
15104 OPC_SwitchField, 25, 1, // 118: switch Inst[25] {
15105 0, 12, // 121: case 0x0: {
15106 OPC_CheckPredicate, 167, 1, // 123: check predicate 167
15107 OPC_CheckField, 0, 7, 91, // 126: check Inst[6:0] == 0x5b
15108 OPC_Decode, 148, 124, 130, 2, // 130: decode to SF_VC_V_VV using decoder 258
15109 // 130: }
15110 1, 0, // 135: case 0x1: {
15111 OPC_CheckPredicate, 167, 1, // 137: check predicate 167
15112 OPC_CheckField, 0, 7, 91, // 140: check Inst[6:0] == 0x5b
15113 OPC_Decode, 138, 124, 131, 2, // 144: decode to SF_VC_VV using decoder 259
15114 // 144: }
15115 // 144: } // switch Inst[25]
15116 // 144: }
15117 3, 31, // 149: case 0x3: {
15118 OPC_SwitchField, 25, 1, // 151: switch Inst[25] {
15119 0, 12, // 154: case 0x0: {
15120 OPC_CheckPredicate, 167, 1, // 156: check predicate 167
15121 OPC_CheckField, 0, 7, 91, // 159: check Inst[6:0] == 0x5b
15122 OPC_Decode, 145, 124, 132, 2, // 163: decode to SF_VC_V_IV using decoder 260
15123 // 163: }
15124 1, 0, // 168: case 0x1: {
15125 OPC_CheckPredicate, 167, 1, // 170: check predicate 167
15126 OPC_CheckField, 0, 7, 91, // 173: check Inst[6:0] == 0x5b
15127 OPC_Decode, 135, 124, 133, 2, // 177: decode to SF_VC_IV using decoder 261
15128 // 177: }
15129 // 177: } // switch Inst[25]
15130 // 177: }
15131 4, 31, // 182: case 0x4: {
15132 OPC_SwitchField, 25, 1, // 184: switch Inst[25] {
15133 0, 12, // 187: case 0x0: {
15134 OPC_CheckPredicate, 167, 1, // 189: check predicate 167
15135 OPC_CheckField, 0, 7, 91, // 192: check Inst[6:0] == 0x5b
15136 OPC_Decode, 152, 124, 134, 2, // 196: decode to SF_VC_V_XV using decoder 262
15137 // 196: }
15138 1, 0, // 201: case 0x1: {
15139 OPC_CheckPredicate, 167, 1, // 203: check predicate 167
15140 OPC_CheckField, 0, 7, 91, // 206: check Inst[6:0] == 0x5b
15141 OPC_Decode, 156, 124, 135, 2, // 210: decode to SF_VC_XV using decoder 263
15142 // 210: }
15143 // 210: } // switch Inst[25]
15144 // 210: }
15145 5, 0, // 215: case 0x5: {
15146 OPC_SwitchField, 25, 1, // 217: switch Inst[25] {
15147 0, 16, // 220: case 0x0: {
15148 OPC_CheckPredicate, 167, 1, // 222: check predicate 167
15149 OPC_CheckField, 27, 1, 1, // 225: check Inst[27] == 0x1
15150 OPC_CheckField, 0, 7, 91, // 229: check Inst[6:0] == 0x5b
15151 OPC_Decode, 141, 124, 136, 2, // 233: decode to SF_VC_V_FV using decoder 264
15152 // 233: }
15153 1, 0, // 238: case 0x1: {
15154 OPC_CheckPredicate, 167, 1, // 240: check predicate 167
15155 OPC_CheckField, 27, 1, 1, // 243: check Inst[27] == 0x1
15156 OPC_CheckField, 0, 7, 91, // 247: check Inst[6:0] == 0x5b
15157 OPC_Decode, 131, 124, 137, 2, // 251: decode to SF_VC_FV using decoder 265
15158 // 251: }
15159 // 251: } // switch Inst[25]
15160 // 251: }
15161 // 251: } // switch Inst[14:12]
15162 // 251: }
15163 3, 33, // 256: case 0x3: {
15164 OPC_SwitchField, 0, 15, // 258: switch Inst[14:0] {
15165 135, 224, 1, 11, // 261: case 0x7007: {
15166 OPC_CheckPredicate, 168, 1, // 265: check predicate 168
15167 OPC_CheckField, 25, 3, 1, // 268: check Inst[27:25] == 0x1
15168 OPC_Decode, 164, 124, 59, // 272: decode to SF_VLTE16 using decoder 59
15169 // 272: }
15170 167, 224, 1, 0, // 276: case 0x7027: {
15171 OPC_CheckPredicate, 168, 1, // 280: check predicate 168
15172 OPC_CheckField, 25, 3, 1, // 283: check Inst[27:25] == 0x1
15173 OPC_Decode, 179, 124, 59, // 287: decode to SF_VSTE16 using decoder 59
15174 // 287: }
15175 // 287: } // switch Inst[14:0]
15176 // 287: }
15177 4, 95, // 291: case 0x4: {
15178 OPC_SwitchField, 12, 3, // 293: switch Inst[14:12] {
15179 1, 37, // 296: case 0x1: {
15180 OPC_SwitchField, 15, 5, // 298: switch Inst[19:15] {
15181 6, 15, // 301: case 0x6: {
15182 OPC_CheckPredicate, 169, 1, // 303: check predicate 169
15183 OPC_CheckField, 26, 2, 3, // 306: check Inst[27:26] == 0x3
15184 OPC_CheckField, 0, 7, 87, // 310: check Inst[6:0] == 0x57
15185 OPC_Decode, 159, 124, 124, // 314: decode to SF_VFEXPA_V using decoder 124
15186 // 314: }
15187 7, 0, // 318: case 0x7: {
15188 OPC_CheckPredicate, 170, 1, // 320: check predicate 170
15189 OPC_CheckField, 26, 2, 3, // 323: check Inst[27:26] == 0x3
15190 OPC_CheckField, 0, 7, 87, // 327: check Inst[6:0] == 0x57
15191 OPC_Decode, 160, 124, 124, // 331: decode to SF_VFEXP_V using decoder 124
15192 // 331: }
15193 // 331: } // switch Inst[19:15]
15194 // 331: }
15195 6, 0, // 335: case 0x6: {
15196 OPC_SwitchField, 20, 8, // 337: switch Inst[27:20] {
15197 60, 15, // 340: case 0x3c: {
15198 OPC_CheckPredicate, 168, 1, // 342: check predicate 168
15199 OPC_CheckField, 15, 5, 0, // 345: check Inst[19:15] == 0x0
15200 OPC_CheckField, 0, 12, 87, // 349: check Inst[11:0] == 0x57
15201 OPC_Decode, 183, 124, 14, // 353: decode to SF_VTDISCARD using decoder 14
15202 // 353: }
15203 62, 16, // 357: case 0x3e: {
15204 OPC_CheckPredicate, 168, 1, // 359: check predicate 168
15205 OPC_CheckField, 15, 5, 0, // 362: check Inst[19:15] == 0x0
15206 OPC_CheckField, 0, 8, 87, // 366: check Inst[7:0] == 0x57
15207 OPC_Decode, 186, 124, 138, 2, // 370: decode to SF_VTZERO_T using decoder 266
15208 // 370: }
15209 63, 0, // 375: case 0x3f: {
15210 OPC_CheckPredicate, 168, 1, // 377: check predicate 168
15211 OPC_CheckField, 0, 7, 87, // 380: check Inst[6:0] == 0x57
15212 OPC_Decode, 185, 124, 2, // 384: decode to SF_VTMV_V_T using decoder 2
15213 // 384: }
15214 // 384: } // switch Inst[27:20]
15215 // 384: }
15216 // 384: } // switch Inst[14:12]
15217 // 384: }
15218 5, 49, // 388: case 0x5: {
15219 OPC_SwitchField, 0, 15, // 390: switch Inst[14:0] {
15220 215, 192, 1, 12, // 393: case 0x6057: {
15221 OPC_CheckPredicate, 168, 1, // 397: check predicate 168
15222 OPC_CheckField, 25, 3, 7, // 400: check Inst[27:25] == 0x7
15223 OPC_Decode, 184, 124, 139, 2, // 404: decode to SF_VTMV_T_V using decoder 267
15224 // 404: }
15225 135, 224, 1, 11, // 409: case 0x7007: {
15226 OPC_CheckPredicate, 168, 1, // 413: check predicate 168
15227 OPC_CheckField, 25, 3, 1, // 416: check Inst[27:25] == 0x1
15228 OPC_Decode, 165, 124, 59, // 420: decode to SF_VLTE32 using decoder 59
15229 // 420: }
15230 167, 224, 1, 0, // 424: case 0x7027: {
15231 OPC_CheckPredicate, 168, 1, // 428: check predicate 168
15232 OPC_CheckField, 25, 3, 1, // 431: check Inst[27:25] == 0x1
15233 OPC_Decode, 180, 124, 59, // 435: decode to SF_VSTE32 using decoder 59
15234 // 435: }
15235 // 435: } // switch Inst[14:0]
15236 // 435: }
15237 7, 33, // 439: case 0x7: {
15238 OPC_SwitchField, 0, 15, // 441: switch Inst[14:0] {
15239 135, 224, 1, 11, // 444: case 0x7007: {
15240 OPC_CheckPredicate, 168, 1, // 448: check predicate 168
15241 OPC_CheckField, 25, 3, 1, // 451: check Inst[27:25] == 0x1
15242 OPC_Decode, 166, 124, 59, // 455: decode to SF_VLTE64 using decoder 59
15243 // 455: }
15244 167, 224, 1, 0, // 459: case 0x7027: {
15245 OPC_CheckPredicate, 168, 1, // 463: check predicate 168
15246 OPC_CheckField, 25, 3, 1, // 466: check Inst[27:25] == 0x1
15247 OPC_Decode, 181, 124, 59, // 470: decode to SF_VSTE64 using decoder 59
15248 // 470: }
15249 // 470: } // switch Inst[14:0]
15250 // 470: }
15251 8, 95, // 474: case 0x8: {
15252 OPC_SwitchField, 26, 2, // 476: switch Inst[27:26] {
15253 1, 54, // 479: case 0x1: {
15254 OPC_SwitchField, 20, 6, // 481: switch Inst[25:20] {
15255 0, 15, // 484: case 0x0: {
15256 OPC_CheckPredicate, 168, 1, // 486: check predicate 168
15257 OPC_CheckField, 12, 3, 7, // 489: check Inst[14:12] == 0x7
15258 OPC_CheckField, 0, 7, 87, // 493: check Inst[6:0] == 0x57
15259 OPC_Decode, 178, 124, 17, // 497: decode to SF_VSETTN using decoder 17
15260 // 497: }
15261 1, 15, // 501: case 0x1: {
15262 OPC_CheckPredicate, 168, 1, // 503: check predicate 168
15263 OPC_CheckField, 12, 3, 7, // 506: check Inst[14:12] == 0x7
15264 OPC_CheckField, 0, 7, 87, // 510: check Inst[6:0] == 0x57
15265 OPC_Decode, 177, 124, 17, // 514: decode to SF_VSETTM using decoder 17
15266 // 514: }
15267 2, 0, // 518: case 0x2: {
15268 OPC_CheckPredicate, 168, 1, // 520: check predicate 168
15269 OPC_CheckField, 12, 3, 7, // 523: check Inst[14:12] == 0x7
15270 OPC_CheckField, 0, 7, 87, // 527: check Inst[6:0] == 0x57
15271 OPC_Decode, 176, 124, 17, // 531: decode to SF_VSETTK using decoder 17
15272 // 531: }
15273 // 531: } // switch Inst[25:20]
15274 // 531: }
15275 2, 16, // 535: case 0x2: {
15276 OPC_CheckPredicate, 171, 1, // 537: check predicate 171
15277 OPC_CheckField, 12, 3, 5, // 540: check Inst[14:12] == 0x5
15278 OPC_CheckField, 0, 7, 91, // 544: check Inst[6:0] == 0x5b
15279 OPC_Decode, 161, 124, 143, 1, // 548: decode to SF_VFNRCLIP_XU_F_QF using decoder 143
15280 // 548: }
15281 3, 0, // 553: case 0x3: {
15282 OPC_CheckPredicate, 171, 1, // 555: check predicate 171
15283 OPC_CheckField, 12, 3, 5, // 558: check Inst[14:12] == 0x5
15284 OPC_CheckField, 0, 7, 91, // 562: check Inst[6:0] == 0x5b
15285 OPC_Decode, 162, 124, 143, 1, // 566: decode to SF_VFNRCLIP_X_F_QF using decoder 143
15286 // 566: }
15287 // 566: } // switch Inst[27:26]
15288 // 566: }
15289 10, 143, 1, // 571: case 0xa: {
15290 OPC_SwitchField, 12, 3, // 574: switch Inst[14:12] {
15291 0, 31, // 577: case 0x0: {
15292 OPC_SwitchField, 25, 1, // 579: switch Inst[25] {
15293 0, 12, // 582: case 0x0: {
15294 OPC_CheckPredicate, 167, 1, // 584: check predicate 167
15295 OPC_CheckField, 0, 7, 91, // 587: check Inst[6:0] == 0x5b
15296 OPC_Decode, 149, 124, 140, 2, // 591: decode to SF_VC_V_VVV using decoder 268
15297 // 591: }
15298 1, 0, // 596: case 0x1: {
15299 OPC_CheckPredicate, 167, 1, // 598: check predicate 167
15300 OPC_CheckField, 0, 7, 91, // 601: check Inst[6:0] == 0x5b
15301 OPC_Decode, 139, 124, 141, 2, // 605: decode to SF_VC_VVV using decoder 269
15302 // 605: }
15303 // 605: } // switch Inst[25]
15304 // 605: }
15305 3, 31, // 610: case 0x3: {
15306 OPC_SwitchField, 25, 1, // 612: switch Inst[25] {
15307 0, 12, // 615: case 0x0: {
15308 OPC_CheckPredicate, 167, 1, // 617: check predicate 167
15309 OPC_CheckField, 0, 7, 91, // 620: check Inst[6:0] == 0x5b
15310 OPC_Decode, 146, 124, 142, 2, // 624: decode to SF_VC_V_IVV using decoder 270
15311 // 624: }
15312 1, 0, // 629: case 0x1: {
15313 OPC_CheckPredicate, 167, 1, // 631: check predicate 167
15314 OPC_CheckField, 0, 7, 91, // 634: check Inst[6:0] == 0x5b
15315 OPC_Decode, 136, 124, 143, 2, // 638: decode to SF_VC_IVV using decoder 271
15316 // 638: }
15317 // 638: } // switch Inst[25]
15318 // 638: }
15319 4, 31, // 643: case 0x4: {
15320 OPC_SwitchField, 25, 1, // 645: switch Inst[25] {
15321 0, 12, // 648: case 0x0: {
15322 OPC_CheckPredicate, 167, 1, // 650: check predicate 167
15323 OPC_CheckField, 0, 7, 91, // 653: check Inst[6:0] == 0x5b
15324 OPC_Decode, 153, 124, 144, 2, // 657: decode to SF_VC_V_XVV using decoder 272
15325 // 657: }
15326 1, 0, // 662: case 0x1: {
15327 OPC_CheckPredicate, 167, 1, // 664: check predicate 167
15328 OPC_CheckField, 0, 7, 91, // 667: check Inst[6:0] == 0x5b
15329 OPC_Decode, 157, 124, 145, 2, // 671: decode to SF_VC_XVV using decoder 273
15330 // 671: }
15331 // 671: } // switch Inst[25]
15332 // 671: }
15333 5, 0, // 676: case 0x5: {
15334 OPC_SwitchField, 25, 1, // 678: switch Inst[25] {
15335 0, 16, // 681: case 0x0: {
15336 OPC_CheckPredicate, 167, 1, // 683: check predicate 167
15337 OPC_CheckField, 27, 1, 1, // 686: check Inst[27] == 0x1
15338 OPC_CheckField, 0, 7, 91, // 690: check Inst[6:0] == 0x5b
15339 OPC_Decode, 142, 124, 146, 2, // 694: decode to SF_VC_V_FVV using decoder 274
15340 // 694: }
15341 1, 0, // 699: case 0x1: {
15342 OPC_CheckPredicate, 167, 1, // 701: check predicate 167
15343 OPC_CheckField, 27, 1, 1, // 704: check Inst[27] == 0x1
15344 OPC_CheckField, 0, 7, 91, // 708: check Inst[6:0] == 0x5b
15345 OPC_Decode, 132, 124, 147, 2, // 712: decode to SF_VC_FVV using decoder 275
15346 // 712: }
15347 // 712: } // switch Inst[25]
15348 // 712: }
15349 // 712: } // switch Inst[14:12]
15350 // 712: }
15351 11, 71, // 717: case 0xb: {
15352 OPC_SwitchField, 25, 3, // 719: switch Inst[27:25] {
15353 1, 15, // 722: case 0x1: {
15354 OPC_CheckPredicate, 172, 1, // 724: check predicate 172
15355 OPC_CheckField, 12, 3, 2, // 727: check Inst[14:12] == 0x2
15356 OPC_CheckField, 0, 7, 91, // 731: check Inst[6:0] == 0x5b
15357 OPC_Decode, 172, 124, 120, // 735: decode to SF_VQMACCU_2x8x2 using decoder 120
15358 // 735: }
15359 3, 15, // 739: case 0x3: {
15360 OPC_CheckPredicate, 172, 1, // 741: check predicate 172
15361 OPC_CheckField, 12, 3, 2, // 744: check Inst[14:12] == 0x2
15362 OPC_CheckField, 0, 7, 91, // 748: check Inst[6:0] == 0x5b
15363 OPC_Decode, 174, 124, 120, // 752: decode to SF_VQMACC_2x8x2 using decoder 120
15364 // 752: }
15365 5, 15, // 756: case 0x5: {
15366 OPC_CheckPredicate, 172, 1, // 758: check predicate 172
15367 OPC_CheckField, 12, 3, 2, // 761: check Inst[14:12] == 0x2
15368 OPC_CheckField, 0, 7, 91, // 765: check Inst[6:0] == 0x5b
15369 OPC_Decode, 170, 124, 120, // 769: decode to SF_VQMACCUS_2x8x2 using decoder 120
15370 // 769: }
15371 7, 0, // 773: case 0x7: {
15372 OPC_CheckPredicate, 172, 1, // 775: check predicate 172
15373 OPC_CheckField, 12, 3, 2, // 778: check Inst[14:12] == 0x2
15374 OPC_CheckField, 0, 7, 91, // 782: check Inst[6:0] == 0x5b
15375 OPC_Decode, 168, 124, 120, // 786: decode to SF_VQMACCSU_2x8x2 using decoder 120
15376 // 786: }
15377 // 786: } // switch Inst[27:25]
15378 // 786: }
15379 15, 0, // 790: case 0xf: {
15380 OPC_SwitchField, 12, 3, // 792: switch Inst[14:12] {
15381 0, 83, // 795: case 0x0: {
15382 OPC_SwitchField, 0, 7, // 797: switch Inst[6:0] {
15383 91, 23, // 800: case 0x5b: {
15384 OPC_SwitchField, 25, 1, // 802: switch Inst[25] {
15385 0, 8, // 805: case 0x0: {
15386 OPC_CheckPredicate, 167, 1, // 807: check predicate 167
15387 OPC_Decode, 150, 124, 140, 2, // 810: decode to SF_VC_V_VVW using decoder 268
15388 // 810: }
15389 1, 0, // 815: case 0x1: {
15390 OPC_CheckPredicate, 167, 1, // 817: check predicate 167
15391 OPC_Decode, 140, 124, 141, 2, // 820: decode to SF_VC_VVW using decoder 269
15392 // 820: }
15393 // 820: } // switch Inst[25]
15394 // 820: }
15395 119, 0, // 825: case 0x77: {
15396 OPC_SwitchField, 7, 3, // 827: switch Inst[9:7] {
15397 0, 23, // 830: case 0x0: {
15398 OPC_SwitchField, 25, 3, // 832: switch Inst[27:25] {
15399 1, 8, // 835: case 0x1: {
15400 OPC_CheckPredicate, 173, 1, // 837: check predicate 173
15401 OPC_Decode, 130, 124, 148, 2, // 840: decode to SF_MM_U_U using decoder 276
15402 // 840: }
15403 3, 0, // 845: case 0x3: {
15404 OPC_CheckPredicate, 173, 1, // 847: check predicate 173
15405 OPC_Decode, 128, 124, 148, 2, // 850: decode to SF_MM_S_U using decoder 276
15406 // 850: }
15407 // 850: } // switch Inst[27:25]
15408 // 850: }
15409 1, 0, // 855: case 0x1: {
15410 OPC_SwitchField, 25, 3, // 857: switch Inst[27:25] {
15411 1, 8, // 860: case 0x1: {
15412 OPC_CheckPredicate, 173, 1, // 862: check predicate 173
15413 OPC_Decode, 129, 124, 148, 2, // 865: decode to SF_MM_U_S using decoder 276
15414 // 865: }
15415 3, 0, // 870: case 0x3: {
15416 OPC_CheckPredicate, 173, 1, // 872: check predicate 173
15417 OPC_Decode, 255, 123, 148, 2, // 875: decode to SF_MM_S_S using decoder 276
15418 // 875: }
15419 // 875: } // switch Inst[27:25]
15420 // 875: }
15421 // 875: } // switch Inst[9:7]
15422 // 875: }
15423 // 875: } // switch Inst[6:0]
15424 // 875: }
15425 1, 83, // 880: case 0x1: {
15426 OPC_SwitchField, 25, 3, // 882: switch Inst[27:25] {
15427 1, 26, // 885: case 0x1: {
15428 OPC_SwitchField, 0, 7, // 887: switch Inst[6:0] {
15429 91, 7, // 890: case 0x5b: {
15430 OPC_CheckPredicate, 174, 1, // 892: check predicate 174
15431 OPC_Decode, 163, 124, 120, // 895: decode to SF_VFWMACC_4x4x4 using decoder 120
15432 // 895: }
15433 119, 0, // 899: case 0x77: {
15434 OPC_CheckPredicate, 175, 1, // 901: check predicate 175
15435 OPC_CheckField, 7, 2, 0, // 904: check Inst[8:7] == 0x0
15436 OPC_Decode, 254, 123, 149, 2, // 908: decode to SF_MM_F_F using decoder 277
15437 // 908: }
15438 // 908: } // switch Inst[6:0]
15439 // 908: }
15440 5, 24, // 913: case 0x5: {
15441 OPC_SwitchField, 0, 10, // 915: switch Inst[9:0] {
15442 119, 8, // 918: case 0x77: {
15443 OPC_CheckPredicate, 176, 1, // 920: check predicate 176
15444 OPC_Decode, 253, 123, 148, 2, // 923: decode to SF_MM_E5M2_E5M2 using decoder 276
15445 // 923: }
15446 247, 1, 0, // 928: case 0xf7: {
15447 OPC_CheckPredicate, 176, 1, // 931: check predicate 176
15448 OPC_Decode, 252, 123, 148, 2, // 934: decode to SF_MM_E5M2_E4M3 using decoder 276
15449 // 934: }
15450 // 934: } // switch Inst[9:0]
15451 // 934: }
15452 7, 0, // 939: case 0x7: {
15453 OPC_SwitchField, 0, 10, // 941: switch Inst[9:0] {
15454 119, 8, // 944: case 0x77: {
15455 OPC_CheckPredicate, 176, 1, // 946: check predicate 176
15456 OPC_Decode, 251, 123, 148, 2, // 949: decode to SF_MM_E4M3_E5M2 using decoder 276
15457 // 949: }
15458 247, 1, 0, // 954: case 0xf7: {
15459 OPC_CheckPredicate, 176, 1, // 957: check predicate 176
15460 OPC_Decode, 250, 123, 148, 2, // 960: decode to SF_MM_E4M3_E4M3 using decoder 276
15461 // 960: }
15462 // 960: } // switch Inst[9:0]
15463 // 960: }
15464 // 960: } // switch Inst[27:25]
15465 // 960: }
15466 2, 55, // 965: case 0x2: {
15467 OPC_SwitchField, 25, 3, // 967: switch Inst[27:25] {
15468 1, 11, // 970: case 0x1: {
15469 OPC_CheckPredicate, 177, 1, // 972: check predicate 177
15470 OPC_CheckField, 0, 7, 91, // 975: check Inst[6:0] == 0x5b
15471 OPC_Decode, 173, 124, 120, // 979: decode to SF_VQMACCU_4x8x4 using decoder 120
15472 // 979: }
15473 3, 11, // 983: case 0x3: {
15474 OPC_CheckPredicate, 177, 1, // 985: check predicate 177
15475 OPC_CheckField, 0, 7, 91, // 988: check Inst[6:0] == 0x5b
15476 OPC_Decode, 175, 124, 120, // 992: decode to SF_VQMACC_4x8x4 using decoder 120
15477 // 992: }
15478 5, 11, // 996: case 0x5: {
15479 OPC_CheckPredicate, 177, 1, // 998: check predicate 177
15480 OPC_CheckField, 0, 7, 91, // 1001: check Inst[6:0] == 0x5b
15481 OPC_Decode, 171, 124, 120, // 1005: decode to SF_VQMACCUS_4x8x4 using decoder 120
15482 // 1005: }
15483 7, 0, // 1009: case 0x7: {
15484 OPC_CheckPredicate, 177, 1, // 1011: check predicate 177
15485 OPC_CheckField, 0, 7, 91, // 1014: check Inst[6:0] == 0x5b
15486 OPC_Decode, 169, 124, 120, // 1018: decode to SF_VQMACCSU_4x8x4 using decoder 120
15487 // 1018: }
15488 // 1018: } // switch Inst[27:25]
15489 // 1018: }
15490 3, 31, // 1022: case 0x3: {
15491 OPC_SwitchField, 25, 1, // 1024: switch Inst[25] {
15492 0, 12, // 1027: case 0x0: {
15493 OPC_CheckPredicate, 167, 1, // 1029: check predicate 167
15494 OPC_CheckField, 0, 7, 91, // 1032: check Inst[6:0] == 0x5b
15495 OPC_Decode, 147, 124, 142, 2, // 1036: decode to SF_VC_V_IVW using decoder 270
15496 // 1036: }
15497 1, 0, // 1041: case 0x1: {
15498 OPC_CheckPredicate, 167, 1, // 1043: check predicate 167
15499 OPC_CheckField, 0, 7, 91, // 1046: check Inst[6:0] == 0x5b
15500 OPC_Decode, 137, 124, 143, 2, // 1050: decode to SF_VC_IVW using decoder 271
15501 // 1050: }
15502 // 1050: } // switch Inst[25]
15503 // 1050: }
15504 4, 31, // 1055: case 0x4: {
15505 OPC_SwitchField, 25, 1, // 1057: switch Inst[25] {
15506 0, 12, // 1060: case 0x0: {
15507 OPC_CheckPredicate, 167, 1, // 1062: check predicate 167
15508 OPC_CheckField, 0, 7, 91, // 1065: check Inst[6:0] == 0x5b
15509 OPC_Decode, 154, 124, 144, 2, // 1069: decode to SF_VC_V_XVW using decoder 272
15510 // 1069: }
15511 1, 0, // 1074: case 0x1: {
15512 OPC_CheckPredicate, 167, 1, // 1076: check predicate 167
15513 OPC_CheckField, 0, 7, 91, // 1079: check Inst[6:0] == 0x5b
15514 OPC_Decode, 158, 124, 145, 2, // 1083: decode to SF_VC_XVW using decoder 273
15515 // 1083: }
15516 // 1083: } // switch Inst[25]
15517 // 1083: }
15518 5, 0, // 1088: case 0x5: {
15519 OPC_SwitchField, 25, 1, // 1090: switch Inst[25] {
15520 0, 16, // 1093: case 0x0: {
15521 OPC_CheckPredicate, 167, 1, // 1095: check predicate 167
15522 OPC_CheckField, 27, 1, 1, // 1098: check Inst[27] == 0x1
15523 OPC_CheckField, 0, 7, 91, // 1102: check Inst[6:0] == 0x5b
15524 OPC_Decode, 143, 124, 146, 2, // 1106: decode to SF_VC_V_FVW using decoder 274
15525 // 1106: }
15526 1, 0, // 1111: case 0x1: {
15527 OPC_CheckPredicate, 167, 1, // 1113: check predicate 167
15528 OPC_CheckField, 27, 1, 1, // 1116: check Inst[27] == 0x1
15529 OPC_CheckField, 0, 7, 91, // 1120: check Inst[6:0] == 0x5b
15530 OPC_Decode, 133, 124, 147, 2, // 1124: decode to SF_VC_FVW using decoder 275
15531 // 1124: }
15532 // 1124: } // switch Inst[25]
15533 // 1124: }
15534 // 1124: } // switch Inst[14:12]
15535 // 1124: }
15536 // 1124: } // switch Inst[31:28]
15537};
15538static const uint8_t DecoderTableXTHead32[1598] = {
15539 32, // 0: BitWidth 32
15540 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
15541 0, 235, 2, // 4: case 0x0: {
15542 OPC_SwitchField, 25, 7, // 7: switch Inst[31:25] {
15543 0, 168, 1, // 10: case 0x0: {
15544 OPC_SwitchField, 15, 10, // 13: switch Inst[24:15] {
15545 32, 11, // 16: case 0x20: {
15546 OPC_CheckPredicate, 178, 1, // 18: check predicate 178
15547 OPC_CheckField, 0, 12, 11, // 21: check Inst[11:0] == 0xb
15548 OPC_Decode, 192, 125, 14, // 25: decode to TH_DCACHE_CALL using decoder 14
15549 // 25: }
15550 64, 11, // 29: case 0x40: {
15551 OPC_CheckPredicate, 178, 1, // 31: check predicate 178
15552 OPC_CheckField, 0, 12, 11, // 34: check Inst[11:0] == 0xb
15553 OPC_Decode, 202, 125, 14, // 38: decode to TH_DCACHE_IALL using decoder 14
15554 // 38: }
15555 96, 11, // 42: case 0x60: {
15556 OPC_CheckPredicate, 178, 1, // 44: check predicate 178
15557 OPC_CheckField, 0, 12, 11, // 47: check Inst[11:0] == 0xb
15558 OPC_Decode, 193, 125, 14, // 51: decode to TH_DCACHE_CIALL using decoder 14
15559 // 51: }
15560 128, 4, 11, // 55: case 0x200: {
15561 OPC_CheckPredicate, 178, 1, // 58: check predicate 178
15562 OPC_CheckField, 0, 12, 11, // 61: check Inst[11:0] == 0xb
15563 OPC_Decode, 218, 125, 14, // 65: decode to TH_ICACHE_IALL using decoder 14
15564 // 65: }
15565 160, 4, 11, // 69: case 0x220: {
15566 OPC_CheckPredicate, 178, 1, // 72: check predicate 178
15567 OPC_CheckField, 0, 12, 11, // 75: check Inst[11:0] == 0xb
15568 OPC_Decode, 219, 125, 14, // 79: decode to TH_ICACHE_IALLS using decoder 14
15569 // 79: }
15570 160, 5, 11, // 83: case 0x2a0: {
15571 OPC_CheckPredicate, 178, 1, // 86: check predicate 178
15572 OPC_CheckField, 0, 12, 11, // 89: check Inst[11:0] == 0xb
15573 OPC_Decode, 222, 125, 14, // 93: decode to TH_L2CACHE_CALL using decoder 14
15574 // 93: }
15575 192, 5, 11, // 97: case 0x2c0: {
15576 OPC_CheckPredicate, 178, 1, // 100: check predicate 178
15577 OPC_CheckField, 0, 12, 11, // 103: check Inst[11:0] == 0xb
15578 OPC_Decode, 224, 125, 14, // 107: decode to TH_L2CACHE_IALL using decoder 14
15579 // 107: }
15580 224, 5, 11, // 111: case 0x2e0: {
15581 OPC_CheckPredicate, 178, 1, // 114: check predicate 178
15582 OPC_CheckField, 0, 12, 11, // 117: check Inst[11:0] == 0xb
15583 OPC_Decode, 223, 125, 14, // 121: decode to TH_L2CACHE_CIALL using decoder 14
15584 // 121: }
15585 128, 6, 11, // 125: case 0x300: {
15586 OPC_CheckPredicate, 179, 1, // 128: check predicate 179
15587 OPC_CheckField, 0, 12, 11, // 131: check Inst[11:0] == 0xb
15588 OPC_Decode, 159, 126, 14, // 135: decode to TH_SYNC using decoder 14
15589 // 135: }
15590 160, 6, 11, // 139: case 0x320: {
15591 OPC_CheckPredicate, 179, 1, // 142: check predicate 179
15592 OPC_CheckField, 0, 12, 11, // 145: check Inst[11:0] == 0xb
15593 OPC_Decode, 162, 126, 14, // 149: decode to TH_SYNC_S using decoder 14
15594 // 149: }
15595 192, 6, 11, // 153: case 0x340: {
15596 OPC_CheckPredicate, 179, 1, // 156: check predicate 179
15597 OPC_CheckField, 0, 12, 11, // 159: check Inst[11:0] == 0xb
15598 OPC_Decode, 160, 126, 14, // 163: decode to TH_SYNC_I using decoder 14
15599 // 163: }
15600 224, 6, 0, // 167: case 0x360: {
15601 OPC_CheckPredicate, 179, 1, // 170: check predicate 179
15602 OPC_CheckField, 0, 12, 11, // 173: check Inst[11:0] == 0xb
15603 OPC_Decode, 161, 126, 14, // 177: decode to TH_SYNC_IS using decoder 14
15604 // 177: }
15605 // 177: } // switch Inst[24:15]
15606 // 177: }
15607 1, 172, 1, // 181: case 0x1: {
15608 OPC_SwitchField, 20, 5, // 184: switch Inst[24:20] {
15609 1, 11, // 187: case 0x1: {
15610 OPC_CheckPredicate, 178, 1, // 189: check predicate 178
15611 OPC_CheckField, 0, 12, 11, // 192: check Inst[11:0] == 0xb
15612 OPC_Decode, 199, 125, 15, // 196: decode to TH_DCACHE_CSW using decoder 15
15613 // 196: }
15614 2, 11, // 200: case 0x2: {
15615 OPC_CheckPredicate, 178, 1, // 202: check predicate 178
15616 OPC_CheckField, 0, 12, 11, // 205: check Inst[11:0] == 0xb
15617 OPC_Decode, 204, 125, 15, // 209: decode to TH_DCACHE_ISW using decoder 15
15618 // 209: }
15619 3, 11, // 213: case 0x3: {
15620 OPC_CheckPredicate, 178, 1, // 215: check predicate 178
15621 OPC_CheckField, 0, 12, 11, // 218: check Inst[11:0] == 0xb
15622 OPC_Decode, 195, 125, 15, // 222: decode to TH_DCACHE_CISW using decoder 15
15623 // 222: }
15624 4, 11, // 226: case 0x4: {
15625 OPC_CheckPredicate, 178, 1, // 228: check predicate 178
15626 OPC_CheckField, 0, 12, 11, // 231: check Inst[11:0] == 0xb
15627 OPC_Decode, 201, 125, 15, // 235: decode to TH_DCACHE_CVAL1 using decoder 15
15628 // 235: }
15629 5, 11, // 239: case 0x5: {
15630 OPC_CheckPredicate, 178, 1, // 241: check predicate 178
15631 OPC_CheckField, 0, 12, 11, // 244: check Inst[11:0] == 0xb
15632 OPC_Decode, 200, 125, 15, // 248: decode to TH_DCACHE_CVA using decoder 15
15633 // 248: }
15634 6, 11, // 252: case 0x6: {
15635 OPC_CheckPredicate, 178, 1, // 254: check predicate 178
15636 OPC_CheckField, 0, 12, 11, // 257: check Inst[11:0] == 0xb
15637 OPC_Decode, 205, 125, 15, // 261: decode to TH_DCACHE_IVA using decoder 15
15638 // 261: }
15639 7, 11, // 265: case 0x7: {
15640 OPC_CheckPredicate, 178, 1, // 267: check predicate 178
15641 OPC_CheckField, 0, 12, 11, // 270: check Inst[11:0] == 0xb
15642 OPC_Decode, 196, 125, 15, // 274: decode to TH_DCACHE_CIVA using decoder 15
15643 // 274: }
15644 8, 11, // 278: case 0x8: {
15645 OPC_CheckPredicate, 178, 1, // 280: check predicate 178
15646 OPC_CheckField, 0, 12, 11, // 283: check Inst[11:0] == 0xb
15647 OPC_Decode, 198, 125, 15, // 287: decode to TH_DCACHE_CPAL1 using decoder 15
15648 // 287: }
15649 9, 11, // 291: case 0x9: {
15650 OPC_CheckPredicate, 178, 1, // 293: check predicate 178
15651 OPC_CheckField, 0, 12, 11, // 296: check Inst[11:0] == 0xb
15652 OPC_Decode, 197, 125, 15, // 300: decode to TH_DCACHE_CPA using decoder 15
15653 // 300: }
15654 10, 11, // 304: case 0xa: {
15655 OPC_CheckPredicate, 178, 1, // 306: check predicate 178
15656 OPC_CheckField, 0, 12, 11, // 309: check Inst[11:0] == 0xb
15657 OPC_Decode, 203, 125, 15, // 313: decode to TH_DCACHE_IPA using decoder 15
15658 // 313: }
15659 11, 11, // 317: case 0xb: {
15660 OPC_CheckPredicate, 178, 1, // 319: check predicate 178
15661 OPC_CheckField, 0, 12, 11, // 322: check Inst[11:0] == 0xb
15662 OPC_Decode, 194, 125, 15, // 326: decode to TH_DCACHE_CIPA using decoder 15
15663 // 326: }
15664 16, 11, // 330: case 0x10: {
15665 OPC_CheckPredicate, 178, 1, // 332: check predicate 178
15666 OPC_CheckField, 0, 12, 11, // 335: check Inst[11:0] == 0xb
15667 OPC_Decode, 221, 125, 15, // 339: decode to TH_ICACHE_IVA using decoder 15
15668 // 339: }
15669 24, 0, // 343: case 0x18: {
15670 OPC_CheckPredicate, 178, 1, // 345: check predicate 178
15671 OPC_CheckField, 0, 12, 11, // 348: check Inst[11:0] == 0xb
15672 OPC_Decode, 220, 125, 15, // 352: decode to TH_ICACHE_IPA using decoder 15
15673 // 352: }
15674 // 352: } // switch Inst[24:20]
15675 // 352: }
15676 2, 0, // 356: case 0x2: {
15677 OPC_CheckPredicate, 179, 1, // 358: check predicate 179
15678 OPC_CheckField, 0, 12, 11, // 361: check Inst[11:0] == 0xb
15679 OPC_Decode, 143, 126, 156, 1, // 365: decode to TH_SFENCE_VMAS using decoder 156
15680 // 365: }
15681 // 365: } // switch Inst[31:25]
15682 // 365: }
15683 1, 134, 2, // 370: case 0x1: {
15684 OPC_SwitchField, 27, 5, // 373: switch Inst[31:27] {
15685 0, 12, // 376: case 0x0: {
15686 OPC_CheckPredicate, 180, 1, // 378: check predicate 180
15687 OPC_CheckField, 0, 7, 11, // 381: check Inst[6:0] == 0xb
15688 OPC_Decode, 191, 125, 150, 2, // 385: decode to TH_ADDSL using decoder 278
15689 // 385: }
15690 2, 33, // 390: case 0x2: {
15691 OPC_SwitchField, 26, 1, // 392: switch Inst[26] {
15692 0, 11, // 395: case 0x0: {
15693 OPC_CheckPredicate, 181, 1, // 397: check predicate 181
15694 OPC_CheckField, 0, 7, 11, // 400: check Inst[6:0] == 0xb
15695 OPC_Decode, 149, 126, 16, // 404: decode to TH_SRRI using decoder 16
15696 // 404: }
15697 1, 0, // 408: case 0x1: {
15698 OPC_CheckPredicate, 182, 1, // 410: check predicate 182
15699 OPC_CheckField, 25, 1, 0, // 413: check Inst[25] == 0x0
15700 OPC_CheckField, 0, 7, 11, // 417: check Inst[6:0] == 0xb
15701 OPC_Decode, 150, 126, 21, // 421: decode to TH_SRRIW using decoder 21
15702 // 421: }
15703 // 421: } // switch Inst[26]
15704 // 421: }
15705 4, 55, // 425: case 0x4: {
15706 OPC_SwitchField, 25, 2, // 427: switch Inst[26:25] {
15707 0, 11, // 430: case 0x0: {
15708 OPC_CheckPredicate, 183, 1, // 432: check predicate 183
15709 OPC_CheckField, 0, 7, 11, // 435: check Inst[6:0] == 0xb
15710 OPC_Decode, 128, 126, 61, // 439: decode to TH_MULA using decoder 61
15711 // 439: }
15712 1, 11, // 443: case 0x1: {
15713 OPC_CheckPredicate, 183, 1, // 445: check predicate 183
15714 OPC_CheckField, 0, 7, 11, // 448: check Inst[6:0] == 0xb
15715 OPC_Decode, 131, 126, 61, // 452: decode to TH_MULS using decoder 61
15716 // 452: }
15717 2, 11, // 456: case 0x2: {
15718 OPC_CheckPredicate, 184, 1, // 458: check predicate 184
15719 OPC_CheckField, 0, 7, 11, // 461: check Inst[6:0] == 0xb
15720 OPC_Decode, 130, 126, 61, // 465: decode to TH_MULAW using decoder 61
15721 // 465: }
15722 3, 0, // 469: case 0x3: {
15723 OPC_CheckPredicate, 184, 1, // 471: check predicate 184
15724 OPC_CheckField, 0, 7, 11, // 474: check Inst[6:0] == 0xb
15725 OPC_Decode, 133, 126, 61, // 478: decode to TH_MULSW using decoder 61
15726 // 478: }
15727 // 478: } // switch Inst[26:25]
15728 // 478: }
15729 5, 29, // 482: case 0x5: {
15730 OPC_SwitchField, 25, 2, // 484: switch Inst[26:25] {
15731 0, 11, // 487: case 0x0: {
15732 OPC_CheckPredicate, 183, 1, // 489: check predicate 183
15733 OPC_CheckField, 0, 7, 11, // 492: check Inst[6:0] == 0xb
15734 OPC_Decode, 129, 126, 61, // 496: decode to TH_MULAH using decoder 61
15735 // 496: }
15736 1, 0, // 500: case 0x1: {
15737 OPC_CheckPredicate, 183, 1, // 502: check predicate 183
15738 OPC_CheckField, 0, 7, 11, // 505: check Inst[6:0] == 0xb
15739 OPC_Decode, 132, 126, 61, // 509: decode to TH_MULSH using decoder 61
15740 // 509: }
15741 // 509: } // switch Inst[26:25]
15742 // 509: }
15743 8, 29, // 513: case 0x8: {
15744 OPC_SwitchField, 25, 2, // 515: switch Inst[26:25] {
15745 0, 11, // 518: case 0x0: {
15746 OPC_CheckPredicate, 185, 1, // 520: check predicate 185
15747 OPC_CheckField, 0, 7, 11, // 523: check Inst[6:0] == 0xb
15748 OPC_Decode, 134, 126, 61, // 527: decode to TH_MVEQZ using decoder 61
15749 // 527: }
15750 1, 0, // 531: case 0x1: {
15751 OPC_CheckPredicate, 185, 1, // 533: check predicate 185
15752 OPC_CheckField, 0, 7, 11, // 536: check Inst[6:0] == 0xb
15753 OPC_Decode, 135, 126, 61, // 540: decode to TH_MVNEZ using decoder 61
15754 // 540: }
15755 // 540: } // switch Inst[26:25]
15756 // 540: }
15757 16, 55, // 544: case 0x10: {
15758 OPC_SwitchField, 20, 7, // 546: switch Inst[26:20] {
15759 0, 11, // 549: case 0x0: {
15760 OPC_CheckPredicate, 181, 1, // 551: check predicate 181
15761 OPC_CheckField, 0, 7, 11, // 554: check Inst[6:0] == 0xb
15762 OPC_Decode, 164, 126, 17, // 558: decode to TH_TSTNBZ using decoder 17
15763 // 558: }
15764 32, 11, // 562: case 0x20: {
15765 OPC_CheckPredicate, 181, 1, // 564: check predicate 181
15766 OPC_CheckField, 0, 7, 11, // 567: check Inst[6:0] == 0xb
15767 OPC_Decode, 136, 126, 17, // 571: decode to TH_REV using decoder 17
15768 // 571: }
15769 64, 11, // 575: case 0x40: {
15770 OPC_CheckPredicate, 181, 1, // 577: check predicate 181
15771 OPC_CheckField, 0, 7, 11, // 580: check Inst[6:0] == 0xb
15772 OPC_Decode, 208, 125, 17, // 584: decode to TH_FF0 using decoder 17
15773 // 584: }
15774 96, 0, // 588: case 0x60: {
15775 OPC_CheckPredicate, 181, 1, // 590: check predicate 181
15776 OPC_CheckField, 0, 7, 11, // 593: check Inst[6:0] == 0xb
15777 OPC_Decode, 209, 125, 17, // 597: decode to TH_FF1 using decoder 17
15778 // 597: }
15779 // 597: } // switch Inst[26:20]
15780 // 597: }
15781 17, 15, // 601: case 0x11: {
15782 OPC_CheckPredicate, 186, 1, // 603: check predicate 186
15783 OPC_CheckField, 26, 1, 0, // 606: check Inst[26] == 0x0
15784 OPC_CheckField, 0, 7, 11, // 610: check Inst[6:0] == 0xb
15785 OPC_Decode, 163, 126, 16, // 614: decode to TH_TST using decoder 16
15786 // 614: }
15787 18, 0, // 618: case 0x12: {
15788 OPC_CheckPredicate, 182, 1, // 620: check predicate 182
15789 OPC_CheckField, 20, 7, 0, // 623: check Inst[26:20] == 0x0
15790 OPC_CheckField, 0, 7, 11, // 627: check Inst[6:0] == 0xb
15791 OPC_Decode, 137, 126, 17, // 631: decode to TH_REVW using decoder 17
15792 // 631: }
15793 // 631: } // switch Inst[31:27]
15794 // 631: }
15795 2, 12, // 635: case 0x2: {
15796 OPC_CheckPredicate, 181, 1, // 637: check predicate 181
15797 OPC_CheckField, 0, 7, 11, // 640: check Inst[6:0] == 0xb
15798 OPC_Decode, 206, 125, 213, 1, // 644: decode to TH_EXT using decoder 213
15799 // 644: }
15800 3, 12, // 649: case 0x3: {
15801 OPC_CheckPredicate, 181, 1, // 651: check predicate 181
15802 OPC_CheckField, 0, 7, 11, // 654: check Inst[6:0] == 0xb
15803 OPC_Decode, 207, 125, 213, 1, // 658: decode to TH_EXTU using decoder 213
15804 // 658: }
15805 4, 181, 3, // 663: case 0x4: {
15806 OPC_SwitchField, 27, 5, // 666: switch Inst[31:27] {
15807 0, 12, // 669: case 0x0: {
15808 OPC_CheckPredicate, 187, 1, // 671: check predicate 187
15809 OPC_CheckField, 0, 7, 11, // 674: check Inst[6:0] == 0xb
15810 OPC_Decode, 236, 125, 150, 2, // 678: decode to TH_LRB using decoder 278
15811 // 678: }
15812 1, 12, // 683: case 0x1: {
15813 OPC_CheckPredicate, 187, 1, // 685: check predicate 187
15814 OPC_CheckField, 0, 7, 11, // 688: check Inst[6:0] == 0xb
15815 OPC_Decode, 226, 125, 151, 2, // 692: decode to TH_LBIB using decoder 279
15816 // 692: }
15817 2, 12, // 697: case 0x2: {
15818 OPC_CheckPredicate, 187, 1, // 699: check predicate 187
15819 OPC_CheckField, 0, 7, 11, // 702: check Inst[6:0] == 0xb
15820 OPC_Decode, 243, 125, 150, 2, // 706: decode to TH_LURB using decoder 278
15821 // 706: }
15822 3, 12, // 711: case 0x3: {
15823 OPC_CheckPredicate, 187, 1, // 713: check predicate 187
15824 OPC_CheckField, 0, 7, 11, // 716: check Inst[6:0] == 0xb
15825 OPC_Decode, 225, 125, 151, 2, // 720: decode to TH_LBIA using decoder 279
15826 // 720: }
15827 4, 12, // 725: case 0x4: {
15828 OPC_CheckPredicate, 187, 1, // 727: check predicate 187
15829 OPC_CheckField, 0, 7, 11, // 730: check Inst[6:0] == 0xb
15830 OPC_Decode, 239, 125, 150, 2, // 734: decode to TH_LRH using decoder 278
15831 // 734: }
15832 5, 12, // 739: case 0x5: {
15833 OPC_CheckPredicate, 187, 1, // 741: check predicate 187
15834 OPC_CheckField, 0, 7, 11, // 744: check Inst[6:0] == 0xb
15835 OPC_Decode, 233, 125, 151, 2, // 748: decode to TH_LHIB using decoder 279
15836 // 748: }
15837 6, 12, // 753: case 0x6: {
15838 OPC_CheckPredicate, 187, 1, // 755: check predicate 187
15839 OPC_CheckField, 0, 7, 11, // 758: check Inst[6:0] == 0xb
15840 OPC_Decode, 246, 125, 150, 2, // 762: decode to TH_LURH using decoder 278
15841 // 762: }
15842 7, 12, // 767: case 0x7: {
15843 OPC_CheckPredicate, 187, 1, // 769: check predicate 187
15844 OPC_CheckField, 0, 7, 11, // 772: check Inst[6:0] == 0xb
15845 OPC_Decode, 232, 125, 151, 2, // 776: decode to TH_LHIA using decoder 279
15846 // 776: }
15847 8, 12, // 781: case 0x8: {
15848 OPC_CheckPredicate, 187, 1, // 783: check predicate 187
15849 OPC_CheckField, 0, 7, 11, // 786: check Inst[6:0] == 0xb
15850 OPC_Decode, 241, 125, 150, 2, // 790: decode to TH_LRW using decoder 278
15851 // 790: }
15852 9, 12, // 795: case 0x9: {
15853 OPC_CheckPredicate, 187, 1, // 797: check predicate 187
15854 OPC_CheckField, 0, 7, 11, // 800: check Inst[6:0] == 0xb
15855 OPC_Decode, 252, 125, 151, 2, // 804: decode to TH_LWIB using decoder 279
15856 // 804: }
15857 10, 12, // 809: case 0xa: {
15858 OPC_CheckPredicate, 187, 1, // 811: check predicate 187
15859 OPC_CheckField, 0, 7, 11, // 814: check Inst[6:0] == 0xb
15860 OPC_Decode, 248, 125, 150, 2, // 818: decode to TH_LURW using decoder 278
15861 // 818: }
15862 11, 12, // 823: case 0xb: {
15863 OPC_CheckPredicate, 187, 1, // 825: check predicate 187
15864 OPC_CheckField, 0, 7, 11, // 828: check Inst[6:0] == 0xb
15865 OPC_Decode, 251, 125, 151, 2, // 832: decode to TH_LWIA using decoder 279
15866 // 832: }
15867 12, 12, // 837: case 0xc: {
15868 OPC_CheckPredicate, 188, 1, // 839: check predicate 188
15869 OPC_CheckField, 0, 7, 11, // 842: check Inst[6:0] == 0xb
15870 OPC_Decode, 238, 125, 150, 2, // 846: decode to TH_LRD using decoder 278
15871 // 846: }
15872 13, 12, // 851: case 0xd: {
15873 OPC_CheckPredicate, 188, 1, // 853: check predicate 188
15874 OPC_CheckField, 0, 7, 11, // 856: check Inst[6:0] == 0xb
15875 OPC_Decode, 231, 125, 151, 2, // 860: decode to TH_LDIB using decoder 279
15876 // 860: }
15877 14, 12, // 865: case 0xe: {
15878 OPC_CheckPredicate, 188, 1, // 867: check predicate 188
15879 OPC_CheckField, 0, 7, 11, // 870: check Inst[6:0] == 0xb
15880 OPC_Decode, 245, 125, 150, 2, // 874: decode to TH_LURD using decoder 278
15881 // 874: }
15882 15, 12, // 879: case 0xf: {
15883 OPC_CheckPredicate, 188, 1, // 881: check predicate 188
15884 OPC_CheckField, 0, 7, 11, // 884: check Inst[6:0] == 0xb
15885 OPC_Decode, 230, 125, 151, 2, // 888: decode to TH_LDIA using decoder 279
15886 // 888: }
15887 16, 12, // 893: case 0x10: {
15888 OPC_CheckPredicate, 187, 1, // 895: check predicate 187
15889 OPC_CheckField, 0, 7, 11, // 898: check Inst[6:0] == 0xb
15890 OPC_Decode, 237, 125, 150, 2, // 902: decode to TH_LRBU using decoder 278
15891 // 902: }
15892 17, 12, // 907: case 0x11: {
15893 OPC_CheckPredicate, 187, 1, // 909: check predicate 187
15894 OPC_CheckField, 0, 7, 11, // 912: check Inst[6:0] == 0xb
15895 OPC_Decode, 228, 125, 151, 2, // 916: decode to TH_LBUIB using decoder 279
15896 // 916: }
15897 18, 12, // 921: case 0x12: {
15898 OPC_CheckPredicate, 187, 1, // 923: check predicate 187
15899 OPC_CheckField, 0, 7, 11, // 926: check Inst[6:0] == 0xb
15900 OPC_Decode, 244, 125, 150, 2, // 930: decode to TH_LURBU using decoder 278
15901 // 930: }
15902 19, 12, // 935: case 0x13: {
15903 OPC_CheckPredicate, 187, 1, // 937: check predicate 187
15904 OPC_CheckField, 0, 7, 11, // 940: check Inst[6:0] == 0xb
15905 OPC_Decode, 227, 125, 151, 2, // 944: decode to TH_LBUIA using decoder 279
15906 // 944: }
15907 20, 12, // 949: case 0x14: {
15908 OPC_CheckPredicate, 187, 1, // 951: check predicate 187
15909 OPC_CheckField, 0, 7, 11, // 954: check Inst[6:0] == 0xb
15910 OPC_Decode, 240, 125, 150, 2, // 958: decode to TH_LRHU using decoder 278
15911 // 958: }
15912 21, 12, // 963: case 0x15: {
15913 OPC_CheckPredicate, 187, 1, // 965: check predicate 187
15914 OPC_CheckField, 0, 7, 11, // 968: check Inst[6:0] == 0xb
15915 OPC_Decode, 235, 125, 151, 2, // 972: decode to TH_LHUIB using decoder 279
15916 // 972: }
15917 22, 12, // 977: case 0x16: {
15918 OPC_CheckPredicate, 187, 1, // 979: check predicate 187
15919 OPC_CheckField, 0, 7, 11, // 982: check Inst[6:0] == 0xb
15920 OPC_Decode, 247, 125, 150, 2, // 986: decode to TH_LURHU using decoder 278
15921 // 986: }
15922 23, 12, // 991: case 0x17: {
15923 OPC_CheckPredicate, 187, 1, // 993: check predicate 187
15924 OPC_CheckField, 0, 7, 11, // 996: check Inst[6:0] == 0xb
15925 OPC_Decode, 234, 125, 151, 2, // 1000: decode to TH_LHUIA using decoder 279
15926 // 1000: }
15927 24, 12, // 1005: case 0x18: {
15928 OPC_CheckPredicate, 188, 1, // 1007: check predicate 188
15929 OPC_CheckField, 0, 7, 11, // 1010: check Inst[6:0] == 0xb
15930 OPC_Decode, 242, 125, 150, 2, // 1014: decode to TH_LRWU using decoder 278
15931 // 1014: }
15932 25, 12, // 1019: case 0x19: {
15933 OPC_CheckPredicate, 188, 1, // 1021: check predicate 188
15934 OPC_CheckField, 0, 7, 11, // 1024: check Inst[6:0] == 0xb
15935 OPC_Decode, 255, 125, 151, 2, // 1028: decode to TH_LWUIB using decoder 279
15936 // 1028: }
15937 26, 12, // 1033: case 0x1a: {
15938 OPC_CheckPredicate, 188, 1, // 1035: check predicate 188
15939 OPC_CheckField, 0, 7, 11, // 1038: check Inst[6:0] == 0xb
15940 OPC_Decode, 249, 125, 150, 2, // 1042: decode to TH_LURWU using decoder 278
15941 // 1042: }
15942 27, 12, // 1047: case 0x1b: {
15943 OPC_CheckPredicate, 188, 1, // 1049: check predicate 188
15944 OPC_CheckField, 0, 7, 11, // 1052: check Inst[6:0] == 0xb
15945 OPC_Decode, 254, 125, 151, 2, // 1056: decode to TH_LWUIA using decoder 279
15946 // 1056: }
15947 28, 12, // 1061: case 0x1c: {
15948 OPC_CheckPredicate, 189, 1, // 1063: check predicate 189
15949 OPC_CheckField, 0, 7, 11, // 1066: check Inst[6:0] == 0xb
15950 OPC_Decode, 250, 125, 152, 2, // 1070: decode to TH_LWD using decoder 280
15951 // 1070: }
15952 30, 12, // 1075: case 0x1e: {
15953 OPC_CheckPredicate, 189, 1, // 1077: check predicate 189
15954 OPC_CheckField, 0, 7, 11, // 1080: check Inst[6:0] == 0xb
15955 OPC_Decode, 253, 125, 152, 2, // 1084: decode to TH_LWUD using decoder 280
15956 // 1084: }
15957 31, 0, // 1089: case 0x1f: {
15958 OPC_CheckPredicate, 190, 1, // 1091: check predicate 190
15959 OPC_CheckField, 0, 7, 11, // 1094: check Inst[6:0] == 0xb
15960 OPC_Decode, 229, 125, 153, 2, // 1098: decode to TH_LDD using decoder 281
15961 // 1098: }
15962 // 1098: } // switch Inst[31:27]
15963 // 1098: }
15964 5, 255, 1, // 1103: case 0x5: {
15965 OPC_SwitchField, 27, 5, // 1106: switch Inst[31:27] {
15966 0, 12, // 1109: case 0x0: {
15967 OPC_CheckPredicate, 187, 1, // 1111: check predicate 187
15968 OPC_CheckField, 0, 7, 11, // 1114: check Inst[6:0] == 0xb
15969 OPC_Decode, 146, 126, 150, 2, // 1118: decode to TH_SRB using decoder 278
15970 // 1118: }
15971 1, 12, // 1123: case 0x1: {
15972 OPC_CheckPredicate, 187, 1, // 1125: check predicate 187
15973 OPC_CheckField, 0, 7, 11, // 1128: check Inst[6:0] == 0xb
15974 OPC_Decode, 139, 126, 154, 2, // 1132: decode to TH_SBIB using decoder 282
15975 // 1132: }
15976 2, 12, // 1137: case 0x2: {
15977 OPC_CheckPredicate, 187, 1, // 1139: check predicate 187
15978 OPC_CheckField, 0, 7, 11, // 1142: check Inst[6:0] == 0xb
15979 OPC_Decode, 152, 126, 150, 2, // 1146: decode to TH_SURB using decoder 278
15980 // 1146: }
15981 3, 12, // 1151: case 0x3: {
15982 OPC_CheckPredicate, 187, 1, // 1153: check predicate 187
15983 OPC_CheckField, 0, 7, 11, // 1156: check Inst[6:0] == 0xb
15984 OPC_Decode, 138, 126, 154, 2, // 1160: decode to TH_SBIA using decoder 282
15985 // 1160: }
15986 4, 12, // 1165: case 0x4: {
15987 OPC_CheckPredicate, 187, 1, // 1167: check predicate 187
15988 OPC_CheckField, 0, 7, 11, // 1170: check Inst[6:0] == 0xb
15989 OPC_Decode, 148, 126, 150, 2, // 1174: decode to TH_SRH using decoder 278
15990 // 1174: }
15991 5, 12, // 1179: case 0x5: {
15992 OPC_CheckPredicate, 187, 1, // 1181: check predicate 187
15993 OPC_CheckField, 0, 7, 11, // 1184: check Inst[6:0] == 0xb
15994 OPC_Decode, 145, 126, 154, 2, // 1188: decode to TH_SHIB using decoder 282
15995 // 1188: }
15996 6, 12, // 1193: case 0x6: {
15997 OPC_CheckPredicate, 187, 1, // 1195: check predicate 187
15998 OPC_CheckField, 0, 7, 11, // 1198: check Inst[6:0] == 0xb
15999 OPC_Decode, 154, 126, 150, 2, // 1202: decode to TH_SURH using decoder 278
16000 // 1202: }
16001 7, 12, // 1207: case 0x7: {
16002 OPC_CheckPredicate, 187, 1, // 1209: check predicate 187
16003 OPC_CheckField, 0, 7, 11, // 1212: check Inst[6:0] == 0xb
16004 OPC_Decode, 144, 126, 154, 2, // 1216: decode to TH_SHIA using decoder 282
16005 // 1216: }
16006 8, 12, // 1221: case 0x8: {
16007 OPC_CheckPredicate, 187, 1, // 1223: check predicate 187
16008 OPC_CheckField, 0, 7, 11, // 1226: check Inst[6:0] == 0xb
16009 OPC_Decode, 151, 126, 150, 2, // 1230: decode to TH_SRW using decoder 278
16010 // 1230: }
16011 9, 12, // 1235: case 0x9: {
16012 OPC_CheckPredicate, 187, 1, // 1237: check predicate 187
16013 OPC_CheckField, 0, 7, 11, // 1240: check Inst[6:0] == 0xb
16014 OPC_Decode, 158, 126, 154, 2, // 1244: decode to TH_SWIB using decoder 282
16015 // 1244: }
16016 10, 12, // 1249: case 0xa: {
16017 OPC_CheckPredicate, 187, 1, // 1251: check predicate 187
16018 OPC_CheckField, 0, 7, 11, // 1254: check Inst[6:0] == 0xb
16019 OPC_Decode, 155, 126, 150, 2, // 1258: decode to TH_SURW using decoder 278
16020 // 1258: }
16021 11, 12, // 1263: case 0xb: {
16022 OPC_CheckPredicate, 187, 1, // 1265: check predicate 187
16023 OPC_CheckField, 0, 7, 11, // 1268: check Inst[6:0] == 0xb
16024 OPC_Decode, 157, 126, 154, 2, // 1272: decode to TH_SWIA using decoder 282
16025 // 1272: }
16026 12, 12, // 1277: case 0xc: {
16027 OPC_CheckPredicate, 188, 1, // 1279: check predicate 188
16028 OPC_CheckField, 0, 7, 11, // 1282: check Inst[6:0] == 0xb
16029 OPC_Decode, 147, 126, 150, 2, // 1286: decode to TH_SRD using decoder 278
16030 // 1286: }
16031 13, 12, // 1291: case 0xd: {
16032 OPC_CheckPredicate, 188, 1, // 1293: check predicate 188
16033 OPC_CheckField, 0, 7, 11, // 1296: check Inst[6:0] == 0xb
16034 OPC_Decode, 142, 126, 154, 2, // 1300: decode to TH_SDIB using decoder 282
16035 // 1300: }
16036 14, 12, // 1305: case 0xe: {
16037 OPC_CheckPredicate, 188, 1, // 1307: check predicate 188
16038 OPC_CheckField, 0, 7, 11, // 1310: check Inst[6:0] == 0xb
16039 OPC_Decode, 153, 126, 150, 2, // 1314: decode to TH_SURD using decoder 278
16040 // 1314: }
16041 15, 12, // 1319: case 0xf: {
16042 OPC_CheckPredicate, 188, 1, // 1321: check predicate 188
16043 OPC_CheckField, 0, 7, 11, // 1324: check Inst[6:0] == 0xb
16044 OPC_Decode, 141, 126, 154, 2, // 1328: decode to TH_SDIA using decoder 282
16045 // 1328: }
16046 28, 12, // 1333: case 0x1c: {
16047 OPC_CheckPredicate, 189, 1, // 1335: check predicate 189
16048 OPC_CheckField, 0, 7, 11, // 1338: check Inst[6:0] == 0xb
16049 OPC_Decode, 156, 126, 155, 2, // 1342: decode to TH_SWD using decoder 283
16050 // 1342: }
16051 31, 0, // 1347: case 0x1f: {
16052 OPC_CheckPredicate, 190, 1, // 1349: check predicate 190
16053 OPC_CheckField, 0, 7, 11, // 1352: check Inst[6:0] == 0xb
16054 OPC_Decode, 140, 126, 156, 2, // 1356: decode to TH_SDD using decoder 284
16055 // 1356: }
16056 // 1356: } // switch Inst[31:27]
16057 // 1356: }
16058 6, 173, 1, // 1361: case 0x6: {
16059 OPC_SwitchField, 27, 5, // 1364: switch Inst[31:27] {
16060 8, 12, // 1367: case 0x8: {
16061 OPC_CheckPredicate, 191, 1, // 1369: check predicate 191
16062 OPC_CheckField, 0, 7, 11, // 1372: check Inst[6:0] == 0xb
16063 OPC_Decode, 211, 125, 157, 2, // 1376: decode to TH_FLRW using decoder 285
16064 // 1376: }
16065 10, 12, // 1381: case 0xa: {
16066 OPC_CheckPredicate, 192, 1, // 1383: check predicate 192
16067 OPC_CheckField, 0, 7, 11, // 1386: check Inst[6:0] == 0xb
16068 OPC_Decode, 213, 125, 157, 2, // 1390: decode to TH_FLURW using decoder 285
16069 // 1390: }
16070 12, 12, // 1395: case 0xc: {
16071 OPC_CheckPredicate, 193, 1, // 1397: check predicate 193
16072 OPC_CheckField, 0, 7, 11, // 1400: check Inst[6:0] == 0xb
16073 OPC_Decode, 210, 125, 158, 2, // 1404: decode to TH_FLRD using decoder 286
16074 // 1404: }
16075 14, 12, // 1409: case 0xe: {
16076 OPC_CheckPredicate, 194, 1, // 1411: check predicate 194
16077 OPC_CheckField, 0, 7, 11, // 1414: check Inst[6:0] == 0xb
16078 OPC_Decode, 212, 125, 158, 2, // 1418: decode to TH_FLURD using decoder 286
16079 // 1418: }
16080 16, 30, // 1423: case 0x10: {
16081 OPC_SwitchField, 26, 1, // 1425: switch Inst[26] {
16082 0, 11, // 1428: case 0x0: {
16083 OPC_CheckPredicate, 195, 1, // 1430: check predicate 195
16084 OPC_CheckField, 0, 7, 11, // 1433: check Inst[6:0] == 0xb
16085 OPC_Decode, 170, 126, 125, // 1437: decode to TH_VMAQA_VV using decoder 125
16086 // 1437: }
16087 1, 0, // 1441: case 0x1: {
16088 OPC_CheckPredicate, 195, 1, // 1443: check predicate 195
16089 OPC_CheckField, 0, 7, 11, // 1446: check Inst[6:0] == 0xb
16090 OPC_Decode, 171, 126, 149, 1, // 1450: decode to TH_VMAQA_VX using decoder 149
16091 // 1450: }
16092 // 1450: } // switch Inst[26]
16093 // 1450: }
16094 17, 30, // 1455: case 0x11: {
16095 OPC_SwitchField, 26, 1, // 1457: switch Inst[26] {
16096 0, 11, // 1460: case 0x0: {
16097 OPC_CheckPredicate, 195, 1, // 1462: check predicate 195
16098 OPC_CheckField, 0, 7, 11, // 1465: check Inst[6:0] == 0xb
16099 OPC_Decode, 168, 126, 125, // 1469: decode to TH_VMAQAU_VV using decoder 125
16100 // 1469: }
16101 1, 0, // 1473: case 0x1: {
16102 OPC_CheckPredicate, 195, 1, // 1475: check predicate 195
16103 OPC_CheckField, 0, 7, 11, // 1478: check Inst[6:0] == 0xb
16104 OPC_Decode, 169, 126, 149, 1, // 1482: decode to TH_VMAQAU_VX using decoder 149
16105 // 1482: }
16106 // 1482: } // switch Inst[26]
16107 // 1482: }
16108 18, 30, // 1487: case 0x12: {
16109 OPC_SwitchField, 26, 1, // 1489: switch Inst[26] {
16110 0, 11, // 1492: case 0x0: {
16111 OPC_CheckPredicate, 195, 1, // 1494: check predicate 195
16112 OPC_CheckField, 0, 7, 11, // 1497: check Inst[6:0] == 0xb
16113 OPC_Decode, 165, 126, 125, // 1501: decode to TH_VMAQASU_VV using decoder 125
16114 // 1501: }
16115 1, 0, // 1505: case 0x1: {
16116 OPC_CheckPredicate, 195, 1, // 1507: check predicate 195
16117 OPC_CheckField, 0, 7, 11, // 1510: check Inst[6:0] == 0xb
16118 OPC_Decode, 166, 126, 149, 1, // 1514: decode to TH_VMAQASU_VX using decoder 149
16119 // 1514: }
16120 // 1514: } // switch Inst[26]
16121 // 1514: }
16122 19, 0, // 1519: case 0x13: {
16123 OPC_CheckPredicate, 195, 1, // 1521: check predicate 195
16124 OPC_CheckField, 26, 1, 1, // 1524: check Inst[26] == 0x1
16125 OPC_CheckField, 0, 7, 11, // 1528: check Inst[6:0] == 0xb
16126 OPC_Decode, 167, 126, 149, 1, // 1532: decode to TH_VMAQAUS_VX using decoder 149
16127 // 1532: }
16128 // 1532: } // switch Inst[31:27]
16129 // 1532: }
16130 7, 0, // 1537: case 0x7: {
16131 OPC_SwitchField, 27, 5, // 1539: switch Inst[31:27] {
16132 8, 12, // 1542: case 0x8: {
16133 OPC_CheckPredicate, 191, 1, // 1544: check predicate 191
16134 OPC_CheckField, 0, 7, 11, // 1547: check Inst[6:0] == 0xb
16135 OPC_Decode, 215, 125, 157, 2, // 1551: decode to TH_FSRW using decoder 285
16136 // 1551: }
16137 10, 12, // 1556: case 0xa: {
16138 OPC_CheckPredicate, 192, 1, // 1558: check predicate 192
16139 OPC_CheckField, 0, 7, 11, // 1561: check Inst[6:0] == 0xb
16140 OPC_Decode, 217, 125, 157, 2, // 1565: decode to TH_FSURW using decoder 285
16141 // 1565: }
16142 12, 12, // 1570: case 0xc: {
16143 OPC_CheckPredicate, 193, 1, // 1572: check predicate 193
16144 OPC_CheckField, 0, 7, 11, // 1575: check Inst[6:0] == 0xb
16145 OPC_Decode, 214, 125, 158, 2, // 1579: decode to TH_FSRD using decoder 286
16146 // 1579: }
16147 14, 0, // 1584: case 0xe: {
16148 OPC_CheckPredicate, 194, 1, // 1586: check predicate 194
16149 OPC_CheckField, 0, 7, 11, // 1589: check Inst[6:0] == 0xb
16150 OPC_Decode, 216, 125, 158, 2, // 1593: decode to TH_FSURD using decoder 286
16151 // 1593: }
16152 // 1593: } // switch Inst[31:27]
16153 // 1593: }
16154 // 1593: } // switch Inst[14:12]
16155};
16156static const uint8_t DecoderTableXqci32[1203] = {
16157 32, // 0: BitWidth 32
16158 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
16159 11, 143, 4, // 4: case 0xb: {
16160 OPC_SwitchField, 12, 3, // 7: switch Inst[14:12] {
16161 0, 22, // 10: case 0x0: {
16162 OPC_SwitchField, 31, 1, // 12: switch Inst[31] {
16163 0, 8, // 15: case 0x0: {
16164 OPC_CheckPredicate, 196, 1, // 17: check predicate 196
16165 OPC_Decode, 196, 123, 159, 2, // 20: decode to QC_WRAPI using decoder 287
16166 // 20: }
16167 1, 0, // 25: case 0x1: {
16168 OPC_CheckPredicate, 14, // 27: check predicate 14
16169 OPC_Decode, 130, 123, 160, 2, // 29: decode to QC_INSBRI using decoder 288
16170 // 29: }
16171 // 29: } // switch Inst[31]
16172 // 29: }
16173 1, 30, // 34: case 0x1: {
16174 OPC_SwitchField, 30, 2, // 36: switch Inst[31:30] {
16175 0, 7, // 39: case 0x0: {
16176 OPC_CheckPredicate, 14, // 41: check predicate 14
16177 OPC_Decode, 254, 122, 161, 2, // 43: decode to QC_INSBI using decoder 289
16178 // 43: }
16179 1, 7, // 48: case 0x1: {
16180 OPC_CheckPredicate, 14, // 50: check predicate 14
16181 OPC_Decode, 251, 122, 162, 2, // 52: decode to QC_INSB using decoder 290
16182 // 52: }
16183 2, 0, // 57: case 0x2: {
16184 OPC_CheckPredicate, 14, // 59: check predicate 14
16185 OPC_Decode, 252, 122, 162, 2, // 61: decode to QC_INSBH using decoder 290
16186 // 61: }
16187 // 61: } // switch Inst[31:30]
16188 // 61: }
16189 2, 39, // 66: case 0x2: {
16190 OPC_SwitchField, 30, 2, // 68: switch Inst[31:30] {
16191 0, 7, // 71: case 0x0: {
16192 OPC_CheckPredicate, 14, // 73: check predicate 14
16193 OPC_Decode, 225, 122, 163, 2, // 75: decode to QC_EXTU using decoder 291
16194 // 75: }
16195 1, 7, // 80: case 0x1: {
16196 OPC_CheckPredicate, 14, // 82: check predicate 14
16197 OPC_Decode, 216, 122, 163, 2, // 84: decode to QC_EXT using decoder 291
16198 // 84: }
16199 2, 7, // 89: case 0x2: {
16200 OPC_CheckPredicate, 14, // 91: check predicate 14
16201 OPC_Decode, 221, 122, 164, 2, // 93: decode to QC_EXTDU using decoder 292
16202 // 93: }
16203 3, 0, // 98: case 0x3: {
16204 OPC_CheckPredicate, 14, // 100: check predicate 14
16205 OPC_Decode, 217, 122, 164, 2, // 102: decode to QC_EXTD using decoder 292
16206 // 102: }
16207 // 102: } // switch Inst[31:30]
16208 // 102: }
16209 3, 183, 2, // 107: case 0x3: {
16210 OPC_SwitchField, 30, 2, // 110: switch Inst[31:30] {
16211 0, 168, 2, // 113: case 0x0: {
16212 OPC_SwitchField, 25, 5, // 116: switch Inst[29:25] {
16213 0, 20, // 119: case 0x0: {
16214 OPC_Scope, 11, // 121: try {
16215 OPC_CheckField, 20, 5, 0, // 123: check Inst[24:20] == 0x0
16216 OPC_CheckPredicate, 14, // 127: check predicate 14
16217 OPC_Decode, 189, 122, 165, 2, // 129: decode to QC_COMPRESS2 using decoder 293
16218 // 129: } else try {
16219 OPC_CheckPredicate, 14, // 134: check predicate 14
16220 OPC_Decode, 129, 123, 166, 2, // 136: decode to QC_INSBR using decoder 294
16221 // 136: }
16222 // 136: }
16223 1, 20, // 141: case 0x1: {
16224 OPC_Scope, 11, // 143: try {
16225 OPC_CheckField, 20, 5, 0, // 145: check Inst[24:20] == 0x0
16226 OPC_CheckPredicate, 14, // 149: check predicate 14
16227 OPC_Decode, 190, 122, 165, 2, // 151: decode to QC_COMPRESS3 using decoder 293
16228 // 151: } else try {
16229 OPC_CheckPredicate, 14, // 156: check predicate 14
16230 OPC_Decode, 253, 122, 166, 2, // 158: decode to QC_INSBHR using decoder 294
16231 // 158: }
16232 // 158: }
16233 2, 20, // 163: case 0x2: {
16234 OPC_Scope, 11, // 165: try {
16235 OPC_CheckField, 20, 5, 0, // 167: check Inst[24:20] == 0x0
16236 OPC_CheckPredicate, 14, // 171: check predicate 14
16237 OPC_Decode, 214, 122, 165, 2, // 173: decode to QC_EXPAND2 using decoder 293
16238 // 173: } else try {
16239 OPC_CheckPredicate, 14, // 178: check predicate 14
16240 OPC_Decode, 255, 122, 166, 2, // 180: decode to QC_INSBPR using decoder 294
16241 // 180: }
16242 // 180: }
16243 3, 20, // 185: case 0x3: {
16244 OPC_Scope, 11, // 187: try {
16245 OPC_CheckField, 20, 5, 0, // 189: check Inst[24:20] == 0x0
16246 OPC_CheckPredicate, 14, // 193: check predicate 14
16247 OPC_Decode, 215, 122, 165, 2, // 195: decode to QC_EXPAND3 using decoder 293
16248 // 195: } else try {
16249 OPC_CheckPredicate, 14, // 200: check predicate 14
16250 OPC_Decode, 128, 123, 166, 2, // 202: decode to QC_INSBPRH using decoder 294
16251 // 202: }
16252 // 202: }
16253 4, 20, // 207: case 0x4: {
16254 OPC_Scope, 11, // 209: try {
16255 OPC_CheckField, 20, 5, 0, // 211: check Inst[24:20] == 0x0
16256 OPC_CheckPredicate, 14, // 215: check predicate 14
16257 OPC_Decode, 177, 122, 165, 2, // 217: decode to QC_CLO using decoder 293
16258 // 217: } else try {
16259 OPC_CheckPredicate, 14, // 222: check predicate 14
16260 OPC_Decode, 224, 122, 167, 2, // 224: decode to QC_EXTDUR using decoder 295
16261 // 224: }
16262 // 224: }
16263 5, 20, // 229: case 0x5: {
16264 OPC_Scope, 11, // 231: try {
16265 OPC_CheckField, 20, 5, 0, // 233: check Inst[24:20] == 0x0
16266 OPC_CheckPredicate, 14, // 237: check predicate 14
16267 OPC_Decode, 193, 122, 165, 2, // 239: decode to QC_CTO using decoder 293
16268 // 239: } else try {
16269 OPC_CheckPredicate, 14, // 244: check predicate 14
16270 OPC_Decode, 220, 122, 167, 2, // 246: decode to QC_EXTDR using decoder 295
16271 // 246: }
16272 // 246: }
16273 6, 20, // 251: case 0x6: {
16274 OPC_Scope, 11, // 253: try {
16275 OPC_CheckField, 20, 5, 0, // 255: check Inst[24:20] == 0x0
16276 OPC_CheckPredicate, 14, // 259: check predicate 14
16277 OPC_Decode, 176, 122, 165, 2, // 261: decode to QC_BREV32 using decoder 293
16278 // 261: } else try {
16279 OPC_CheckPredicate, 14, // 266: check predicate 14
16280 OPC_Decode, 222, 122, 167, 2, // 268: decode to QC_EXTDUPR using decoder 295
16281 // 268: }
16282 // 268: }
16283 7, 21, // 273: case 0x7: {
16284 OPC_Scope, 12, // 275: try {
16285 OPC_CheckField, 20, 5, 0, // 277: check Inst[24:20] == 0x0
16286 OPC_CheckPredicate, 196, 1, // 281: check predicate 196
16287 OPC_Decode, 165, 123, 165, 2, // 284: decode to QC_NORM using decoder 293
16288 // 284: } else try {
16289 OPC_CheckPredicate, 14, // 289: check predicate 14
16290 OPC_Decode, 223, 122, 167, 2, // 291: decode to QC_EXTDUPRH using decoder 295
16291 // 291: }
16292 // 291: }
16293 8, 21, // 296: case 0x8: {
16294 OPC_Scope, 12, // 298: try {
16295 OPC_CheckField, 20, 5, 0, // 300: check Inst[24:20] == 0x0
16296 OPC_CheckPredicate, 196, 1, // 304: check predicate 196
16297 OPC_Decode, 167, 123, 165, 2, // 307: decode to QC_NORMU using decoder 293
16298 // 307: } else try {
16299 OPC_CheckPredicate, 14, // 312: check predicate 14
16300 OPC_Decode, 218, 122, 167, 2, // 314: decode to QC_EXTDPR using decoder 295
16301 // 314: }
16302 // 314: }
16303 9, 21, // 319: case 0x9: {
16304 OPC_Scope, 12, // 321: try {
16305 OPC_CheckField, 20, 5, 0, // 323: check Inst[24:20] == 0x0
16306 OPC_CheckPredicate, 196, 1, // 327: check predicate 196
16307 OPC_Decode, 166, 123, 165, 2, // 330: decode to QC_NORMEU using decoder 293
16308 // 330: } else try {
16309 OPC_CheckPredicate, 14, // 335: check predicate 14
16310 OPC_Decode, 219, 122, 167, 2, // 337: decode to QC_EXTDPRH using decoder 295
16311 // 337: }
16312 // 337: }
16313 10, 8, // 342: case 0xa: {
16314 OPC_CheckPredicate, 196, 1, // 344: check predicate 196
16315 OPC_Decode, 182, 123, 168, 2, // 347: decode to QC_SHLSAT using decoder 296
16316 // 347: }
16317 12, 8, // 352: case 0xc: {
16318 OPC_CheckPredicate, 196, 1, // 354: check predicate 196
16319 OPC_Decode, 183, 123, 168, 2, // 357: decode to QC_SHLUSAT using decoder 296
16320 // 357: }
16321 14, 8, // 362: case 0xe: {
16322 OPC_CheckPredicate, 196, 1, // 364: check predicate 196
16323 OPC_Decode, 168, 122, 168, 2, // 367: decode to QC_ADDSAT using decoder 296
16324 // 367: }
16325 15, 8, // 372: case 0xf: {
16326 OPC_CheckPredicate, 196, 1, // 374: check predicate 196
16327 OPC_Decode, 169, 122, 168, 2, // 377: decode to QC_ADDUSAT using decoder 296
16328 // 377: }
16329 16, 8, // 382: case 0x10: {
16330 OPC_CheckPredicate, 196, 1, // 384: check predicate 196
16331 OPC_Decode, 187, 123, 168, 2, // 387: decode to QC_SUBSAT using decoder 296
16332 // 387: }
16333 17, 8, // 392: case 0x11: {
16334 OPC_CheckPredicate, 196, 1, // 394: check predicate 196
16335 OPC_Decode, 188, 123, 168, 2, // 397: decode to QC_SUBUSAT using decoder 296
16336 // 397: }
16337 18, 0, // 402: case 0x12: {
16338 OPC_CheckPredicate, 196, 1, // 404: check predicate 196
16339 OPC_Decode, 195, 123, 169, 2, // 407: decode to QC_WRAP using decoder 297
16340 // 407: }
16341 // 407: } // switch Inst[29:25]
16342 // 407: }
16343 1, 0, // 412: case 0x1: {
16344 OPC_CheckPredicate, 15, // 414: check predicate 15
16345 OPC_Decode, 181, 123, 170, 2, // 416: decode to QC_SHLADD using decoder 298
16346 // 416: }
16347 // 416: } // switch Inst[31:30]
16348 // 416: }
16349 4, 8, // 421: case 0x4: {
16350 OPC_CheckPredicate, 197, 1, // 423: check predicate 197
16351 OPC_Decode, 168, 123, 171, 2, // 426: decode to QC_OUTW using decoder 299
16352 // 426: }
16353 5, 8, // 431: case 0x5: {
16354 OPC_CheckPredicate, 197, 1, // 433: check predicate 197
16355 OPC_Decode, 131, 123, 171, 2, // 436: decode to QC_INW using decoder 299
16356 // 436: }
16357 6, 7, // 441: case 0x6: {
16358 OPC_CheckPredicate, 15, // 443: check predicate 15
16359 OPC_Decode, 152, 123, 172, 2, // 445: decode to QC_MULIADD using decoder 300
16360 // 445: }
16361 7, 0, // 450: case 0x7: {
16362 OPC_SwitchField, 30, 2, // 452: switch Inst[31:30] {
16363 0, 8, // 455: case 0x0: {
16364 OPC_CheckPredicate, 198, 1, // 457: check predicate 198
16365 OPC_Decode, 150, 123, 173, 2, // 460: decode to QC_LWM using decoder 301
16366 // 460: }
16367 1, 8, // 465: case 0x1: {
16368 OPC_CheckPredicate, 198, 1, // 467: check predicate 198
16369 OPC_Decode, 151, 123, 174, 2, // 470: decode to QC_LWMI using decoder 302
16370 // 470: }
16371 2, 43, // 475: case 0x2: {
16372 OPC_SwitchField, 28, 2, // 477: switch Inst[29:28] {
16373 0, 8, // 480: case 0x0: {
16374 OPC_CheckPredicate, 199, 1, // 482: check predicate 199
16375 OPC_Decode, 145, 123, 175, 2, // 485: decode to QC_LRB using decoder 303
16376 // 485: }
16377 1, 8, // 490: case 0x1: {
16378 OPC_CheckPredicate, 199, 1, // 492: check predicate 199
16379 OPC_Decode, 147, 123, 175, 2, // 495: decode to QC_LRH using decoder 303
16380 // 495: }
16381 2, 8, // 500: case 0x2: {
16382 OPC_CheckPredicate, 199, 1, // 502: check predicate 199
16383 OPC_Decode, 149, 123, 175, 2, // 505: decode to QC_LRW using decoder 303
16384 // 505: }
16385 3, 0, // 510: case 0x3: {
16386 OPC_CheckPredicate, 199, 1, // 512: check predicate 199
16387 OPC_Decode, 146, 123, 175, 2, // 515: decode to QC_LRBU using decoder 303
16388 // 515: }
16389 // 515: } // switch Inst[29:28]
16390 // 515: }
16391 3, 0, // 520: case 0x3: {
16392 OPC_CheckPredicate, 199, 1, // 522: check predicate 199
16393 OPC_CheckField, 28, 2, 0, // 525: check Inst[29:28] == 0x0
16394 OPC_Decode, 148, 123, 175, 2, // 529: decode to QC_LRHU using decoder 303
16395 // 529: }
16396 // 529: } // switch Inst[31:30]
16397 // 529: }
16398 // 529: } // switch Inst[14:12]
16399 // 529: }
16400 19, 82, // 534: case 0x13: {
16401 OPC_SwitchField, 28, 4, // 536: switch Inst[31:28] {
16402 1, 15, // 539: case 0x1: {
16403 OPC_CheckPredicate, 16, // 541: check predicate 16
16404 OPC_CheckField, 25, 3, 0, // 543: check Inst[27:25] == 0x0
16405 OPC_CheckField, 7, 13, 96, // 547: check Inst[19:7] == 0x60
16406 OPC_Decode, 191, 123, 176, 2, // 551: decode to QC_SYNC using decoder 304
16407 // 551: }
16408 2, 15, // 556: case 0x2: {
16409 OPC_CheckPredicate, 16, // 558: check predicate 16
16410 OPC_CheckField, 25, 3, 0, // 560: check Inst[27:25] == 0x0
16411 OPC_CheckField, 7, 13, 96, // 564: check Inst[19:7] == 0x60
16412 OPC_Decode, 192, 123, 176, 2, // 568: decode to QC_SYNCR using decoder 304
16413 // 568: }
16414 4, 26, // 573: case 0x4: {
16415 OPC_SwitchField, 7, 13, // 575: switch Inst[19:7] {
16416 64, 8, // 578: case 0x40: {
16417 OPC_CheckPredicate, 200, 1, // 580: check predicate 200
16418 OPC_Decode, 169, 123, 177, 2, // 583: decode to QC_PPUTCI using decoder 305
16419 // 583: }
16420 96, 0, // 588: case 0x60: {
16421 OPC_CheckPredicate, 16, // 590: check predicate 16
16422 OPC_CheckField, 25, 3, 0, // 592: check Inst[27:25] == 0x0
16423 OPC_Decode, 193, 123, 176, 2, // 596: decode to QC_SYNCWF using decoder 304
16424 // 596: }
16425 // 596: } // switch Inst[19:7]
16426 // 596: }
16427 8, 0, // 601: case 0x8: {
16428 OPC_CheckPredicate, 16, // 603: check predicate 16
16429 OPC_CheckField, 25, 3, 0, // 605: check Inst[27:25] == 0x0
16430 OPC_CheckField, 7, 13, 96, // 609: check Inst[19:7] == 0x60
16431 OPC_Decode, 194, 123, 176, 2, // 613: decode to QC_SYNCWL using decoder 304
16432 // 613: }
16433 // 613: } // switch Inst[31:28]
16434 // 613: }
16435 27, 8, // 618: case 0x1b: {
16436 OPC_CheckPredicate, 201, 1, // 620: check predicate 201
16437 OPC_Decode, 132, 123, 178, 2, // 623: decode to QC_LI using decoder 306
16438 // 623: }
16439 43, 95, // 628: case 0x2b: {
16440 OPC_SwitchField, 30, 2, // 630: switch Inst[31:30] {
16441 0, 12, // 633: case 0x0: {
16442 OPC_CheckPredicate, 198, 1, // 635: check predicate 198
16443 OPC_CheckField, 12, 3, 7, // 638: check Inst[14:12] == 0x7
16444 OPC_Decode, 189, 123, 173, 2, // 642: decode to QC_SWM using decoder 301
16445 // 642: }
16446 1, 12, // 647: case 0x1: {
16447 OPC_CheckPredicate, 198, 1, // 649: check predicate 198
16448 OPC_CheckField, 12, 3, 7, // 652: check Inst[14:12] == 0x7
16449 OPC_Decode, 190, 123, 174, 2, // 656: decode to QC_SWMI using decoder 302
16450 // 656: }
16451 2, 12, // 661: case 0x2: {
16452 OPC_CheckPredicate, 198, 1, // 663: check predicate 198
16453 OPC_CheckField, 12, 3, 7, // 666: check Inst[14:12] == 0x7
16454 OPC_Decode, 179, 123, 179, 2, // 670: decode to QC_SETWM using decoder 307
16455 // 670: }
16456 3, 0, // 675: case 0x3: {
16457 OPC_SwitchField, 12, 3, // 677: switch Inst[14:12] {
16458 6, 33, // 680: case 0x6: {
16459 OPC_SwitchField, 28, 2, // 682: switch Inst[29:28] {
16460 1, 8, // 685: case 0x1: {
16461 OPC_CheckPredicate, 199, 1, // 687: check predicate 199
16462 OPC_Decode, 184, 123, 175, 2, // 690: decode to QC_SRB using decoder 303
16463 // 690: }
16464 2, 8, // 695: case 0x2: {
16465 OPC_CheckPredicate, 199, 1, // 697: check predicate 199
16466 OPC_Decode, 185, 123, 175, 2, // 700: decode to QC_SRH using decoder 303
16467 // 700: }
16468 3, 0, // 705: case 0x3: {
16469 OPC_CheckPredicate, 199, 1, // 707: check predicate 199
16470 OPC_Decode, 186, 123, 175, 2, // 710: decode to QC_SRW using decoder 303
16471 // 710: }
16472 // 710: } // switch Inst[29:28]
16473 // 710: }
16474 7, 0, // 715: case 0x7: {
16475 OPC_CheckPredicate, 198, 1, // 717: check predicate 198
16476 OPC_Decode, 180, 123, 180, 2, // 720: decode to QC_SETWMI using decoder 308
16477 // 720: }
16478 // 720: } // switch Inst[14:12]
16479 // 720: }
16480 // 720: } // switch Inst[31:30]
16481 // 720: }
16482 91, 223, 2, // 725: case 0x5b: {
16483 OPC_SwitchField, 12, 3, // 728: switch Inst[14:12] {
16484 0, 41, // 731: case 0x0: {
16485 OPC_SwitchField, 25, 2, // 733: switch Inst[26:25] {
16486 0, 7, // 736: case 0x0: {
16487 OPC_CheckPredicate, 17, // 738: check predicate 17
16488 OPC_Decode, 153, 123, 181, 2, // 740: decode to QC_MVEQ using decoder 309
16489 // 740: }
16490 1, 8, // 745: case 0x1: {
16491 OPC_CheckPredicate, 202, 1, // 747: check predicate 202
16492 OPC_Decode, 133, 123, 182, 2, // 750: decode to QC_LIEQ using decoder 310
16493 // 750: }
16494 2, 7, // 755: case 0x2: {
16495 OPC_CheckPredicate, 17, // 757: check predicate 17
16496 OPC_Decode, 154, 123, 183, 2, // 759: decode to QC_MVEQI using decoder 311
16497 // 759: }
16498 3, 0, // 764: case 0x3: {
16499 OPC_CheckPredicate, 202, 1, // 766: check predicate 202
16500 OPC_Decode, 134, 123, 184, 2, // 769: decode to QC_LIEQI using decoder 312
16501 // 769: }
16502 // 769: } // switch Inst[26:25]
16503 // 769: }
16504 1, 41, // 774: case 0x1: {
16505 OPC_SwitchField, 25, 2, // 776: switch Inst[26:25] {
16506 0, 7, // 779: case 0x0: {
16507 OPC_CheckPredicate, 17, // 781: check predicate 17
16508 OPC_Decode, 163, 123, 181, 2, // 783: decode to QC_MVNE using decoder 309
16509 // 783: }
16510 1, 8, // 788: case 0x1: {
16511 OPC_CheckPredicate, 202, 1, // 790: check predicate 202
16512 OPC_Decode, 143, 123, 182, 2, // 793: decode to QC_LINE using decoder 310
16513 // 793: }
16514 2, 7, // 798: case 0x2: {
16515 OPC_CheckPredicate, 17, // 800: check predicate 17
16516 OPC_Decode, 164, 123, 183, 2, // 802: decode to QC_MVNEI using decoder 311
16517 // 802: }
16518 3, 0, // 807: case 0x3: {
16519 OPC_CheckPredicate, 202, 1, // 809: check predicate 202
16520 OPC_Decode, 144, 123, 184, 2, // 812: decode to QC_LINEI using decoder 312
16521 // 812: }
16522 // 812: } // switch Inst[26:25]
16523 // 812: }
16524 2, 43, // 817: case 0x2: {
16525 OPC_SwitchField, 25, 2, // 819: switch Inst[26:25] {
16526 0, 8, // 822: case 0x0: {
16527 OPC_CheckPredicate, 203, 1, // 824: check predicate 203
16528 OPC_Decode, 173, 123, 184, 2, // 827: decode to QC_SELECTIIEQ using decoder 312
16529 // 827: }
16530 1, 8, // 832: case 0x1: {
16531 OPC_CheckPredicate, 203, 1, // 834: check predicate 203
16532 OPC_Decode, 171, 123, 182, 2, // 837: decode to QC_SELECTIEQ using decoder 310
16533 // 837: }
16534 2, 8, // 842: case 0x2: {
16535 OPC_CheckPredicate, 203, 1, // 844: check predicate 203
16536 OPC_Decode, 170, 123, 185, 2, // 847: decode to QC_SELECTEQI using decoder 313
16537 // 847: }
16538 3, 0, // 852: case 0x3: {
16539 OPC_CheckPredicate, 203, 1, // 854: check predicate 203
16540 OPC_Decode, 172, 123, 186, 2, // 857: decode to QC_SELECTIEQI using decoder 314
16541 // 857: }
16542 // 857: } // switch Inst[26:25]
16543 // 857: }
16544 3, 43, // 862: case 0x3: {
16545 OPC_SwitchField, 25, 2, // 864: switch Inst[26:25] {
16546 0, 8, // 867: case 0x0: {
16547 OPC_CheckPredicate, 203, 1, // 869: check predicate 203
16548 OPC_Decode, 174, 123, 184, 2, // 872: decode to QC_SELECTIINE using decoder 312
16549 // 872: }
16550 1, 8, // 877: case 0x1: {
16551 OPC_CheckPredicate, 203, 1, // 879: check predicate 203
16552 OPC_Decode, 175, 123, 182, 2, // 882: decode to QC_SELECTINE using decoder 310
16553 // 882: }
16554 2, 8, // 887: case 0x2: {
16555 OPC_CheckPredicate, 203, 1, // 889: check predicate 203
16556 OPC_Decode, 177, 123, 185, 2, // 892: decode to QC_SELECTNEI using decoder 313
16557 // 892: }
16558 3, 0, // 897: case 0x3: {
16559 OPC_CheckPredicate, 203, 1, // 899: check predicate 203
16560 OPC_Decode, 176, 123, 186, 2, // 902: decode to QC_SELECTINEI using decoder 314
16561 // 902: }
16562 // 902: } // switch Inst[26:25]
16563 // 902: }
16564 4, 41, // 907: case 0x4: {
16565 OPC_SwitchField, 25, 2, // 909: switch Inst[26:25] {
16566 0, 7, // 912: case 0x0: {
16567 OPC_CheckPredicate, 17, // 914: check predicate 17
16568 OPC_Decode, 159, 123, 181, 2, // 916: decode to QC_MVLT using decoder 309
16569 // 916: }
16570 1, 8, // 921: case 0x1: {
16571 OPC_CheckPredicate, 202, 1, // 923: check predicate 202
16572 OPC_Decode, 139, 123, 182, 2, // 926: decode to QC_LILT using decoder 310
16573 // 926: }
16574 2, 7, // 931: case 0x2: {
16575 OPC_CheckPredicate, 17, // 933: check predicate 17
16576 OPC_Decode, 160, 123, 183, 2, // 935: decode to QC_MVLTI using decoder 311
16577 // 935: }
16578 3, 0, // 940: case 0x3: {
16579 OPC_CheckPredicate, 202, 1, // 942: check predicate 202
16580 OPC_Decode, 140, 123, 184, 2, // 945: decode to QC_LILTI using decoder 312
16581 // 945: }
16582 // 945: } // switch Inst[26:25]
16583 // 945: }
16584 5, 41, // 950: case 0x5: {
16585 OPC_SwitchField, 25, 2, // 952: switch Inst[26:25] {
16586 0, 7, // 955: case 0x0: {
16587 OPC_CheckPredicate, 17, // 957: check predicate 17
16588 OPC_Decode, 155, 123, 181, 2, // 959: decode to QC_MVGE using decoder 309
16589 // 959: }
16590 1, 8, // 964: case 0x1: {
16591 OPC_CheckPredicate, 202, 1, // 966: check predicate 202
16592 OPC_Decode, 135, 123, 182, 2, // 969: decode to QC_LIGE using decoder 310
16593 // 969: }
16594 2, 7, // 974: case 0x2: {
16595 OPC_CheckPredicate, 17, // 976: check predicate 17
16596 OPC_Decode, 156, 123, 183, 2, // 978: decode to QC_MVGEI using decoder 311
16597 // 978: }
16598 3, 0, // 983: case 0x3: {
16599 OPC_CheckPredicate, 202, 1, // 985: check predicate 202
16600 OPC_Decode, 136, 123, 184, 2, // 988: decode to QC_LIGEI using decoder 312
16601 // 988: }
16602 // 988: } // switch Inst[26:25]
16603 // 988: }
16604 6, 41, // 993: case 0x6: {
16605 OPC_SwitchField, 25, 2, // 995: switch Inst[26:25] {
16606 0, 7, // 998: case 0x0: {
16607 OPC_CheckPredicate, 17, // 1000: check predicate 17
16608 OPC_Decode, 161, 123, 181, 2, // 1002: decode to QC_MVLTU using decoder 309
16609 // 1002: }
16610 1, 8, // 1007: case 0x1: {
16611 OPC_CheckPredicate, 202, 1, // 1009: check predicate 202
16612 OPC_Decode, 141, 123, 182, 2, // 1012: decode to QC_LILTU using decoder 310
16613 // 1012: }
16614 2, 7, // 1017: case 0x2: {
16615 OPC_CheckPredicate, 17, // 1019: check predicate 17
16616 OPC_Decode, 162, 123, 187, 2, // 1021: decode to QC_MVLTUI using decoder 315
16617 // 1021: }
16618 3, 0, // 1026: case 0x3: {
16619 OPC_CheckPredicate, 202, 1, // 1028: check predicate 202
16620 OPC_Decode, 142, 123, 188, 2, // 1031: decode to QC_LILTUI using decoder 316
16621 // 1031: }
16622 // 1031: } // switch Inst[26:25]
16623 // 1031: }
16624 7, 0, // 1036: case 0x7: {
16625 OPC_SwitchField, 25, 2, // 1038: switch Inst[26:25] {
16626 0, 7, // 1041: case 0x0: {
16627 OPC_CheckPredicate, 17, // 1043: check predicate 17
16628 OPC_Decode, 157, 123, 181, 2, // 1045: decode to QC_MVGEU using decoder 309
16629 // 1045: }
16630 1, 8, // 1050: case 0x1: {
16631 OPC_CheckPredicate, 202, 1, // 1052: check predicate 202
16632 OPC_Decode, 137, 123, 182, 2, // 1055: decode to QC_LIGEU using decoder 310
16633 // 1055: }
16634 2, 7, // 1060: case 0x2: {
16635 OPC_CheckPredicate, 17, // 1062: check predicate 17
16636 OPC_Decode, 158, 123, 187, 2, // 1064: decode to QC_MVGEUI using decoder 315
16637 // 1064: }
16638 3, 0, // 1069: case 0x3: {
16639 OPC_CheckPredicate, 202, 1, // 1071: check predicate 202
16640 OPC_Decode, 138, 123, 188, 2, // 1074: decode to QC_LIGEUI using decoder 316
16641 // 1074: }
16642 // 1074: } // switch Inst[26:25]
16643 // 1074: }
16644 // 1074: } // switch Inst[14:12]
16645 // 1074: }
16646 115, 57, // 1079: case 0x73: {
16647 OPC_SwitchField, 25, 7, // 1081: switch Inst[31:25] {
16648 70, 12, // 1084: case 0x46: {
16649 OPC_CheckPredicate, 204, 1, // 1086: check predicate 204
16650 OPC_CheckField, 12, 3, 0, // 1089: check Inst[14:12] == 0x0
16651 OPC_Decode, 191, 122, 189, 2, // 1093: decode to QC_CSRRWR using decoder 317
16652 // 1093: }
16653 71, 12, // 1098: case 0x47: {
16654 OPC_CheckPredicate, 204, 1, // 1100: check predicate 204
16655 OPC_CheckField, 12, 3, 0, // 1103: check Inst[14:12] == 0x0
16656 OPC_Decode, 192, 122, 190, 2, // 1107: decode to QC_CSRRWRI using decoder 318
16657 // 1107: }
16658 102, 11, // 1112: case 0x66: {
16659 OPC_CheckPredicate, 13, // 1114: check predicate 13
16660 OPC_CheckField, 7, 8, 0, // 1116: check Inst[14:7] == 0x0
16661 OPC_Decode, 178, 123, 191, 2, // 1120: decode to QC_SETINTI using decoder 319
16662 // 1120: }
16663 103, 0, // 1125: case 0x67: {
16664 OPC_CheckPredicate, 13, // 1127: check predicate 13
16665 OPC_CheckField, 7, 8, 0, // 1129: check Inst[14:7] == 0x0
16666 OPC_Decode, 178, 122, 191, 2, // 1133: decode to QC_CLRINTI using decoder 319
16667 // 1133: }
16668 // 1133: } // switch Inst[31:25]
16669 // 1133: }
16670 123, 0, // 1138: case 0x7b: {
16671 OPC_SwitchField, 12, 3, // 1140: switch Inst[14:12] {
16672 0, 8, // 1143: case 0x0: {
16673 OPC_CheckPredicate, 205, 1, // 1145: check predicate 205
16674 OPC_Decode, 170, 122, 192, 2, // 1148: decode to QC_BEQI using decoder 320
16675 // 1148: }
16676 1, 8, // 1153: case 0x1: {
16677 OPC_CheckPredicate, 205, 1, // 1155: check predicate 205
16678 OPC_Decode, 175, 122, 192, 2, // 1158: decode to QC_BNEI using decoder 320
16679 // 1158: }
16680 4, 8, // 1163: case 0x4: {
16681 OPC_CheckPredicate, 205, 1, // 1165: check predicate 205
16682 OPC_Decode, 173, 122, 192, 2, // 1168: decode to QC_BLTI using decoder 320
16683 // 1168: }
16684 5, 8, // 1173: case 0x5: {
16685 OPC_CheckPredicate, 205, 1, // 1175: check predicate 205
16686 OPC_Decode, 171, 122, 192, 2, // 1178: decode to QC_BGEI using decoder 320
16687 // 1178: }
16688 6, 8, // 1183: case 0x6: {
16689 OPC_CheckPredicate, 205, 1, // 1185: check predicate 205
16690 OPC_Decode, 174, 122, 193, 2, // 1188: decode to QC_BLTUI using decoder 321
16691 // 1188: }
16692 7, 0, // 1193: case 0x7: {
16693 OPC_CheckPredicate, 205, 1, // 1195: check predicate 205
16694 OPC_Decode, 172, 122, 193, 2, // 1198: decode to QC_BGEUI using decoder 321
16695 // 1198: }
16696 // 1198: } // switch Inst[14:12]
16697 // 1198: }
16698 // 1198: } // switch Inst[6:0]
16699};
16700static const uint8_t DecoderTableZdinxGPRPairRV3232[34] = {
16701 32, // 0: BitWidth 32
16702 OPC_SwitchField, 20, 12, // 1: switch Inst[31:20] {
16703 162, 8, 12, // 4: case 0x422: {
16704 OPC_CheckPredicate, 206, 1, // 7: check predicate 206
16705 OPC_CheckField, 0, 7, 83, // 10: check Inst[6:0] == 0x53
16706 OPC_Decode, 175, 114, 194, 2, // 14: decode to FCVT_D_H_IN32X using decoder 322
16707 // 14: }
16708 193, 8, 0, // 19: case 0x441: {
16709 OPC_CheckPredicate, 206, 1, // 22: check predicate 206
16710 OPC_CheckField, 0, 7, 83, // 25: check Inst[6:0] == 0x53
16711 OPC_Decode, 192, 114, 195, 2, // 29: decode to FCVT_H_D_IN32X using decoder 323
16712 // 29: }
16713 // 29: } // switch Inst[31:20]
16714};
16715static const uint8_t DecoderTableZdinxRV32Only32[310] = {
16716 32, // 0: BitWidth 32
16717 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
16718 67, 12, // 4: case 0x43: {
16719 OPC_CheckPredicate, 207, 1, // 6: check predicate 207
16720 OPC_CheckField, 25, 2, 1, // 9: check Inst[26:25] == 0x1
16721 OPC_Decode, 181, 115, 196, 2, // 13: decode to FMADD_D_IN32X using decoder 324
16722 // 13: }
16723 71, 12, // 18: case 0x47: {
16724 OPC_CheckPredicate, 207, 1, // 20: check predicate 207
16725 OPC_CheckField, 25, 2, 1, // 23: check Inst[26:25] == 0x1
16726 OPC_Decode, 213, 115, 196, 2, // 27: decode to FMSUB_D_IN32X using decoder 324
16727 // 27: }
16728 75, 12, // 32: case 0x4b: {
16729 OPC_CheckPredicate, 207, 1, // 34: check predicate 207
16730 OPC_CheckField, 25, 2, 1, // 37: check Inst[26:25] == 0x1
16731 OPC_Decode, 248, 115, 196, 2, // 41: decode to FNMSUB_D_IN32X using decoder 324
16732 // 41: }
16733 79, 12, // 46: case 0x4f: {
16734 OPC_CheckPredicate, 207, 1, // 48: check predicate 207
16735 OPC_CheckField, 25, 2, 1, // 51: check Inst[26:25] == 0x1
16736 OPC_Decode, 240, 115, 196, 2, // 55: decode to FNMADD_D_IN32X using decoder 324
16737 // 55: }
16738 83, 0, // 60: case 0x53: {
16739 OPC_SwitchField, 25, 7, // 62: switch Inst[31:25] {
16740 1, 8, // 65: case 0x1: {
16741 OPC_CheckPredicate, 207, 1, // 67: check predicate 207
16742 OPC_Decode, 157, 114, 197, 2, // 70: decode to FADD_D_IN32X using decoder 325
16743 // 70: }
16744 5, 8, // 75: case 0x5: {
16745 OPC_CheckPredicate, 207, 1, // 77: check predicate 207
16746 OPC_Decode, 171, 116, 197, 2, // 80: decode to FSUB_D_IN32X using decoder 325
16747 // 80: }
16748 9, 8, // 85: case 0x9: {
16749 OPC_CheckPredicate, 207, 1, // 87: check predicate 207
16750 OPC_Decode, 221, 115, 197, 2, // 90: decode to FMUL_D_IN32X using decoder 325
16751 // 90: }
16752 13, 8, // 95: case 0xd: {
16753 OPC_CheckPredicate, 207, 1, // 97: check predicate 207
16754 OPC_Decode, 130, 115, 197, 2, // 100: decode to FDIV_D_IN32X using decoder 325
16755 // 100: }
16756 17, 33, // 105: case 0x11: {
16757 OPC_SwitchField, 12, 3, // 107: switch Inst[14:12] {
16758 0, 8, // 110: case 0x0: {
16759 OPC_CheckPredicate, 207, 1, // 112: check predicate 207
16760 OPC_Decode, 153, 116, 198, 2, // 115: decode to FSGNJ_D_IN32X using decoder 326
16761 // 115: }
16762 1, 8, // 120: case 0x1: {
16763 OPC_CheckPredicate, 207, 1, // 122: check predicate 207
16764 OPC_Decode, 137, 116, 198, 2, // 125: decode to FSGNJN_D_IN32X using decoder 326
16765 // 125: }
16766 2, 0, // 130: case 0x2: {
16767 OPC_CheckPredicate, 207, 1, // 132: check predicate 207
16768 OPC_Decode, 145, 116, 198, 2, // 135: decode to FSGNJX_D_IN32X using decoder 326
16769 // 135: }
16770 // 135: } // switch Inst[14:12]
16771 // 135: }
16772 21, 23, // 140: case 0x15: {
16773 OPC_SwitchField, 12, 3, // 142: switch Inst[14:12] {
16774 0, 8, // 145: case 0x0: {
16775 OPC_CheckPredicate, 207, 1, // 147: check predicate 207
16776 OPC_Decode, 205, 115, 198, 2, // 150: decode to FMIN_D_IN32X using decoder 326
16777 // 150: }
16778 1, 0, // 155: case 0x1: {
16779 OPC_CheckPredicate, 207, 1, // 157: check predicate 207
16780 OPC_Decode, 193, 115, 198, 2, // 160: decode to FMAX_D_IN32X using decoder 326
16781 // 160: }
16782 // 160: } // switch Inst[14:12]
16783 // 160: }
16784 32, 12, // 165: case 0x20: {
16785 OPC_CheckPredicate, 207, 1, // 167: check predicate 207
16786 OPC_CheckField, 20, 5, 1, // 170: check Inst[24:20] == 0x1
16787 OPC_Decode, 228, 114, 199, 2, // 174: decode to FCVT_S_D_IN32X using decoder 327
16788 // 174: }
16789 33, 12, // 179: case 0x21: {
16790 OPC_CheckPredicate, 207, 1, // 181: check predicate 207
16791 OPC_CheckField, 20, 5, 0, // 184: check Inst[24:20] == 0x0
16792 OPC_Decode, 183, 114, 200, 2, // 188: decode to FCVT_D_S_IN32X using decoder 328
16793 // 188: }
16794 45, 12, // 193: case 0x2d: {
16795 OPC_CheckPredicate, 207, 1, // 195: check predicate 207
16796 OPC_CheckField, 20, 5, 0, // 198: check Inst[24:20] == 0x0
16797 OPC_Decode, 163, 116, 201, 2, // 202: decode to FSQRT_D_IN32X using decoder 329
16798 // 202: }
16799 81, 33, // 207: case 0x51: {
16800 OPC_SwitchField, 12, 3, // 209: switch Inst[14:12] {
16801 0, 8, // 212: case 0x0: {
16802 OPC_CheckPredicate, 207, 1, // 214: check predicate 207
16803 OPC_Decode, 154, 115, 202, 2, // 217: decode to FLE_D_IN32X using decoder 330
16804 // 217: }
16805 1, 8, // 222: case 0x1: {
16806 OPC_CheckPredicate, 207, 1, // 224: check predicate 207
16807 OPC_Decode, 172, 115, 202, 2, // 227: decode to FLT_D_IN32X using decoder 330
16808 // 227: }
16809 2, 0, // 232: case 0x2: {
16810 OPC_CheckPredicate, 207, 1, // 234: check predicate 207
16811 OPC_Decode, 141, 115, 202, 2, // 237: decode to FEQ_D_IN32X using decoder 330
16812 // 237: }
16813 // 237: } // switch Inst[14:12]
16814 // 237: }
16815 97, 23, // 242: case 0x61: {
16816 OPC_SwitchField, 20, 5, // 244: switch Inst[24:20] {
16817 0, 8, // 247: case 0x0: {
16818 OPC_CheckPredicate, 207, 1, // 249: check predicate 207
16819 OPC_Decode, 250, 114, 203, 2, // 252: decode to FCVT_W_D_IN32X using decoder 331
16820 // 252: }
16821 1, 0, // 257: case 0x1: {
16822 OPC_CheckPredicate, 207, 1, // 259: check predicate 207
16823 OPC_Decode, 242, 114, 203, 2, // 262: decode to FCVT_WU_D_IN32X using decoder 331
16824 // 262: }
16825 // 262: } // switch Inst[24:20]
16826 // 262: }
16827 105, 23, // 267: case 0x69: {
16828 OPC_SwitchField, 20, 5, // 269: switch Inst[24:20] {
16829 0, 8, // 272: case 0x0: {
16830 OPC_CheckPredicate, 207, 1, // 274: check predicate 207
16831 OPC_Decode, 189, 114, 204, 2, // 277: decode to FCVT_D_W_IN32X using decoder 332
16832 // 277: }
16833 1, 0, // 282: case 0x1: {
16834 OPC_CheckPredicate, 207, 1, // 284: check predicate 207
16835 OPC_Decode, 187, 114, 204, 2, // 287: decode to FCVT_D_WU_IN32X using decoder 332
16836 // 287: }
16837 // 287: } // switch Inst[24:20]
16838 // 287: }
16839 113, 0, // 292: case 0x71: {
16840 OPC_CheckPredicate, 207, 1, // 294: check predicate 207
16841 OPC_CheckField, 20, 5, 0, // 297: check Inst[24:20] == 0x0
16842 OPC_CheckField, 12, 3, 1, // 301: check Inst[14:12] == 0x1
16843 OPC_Decode, 165, 114, 205, 2, // 305: decode to FCLASS_D_IN32X using decoder 333
16844 // 305: }
16845 // 305: } // switch Inst[31:25]
16846 // 305: }
16847 // 305: } // switch Inst[6:0]
16848};
16849static const uint8_t DecoderTableZfinx32[986] = {
16850 32, // 0: BitWidth 32
16851 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
16852 67, 33, // 4: case 0x43: {
16853 OPC_SwitchField, 25, 2, // 6: switch Inst[26:25] {
16854 0, 8, // 9: case 0x0: {
16855 OPC_CheckPredicate, 208, 1, // 11: check predicate 208
16856 OPC_Decode, 187, 115, 206, 2, // 14: decode to FMADD_S_INX using decoder 334
16857 // 14: }
16858 1, 8, // 19: case 0x1: {
16859 OPC_CheckPredicate, 209, 1, // 21: check predicate 209
16860 OPC_Decode, 182, 115, 207, 2, // 24: decode to FMADD_D_INX using decoder 335
16861 // 24: }
16862 2, 0, // 29: case 0x2: {
16863 OPC_CheckPredicate, 210, 1, // 31: check predicate 210
16864 OPC_Decode, 184, 115, 208, 2, // 34: decode to FMADD_H_INX using decoder 336
16865 // 34: }
16866 // 34: } // switch Inst[26:25]
16867 // 34: }
16868 71, 33, // 39: case 0x47: {
16869 OPC_SwitchField, 25, 2, // 41: switch Inst[26:25] {
16870 0, 8, // 44: case 0x0: {
16871 OPC_CheckPredicate, 208, 1, // 46: check predicate 208
16872 OPC_Decode, 219, 115, 206, 2, // 49: decode to FMSUB_S_INX using decoder 334
16873 // 49: }
16874 1, 8, // 54: case 0x1: {
16875 OPC_CheckPredicate, 209, 1, // 56: check predicate 209
16876 OPC_Decode, 214, 115, 207, 2, // 59: decode to FMSUB_D_INX using decoder 335
16877 // 59: }
16878 2, 0, // 64: case 0x2: {
16879 OPC_CheckPredicate, 210, 1, // 66: check predicate 210
16880 OPC_Decode, 216, 115, 208, 2, // 69: decode to FMSUB_H_INX using decoder 336
16881 // 69: }
16882 // 69: } // switch Inst[26:25]
16883 // 69: }
16884 75, 33, // 74: case 0x4b: {
16885 OPC_SwitchField, 25, 2, // 76: switch Inst[26:25] {
16886 0, 8, // 79: case 0x0: {
16887 OPC_CheckPredicate, 208, 1, // 81: check predicate 208
16888 OPC_Decode, 254, 115, 206, 2, // 84: decode to FNMSUB_S_INX using decoder 334
16889 // 84: }
16890 1, 8, // 89: case 0x1: {
16891 OPC_CheckPredicate, 209, 1, // 91: check predicate 209
16892 OPC_Decode, 249, 115, 207, 2, // 94: decode to FNMSUB_D_INX using decoder 335
16893 // 94: }
16894 2, 0, // 99: case 0x2: {
16895 OPC_CheckPredicate, 210, 1, // 101: check predicate 210
16896 OPC_Decode, 251, 115, 208, 2, // 104: decode to FNMSUB_H_INX using decoder 336
16897 // 104: }
16898 // 104: } // switch Inst[26:25]
16899 // 104: }
16900 79, 33, // 109: case 0x4f: {
16901 OPC_SwitchField, 25, 2, // 111: switch Inst[26:25] {
16902 0, 8, // 114: case 0x0: {
16903 OPC_CheckPredicate, 208, 1, // 116: check predicate 208
16904 OPC_Decode, 246, 115, 206, 2, // 119: decode to FNMADD_S_INX using decoder 334
16905 // 119: }
16906 1, 8, // 124: case 0x1: {
16907 OPC_CheckPredicate, 209, 1, // 126: check predicate 209
16908 OPC_Decode, 241, 115, 207, 2, // 129: decode to FNMADD_D_INX using decoder 335
16909 // 129: }
16910 2, 0, // 134: case 0x2: {
16911 OPC_CheckPredicate, 210, 1, // 136: check predicate 210
16912 OPC_Decode, 243, 115, 208, 2, // 139: decode to FNMADD_H_INX using decoder 336
16913 // 139: }
16914 // 139: } // switch Inst[26:25]
16915 // 139: }
16916 83, 0, // 144: case 0x53: {
16917 OPC_SwitchField, 25, 7, // 146: switch Inst[31:25] {
16918 0, 8, // 149: case 0x0: {
16919 OPC_CheckPredicate, 208, 1, // 151: check predicate 208
16920 OPC_Decode, 163, 114, 209, 2, // 154: decode to FADD_S_INX using decoder 337
16921 // 154: }
16922 1, 8, // 159: case 0x1: {
16923 OPC_CheckPredicate, 209, 1, // 161: check predicate 209
16924 OPC_Decode, 158, 114, 210, 2, // 164: decode to FADD_D_INX using decoder 338
16925 // 164: }
16926 2, 8, // 169: case 0x2: {
16927 OPC_CheckPredicate, 210, 1, // 171: check predicate 210
16928 OPC_Decode, 160, 114, 211, 2, // 174: decode to FADD_H_INX using decoder 339
16929 // 174: }
16930 4, 8, // 179: case 0x4: {
16931 OPC_CheckPredicate, 208, 1, // 181: check predicate 208
16932 OPC_Decode, 177, 116, 209, 2, // 184: decode to FSUB_S_INX using decoder 337
16933 // 184: }
16934 5, 8, // 189: case 0x5: {
16935 OPC_CheckPredicate, 209, 1, // 191: check predicate 209
16936 OPC_Decode, 172, 116, 210, 2, // 194: decode to FSUB_D_INX using decoder 338
16937 // 194: }
16938 6, 8, // 199: case 0x6: {
16939 OPC_CheckPredicate, 210, 1, // 201: check predicate 210
16940 OPC_Decode, 174, 116, 211, 2, // 204: decode to FSUB_H_INX using decoder 339
16941 // 204: }
16942 8, 8, // 209: case 0x8: {
16943 OPC_CheckPredicate, 208, 1, // 211: check predicate 208
16944 OPC_Decode, 227, 115, 209, 2, // 214: decode to FMUL_S_INX using decoder 337
16945 // 214: }
16946 9, 8, // 219: case 0x9: {
16947 OPC_CheckPredicate, 209, 1, // 221: check predicate 209
16948 OPC_Decode, 222, 115, 210, 2, // 224: decode to FMUL_D_INX using decoder 338
16949 // 224: }
16950 10, 8, // 229: case 0xa: {
16951 OPC_CheckPredicate, 210, 1, // 231: check predicate 210
16952 OPC_Decode, 224, 115, 211, 2, // 234: decode to FMUL_H_INX using decoder 339
16953 // 234: }
16954 12, 8, // 239: case 0xc: {
16955 OPC_CheckPredicate, 208, 1, // 241: check predicate 208
16956 OPC_Decode, 136, 115, 209, 2, // 244: decode to FDIV_S_INX using decoder 337
16957 // 244: }
16958 13, 8, // 249: case 0xd: {
16959 OPC_CheckPredicate, 209, 1, // 251: check predicate 209
16960 OPC_Decode, 131, 115, 210, 2, // 254: decode to FDIV_D_INX using decoder 338
16961 // 254: }
16962 14, 8, // 259: case 0xe: {
16963 OPC_CheckPredicate, 210, 1, // 261: check predicate 210
16964 OPC_Decode, 133, 115, 211, 2, // 264: decode to FDIV_H_INX using decoder 339
16965 // 264: }
16966 16, 33, // 269: case 0x10: {
16967 OPC_SwitchField, 12, 3, // 271: switch Inst[14:12] {
16968 0, 8, // 274: case 0x0: {
16969 OPC_CheckPredicate, 208, 1, // 276: check predicate 208
16970 OPC_Decode, 159, 116, 212, 2, // 279: decode to FSGNJ_S_INX using decoder 340
16971 // 279: }
16972 1, 8, // 284: case 0x1: {
16973 OPC_CheckPredicate, 208, 1, // 286: check predicate 208
16974 OPC_Decode, 143, 116, 212, 2, // 289: decode to FSGNJN_S_INX using decoder 340
16975 // 289: }
16976 2, 0, // 294: case 0x2: {
16977 OPC_CheckPredicate, 208, 1, // 296: check predicate 208
16978 OPC_Decode, 151, 116, 212, 2, // 299: decode to FSGNJX_S_INX using decoder 340
16979 // 299: }
16980 // 299: } // switch Inst[14:12]
16981 // 299: }
16982 17, 30, // 304: case 0x11: {
16983 OPC_SwitchField, 12, 3, // 306: switch Inst[14:12] {
16984 0, 7, // 309: case 0x0: {
16985 OPC_CheckPredicate, 209, 1, // 311: check predicate 209
16986 OPC_Decode, 154, 116, 31, // 314: decode to FSGNJ_D_INX using decoder 31
16987 // 314: }
16988 1, 7, // 318: case 0x1: {
16989 OPC_CheckPredicate, 209, 1, // 320: check predicate 209
16990 OPC_Decode, 138, 116, 31, // 323: decode to FSGNJN_D_INX using decoder 31
16991 // 323: }
16992 2, 0, // 327: case 0x2: {
16993 OPC_CheckPredicate, 209, 1, // 329: check predicate 209
16994 OPC_Decode, 146, 116, 31, // 332: decode to FSGNJX_D_INX using decoder 31
16995 // 332: }
16996 // 332: } // switch Inst[14:12]
16997 // 332: }
16998 18, 33, // 336: case 0x12: {
16999 OPC_SwitchField, 12, 3, // 338: switch Inst[14:12] {
17000 0, 8, // 341: case 0x0: {
17001 OPC_CheckPredicate, 210, 1, // 343: check predicate 210
17002 OPC_Decode, 156, 116, 213, 2, // 346: decode to FSGNJ_H_INX using decoder 341
17003 // 346: }
17004 1, 8, // 351: case 0x1: {
17005 OPC_CheckPredicate, 210, 1, // 353: check predicate 210
17006 OPC_Decode, 140, 116, 213, 2, // 356: decode to FSGNJN_H_INX using decoder 341
17007 // 356: }
17008 2, 0, // 361: case 0x2: {
17009 OPC_CheckPredicate, 210, 1, // 363: check predicate 210
17010 OPC_Decode, 148, 116, 213, 2, // 366: decode to FSGNJX_H_INX using decoder 341
17011 // 366: }
17012 // 366: } // switch Inst[14:12]
17013 // 366: }
17014 20, 23, // 371: case 0x14: {
17015 OPC_SwitchField, 12, 3, // 373: switch Inst[14:12] {
17016 0, 8, // 376: case 0x0: {
17017 OPC_CheckPredicate, 208, 1, // 378: check predicate 208
17018 OPC_Decode, 211, 115, 212, 2, // 381: decode to FMIN_S_INX using decoder 340
17019 // 381: }
17020 1, 0, // 386: case 0x1: {
17021 OPC_CheckPredicate, 208, 1, // 388: check predicate 208
17022 OPC_Decode, 199, 115, 212, 2, // 391: decode to FMAX_S_INX using decoder 340
17023 // 391: }
17024 // 391: } // switch Inst[14:12]
17025 // 391: }
17026 21, 21, // 396: case 0x15: {
17027 OPC_SwitchField, 12, 3, // 398: switch Inst[14:12] {
17028 0, 7, // 401: case 0x0: {
17029 OPC_CheckPredicate, 209, 1, // 403: check predicate 209
17030 OPC_Decode, 206, 115, 31, // 406: decode to FMIN_D_INX using decoder 31
17031 // 406: }
17032 1, 0, // 410: case 0x1: {
17033 OPC_CheckPredicate, 209, 1, // 412: check predicate 209
17034 OPC_Decode, 194, 115, 31, // 415: decode to FMAX_D_INX using decoder 31
17035 // 415: }
17036 // 415: } // switch Inst[14:12]
17037 // 415: }
17038 22, 23, // 419: case 0x16: {
17039 OPC_SwitchField, 12, 3, // 421: switch Inst[14:12] {
17040 0, 8, // 424: case 0x0: {
17041 OPC_CheckPredicate, 210, 1, // 426: check predicate 210
17042 OPC_Decode, 208, 115, 213, 2, // 429: decode to FMIN_H_INX using decoder 341
17043 // 429: }
17044 1, 0, // 434: case 0x1: {
17045 OPC_CheckPredicate, 210, 1, // 436: check predicate 210
17046 OPC_Decode, 196, 115, 213, 2, // 439: decode to FMAX_H_INX using decoder 341
17047 // 439: }
17048 // 439: } // switch Inst[14:12]
17049 // 439: }
17050 32, 23, // 444: case 0x20: {
17051 OPC_SwitchField, 20, 5, // 446: switch Inst[24:20] {
17052 1, 8, // 449: case 0x1: {
17053 OPC_CheckPredicate, 209, 1, // 451: check predicate 209
17054 OPC_Decode, 229, 114, 214, 2, // 454: decode to FCVT_S_D_INX using decoder 342
17055 // 454: }
17056 2, 0, // 459: case 0x2: {
17057 OPC_CheckPredicate, 211, 1, // 461: check predicate 211
17058 OPC_Decode, 231, 114, 215, 2, // 464: decode to FCVT_S_H_INX using decoder 343
17059 // 464: }
17060 // 464: } // switch Inst[24:20]
17061 // 464: }
17062 33, 23, // 469: case 0x21: {
17063 OPC_SwitchField, 20, 5, // 471: switch Inst[24:20] {
17064 0, 8, // 474: case 0x0: {
17065 OPC_CheckPredicate, 209, 1, // 476: check predicate 209
17066 OPC_Decode, 184, 114, 216, 2, // 479: decode to FCVT_D_S_INX using decoder 344
17067 // 479: }
17068 2, 0, // 484: case 0x2: {
17069 OPC_CheckPredicate, 212, 1, // 486: check predicate 212
17070 OPC_Decode, 176, 114, 217, 2, // 489: decode to FCVT_D_H_INX using decoder 345
17071 // 489: }
17072 // 489: } // switch Inst[24:20]
17073 // 489: }
17074 34, 23, // 494: case 0x22: {
17075 OPC_SwitchField, 20, 5, // 496: switch Inst[24:20] {
17076 0, 8, // 499: case 0x0: {
17077 OPC_CheckPredicate, 211, 1, // 501: check predicate 211
17078 OPC_Decode, 200, 114, 218, 2, // 504: decode to FCVT_H_S_INX using decoder 346
17079 // 504: }
17080 1, 0, // 509: case 0x1: {
17081 OPC_CheckPredicate, 212, 1, // 511: check predicate 212
17082 OPC_Decode, 193, 114, 219, 2, // 514: decode to FCVT_H_D_INX using decoder 347
17083 // 514: }
17084 // 514: } // switch Inst[24:20]
17085 // 514: }
17086 44, 12, // 519: case 0x2c: {
17087 OPC_CheckPredicate, 208, 1, // 521: check predicate 208
17088 OPC_CheckField, 20, 5, 0, // 524: check Inst[24:20] == 0x0
17089 OPC_Decode, 169, 116, 220, 2, // 528: decode to FSQRT_S_INX using decoder 348
17090 // 528: }
17091 45, 12, // 533: case 0x2d: {
17092 OPC_CheckPredicate, 209, 1, // 535: check predicate 209
17093 OPC_CheckField, 20, 5, 0, // 538: check Inst[24:20] == 0x0
17094 OPC_Decode, 164, 116, 221, 2, // 542: decode to FSQRT_D_INX using decoder 349
17095 // 542: }
17096 46, 12, // 547: case 0x2e: {
17097 OPC_CheckPredicate, 210, 1, // 549: check predicate 210
17098 OPC_CheckField, 20, 5, 0, // 552: check Inst[24:20] == 0x0
17099 OPC_Decode, 166, 116, 222, 2, // 556: decode to FSQRT_H_INX using decoder 350
17100 // 556: }
17101 80, 33, // 561: case 0x50: {
17102 OPC_SwitchField, 12, 3, // 563: switch Inst[14:12] {
17103 0, 8, // 566: case 0x0: {
17104 OPC_CheckPredicate, 208, 1, // 568: check predicate 208
17105 OPC_Decode, 160, 115, 223, 2, // 571: decode to FLE_S_INX using decoder 351
17106 // 571: }
17107 1, 8, // 576: case 0x1: {
17108 OPC_CheckPredicate, 208, 1, // 578: check predicate 208
17109 OPC_Decode, 178, 115, 223, 2, // 581: decode to FLT_S_INX using decoder 351
17110 // 581: }
17111 2, 0, // 586: case 0x2: {
17112 OPC_CheckPredicate, 208, 1, // 588: check predicate 208
17113 OPC_Decode, 147, 115, 223, 2, // 591: decode to FEQ_S_INX using decoder 351
17114 // 591: }
17115 // 591: } // switch Inst[14:12]
17116 // 591: }
17117 81, 30, // 596: case 0x51: {
17118 OPC_SwitchField, 12, 3, // 598: switch Inst[14:12] {
17119 0, 7, // 601: case 0x0: {
17120 OPC_CheckPredicate, 209, 1, // 603: check predicate 209
17121 OPC_Decode, 155, 115, 31, // 606: decode to FLE_D_INX using decoder 31
17122 // 606: }
17123 1, 7, // 610: case 0x1: {
17124 OPC_CheckPredicate, 209, 1, // 612: check predicate 209
17125 OPC_Decode, 173, 115, 31, // 615: decode to FLT_D_INX using decoder 31
17126 // 615: }
17127 2, 0, // 619: case 0x2: {
17128 OPC_CheckPredicate, 209, 1, // 621: check predicate 209
17129 OPC_Decode, 142, 115, 31, // 624: decode to FEQ_D_INX using decoder 31
17130 // 624: }
17131 // 624: } // switch Inst[14:12]
17132 // 624: }
17133 82, 33, // 628: case 0x52: {
17134 OPC_SwitchField, 12, 3, // 630: switch Inst[14:12] {
17135 0, 8, // 633: case 0x0: {
17136 OPC_CheckPredicate, 210, 1, // 635: check predicate 210
17137 OPC_Decode, 157, 115, 224, 2, // 638: decode to FLE_H_INX using decoder 352
17138 // 638: }
17139 1, 8, // 643: case 0x1: {
17140 OPC_CheckPredicate, 210, 1, // 645: check predicate 210
17141 OPC_Decode, 175, 115, 224, 2, // 648: decode to FLT_H_INX using decoder 352
17142 // 648: }
17143 2, 0, // 653: case 0x2: {
17144 OPC_CheckPredicate, 210, 1, // 655: check predicate 210
17145 OPC_Decode, 144, 115, 224, 2, // 658: decode to FEQ_H_INX using decoder 352
17146 // 658: }
17147 // 658: } // switch Inst[14:12]
17148 // 658: }
17149 96, 43, // 663: case 0x60: {
17150 OPC_SwitchField, 20, 5, // 665: switch Inst[24:20] {
17151 0, 8, // 668: case 0x0: {
17152 OPC_CheckPredicate, 208, 1, // 670: check predicate 208
17153 OPC_Decode, 128, 115, 216, 2, // 673: decode to FCVT_W_S_INX using decoder 344
17154 // 673: }
17155 1, 8, // 678: case 0x1: {
17156 OPC_CheckPredicate, 208, 1, // 680: check predicate 208
17157 OPC_Decode, 248, 114, 216, 2, // 683: decode to FCVT_WU_S_INX using decoder 344
17158 // 683: }
17159 2, 8, // 688: case 0x2: {
17160 OPC_CheckPredicate, 213, 1, // 690: check predicate 213
17161 OPC_Decode, 218, 114, 216, 2, // 693: decode to FCVT_L_S_INX using decoder 344
17162 // 693: }
17163 3, 0, // 698: case 0x3: {
17164 OPC_CheckPredicate, 213, 1, // 700: check predicate 213
17165 OPC_Decode, 211, 114, 216, 2, // 703: decode to FCVT_LU_S_INX using decoder 344
17166 // 703: }
17167 // 703: } // switch Inst[24:20]
17168 // 703: }
17169 97, 43, // 708: case 0x61: {
17170 OPC_SwitchField, 20, 5, // 710: switch Inst[24:20] {
17171 0, 8, // 713: case 0x0: {
17172 OPC_CheckPredicate, 209, 1, // 715: check predicate 209
17173 OPC_Decode, 251, 114, 221, 2, // 718: decode to FCVT_W_D_INX using decoder 349
17174 // 718: }
17175 1, 8, // 723: case 0x1: {
17176 OPC_CheckPredicate, 209, 1, // 725: check predicate 209
17177 OPC_Decode, 243, 114, 221, 2, // 728: decode to FCVT_WU_D_INX using decoder 349
17178 // 728: }
17179 2, 8, // 733: case 0x2: {
17180 OPC_CheckPredicate, 214, 1, // 735: check predicate 214
17181 OPC_Decode, 213, 114, 221, 2, // 738: decode to FCVT_L_D_INX using decoder 349
17182 // 738: }
17183 3, 0, // 743: case 0x3: {
17184 OPC_CheckPredicate, 214, 1, // 745: check predicate 214
17185 OPC_Decode, 206, 114, 221, 2, // 748: decode to FCVT_LU_D_INX using decoder 349
17186 // 748: }
17187 // 748: } // switch Inst[24:20]
17188 // 748: }
17189 98, 43, // 753: case 0x62: {
17190 OPC_SwitchField, 20, 5, // 755: switch Inst[24:20] {
17191 0, 8, // 758: case 0x0: {
17192 OPC_CheckPredicate, 210, 1, // 760: check predicate 210
17193 OPC_Decode, 253, 114, 217, 2, // 763: decode to FCVT_W_H_INX using decoder 345
17194 // 763: }
17195 1, 8, // 768: case 0x1: {
17196 OPC_CheckPredicate, 210, 1, // 770: check predicate 210
17197 OPC_Decode, 245, 114, 217, 2, // 773: decode to FCVT_WU_H_INX using decoder 345
17198 // 773: }
17199 2, 8, // 778: case 0x2: {
17200 OPC_CheckPredicate, 215, 1, // 780: check predicate 215
17201 OPC_Decode, 215, 114, 217, 2, // 783: decode to FCVT_L_H_INX using decoder 345
17202 // 783: }
17203 3, 0, // 788: case 0x3: {
17204 OPC_CheckPredicate, 215, 1, // 790: check predicate 215
17205 OPC_Decode, 208, 114, 217, 2, // 793: decode to FCVT_LU_H_INX using decoder 345
17206 // 793: }
17207 // 793: } // switch Inst[24:20]
17208 // 793: }
17209 104, 43, // 798: case 0x68: {
17210 OPC_SwitchField, 20, 5, // 800: switch Inst[24:20] {
17211 0, 8, // 803: case 0x0: {
17212 OPC_CheckPredicate, 208, 1, // 805: check predicate 208
17213 OPC_Decode, 240, 114, 214, 2, // 808: decode to FCVT_S_W_INX using decoder 342
17214 // 808: }
17215 1, 8, // 813: case 0x1: {
17216 OPC_CheckPredicate, 208, 1, // 815: check predicate 208
17217 OPC_Decode, 239, 114, 214, 2, // 818: decode to FCVT_S_WU_INX using decoder 342
17218 // 818: }
17219 2, 8, // 823: case 0x2: {
17220 OPC_CheckPredicate, 213, 1, // 825: check predicate 213
17221 OPC_Decode, 235, 114, 214, 2, // 828: decode to FCVT_S_L_INX using decoder 342
17222 // 828: }
17223 3, 0, // 833: case 0x3: {
17224 OPC_CheckPredicate, 213, 1, // 835: check predicate 213
17225 OPC_Decode, 234, 114, 214, 2, // 838: decode to FCVT_S_LU_INX using decoder 342
17226 // 838: }
17227 // 838: } // switch Inst[24:20]
17228 // 838: }
17229 105, 43, // 843: case 0x69: {
17230 OPC_SwitchField, 20, 5, // 845: switch Inst[24:20] {
17231 0, 8, // 848: case 0x0: {
17232 OPC_CheckPredicate, 209, 1, // 850: check predicate 209
17233 OPC_Decode, 190, 114, 221, 2, // 853: decode to FCVT_D_W_INX using decoder 349
17234 // 853: }
17235 1, 8, // 858: case 0x1: {
17236 OPC_CheckPredicate, 209, 1, // 860: check predicate 209
17237 OPC_Decode, 188, 114, 221, 2, // 863: decode to FCVT_D_WU_INX using decoder 349
17238 // 863: }
17239 2, 8, // 868: case 0x2: {
17240 OPC_CheckPredicate, 214, 1, // 870: check predicate 214
17241 OPC_Decode, 180, 114, 221, 2, // 873: decode to FCVT_D_L_INX using decoder 349
17242 // 873: }
17243 3, 0, // 878: case 0x3: {
17244 OPC_CheckPredicate, 214, 1, // 880: check predicate 214
17245 OPC_Decode, 179, 114, 221, 2, // 883: decode to FCVT_D_LU_INX using decoder 349
17246 // 883: }
17247 // 883: } // switch Inst[24:20]
17248 // 883: }
17249 106, 43, // 888: case 0x6a: {
17250 OPC_SwitchField, 20, 5, // 890: switch Inst[24:20] {
17251 0, 8, // 893: case 0x0: {
17252 OPC_CheckPredicate, 210, 1, // 895: check predicate 210
17253 OPC_Decode, 204, 114, 219, 2, // 898: decode to FCVT_H_W_INX using decoder 347
17254 // 898: }
17255 1, 8, // 903: case 0x1: {
17256 OPC_CheckPredicate, 210, 1, // 905: check predicate 210
17257 OPC_Decode, 203, 114, 219, 2, // 908: decode to FCVT_H_WU_INX using decoder 347
17258 // 908: }
17259 2, 8, // 913: case 0x2: {
17260 OPC_CheckPredicate, 215, 1, // 915: check predicate 215
17261 OPC_Decode, 197, 114, 219, 2, // 918: decode to FCVT_H_L_INX using decoder 347
17262 // 918: }
17263 3, 0, // 923: case 0x3: {
17264 OPC_CheckPredicate, 215, 1, // 925: check predicate 215
17265 OPC_Decode, 196, 114, 219, 2, // 928: decode to FCVT_H_LU_INX using decoder 347
17266 // 928: }
17267 // 928: } // switch Inst[24:20]
17268 // 928: }
17269 112, 16, // 933: case 0x70: {
17270 OPC_CheckPredicate, 208, 1, // 935: check predicate 208
17271 OPC_CheckField, 20, 5, 0, // 938: check Inst[24:20] == 0x0
17272 OPC_CheckField, 12, 3, 1, // 942: check Inst[14:12] == 0x1
17273 OPC_Decode, 171, 114, 225, 2, // 946: decode to FCLASS_S_INX using decoder 353
17274 // 946: }
17275 113, 15, // 951: case 0x71: {
17276 OPC_CheckPredicate, 209, 1, // 953: check predicate 209
17277 OPC_CheckField, 20, 5, 0, // 956: check Inst[24:20] == 0x0
17278 OPC_CheckField, 12, 3, 1, // 960: check Inst[14:12] == 0x1
17279 OPC_Decode, 166, 114, 17, // 964: decode to FCLASS_D_INX using decoder 17
17280 // 964: }
17281 114, 0, // 968: case 0x72: {
17282 OPC_CheckPredicate, 210, 1, // 970: check predicate 210
17283 OPC_CheckField, 20, 5, 0, // 973: check Inst[24:20] == 0x0
17284 OPC_CheckField, 12, 3, 1, // 977: check Inst[14:12] == 0x1
17285 OPC_Decode, 168, 114, 226, 2, // 981: decode to FCLASS_H_INX using decoder 354
17286 // 981: }
17287 // 981: } // switch Inst[31:25]
17288 // 981: }
17289 // 981: } // switch Inst[6:0]
17290};
17291// Handling 355 cases.
17292template <typename InsnType>
17293static std::enable_if_t<InsnBitWidth<InsnType> == 32, DecodeStatus>
17294decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
17295 DecodeComplete = true;
17296 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
17297 TmpType tmp;
17298 switch (Idx) {
17299 default: llvm_unreachable("Invalid decoder index!");
17300 case 0:
17301 tmp = fieldFromInstruction(insn, 7, 5);
17302 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17303 tmp = fieldFromInstruction(insn, 15, 5);
17304 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17305 tmp = fieldFromInstruction(insn, 20, 12);
17306 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17307 return S;
17308 case 1:
17309 tmp = fieldFromInstruction(insn, 7, 5);
17310 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17311 tmp = fieldFromInstruction(insn, 15, 5);
17312 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17313 tmp = fieldFromInstruction(insn, 25, 1);
17314 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17315 return S;
17316 case 2:
17317 tmp = fieldFromInstruction(insn, 7, 5);
17318 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17319 tmp = fieldFromInstruction(insn, 15, 5);
17320 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17321 return S;
17322 case 3:
17323 tmp = fieldFromInstruction(insn, 7, 5);
17324 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17325 tmp = fieldFromInstruction(insn, 15, 5);
17326 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17327 tmp = fieldFromInstruction(insn, 20, 5);
17328 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17329 tmp = fieldFromInstruction(insn, 25, 1);
17330 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17331 return S;
17332 case 4:
17333 tmp = fieldFromInstruction(insn, 7, 5);
17334 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17335 tmp = fieldFromInstruction(insn, 15, 5);
17336 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17337 tmp = fieldFromInstruction(insn, 20, 5);
17338 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17339 tmp = fieldFromInstruction(insn, 25, 1);
17340 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17341 return S;
17342 case 5:
17343 tmp = fieldFromInstruction(insn, 7, 5);
17344 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17345 tmp = fieldFromInstruction(insn, 15, 5);
17346 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17347 return S;
17348 case 6:
17349 tmp = fieldFromInstruction(insn, 7, 5);
17350 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM4RegClassID, 32, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17351 tmp = fieldFromInstruction(insn, 15, 5);
17352 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17353 return S;
17354 case 7:
17355 tmp = fieldFromInstruction(insn, 7, 5);
17356 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17357 tmp = fieldFromInstruction(insn, 15, 5);
17358 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17359 return S;
17360 case 8:
17361 tmp = fieldFromInstruction(insn, 7, 5);
17362 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17363 tmp = fieldFromInstruction(insn, 15, 5);
17364 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17365 tmp = fieldFromInstruction(insn, 20, 12);
17366 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17367 return S;
17368 case 9:
17369 tmp = fieldFromInstruction(insn, 7, 5);
17370 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17371 tmp = fieldFromInstruction(insn, 15, 5);
17372 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17373 tmp = fieldFromInstruction(insn, 20, 12);
17374 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17375 return S;
17376 case 10:
17377 tmp = fieldFromInstruction(insn, 7, 5);
17378 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17379 tmp = fieldFromInstruction(insn, 15, 5);
17380 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17381 tmp = fieldFromInstruction(insn, 20, 12);
17382 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17383 return S;
17384 case 11:
17385 tmp = fieldFromInstruction(insn, 7, 5);
17386 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17387 tmp = fieldFromInstruction(insn, 15, 5);
17388 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17389 tmp = fieldFromInstruction(insn, 20, 12);
17390 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17391 return S;
17392 case 12:
17393 tmp = fieldFromInstruction(insn, 7, 5);
17394 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17395 tmp = fieldFromInstruction(insn, 15, 5);
17396 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17397 tmp = fieldFromInstruction(insn, 20, 5);
17398 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17399 tmp = fieldFromInstruction(insn, 29, 3);
17400 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17401 tmp = fieldFromInstruction(insn, 25, 1);
17402 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17403 return S;
17404 case 13:
17405 tmp = fieldFromInstruction(insn, 24, 4);
17406 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17407 tmp = fieldFromInstruction(insn, 20, 4);
17408 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17409 return S;
17410 case 14:
17411 return S;
17412 case 15:
17413 tmp = fieldFromInstruction(insn, 15, 5);
17414 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17415 return S;
17416 case 16:
17417 tmp = fieldFromInstruction(insn, 7, 5);
17418 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17419 tmp = fieldFromInstruction(insn, 15, 5);
17420 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17421 tmp = fieldFromInstruction(insn, 20, 6);
17422 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17423 return S;
17424 case 17:
17425 tmp = fieldFromInstruction(insn, 7, 5);
17426 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17427 tmp = fieldFromInstruction(insn, 15, 5);
17428 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17429 return S;
17430 case 18:
17431 tmp = fieldFromInstruction(insn, 7, 5);
17432 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17433 tmp = fieldFromInstruction(insn, 15, 5);
17434 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17435 tmp = fieldFromInstruction(insn, 20, 4);
17436 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17437 return S;
17438 case 19:
17439 tmp = fieldFromInstruction(insn, 15, 5);
17440 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17441 tmp = fieldFromInstruction(insn, 25, 7) << 5;
17442 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17443 return S;
17444 case 20:
17445 tmp = fieldFromInstruction(insn, 7, 5);
17446 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17447 tmp = fieldFromInstruction(insn, 12, 20);
17448 if (!Check(S, decodeUImm20Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17449 return S;
17450 case 21:
17451 tmp = fieldFromInstruction(insn, 7, 5);
17452 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17453 tmp = fieldFromInstruction(insn, 15, 5);
17454 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17455 tmp = fieldFromInstruction(insn, 20, 5);
17456 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17457 return S;
17458 case 22:
17459 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17460 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17461 tmp = fieldFromInstruction(insn, 15, 5);
17462 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17463 tmp = fieldFromInstruction(insn, 20, 4);
17464 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17465 return S;
17466 case 23:
17467 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17468 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17469 tmp = fieldFromInstruction(insn, 15, 5);
17470 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17471 tmp = fieldFromInstruction(insn, 20, 5);
17472 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17473 return S;
17474 case 24:
17475 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17476 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17477 tmp = fieldFromInstruction(insn, 15, 5);
17478 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17479 tmp = fieldFromInstruction(insn, 20, 5);
17480 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17481 return S;
17482 case 25:
17483 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17484 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17485 tmp = fieldFromInstruction(insn, 15, 5);
17486 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17487 tmp = fieldFromInstruction(insn, 20, 6);
17488 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17489 return S;
17490 case 26:
17491 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17492 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17493 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17494 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17495 tmp = fieldFromInstruction(insn, 15, 5);
17496 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17497 tmp = fieldFromInstruction(insn, 20, 5);
17498 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17499 return S;
17500 case 27:
17501 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17502 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17503 tmp = 0x0;
17504 tmp |= fieldFromInstruction(insn, 15, 1) << 9;
17505 tmp |= fieldFromInstruction(insn, 16, 9);
17506 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17507 return S;
17508 case 28:
17509 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17510 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17511 tmp = fieldFromInstruction(insn, 16, 8);
17512 if (!Check(S, decodeSImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17513 return S;
17514 case 29:
17515 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17516 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17517 tmp = 0x0;
17518 tmp |= fieldFromInstruction(insn, 15, 9) << 1;
17519 tmp |= fieldFromInstruction(insn, 24, 1);
17520 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17521 return S;
17522 case 30:
17523 tmp = fieldFromInstruction(insn, 7, 5);
17524 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17525 tmp = fieldFromInstruction(insn, 15, 5);
17526 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17527 tmp = fieldFromInstruction(insn, 20, 3);
17528 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17529 return S;
17530 case 31:
17531 tmp = fieldFromInstruction(insn, 7, 5);
17532 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17533 tmp = fieldFromInstruction(insn, 15, 5);
17534 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17535 tmp = fieldFromInstruction(insn, 20, 5);
17536 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17537 return S;
17538 case 32:
17539 tmp = fieldFromInstruction(insn, 7, 5);
17540 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17541 tmp = 0x0;
17542 tmp |= fieldFromInstruction(insn, 15, 1) << 9;
17543 tmp |= fieldFromInstruction(insn, 16, 9);
17544 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17545 return S;
17546 case 33:
17547 tmp = fieldFromInstruction(insn, 7, 5);
17548 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17549 tmp = fieldFromInstruction(insn, 16, 8);
17550 if (!Check(S, decodeSImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17551 return S;
17552 case 34:
17553 tmp = fieldFromInstruction(insn, 7, 5);
17554 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17555 tmp = 0x0;
17556 tmp |= fieldFromInstruction(insn, 15, 9) << 1;
17557 tmp |= fieldFromInstruction(insn, 24, 1);
17558 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17559 return S;
17560 case 35:
17561 tmp = fieldFromInstruction(insn, 7, 5);
17562 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17563 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17564 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17565 tmp = fieldFromInstruction(insn, 20, 4);
17566 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17567 return S;
17568 case 36:
17569 tmp = fieldFromInstruction(insn, 7, 5);
17570 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17571 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17572 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17573 tmp = fieldFromInstruction(insn, 20, 5);
17574 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17575 return S;
17576 case 37:
17577 tmp = fieldFromInstruction(insn, 7, 5);
17578 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17579 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17580 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17581 tmp = fieldFromInstruction(insn, 20, 6);
17582 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17583 return S;
17584 case 38:
17585 tmp = fieldFromInstruction(insn, 7, 5);
17586 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17587 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17588 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17589 tmp = fieldFromInstruction(insn, 20, 5);
17590 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17591 return S;
17592 case 39:
17593 tmp = fieldFromInstruction(insn, 7, 5);
17594 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17595 tmp = fieldFromInstruction(insn, 15, 5);
17596 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17597 tmp = fieldFromInstruction(insn, 20, 6);
17598 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17599 return S;
17600 case 40:
17601 tmp = fieldFromInstruction(insn, 7, 5);
17602 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17603 tmp = fieldFromInstruction(insn, 15, 5);
17604 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17605 tmp = fieldFromInstruction(insn, 20, 4);
17606 if (!Check(S, decodeUImmPlus1Operand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17607 return S;
17608 case 41:
17609 tmp = fieldFromInstruction(insn, 7, 5);
17610 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17611 tmp = fieldFromInstruction(insn, 15, 5);
17612 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17613 tmp = fieldFromInstruction(insn, 20, 5);
17614 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17615 return S;
17616 case 42:
17617 tmp = fieldFromInstruction(insn, 7, 5);
17618 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17619 tmp = fieldFromInstruction(insn, 15, 5);
17620 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17621 tmp = fieldFromInstruction(insn, 20, 6);
17622 if (!Check(S, decodeUImmPlus1Operand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17623 return S;
17624 case 43:
17625 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17626 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17627 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17628 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17629 tmp = fieldFromInstruction(insn, 20, 3);
17630 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17631 return S;
17632 case 44:
17633 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17634 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17635 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17636 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17637 tmp = fieldFromInstruction(insn, 20, 4);
17638 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17639 return S;
17640 case 45:
17641 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17642 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17643 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17644 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17645 tmp = fieldFromInstruction(insn, 20, 5);
17646 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17647 return S;
17648 case 46:
17649 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17650 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17651 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17652 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17653 tmp = fieldFromInstruction(insn, 20, 5);
17654 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17655 return S;
17656 case 47:
17657 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17658 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17659 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17660 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17661 return S;
17662 case 48:
17663 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17664 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17665 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17666 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17667 tmp = fieldFromInstruction(insn, 20, 4);
17668 if (!Check(S, decodeUImmPlus1Operand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17669 return S;
17670 case 49:
17671 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17672 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17673 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17674 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17675 tmp = fieldFromInstruction(insn, 20, 5);
17676 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17677 return S;
17678 case 50:
17679 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17680 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17681 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17682 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17683 tmp = fieldFromInstruction(insn, 21, 4) << 1;
17684 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17685 return S;
17686 case 51:
17687 tmp = fieldFromInstruction(insn, 20, 5);
17688 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17689 tmp = fieldFromInstruction(insn, 15, 5);
17690 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17691 tmp = 0x0;
17692 tmp |= fieldFromInstruction(insn, 7, 5);
17693 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17694 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17695 return S;
17696 case 52:
17697 tmp = fieldFromInstruction(insn, 20, 5);
17698 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17699 tmp = fieldFromInstruction(insn, 15, 5);
17700 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17701 tmp = 0x0;
17702 tmp |= fieldFromInstruction(insn, 7, 5);
17703 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17704 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17705 return S;
17706 case 53:
17707 tmp = fieldFromInstruction(insn, 20, 5);
17708 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17709 tmp = fieldFromInstruction(insn, 15, 5);
17710 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17711 tmp = 0x0;
17712 tmp |= fieldFromInstruction(insn, 7, 5);
17713 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17714 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17715 return S;
17716 case 54:
17717 tmp = fieldFromInstruction(insn, 20, 5);
17718 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17719 tmp = fieldFromInstruction(insn, 15, 5);
17720 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17721 tmp = 0x0;
17722 tmp |= fieldFromInstruction(insn, 7, 5);
17723 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17724 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17725 return S;
17726 case 55:
17727 tmp = fieldFromInstruction(insn, 20, 5);
17728 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17729 tmp = fieldFromInstruction(insn, 15, 5);
17730 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17731 tmp = 0x0;
17732 tmp |= fieldFromInstruction(insn, 7, 5);
17733 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17734 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17735 return S;
17736 case 56:
17737 tmp = fieldFromInstruction(insn, 7, 5);
17738 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17739 tmp = fieldFromInstruction(insn, 20, 5);
17740 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17741 tmp = fieldFromInstruction(insn, 15, 5);
17742 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17743 return S;
17744 case 57:
17745 tmp = fieldFromInstruction(insn, 7, 5);
17746 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17747 tmp = fieldFromInstruction(insn, 7, 5);
17748 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17749 tmp = fieldFromInstruction(insn, 20, 5);
17750 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17751 tmp = fieldFromInstruction(insn, 15, 5);
17752 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17753 return S;
17754 case 58:
17755 tmp = fieldFromInstruction(insn, 7, 5);
17756 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17757 tmp = fieldFromInstruction(insn, 7, 5);
17758 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17759 tmp = fieldFromInstruction(insn, 20, 5);
17760 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17761 tmp = fieldFromInstruction(insn, 15, 5);
17762 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17763 return S;
17764 case 59:
17765 tmp = fieldFromInstruction(insn, 20, 5);
17766 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17767 tmp = fieldFromInstruction(insn, 15, 5);
17768 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17769 return S;
17770 case 60:
17771 tmp = fieldFromInstruction(insn, 7, 5);
17772 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17773 tmp = fieldFromInstruction(insn, 15, 5);
17774 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17775 tmp = fieldFromInstruction(insn, 20, 5);
17776 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17777 tmp = fieldFromInstruction(insn, 30, 2);
17778 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17779 return S;
17780 case 61:
17781 tmp = fieldFromInstruction(insn, 7, 5);
17782 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17783 tmp = fieldFromInstruction(insn, 7, 5);
17784 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17785 tmp = fieldFromInstruction(insn, 15, 5);
17786 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17787 tmp = fieldFromInstruction(insn, 20, 5);
17788 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17789 return S;
17790 case 62:
17791 tmp = fieldFromInstruction(insn, 7, 5);
17792 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17793 tmp = fieldFromInstruction(insn, 15, 5);
17794 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17795 tmp = fieldFromInstruction(insn, 20, 5);
17796 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17797 tmp = fieldFromInstruction(insn, 27, 5);
17798 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17799 tmp = fieldFromInstruction(insn, 12, 3);
17800 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17801 return S;
17802 case 63:
17803 tmp = fieldFromInstruction(insn, 7, 5);
17804 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17805 tmp = fieldFromInstruction(insn, 15, 5);
17806 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17807 tmp = fieldFromInstruction(insn, 20, 5);
17808 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17809 tmp = fieldFromInstruction(insn, 27, 5);
17810 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17811 tmp = fieldFromInstruction(insn, 12, 3);
17812 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17813 return S;
17814 case 64:
17815 tmp = fieldFromInstruction(insn, 7, 5);
17816 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17817 tmp = fieldFromInstruction(insn, 15, 5);
17818 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17819 tmp = fieldFromInstruction(insn, 20, 5);
17820 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17821 tmp = fieldFromInstruction(insn, 27, 5);
17822 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17823 tmp = fieldFromInstruction(insn, 12, 3);
17824 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17825 return S;
17826 case 65:
17827 tmp = fieldFromInstruction(insn, 7, 5);
17828 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17829 tmp = fieldFromInstruction(insn, 15, 5);
17830 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17831 tmp = fieldFromInstruction(insn, 20, 5);
17832 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17833 tmp = fieldFromInstruction(insn, 27, 5);
17834 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17835 tmp = fieldFromInstruction(insn, 12, 3);
17836 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17837 return S;
17838 case 66:
17839 tmp = fieldFromInstruction(insn, 7, 5);
17840 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17841 tmp = fieldFromInstruction(insn, 15, 5);
17842 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17843 tmp = fieldFromInstruction(insn, 20, 5);
17844 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17845 tmp = fieldFromInstruction(insn, 12, 3);
17846 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17847 return S;
17848 case 67:
17849 tmp = fieldFromInstruction(insn, 7, 5);
17850 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17851 tmp = fieldFromInstruction(insn, 15, 5);
17852 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17853 tmp = fieldFromInstruction(insn, 20, 5);
17854 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17855 tmp = fieldFromInstruction(insn, 12, 3);
17856 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17857 return S;
17858 case 68:
17859 tmp = fieldFromInstruction(insn, 7, 5);
17860 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17861 tmp = fieldFromInstruction(insn, 15, 5);
17862 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17863 tmp = fieldFromInstruction(insn, 20, 5);
17864 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17865 tmp = fieldFromInstruction(insn, 12, 3);
17866 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17867 return S;
17868 case 69:
17869 tmp = fieldFromInstruction(insn, 7, 5);
17870 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17871 tmp = fieldFromInstruction(insn, 15, 5);
17872 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17873 tmp = fieldFromInstruction(insn, 20, 5);
17874 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17875 tmp = fieldFromInstruction(insn, 12, 3);
17876 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17877 return S;
17878 case 70:
17879 tmp = fieldFromInstruction(insn, 7, 5);
17880 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17881 tmp = fieldFromInstruction(insn, 15, 5);
17882 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17883 tmp = fieldFromInstruction(insn, 20, 5);
17884 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17885 return S;
17886 case 71:
17887 tmp = fieldFromInstruction(insn, 7, 5);
17888 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17889 tmp = fieldFromInstruction(insn, 15, 5);
17890 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17891 tmp = fieldFromInstruction(insn, 20, 5);
17892 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17893 return S;
17894 case 72:
17895 tmp = fieldFromInstruction(insn, 7, 5);
17896 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17897 tmp = fieldFromInstruction(insn, 15, 5);
17898 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17899 tmp = fieldFromInstruction(insn, 20, 5);
17900 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17901 return S;
17902 case 73:
17903 tmp = fieldFromInstruction(insn, 7, 5);
17904 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17905 tmp = fieldFromInstruction(insn, 15, 5);
17906 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17907 tmp = fieldFromInstruction(insn, 20, 5);
17908 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17909 return S;
17910 case 74:
17911 tmp = fieldFromInstruction(insn, 7, 5);
17912 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17913 tmp = fieldFromInstruction(insn, 15, 5);
17914 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17915 tmp = fieldFromInstruction(insn, 12, 3);
17916 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17917 return S;
17918 case 75:
17919 tmp = fieldFromInstruction(insn, 7, 5);
17920 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17921 tmp = fieldFromInstruction(insn, 15, 5);
17922 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17923 tmp = fieldFromInstruction(insn, 12, 3);
17924 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17925 return S;
17926 case 76:
17927 tmp = fieldFromInstruction(insn, 7, 5);
17928 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17929 tmp = fieldFromInstruction(insn, 15, 5);
17930 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17931 tmp = fieldFromInstruction(insn, 12, 3);
17932 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17933 return S;
17934 case 77:
17935 tmp = fieldFromInstruction(insn, 7, 5);
17936 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17937 tmp = fieldFromInstruction(insn, 15, 5);
17938 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17939 tmp = fieldFromInstruction(insn, 12, 3);
17940 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17941 return S;
17942 case 78:
17943 tmp = fieldFromInstruction(insn, 7, 5);
17944 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17945 tmp = fieldFromInstruction(insn, 15, 5);
17946 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17947 tmp = fieldFromInstruction(insn, 12, 3);
17948 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17949 return S;
17950 case 79:
17951 tmp = fieldFromInstruction(insn, 7, 5);
17952 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17953 tmp = fieldFromInstruction(insn, 15, 5);
17954 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17955 tmp = fieldFromInstruction(insn, 12, 3);
17956 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17957 return S;
17958 case 80:
17959 tmp = fieldFromInstruction(insn, 7, 5);
17960 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17961 tmp = fieldFromInstruction(insn, 15, 5);
17962 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17963 tmp = fieldFromInstruction(insn, 12, 3);
17964 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17965 return S;
17966 case 81:
17967 tmp = fieldFromInstruction(insn, 7, 5);
17968 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17969 tmp = fieldFromInstruction(insn, 15, 5);
17970 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17971 tmp = fieldFromInstruction(insn, 12, 3);
17972 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17973 return S;
17974 case 82:
17975 tmp = fieldFromInstruction(insn, 7, 5);
17976 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17977 tmp = fieldFromInstruction(insn, 15, 5);
17978 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17979 tmp = fieldFromInstruction(insn, 12, 3);
17980 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17981 return S;
17982 case 83:
17983 tmp = fieldFromInstruction(insn, 7, 5);
17984 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17985 tmp = fieldFromInstruction(insn, 15, 5);
17986 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17987 tmp = fieldFromInstruction(insn, 12, 3);
17988 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17989 return S;
17990 case 84:
17991 tmp = fieldFromInstruction(insn, 7, 5);
17992 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17993 tmp = fieldFromInstruction(insn, 15, 5);
17994 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17995 tmp = fieldFromInstruction(insn, 12, 3);
17996 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17997 return S;
17998 case 85:
17999 tmp = fieldFromInstruction(insn, 7, 5);
18000 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18001 tmp = fieldFromInstruction(insn, 15, 5);
18002 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18003 tmp = fieldFromInstruction(insn, 12, 3);
18004 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18005 return S;
18006 case 86:
18007 tmp = fieldFromInstruction(insn, 7, 5);
18008 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18009 tmp = fieldFromInstruction(insn, 15, 5);
18010 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18011 tmp = fieldFromInstruction(insn, 12, 3);
18012 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18013 return S;
18014 case 87:
18015 tmp = fieldFromInstruction(insn, 7, 5);
18016 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18017 tmp = fieldFromInstruction(insn, 15, 5);
18018 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18019 tmp = fieldFromInstruction(insn, 12, 3);
18020 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18021 return S;
18022 case 88:
18023 tmp = fieldFromInstruction(insn, 7, 5);
18024 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18025 tmp = fieldFromInstruction(insn, 15, 5);
18026 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18027 tmp = fieldFromInstruction(insn, 12, 3);
18028 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18029 return S;
18030 case 89:
18031 tmp = fieldFromInstruction(insn, 7, 5);
18032 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18033 tmp = fieldFromInstruction(insn, 15, 5);
18034 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18035 tmp = fieldFromInstruction(insn, 12, 3);
18036 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18037 return S;
18038 case 90:
18039 tmp = fieldFromInstruction(insn, 7, 5);
18040 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18041 tmp = fieldFromInstruction(insn, 15, 5);
18042 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18043 tmp = fieldFromInstruction(insn, 20, 5);
18044 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18045 return S;
18046 case 91:
18047 tmp = fieldFromInstruction(insn, 7, 5);
18048 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18049 tmp = fieldFromInstruction(insn, 15, 5);
18050 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18051 tmp = fieldFromInstruction(insn, 20, 5);
18052 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18053 return S;
18054 case 92:
18055 tmp = fieldFromInstruction(insn, 7, 5);
18056 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18057 tmp = fieldFromInstruction(insn, 15, 5);
18058 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18059 tmp = fieldFromInstruction(insn, 20, 5);
18060 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18061 return S;
18062 case 93:
18063 tmp = fieldFromInstruction(insn, 7, 5);
18064 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18065 tmp = fieldFromInstruction(insn, 15, 5);
18066 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18067 tmp = fieldFromInstruction(insn, 20, 5);
18068 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18069 return S;
18070 case 94:
18071 tmp = fieldFromInstruction(insn, 7, 5);
18072 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18073 tmp = fieldFromInstruction(insn, 15, 5);
18074 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18075 tmp = fieldFromInstruction(insn, 20, 5);
18076 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18077 return S;
18078 case 95:
18079 tmp = fieldFromInstruction(insn, 7, 5);
18080 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18081 tmp = fieldFromInstruction(insn, 15, 5);
18082 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18083 tmp = fieldFromInstruction(insn, 20, 5);
18084 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18085 return S;
18086 case 96:
18087 tmp = fieldFromInstruction(insn, 7, 5);
18088 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18089 tmp = fieldFromInstruction(insn, 15, 5);
18090 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18091 tmp = fieldFromInstruction(insn, 12, 3);
18092 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18093 return S;
18094 case 97:
18095 tmp = fieldFromInstruction(insn, 7, 5);
18096 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18097 tmp = fieldFromInstruction(insn, 15, 5);
18098 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18099 tmp = fieldFromInstruction(insn, 12, 3);
18100 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18101 return S;
18102 case 98:
18103 tmp = fieldFromInstruction(insn, 7, 5);
18104 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18105 tmp = fieldFromInstruction(insn, 15, 5);
18106 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18107 tmp = 0x1;
18108 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18109 return S;
18110 case 99:
18111 tmp = fieldFromInstruction(insn, 7, 5);
18112 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18113 tmp = fieldFromInstruction(insn, 15, 5);
18114 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18115 tmp = fieldFromInstruction(insn, 12, 3);
18116 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18117 return S;
18118 case 100:
18119 tmp = fieldFromInstruction(insn, 7, 5);
18120 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18121 tmp = fieldFromInstruction(insn, 15, 5);
18122 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18123 tmp = fieldFromInstruction(insn, 12, 3);
18124 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18125 return S;
18126 case 101:
18127 tmp = fieldFromInstruction(insn, 7, 5);
18128 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18129 tmp = fieldFromInstruction(insn, 15, 5);
18130 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18131 tmp = fieldFromInstruction(insn, 12, 3);
18132 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18133 return S;
18134 case 102:
18135 tmp = fieldFromInstruction(insn, 7, 5);
18136 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18137 tmp = fieldFromInstruction(insn, 15, 5);
18138 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18139 tmp = fieldFromInstruction(insn, 12, 3);
18140 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18141 return S;
18142 case 103:
18143 tmp = fieldFromInstruction(insn, 7, 5);
18144 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18145 tmp = fieldFromInstruction(insn, 15, 5);
18146 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18147 tmp = fieldFromInstruction(insn, 12, 3);
18148 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18149 return S;
18150 case 104:
18151 tmp = fieldFromInstruction(insn, 7, 5);
18152 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18153 tmp = fieldFromInstruction(insn, 15, 5);
18154 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18155 tmp = fieldFromInstruction(insn, 12, 3);
18156 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18157 return S;
18158 case 105:
18159 tmp = fieldFromInstruction(insn, 7, 5);
18160 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18161 tmp = fieldFromInstruction(insn, 15, 5);
18162 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18163 return S;
18164 case 106:
18165 tmp = fieldFromInstruction(insn, 7, 5);
18166 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18167 tmp = fieldFromInstruction(insn, 15, 5);
18168 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18169 return S;
18170 case 107:
18171 tmp = fieldFromInstruction(insn, 7, 5);
18172 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18173 tmp = fieldFromInstruction(insn, 15, 5);
18174 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18175 return S;
18176 case 108:
18177 tmp = fieldFromInstruction(insn, 7, 5);
18178 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18179 tmp = fieldFromInstruction(insn, 15, 5);
18180 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18181 return S;
18182 case 109:
18183 tmp = fieldFromInstruction(insn, 7, 5);
18184 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18185 tmp = fieldFromInstruction(insn, 15, 5);
18186 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18187 return S;
18188 case 110:
18189 tmp = fieldFromInstruction(insn, 7, 5);
18190 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18191 tmp = fieldFromInstruction(insn, 15, 5);
18192 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
18193 return S;
18194 case 111:
18195 tmp = fieldFromInstruction(insn, 7, 5);
18196 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18197 tmp = fieldFromInstruction(insn, 15, 5);
18198 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18199 return S;
18200 case 112:
18201 tmp = fieldFromInstruction(insn, 7, 5);
18202 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18203 tmp = fieldFromInstruction(insn, 15, 5);
18204 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
18205 return S;
18206 case 113:
18207 tmp = fieldFromInstruction(insn, 7, 5);
18208 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18209 tmp = fieldFromInstruction(insn, 15, 5);
18210 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18211 return S;
18212 case 114:
18213 tmp = fieldFromInstruction(insn, 7, 5);
18214 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18215 tmp = fieldFromInstruction(insn, 15, 5);
18216 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
18217 return S;
18218 case 115:
18219 tmp = fieldFromInstruction(insn, 7, 5);
18220 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18221 tmp = fieldFromInstruction(insn, 15, 5);
18222 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
18223 return S;
18224 case 116:
18225 tmp = fieldFromInstruction(insn, 7, 5);
18226 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18227 tmp = fieldFromInstruction(insn, 20, 5);
18228 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18229 tmp = fieldFromInstruction(insn, 15, 5);
18230 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18231 tmp = fieldFromInstruction(insn, 25, 1);
18232 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18233 return S;
18234 case 117:
18235 tmp = fieldFromInstruction(insn, 7, 5);
18236 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18237 tmp = fieldFromInstruction(insn, 20, 5);
18238 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18239 tmp = fieldFromInstruction(insn, 15, 5);
18240 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18241 tmp = 0x0;
18242 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18243 return S;
18244 case 118:
18245 tmp = fieldFromInstruction(insn, 7, 5);
18246 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18247 tmp = fieldFromInstruction(insn, 20, 5);
18248 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18249 tmp = fieldFromInstruction(insn, 15, 5);
18250 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18251 return S;
18252 case 119:
18253 tmp = fieldFromInstruction(insn, 7, 5);
18254 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18255 tmp = fieldFromInstruction(insn, 15, 5);
18256 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18257 return S;
18258 case 120:
18259 tmp = fieldFromInstruction(insn, 7, 5);
18260 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18261 tmp = fieldFromInstruction(insn, 7, 5);
18262 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18263 tmp = fieldFromInstruction(insn, 15, 5);
18264 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18265 tmp = fieldFromInstruction(insn, 20, 5);
18266 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18267 return S;
18268 case 121:
18269 tmp = fieldFromInstruction(insn, 7, 5);
18270 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18271 tmp = fieldFromInstruction(insn, 7, 5);
18272 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18273 tmp = fieldFromInstruction(insn, 15, 5);
18274 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18275 tmp = fieldFromInstruction(insn, 20, 5);
18276 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18277 tmp = 0x0;
18278 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18279 return S;
18280 case 122:
18281 tmp = fieldFromInstruction(insn, 7, 5);
18282 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18283 tmp = fieldFromInstruction(insn, 7, 5);
18284 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18285 tmp = fieldFromInstruction(insn, 20, 5);
18286 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18287 tmp = fieldFromInstruction(insn, 15, 5);
18288 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18289 tmp = fieldFromInstruction(insn, 25, 1);
18290 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18291 return S;
18292 case 123:
18293 tmp = fieldFromInstruction(insn, 7, 5);
18294 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18295 tmp = fieldFromInstruction(insn, 20, 5);
18296 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18297 return S;
18298 case 124:
18299 tmp = fieldFromInstruction(insn, 7, 5);
18300 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18301 tmp = fieldFromInstruction(insn, 20, 5);
18302 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18303 tmp = fieldFromInstruction(insn, 25, 1);
18304 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18305 return S;
18306 case 125:
18307 tmp = fieldFromInstruction(insn, 7, 5);
18308 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18309 tmp = fieldFromInstruction(insn, 7, 5);
18310 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18311 tmp = fieldFromInstruction(insn, 15, 5);
18312 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18313 tmp = fieldFromInstruction(insn, 20, 5);
18314 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18315 tmp = fieldFromInstruction(insn, 25, 1);
18316 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18317 return S;
18318 case 126:
18319 tmp = fieldFromInstruction(insn, 7, 5);
18320 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18321 tmp = fieldFromInstruction(insn, 20, 5);
18322 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18323 return S;
18324 case 127:
18325 tmp = fieldFromInstruction(insn, 7, 5);
18326 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18327 tmp = fieldFromInstruction(insn, 20, 5);
18328 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18329 tmp = fieldFromInstruction(insn, 25, 1);
18330 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18331 return S;
18332 case 128:
18333 tmp = fieldFromInstruction(insn, 7, 5);
18334 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18335 tmp = fieldFromInstruction(insn, 25, 1);
18336 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18337 return S;
18338 case 129:
18339 tmp = fieldFromInstruction(insn, 7, 5);
18340 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18341 tmp = fieldFromInstruction(insn, 20, 5);
18342 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18343 tmp = fieldFromInstruction(insn, 15, 5);
18344 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18345 tmp = fieldFromInstruction(insn, 25, 1);
18346 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18347 return S;
18348 case 130:
18349 tmp = fieldFromInstruction(insn, 7, 5);
18350 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18351 tmp = fieldFromInstruction(insn, 20, 5);
18352 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18353 tmp = fieldFromInstruction(insn, 15, 5);
18354 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18355 tmp = fieldFromInstruction(insn, 25, 1);
18356 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18357 return S;
18358 case 131:
18359 tmp = fieldFromInstruction(insn, 7, 5);
18360 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18361 tmp = fieldFromInstruction(insn, 20, 5);
18362 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18363 tmp = fieldFromInstruction(insn, 15, 5);
18364 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18365 tmp = 0x0;
18366 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18367 return S;
18368 case 132:
18369 tmp = fieldFromInstruction(insn, 7, 5);
18370 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18371 tmp = fieldFromInstruction(insn, 20, 5);
18372 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18373 tmp = fieldFromInstruction(insn, 15, 5);
18374 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18375 return S;
18376 case 133:
18377 tmp = fieldFromInstruction(insn, 7, 5);
18378 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18379 tmp = fieldFromInstruction(insn, 20, 5);
18380 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18381 tmp = 0x0;
18382 tmp |= fieldFromInstruction(insn, 15, 5);
18383 tmp |= fieldFromInstruction(insn, 26, 1) << 5;
18384 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18385 tmp = fieldFromInstruction(insn, 25, 1);
18386 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18387 return S;
18388 case 134:
18389 tmp = fieldFromInstruction(insn, 7, 5);
18390 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18391 tmp = fieldFromInstruction(insn, 15, 5);
18392 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18393 return S;
18394 case 135:
18395 tmp = fieldFromInstruction(insn, 7, 5);
18396 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18397 tmp = fieldFromInstruction(insn, 20, 5);
18398 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18399 return S;
18400 case 136:
18401 tmp = fieldFromInstruction(insn, 7, 5);
18402 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18403 tmp = fieldFromInstruction(insn, 20, 5);
18404 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18405 return S;
18406 case 137:
18407 tmp = fieldFromInstruction(insn, 7, 5);
18408 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM4RegClassID, 32, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18409 tmp = fieldFromInstruction(insn, 20, 5);
18410 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM4RegClassID, 32, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18411 return S;
18412 case 138:
18413 tmp = fieldFromInstruction(insn, 7, 5);
18414 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18415 tmp = fieldFromInstruction(insn, 20, 5);
18416 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18417 return S;
18418 case 139:
18419 tmp = fieldFromInstruction(insn, 7, 5);
18420 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18421 tmp = fieldFromInstruction(insn, 20, 5);
18422 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18423 tmp = fieldFromInstruction(insn, 15, 5);
18424 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18425 tmp = fieldFromInstruction(insn, 25, 1);
18426 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18427 return S;
18428 case 140:
18429 tmp = fieldFromInstruction(insn, 7, 5);
18430 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18431 tmp = fieldFromInstruction(insn, 20, 5);
18432 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18433 tmp = fieldFromInstruction(insn, 15, 5);
18434 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18435 tmp = 0x0;
18436 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18437 return S;
18438 case 141:
18439 tmp = fieldFromInstruction(insn, 7, 5);
18440 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18441 tmp = fieldFromInstruction(insn, 20, 5);
18442 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18443 tmp = fieldFromInstruction(insn, 15, 5);
18444 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18445 return S;
18446 case 142:
18447 tmp = fieldFromInstruction(insn, 7, 5);
18448 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18449 tmp = fieldFromInstruction(insn, 7, 5);
18450 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18451 tmp = fieldFromInstruction(insn, 20, 5);
18452 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18453 tmp = fieldFromInstruction(insn, 15, 5);
18454 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18455 tmp = fieldFromInstruction(insn, 25, 1);
18456 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18457 return S;
18458 case 143:
18459 tmp = fieldFromInstruction(insn, 7, 5);
18460 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18461 tmp = fieldFromInstruction(insn, 20, 5);
18462 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18463 tmp = fieldFromInstruction(insn, 15, 5);
18464 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18465 tmp = fieldFromInstruction(insn, 25, 1);
18466 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18467 return S;
18468 case 144:
18469 tmp = fieldFromInstruction(insn, 7, 5);
18470 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18471 tmp = fieldFromInstruction(insn, 7, 5);
18472 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18473 tmp = fieldFromInstruction(insn, 15, 5);
18474 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18475 return S;
18476 case 145:
18477 tmp = fieldFromInstruction(insn, 7, 5);
18478 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18479 tmp = fieldFromInstruction(insn, 20, 5);
18480 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18481 tmp = fieldFromInstruction(insn, 15, 5);
18482 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18483 tmp = 0x0;
18484 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18485 return S;
18486 case 146:
18487 tmp = fieldFromInstruction(insn, 7, 5);
18488 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18489 tmp = fieldFromInstruction(insn, 15, 5);
18490 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18491 return S;
18492 case 147:
18493 tmp = fieldFromInstruction(insn, 7, 5);
18494 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18495 tmp = fieldFromInstruction(insn, 7, 5);
18496 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18497 tmp = fieldFromInstruction(insn, 15, 5);
18498 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18499 tmp = fieldFromInstruction(insn, 20, 5);
18500 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18501 tmp = fieldFromInstruction(insn, 25, 1);
18502 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18503 return S;
18504 case 148:
18505 tmp = fieldFromInstruction(insn, 7, 5);
18506 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18507 tmp = fieldFromInstruction(insn, 7, 5);
18508 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18509 tmp = fieldFromInstruction(insn, 15, 5);
18510 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18511 return S;
18512 case 149:
18513 tmp = fieldFromInstruction(insn, 7, 5);
18514 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18515 tmp = fieldFromInstruction(insn, 7, 5);
18516 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18517 tmp = fieldFromInstruction(insn, 15, 5);
18518 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18519 tmp = fieldFromInstruction(insn, 20, 5);
18520 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18521 tmp = fieldFromInstruction(insn, 25, 1);
18522 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18523 return S;
18524 case 150:
18525 tmp = fieldFromInstruction(insn, 7, 5);
18526 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18527 tmp = fieldFromInstruction(insn, 15, 5);
18528 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18529 tmp = fieldFromInstruction(insn, 20, 11);
18530 if (!Check(S, decodeUImmOperand<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18531 return S;
18532 case 151:
18533 tmp = fieldFromInstruction(insn, 7, 5);
18534 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18535 tmp = fieldFromInstruction(insn, 15, 5);
18536 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18537 tmp = fieldFromInstruction(insn, 20, 10);
18538 if (!Check(S, decodeUImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18539 return S;
18540 case 152:
18541 tmp = fieldFromInstruction(insn, 15, 5);
18542 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18543 tmp = fieldFromInstruction(insn, 20, 5);
18544 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18545 tmp = 0x0;
18546 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
18547 tmp |= fieldFromInstruction(insn, 8, 4);
18548 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
18549 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
18550 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18551 return S;
18552 case 153:
18553 tmp = fieldFromInstruction(insn, 15, 5);
18554 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18555 tmp = fieldFromInstruction(insn, 20, 5);
18556 if (!Check(S, decodeImmZibiOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18557 tmp = 0x0;
18558 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
18559 tmp |= fieldFromInstruction(insn, 8, 4);
18560 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
18561 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
18562 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18563 return S;
18564 case 154:
18565 tmp = fieldFromInstruction(insn, 7, 5);
18566 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18567 tmp = 0x0;
18568 tmp |= fieldFromInstruction(insn, 12, 8) << 11;
18569 tmp |= fieldFromInstruction(insn, 20, 1) << 10;
18570 tmp |= fieldFromInstruction(insn, 21, 10);
18571 tmp |= fieldFromInstruction(insn, 31, 1) << 19;
18572 if (!Check(S, decodeSImmOperandAndLslN<21, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18573 return S;
18574 case 155:
18575 tmp = fieldFromInstruction(insn, 7, 5);
18576 if (!Check(S, DecodeSingleRegister<RISCV::X2, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18577 tmp = fieldFromInstruction(insn, 15, 5);
18578 if (!Check(S, DecodeSingleRegister<RISCV::X2, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18579 return S;
18580 case 156:
18581 tmp = fieldFromInstruction(insn, 15, 5);
18582 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18583 tmp = fieldFromInstruction(insn, 20, 5);
18584 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18585 return S;
18586 case 157:
18587 tmp = fieldFromInstruction(insn, 7, 5);
18588 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18589 tmp = fieldFromInstruction(insn, 20, 12);
18590 if (!Check(S, decodeUImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18591 tmp = fieldFromInstruction(insn, 15, 5);
18592 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18593 return S;
18594 case 158:
18595 tmp = fieldFromInstruction(insn, 15, 5);
18596 if (!Check(S, DecodeGPRX1X5RegisterClass(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; }
18597 return S;
18598 case 159:
18599 tmp = fieldFromInstruction(insn, 7, 5);
18600 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; }
18601 return S;
18602 case 160:
18603 tmp = fieldFromInstruction(insn, 20, 5);
18604 if (!Check(S, DecodeGPRX1X5RegisterClass(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; }
18605 return S;
18606 case 161:
18607 tmp = fieldFromInstruction(insn, 7, 5);
18608 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18609 tmp = fieldFromInstruction(insn, 20, 12);
18610 if (!Check(S, decodeUImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18611 tmp = fieldFromInstruction(insn, 15, 5);
18612 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18613 return S;
18614 case 162:
18615 tmp = fieldFromInstruction(insn, 7, 5);
18616 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18617 tmp = fieldFromInstruction(insn, 20, 5);
18618 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18619 tmp = fieldFromInstruction(insn, 15, 5);
18620 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18621 return S;
18622 case 163:
18623 tmp = fieldFromInstruction(insn, 7, 5);
18624 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18625 tmp = fieldFromInstruction(insn, 7, 5);
18626 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18627 tmp = fieldFromInstruction(insn, 20, 5);
18628 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18629 tmp = fieldFromInstruction(insn, 15, 5);
18630 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18631 return S;
18632 case 164:
18633 tmp = fieldFromInstruction(insn, 7, 5);
18634 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18635 tmp = fieldFromInstruction(insn, 7, 5);
18636 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18637 tmp = fieldFromInstruction(insn, 20, 5);
18638 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18639 return S;
18640 case 165:
18641 tmp = fieldFromInstruction(insn, 7, 5);
18642 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18643 tmp = fieldFromInstruction(insn, 7, 5);
18644 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18645 tmp = fieldFromInstruction(insn, 20, 5);
18646 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18647 tmp = fieldFromInstruction(insn, 15, 5);
18648 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18649 return S;
18650 case 166:
18651 tmp = fieldFromInstruction(insn, 7, 5);
18652 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18653 tmp = fieldFromInstruction(insn, 7, 5);
18654 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18655 tmp = fieldFromInstruction(insn, 23, 2) << 3;
18656 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18657 tmp = fieldFromInstruction(insn, 15, 5);
18658 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18659 tmp = fieldFromInstruction(insn, 20, 3) << 3;
18660 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18661 tmp = fieldFromInstruction(insn, 25, 1);
18662 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18663 return S;
18664 case 167:
18665 tmp = fieldFromInstruction(insn, 7, 5);
18666 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18667 tmp = fieldFromInstruction(insn, 15, 5);
18668 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18669 tmp = fieldFromInstruction(insn, 20, 5);
18670 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18671 return S;
18672 case 168:
18673 tmp = fieldFromInstruction(insn, 7, 5);
18674 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18675 tmp = fieldFromInstruction(insn, 15, 5);
18676 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18677 return S;
18678 case 169:
18679 tmp = fieldFromInstruction(insn, 7, 5);
18680 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18681 tmp = fieldFromInstruction(insn, 15, 5);
18682 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18683 tmp = fieldFromInstruction(insn, 20, 5);
18684 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18685 return S;
18686 case 170:
18687 tmp = fieldFromInstruction(insn, 7, 5);
18688 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18689 tmp = fieldFromInstruction(insn, 15, 5);
18690 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18691 tmp = fieldFromInstruction(insn, 20, 5);
18692 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18693 return S;
18694 case 171:
18695 tmp = fieldFromInstruction(insn, 7, 5);
18696 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18697 tmp = fieldFromInstruction(insn, 15, 5);
18698 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18699 tmp = fieldFromInstruction(insn, 20, 5);
18700 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18701 return S;
18702 case 172:
18703 tmp = fieldFromInstruction(insn, 7, 5);
18704 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18705 tmp = fieldFromInstruction(insn, 15, 5);
18706 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18707 tmp = fieldFromInstruction(insn, 20, 5);
18708 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18709 return S;
18710 case 173:
18711 tmp = fieldFromInstruction(insn, 7, 5);
18712 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18713 tmp = fieldFromInstruction(insn, 20, 5);
18714 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18715 return S;
18716 case 174:
18717 tmp = fieldFromInstruction(insn, 7, 5);
18718 if (!Check(S, DecodeYGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18719 tmp = fieldFromInstruction(insn, 15, 5);
18720 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18721 tmp = fieldFromInstruction(insn, 20, 5);
18722 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18723 return S;
18724 case 175:
18725 tmp = fieldFromInstruction(insn, 7, 5);
18726 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18727 tmp = fieldFromInstruction(insn, 15, 5);
18728 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18729 return S;
18730 case 176:
18731 tmp = fieldFromInstruction(insn, 7, 5);
18732 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18733 tmp = fieldFromInstruction(insn, 15, 5);
18734 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18735 tmp = fieldFromInstruction(insn, 20, 12);
18736 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18737 return S;
18738 case 177:
18739 tmp = fieldFromInstruction(insn, 7, 5);
18740 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18741 tmp = fieldFromInstruction(insn, 15, 5);
18742 if (!Check(S, DecodeYGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18743 tmp = fieldFromInstruction(insn, 20, 9);
18744 if (!Check(S, DecodeYBNDSWImm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18745 return S;
18746 case 178:
18747 tmp = fieldFromInstruction(insn, 7, 5);
18748 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18749 tmp = fieldFromInstruction(insn, 15, 5);
18750 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18751 tmp = fieldFromInstruction(insn, 20, 12);
18752 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18753 return S;
18754 case 179:
18755 tmp = fieldFromInstruction(insn, 20, 5);
18756 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18757 tmp = fieldFromInstruction(insn, 15, 5);
18758 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18759 tmp = 0x0;
18760 tmp |= fieldFromInstruction(insn, 7, 5);
18761 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
18762 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18763 return S;
18764 case 180:
18765 tmp = fieldFromInstruction(insn, 7, 5);
18766 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18767 tmp = fieldFromInstruction(insn, 20, 12);
18768 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18769 tmp = fieldFromInstruction(insn, 15, 5);
18770 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18771 return S;
18772 case 181:
18773 tmp = fieldFromInstruction(insn, 7, 5);
18774 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18775 tmp = fieldFromInstruction(insn, 15, 5);
18776 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18777 tmp = fieldFromInstruction(insn, 20, 5);
18778 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18779 return S;
18780 case 182:
18781 tmp = fieldFromInstruction(insn, 7, 5);
18782 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18783 tmp = fieldFromInstruction(insn, 15, 5);
18784 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18785 tmp = fieldFromInstruction(insn, 20, 5);
18786 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18787 return S;
18788 case 183:
18789 tmp = fieldFromInstruction(insn, 7, 5);
18790 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18791 tmp = fieldFromInstruction(insn, 15, 5);
18792 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18793 return S;
18794 case 184:
18795 tmp = fieldFromInstruction(insn, 20, 5);
18796 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18797 tmp = 0x0;
18798 tmp |= fieldFromInstruction(insn, 7, 5);
18799 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
18800 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18801 tmp = fieldFromInstruction(insn, 15, 5);
18802 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18803 return S;
18804 case 185:
18805 tmp = fieldFromInstruction(insn, 7, 5);
18806 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18807 tmp = fieldFromInstruction(insn, 12, 20);
18808 if (!Check(S, decodeUImm20Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18809 return S;
18810 case 186:
18811 tmp = fieldFromInstruction(insn, 7, 5);
18812 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18813 tmp = fieldFromInstruction(insn, 15, 5);
18814 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18815 tmp = 0x0;
18816 tmp |= fieldFromInstruction(insn, 20, 5);
18817 tmp |= fieldFromInstruction(insn, 27, 5) << 5;
18818 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18819 return S;
18820 case 187:
18821 tmp = fieldFromInstruction(insn, 7, 5);
18822 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18823 tmp = fieldFromInstruction(insn, 15, 5);
18824 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18825 tmp = fieldFromInstruction(insn, 20, 5);
18826 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18827 tmp = fieldFromInstruction(insn, 27, 5);
18828 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18829 return S;
18830 case 188:
18831 tmp = fieldFromInstruction(insn, 7, 5);
18832 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18833 tmp = fieldFromInstruction(insn, 15, 5);
18834 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18835 tmp = fieldFromInstruction(insn, 20, 5);
18836 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18837 tmp = fieldFromInstruction(insn, 27, 5);
18838 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18839 tmp = fieldFromInstruction(insn, 12, 3);
18840 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18841 return S;
18842 case 189:
18843 tmp = fieldFromInstruction(insn, 7, 5);
18844 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18845 tmp = fieldFromInstruction(insn, 15, 5);
18846 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18847 tmp = fieldFromInstruction(insn, 20, 5);
18848 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18849 return S;
18850 case 190:
18851 tmp = fieldFromInstruction(insn, 7, 5);
18852 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18853 tmp = fieldFromInstruction(insn, 15, 5);
18854 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18855 tmp = fieldFromInstruction(insn, 20, 5);
18856 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18857 tmp = fieldFromInstruction(insn, 12, 3);
18858 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18859 return S;
18860 case 191:
18861 tmp = fieldFromInstruction(insn, 7, 5);
18862 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18863 tmp = fieldFromInstruction(insn, 15, 5);
18864 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18865 return S;
18866 case 192:
18867 tmp = fieldFromInstruction(insn, 7, 5);
18868 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18869 tmp = fieldFromInstruction(insn, 15, 5);
18870 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18871 tmp = fieldFromInstruction(insn, 20, 5);
18872 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18873 return S;
18874 case 193:
18875 tmp = fieldFromInstruction(insn, 7, 5);
18876 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18877 tmp = fieldFromInstruction(insn, 15, 5);
18878 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18879 tmp = fieldFromInstruction(insn, 20, 5);
18880 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18881 return S;
18882 case 194:
18883 tmp = fieldFromInstruction(insn, 7, 5);
18884 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18885 tmp = fieldFromInstruction(insn, 15, 3);
18886 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18887 return S;
18888 case 195:
18889 tmp = fieldFromInstruction(insn, 7, 3);
18890 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18891 tmp = fieldFromInstruction(insn, 15, 5);
18892 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18893 tmp = 0x0;
18894 tmp |= fieldFromInstruction(insn, 12, 3);
18895 tmp |= fieldFromInstruction(insn, 20, 5) << 3;
18896 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18897 return S;
18898 case 196:
18899 tmp = fieldFromInstruction(insn, 7, 5);
18900 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18901 tmp = fieldFromInstruction(insn, 15, 5);
18902 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18903 tmp = fieldFromInstruction(insn, 12, 3);
18904 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18905 return S;
18906 case 197:
18907 tmp = fieldFromInstruction(insn, 7, 5);
18908 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18909 tmp = fieldFromInstruction(insn, 15, 3);
18910 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18911 tmp = fieldFromInstruction(insn, 20, 3);
18912 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18913 tmp = 0x0;
18914 tmp |= fieldFromInstruction(insn, 18, 2);
18915 tmp |= fieldFromInstruction(insn, 23, 2) << 2;
18916 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18917 return S;
18918 case 198:
18919 tmp = fieldFromInstruction(insn, 7, 3);
18920 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18921 tmp = fieldFromInstruction(insn, 15, 3);
18922 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18923 return S;
18924 case 199:
18925 tmp = fieldFromInstruction(insn, 7, 3);
18926 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18927 tmp = fieldFromInstruction(insn, 15, 3);
18928 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18929 tmp = fieldFromInstruction(insn, 20, 3);
18930 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18931 return S;
18932 case 200:
18933 tmp = fieldFromInstruction(insn, 7, 5);
18934 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18935 tmp = fieldFromInstruction(insn, 15, 5);
18936 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18937 return S;
18938 case 201:
18939 tmp = fieldFromInstruction(insn, 7, 5);
18940 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18941 return S;
18942 case 202:
18943 tmp = fieldFromInstruction(insn, 7, 5);
18944 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18945 tmp = fieldFromInstruction(insn, 15, 5);
18946 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18947 tmp = fieldFromInstruction(insn, 20, 3);
18948 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18949 return S;
18950 case 203:
18951 tmp = fieldFromInstruction(insn, 7, 5);
18952 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18953 tmp = fieldFromInstruction(insn, 15, 5);
18954 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18955 tmp = 0x0;
18956 tmp |= fieldFromInstruction(insn, 12, 3);
18957 tmp |= fieldFromInstruction(insn, 20, 5) << 3;
18958 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18959 return S;
18960 case 204:
18961 tmp = fieldFromInstruction(insn, 7, 5);
18962 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18963 tmp = 0x0;
18964 tmp |= fieldFromInstruction(insn, 14, 1);
18965 tmp |= fieldFromInstruction(insn, 15, 2) << 15;
18966 tmp |= fieldFromInstruction(insn, 17, 3) << 12;
18967 tmp |= fieldFromInstruction(insn, 20, 1) << 11;
18968 tmp |= fieldFromInstruction(insn, 21, 10) << 1;
18969 tmp |= fieldFromInstruction(insn, 31, 1) << 17;
18970 if (!Check(S, decodeSImmOperand<18>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18971 return S;
18972 case 205:
18973 tmp = fieldFromInstruction(insn, 20, 5);
18974 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18975 tmp = 0x0;
18976 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
18977 tmp |= fieldFromInstruction(insn, 8, 4);
18978 tmp |= fieldFromInstruction(insn, 15, 2) << 14;
18979 tmp |= fieldFromInstruction(insn, 17, 3) << 11;
18980 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
18981 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18982 if (!Check(S, decodeSImmOperandAndLslN<18, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18983 return S;
18984 case 206:
18985 tmp = fieldFromInstruction(insn, 20, 5);
18986 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18987 tmp = 0x0;
18988 tmp |= fieldFromInstruction(insn, 7, 1) << 9;
18989 tmp |= fieldFromInstruction(insn, 8, 1) << 15;
18990 tmp |= fieldFromInstruction(insn, 9, 3);
18991 tmp |= fieldFromInstruction(insn, 15, 2) << 13;
18992 tmp |= fieldFromInstruction(insn, 17, 3) << 10;
18993 tmp |= fieldFromInstruction(insn, 25, 6) << 3;
18994 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18995 if (!Check(S, decodeSImmOperandAndLslN<19, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18996 return S;
18997 case 207:
18998 tmp = fieldFromInstruction(insn, 7, 5);
18999 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19000 tmp = fieldFromInstruction(insn, 20, 5);
19001 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19002 return S;
19003 case 208:
19004 tmp = fieldFromInstruction(insn, 7, 5);
19005 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19006 tmp = fieldFromInstruction(insn, 20, 5);
19007 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19008 return S;
19009 case 209:
19010 tmp = fieldFromInstruction(insn, 7, 5);
19011 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19012 tmp = fieldFromInstruction(insn, 15, 5);
19013 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19014 tmp = fieldFromInstruction(insn, 20, 5);
19015 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19016 tmp = fieldFromInstruction(insn, 25, 1);
19017 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19018 return S;
19019 case 210:
19020 tmp = fieldFromInstruction(insn, 7, 5);
19021 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19022 tmp = 0x0;
19023 tmp |= fieldFromInstruction(insn, 15, 2) << 14;
19024 tmp |= fieldFromInstruction(insn, 17, 3) << 11;
19025 tmp |= fieldFromInstruction(insn, 20, 1) << 10;
19026 tmp |= fieldFromInstruction(insn, 21, 10);
19027 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
19028 if (!Check(S, decodeSImmOperandAndLslN<18, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19029 return S;
19030 case 211:
19031 tmp = fieldFromInstruction(insn, 15, 5);
19032 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19033 tmp = 0x0;
19034 tmp |= fieldFromInstruction(insn, 7, 1) << 5;
19035 tmp |= fieldFromInstruction(insn, 20, 5);
19036 tmp |= fieldFromInstruction(insn, 30, 1) << 6;
19037 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19038 tmp = 0x0;
19039 tmp |= fieldFromInstruction(insn, 8, 4);
19040 tmp |= fieldFromInstruction(insn, 25, 5) << 4;
19041 tmp |= fieldFromInstruction(insn, 31, 1) << 9;
19042 if (!Check(S, decodeSImmOperandAndLslN<11, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19043 return S;
19044 case 212:
19045 tmp = fieldFromInstruction(insn, 7, 5);
19046 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19047 tmp = 0x0;
19048 tmp |= fieldFromInstruction(insn, 15, 2) << 13;
19049 tmp |= fieldFromInstruction(insn, 17, 3) << 10;
19050 tmp |= fieldFromInstruction(insn, 20, 1) << 9;
19051 tmp |= fieldFromInstruction(insn, 21, 1) << 15;
19052 tmp |= fieldFromInstruction(insn, 22, 9);
19053 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
19054 if (!Check(S, decodeSImmOperandAndLslN<19, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19055 return S;
19056 case 213:
19057 tmp = fieldFromInstruction(insn, 7, 5);
19058 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19059 tmp = fieldFromInstruction(insn, 15, 5);
19060 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19061 tmp = fieldFromInstruction(insn, 26, 6);
19062 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19063 tmp = fieldFromInstruction(insn, 20, 6);
19064 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19065 return S;
19066 case 214:
19067 tmp = fieldFromInstruction(insn, 20, 5);
19068 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19069 tmp = 0x0;
19070 tmp |= fieldFromInstruction(insn, 7, 1) << 11;
19071 tmp |= fieldFromInstruction(insn, 8, 4) << 1;
19072 tmp |= fieldFromInstruction(insn, 14, 1);
19073 tmp |= fieldFromInstruction(insn, 15, 2) << 15;
19074 tmp |= fieldFromInstruction(insn, 17, 3) << 12;
19075 tmp |= fieldFromInstruction(insn, 25, 6) << 5;
19076 tmp |= fieldFromInstruction(insn, 31, 1) << 17;
19077 if (!Check(S, decodeSImmOperand<18>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19078 return S;
19079 case 215:
19080 tmp = fieldFromInstruction(insn, 7, 5);
19081 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19082 tmp = 0x0;
19083 tmp |= fieldFromInstruction(insn, 15, 2) << 12;
19084 tmp |= fieldFromInstruction(insn, 17, 3) << 9;
19085 tmp |= fieldFromInstruction(insn, 20, 1) << 8;
19086 tmp |= fieldFromInstruction(insn, 21, 2) << 14;
19087 tmp |= fieldFromInstruction(insn, 23, 8);
19088 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
19089 if (!Check(S, decodeSImmOperandAndLslN<20, 3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19090 return S;
19091 case 216:
19092 tmp = fieldFromInstruction(insn, 20, 5);
19093 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19094 tmp = 0x0;
19095 tmp |= fieldFromInstruction(insn, 7, 1) << 8;
19096 tmp |= fieldFromInstruction(insn, 8, 2) << 14;
19097 tmp |= fieldFromInstruction(insn, 10, 2);
19098 tmp |= fieldFromInstruction(insn, 15, 2) << 12;
19099 tmp |= fieldFromInstruction(insn, 17, 3) << 9;
19100 tmp |= fieldFromInstruction(insn, 25, 6) << 2;
19101 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
19102 if (!Check(S, decodeSImmOperandAndLslN<20, 3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19103 return S;
19104 case 217:
19105 tmp = fieldFromInstruction(insn, 15, 5);
19106 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19107 tmp = 0x0;
19108 tmp |= fieldFromInstruction(insn, 7, 1) << 5;
19109 tmp |= fieldFromInstruction(insn, 20, 5);
19110 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19111 tmp = 0x0;
19112 tmp |= fieldFromInstruction(insn, 8, 4);
19113 tmp |= fieldFromInstruction(insn, 25, 5) << 4;
19114 tmp |= fieldFromInstruction(insn, 31, 1) << 9;
19115 if (!Check(S, decodeSImmOperandAndLslN<11, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19116 return S;
19117 case 218:
19118 tmp = fieldFromInstruction(insn, 7, 5);
19119 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19120 tmp = fieldFromInstruction(insn, 15, 5);
19121 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19122 tmp = fieldFromInstruction(insn, 15, 5);
19123 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19124 tmp = fieldFromInstruction(insn, 20, 12);
19125 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19126 return S;
19127 case 219:
19128 tmp = fieldFromInstruction(insn, 15, 5);
19129 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19130 tmp = fieldFromInstruction(insn, 20, 5);
19131 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19132 tmp = fieldFromInstruction(insn, 15, 5);
19133 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19134 tmp = 0x0;
19135 tmp |= fieldFromInstruction(insn, 7, 5);
19136 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
19137 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19138 return S;
19139 case 220:
19140 tmp = fieldFromInstruction(insn, 7, 5);
19141 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19142 tmp = fieldFromInstruction(insn, 15, 5);
19143 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19144 tmp = fieldFromInstruction(insn, 25, 5);
19145 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19146 tmp = fieldFromInstruction(insn, 20, 5);
19147 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19148 return S;
19149 case 221:
19150 tmp = fieldFromInstruction(insn, 7, 5);
19151 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19152 tmp = fieldFromInstruction(insn, 7, 5);
19153 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19154 tmp = fieldFromInstruction(insn, 15, 5);
19155 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19156 tmp = fieldFromInstruction(insn, 25, 5);
19157 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19158 tmp = fieldFromInstruction(insn, 20, 5);
19159 if (!Check(S, decodeCVInsertIs2Operand(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; }
19160 return S;
19161 case 222:
19162 tmp = fieldFromInstruction(insn, 7, 5);
19163 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19164 tmp = fieldFromInstruction(insn, 15, 5);
19165 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19166 tmp = 0x0;
19167 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19168 tmp |= fieldFromInstruction(insn, 25, 1);
19169 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19170 return S;
19171 case 223:
19172 tmp = fieldFromInstruction(insn, 7, 5);
19173 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19174 tmp = fieldFromInstruction(insn, 15, 5);
19175 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19176 tmp = fieldFromInstruction(insn, 25, 5);
19177 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19178 tmp = fieldFromInstruction(insn, 20, 5);
19179 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19180 return S;
19181 case 224:
19182 tmp = fieldFromInstruction(insn, 7, 5);
19183 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19184 tmp = fieldFromInstruction(insn, 15, 5);
19185 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19186 tmp = 0x0;
19187 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19188 tmp |= fieldFromInstruction(insn, 25, 1);
19189 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19190 return S;
19191 case 225:
19192 tmp = fieldFromInstruction(insn, 7, 5);
19193 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19194 tmp = fieldFromInstruction(insn, 15, 5);
19195 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19196 tmp = fieldFromInstruction(insn, 20, 5);
19197 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19198 tmp = fieldFromInstruction(insn, 25, 5);
19199 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19200 return S;
19201 case 226:
19202 tmp = fieldFromInstruction(insn, 7, 5);
19203 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19204 tmp = fieldFromInstruction(insn, 15, 5);
19205 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19206 tmp = fieldFromInstruction(insn, 15, 5);
19207 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19208 tmp = fieldFromInstruction(insn, 20, 5);
19209 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19210 return S;
19211 case 227:
19212 tmp = fieldFromInstruction(insn, 15, 5);
19213 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19214 tmp = fieldFromInstruction(insn, 20, 5);
19215 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19216 tmp = fieldFromInstruction(insn, 15, 5);
19217 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19218 tmp = fieldFromInstruction(insn, 7, 5);
19219 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19220 return S;
19221 case 228:
19222 tmp = fieldFromInstruction(insn, 20, 5);
19223 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19224 tmp = fieldFromInstruction(insn, 15, 5);
19225 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19226 tmp = fieldFromInstruction(insn, 7, 5);
19227 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19228 return S;
19229 case 229:
19230 tmp = fieldFromInstruction(insn, 7, 5);
19231 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19232 tmp = fieldFromInstruction(insn, 7, 5);
19233 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19234 tmp = fieldFromInstruction(insn, 15, 5);
19235 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19236 tmp = 0x0;
19237 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19238 tmp |= fieldFromInstruction(insn, 25, 1);
19239 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19240 return S;
19241 case 230:
19242 tmp = fieldFromInstruction(insn, 7, 5);
19243 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19244 tmp = fieldFromInstruction(insn, 7, 5);
19245 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19246 tmp = fieldFromInstruction(insn, 15, 5);
19247 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19248 tmp = 0x0;
19249 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19250 tmp |= fieldFromInstruction(insn, 25, 1);
19251 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19252 return S;
19253 case 231:
19254 tmp = fieldFromInstruction(insn, 15, 5);
19255 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19256 tmp = fieldFromInstruction(insn, 20, 5);
19257 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19258 tmp = 0x0;
19259 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
19260 tmp |= fieldFromInstruction(insn, 8, 4);
19261 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
19262 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
19263 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19264 return S;
19265 case 232:
19266 tmp = fieldFromInstruction(insn, 7, 5);
19267 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19268 tmp = fieldFromInstruction(insn, 7, 5);
19269 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19270 tmp = fieldFromInstruction(insn, 15, 5);
19271 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19272 tmp = fieldFromInstruction(insn, 20, 5);
19273 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19274 tmp = fieldFromInstruction(insn, 25, 5);
19275 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19276 return S;
19277 case 233:
19278 tmp = fieldFromInstruction(insn, 7, 5);
19279 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19280 tmp = fieldFromInstruction(insn, 15, 5);
19281 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19282 tmp = 0x0;
19283 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19284 tmp |= fieldFromInstruction(insn, 25, 1);
19285 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19286 return S;
19287 case 234:
19288 tmp = fieldFromInstruction(insn, 7, 5);
19289 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19290 tmp = fieldFromInstruction(insn, 15, 5);
19291 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19292 tmp = 0x0;
19293 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19294 tmp |= fieldFromInstruction(insn, 25, 1);
19295 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19296 return S;
19297 case 235:
19298 tmp = fieldFromInstruction(insn, 7, 5);
19299 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19300 tmp = fieldFromInstruction(insn, 15, 5);
19301 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19302 tmp = 0x0;
19303 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19304 tmp |= fieldFromInstruction(insn, 25, 1);
19305 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19306 return S;
19307 case 236:
19308 tmp = fieldFromInstruction(insn, 7, 5);
19309 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19310 tmp = fieldFromInstruction(insn, 7, 5);
19311 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19312 tmp = fieldFromInstruction(insn, 15, 5);
19313 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19314 tmp = 0x0;
19315 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19316 tmp |= fieldFromInstruction(insn, 25, 1);
19317 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19318 return S;
19319 case 237:
19320 tmp = fieldFromInstruction(insn, 7, 5);
19321 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19322 tmp = fieldFromInstruction(insn, 7, 5);
19323 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19324 tmp = fieldFromInstruction(insn, 15, 5);
19325 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19326 tmp = 0x0;
19327 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19328 tmp |= fieldFromInstruction(insn, 25, 1);
19329 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19330 return S;
19331 case 238:
19332 tmp = fieldFromInstruction(insn, 7, 5);
19333 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19334 tmp = fieldFromInstruction(insn, 15, 5);
19335 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19336 tmp = 0x0;
19337 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19338 tmp |= fieldFromInstruction(insn, 25, 1);
19339 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19340 return S;
19341 case 239:
19342 tmp = fieldFromInstruction(insn, 15, 5);
19343 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19344 tmp = fieldFromInstruction(insn, 20, 9);
19345 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19346 tmp = fieldFromInstruction(insn, 7, 5);
19347 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19348 return S;
19349 case 240:
19350 tmp = fieldFromInstruction(insn, 7, 5);
19351 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19352 tmp = fieldFromInstruction(insn, 15, 5);
19353 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19354 tmp = fieldFromInstruction(insn, 20, 5);
19355 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19356 tmp = fieldFromInstruction(insn, 27, 5);
19357 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19358 return S;
19359 case 241:
19360 tmp = fieldFromInstruction(insn, 7, 5);
19361 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19362 tmp = fieldFromInstruction(insn, 27, 5);
19363 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19364 tmp = fieldFromInstruction(insn, 15, 5);
19365 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19366 tmp = fieldFromInstruction(insn, 23, 4) << 3;
19367 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19368 return S;
19369 case 242:
19370 tmp = fieldFromInstruction(insn, 7, 5);
19371 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19372 tmp = fieldFromInstruction(insn, 27, 5);
19373 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19374 tmp = fieldFromInstruction(insn, 15, 5);
19375 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19376 tmp = fieldFromInstruction(insn, 22, 5) << 2;
19377 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19378 return S;
19379 case 243:
19380 tmp = fieldFromInstruction(insn, 20, 5);
19381 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19382 tmp = fieldFromInstruction(insn, 27, 5);
19383 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19384 tmp = fieldFromInstruction(insn, 15, 5);
19385 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19386 tmp = 0x0;
19387 tmp |= fieldFromInstruction(insn, 10, 2) << 3;
19388 tmp |= fieldFromInstruction(insn, 25, 2) << 5;
19389 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19390 return S;
19391 case 244:
19392 tmp = fieldFromInstruction(insn, 20, 5);
19393 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19394 tmp = fieldFromInstruction(insn, 27, 5);
19395 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19396 tmp = fieldFromInstruction(insn, 15, 5);
19397 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19398 tmp = 0x0;
19399 tmp |= fieldFromInstruction(insn, 9, 3) << 2;
19400 tmp |= fieldFromInstruction(insn, 25, 2) << 5;
19401 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19402 return S;
19403 case 245:
19404 tmp = fieldFromInstruction(insn, 7, 5);
19405 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19406 tmp = fieldFromInstruction(insn, 15, 5);
19407 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19408 tmp = fieldFromInstruction(insn, 20, 5);
19409 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19410 tmp = fieldFromInstruction(insn, 12, 2);
19411 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19412 return S;
19413 case 246:
19414 tmp = fieldFromInstruction(insn, 7, 5);
19415 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19416 tmp = fieldFromInstruction(insn, 7, 5);
19417 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19418 tmp = fieldFromInstruction(insn, 15, 5);
19419 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19420 tmp = fieldFromInstruction(insn, 20, 5);
19421 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19422 return S;
19423 case 247:
19424 tmp = fieldFromInstruction(insn, 7, 5);
19425 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19426 tmp = fieldFromInstruction(insn, 7, 5);
19427 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19428 tmp = fieldFromInstruction(insn, 15, 5);
19429 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19430 tmp = fieldFromInstruction(insn, 20, 5);
19431 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19432 tmp = fieldFromInstruction(insn, 29, 2);
19433 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19434 return S;
19435 case 248:
19436 tmp = fieldFromInstruction(insn, 7, 5);
19437 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19438 tmp = fieldFromInstruction(insn, 15, 5);
19439 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19440 tmp = fieldFromInstruction(insn, 20, 5);
19441 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19442 tmp = fieldFromInstruction(insn, 12, 2);
19443 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19444 return S;
19445 case 249:
19446 tmp = fieldFromInstruction(insn, 7, 5);
19447 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19448 tmp = fieldFromInstruction(insn, 7, 5);
19449 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19450 tmp = fieldFromInstruction(insn, 16, 4) << 1;
19451 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19452 tmp = fieldFromInstruction(insn, 20, 5);
19453 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19454 return S;
19455 case 250:
19456 tmp = fieldFromInstruction(insn, 7, 5);
19457 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19458 tmp = fieldFromInstruction(insn, 7, 5);
19459 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19460 tmp = fieldFromInstruction(insn, 16, 4) << 1;
19461 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19462 tmp = fieldFromInstruction(insn, 20, 5);
19463 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19464 tmp = fieldFromInstruction(insn, 29, 2);
19465 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19466 return S;
19467 case 251:
19468 tmp = fieldFromInstruction(insn, 8, 4) << 1;
19469 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19470 tmp = fieldFromInstruction(insn, 8, 4) << 1;
19471 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19472 tmp = fieldFromInstruction(insn, 16, 4) << 1;
19473 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19474 tmp = fieldFromInstruction(insn, 20, 5);
19475 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19476 tmp = fieldFromInstruction(insn, 25, 1);
19477 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19478 tmp = 0x0;
19479 tmp |= fieldFromInstruction(insn, 7, 1);
19480 tmp |= fieldFromInstruction(insn, 15, 1) << 1;
19481 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19482 tmp = fieldFromInstruction(insn, 29, 2);
19483 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19484 return S;
19485 case 252:
19486 tmp = fieldFromInstruction(insn, 7, 5);
19487 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19488 tmp = fieldFromInstruction(insn, 7, 5);
19489 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19490 tmp = fieldFromInstruction(insn, 15, 5);
19491 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19492 tmp = fieldFromInstruction(insn, 20, 5);
19493 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19494 tmp = fieldFromInstruction(insn, 25, 1);
19495 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19496 tmp = fieldFromInstruction(insn, 12, 3);
19497 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19498 tmp = fieldFromInstruction(insn, 29, 2);
19499 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19500 return S;
19501 case 253:
19502 tmp = fieldFromInstruction(insn, 7, 5);
19503 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19504 tmp = fieldFromInstruction(insn, 7, 5);
19505 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19506 tmp = fieldFromInstruction(insn, 15, 5);
19507 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19508 tmp = fieldFromInstruction(insn, 20, 5);
19509 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19510 return S;
19511 case 254:
19512 tmp = fieldFromInstruction(insn, 7, 5);
19513 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19514 tmp = fieldFromInstruction(insn, 26, 2);
19515 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19516 tmp = fieldFromInstruction(insn, 20, 5);
19517 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19518 tmp = fieldFromInstruction(insn, 15, 5);
19519 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19520 return S;
19521 case 255:
19522 tmp = fieldFromInstruction(insn, 26, 2);
19523 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19524 tmp = fieldFromInstruction(insn, 20, 5);
19525 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19526 tmp = fieldFromInstruction(insn, 7, 5);
19527 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19528 tmp = fieldFromInstruction(insn, 15, 5);
19529 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19530 return S;
19531 case 256:
19532 tmp = fieldFromInstruction(insn, 7, 5);
19533 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19534 tmp = fieldFromInstruction(insn, 26, 2);
19535 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19536 tmp = fieldFromInstruction(insn, 20, 5);
19537 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19538 tmp = fieldFromInstruction(insn, 15, 5);
19539 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19540 return S;
19541 case 257:
19542 tmp = fieldFromInstruction(insn, 26, 2);
19543 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19544 tmp = fieldFromInstruction(insn, 20, 5);
19545 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19546 tmp = fieldFromInstruction(insn, 7, 5);
19547 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19548 tmp = fieldFromInstruction(insn, 15, 5);
19549 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19550 return S;
19551 case 258:
19552 tmp = fieldFromInstruction(insn, 7, 5);
19553 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19554 tmp = fieldFromInstruction(insn, 26, 2);
19555 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19556 tmp = fieldFromInstruction(insn, 20, 5);
19557 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19558 tmp = fieldFromInstruction(insn, 15, 5);
19559 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19560 return S;
19561 case 259:
19562 tmp = fieldFromInstruction(insn, 26, 2);
19563 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19564 tmp = fieldFromInstruction(insn, 7, 5);
19565 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19566 tmp = fieldFromInstruction(insn, 20, 5);
19567 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19568 tmp = fieldFromInstruction(insn, 15, 5);
19569 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19570 return S;
19571 case 260:
19572 tmp = fieldFromInstruction(insn, 7, 5);
19573 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19574 tmp = fieldFromInstruction(insn, 26, 2);
19575 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19576 tmp = fieldFromInstruction(insn, 20, 5);
19577 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19578 tmp = fieldFromInstruction(insn, 15, 5);
19579 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19580 return S;
19581 case 261:
19582 tmp = fieldFromInstruction(insn, 26, 2);
19583 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19584 tmp = fieldFromInstruction(insn, 7, 5);
19585 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19586 tmp = fieldFromInstruction(insn, 20, 5);
19587 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19588 tmp = fieldFromInstruction(insn, 15, 5);
19589 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19590 return S;
19591 case 262:
19592 tmp = fieldFromInstruction(insn, 7, 5);
19593 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19594 tmp = fieldFromInstruction(insn, 26, 2);
19595 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19596 tmp = fieldFromInstruction(insn, 20, 5);
19597 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19598 tmp = fieldFromInstruction(insn, 15, 5);
19599 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19600 return S;
19601 case 263:
19602 tmp = fieldFromInstruction(insn, 26, 2);
19603 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19604 tmp = fieldFromInstruction(insn, 7, 5);
19605 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19606 tmp = fieldFromInstruction(insn, 20, 5);
19607 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19608 tmp = fieldFromInstruction(insn, 15, 5);
19609 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19610 return S;
19611 case 264:
19612 tmp = fieldFromInstruction(insn, 7, 5);
19613 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19614 tmp = fieldFromInstruction(insn, 26, 1);
19615 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19616 tmp = fieldFromInstruction(insn, 20, 5);
19617 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19618 tmp = fieldFromInstruction(insn, 15, 5);
19619 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19620 return S;
19621 case 265:
19622 tmp = fieldFromInstruction(insn, 26, 1);
19623 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19624 tmp = fieldFromInstruction(insn, 7, 5);
19625 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19626 tmp = fieldFromInstruction(insn, 20, 5);
19627 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19628 tmp = fieldFromInstruction(insn, 15, 5);
19629 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19630 return S;
19631 case 266:
19632 tmp = fieldFromInstruction(insn, 8, 4);
19633 if (!Check(S, DecodeSimpleRegisterClass<RISCV::T0, 16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19634 return S;
19635 case 267:
19636 tmp = fieldFromInstruction(insn, 15, 5);
19637 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19638 tmp = fieldFromInstruction(insn, 20, 5);
19639 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19640 return S;
19641 case 268:
19642 tmp = fieldFromInstruction(insn, 7, 5);
19643 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19644 tmp = fieldFromInstruction(insn, 26, 2);
19645 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19646 tmp = fieldFromInstruction(insn, 7, 5);
19647 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19648 tmp = fieldFromInstruction(insn, 20, 5);
19649 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19650 tmp = fieldFromInstruction(insn, 15, 5);
19651 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19652 return S;
19653 case 269:
19654 tmp = fieldFromInstruction(insn, 26, 2);
19655 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19656 tmp = fieldFromInstruction(insn, 7, 5);
19657 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19658 tmp = fieldFromInstruction(insn, 20, 5);
19659 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19660 tmp = fieldFromInstruction(insn, 15, 5);
19661 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19662 return S;
19663 case 270:
19664 tmp = fieldFromInstruction(insn, 7, 5);
19665 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19666 tmp = fieldFromInstruction(insn, 26, 2);
19667 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19668 tmp = fieldFromInstruction(insn, 7, 5);
19669 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19670 tmp = fieldFromInstruction(insn, 20, 5);
19671 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19672 tmp = fieldFromInstruction(insn, 15, 5);
19673 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19674 return S;
19675 case 271:
19676 tmp = fieldFromInstruction(insn, 26, 2);
19677 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19678 tmp = fieldFromInstruction(insn, 7, 5);
19679 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19680 tmp = fieldFromInstruction(insn, 20, 5);
19681 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19682 tmp = fieldFromInstruction(insn, 15, 5);
19683 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19684 return S;
19685 case 272:
19686 tmp = fieldFromInstruction(insn, 7, 5);
19687 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19688 tmp = fieldFromInstruction(insn, 26, 2);
19689 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19690 tmp = fieldFromInstruction(insn, 7, 5);
19691 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19692 tmp = fieldFromInstruction(insn, 20, 5);
19693 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19694 tmp = fieldFromInstruction(insn, 15, 5);
19695 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19696 return S;
19697 case 273:
19698 tmp = fieldFromInstruction(insn, 26, 2);
19699 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19700 tmp = fieldFromInstruction(insn, 7, 5);
19701 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19702 tmp = fieldFromInstruction(insn, 20, 5);
19703 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19704 tmp = fieldFromInstruction(insn, 15, 5);
19705 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19706 return S;
19707 case 274:
19708 tmp = fieldFromInstruction(insn, 7, 5);
19709 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19710 tmp = fieldFromInstruction(insn, 26, 1);
19711 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19712 tmp = fieldFromInstruction(insn, 7, 5);
19713 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19714 tmp = fieldFromInstruction(insn, 20, 5);
19715 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19716 tmp = fieldFromInstruction(insn, 15, 5);
19717 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19718 return S;
19719 case 275:
19720 tmp = fieldFromInstruction(insn, 26, 1);
19721 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19722 tmp = fieldFromInstruction(insn, 7, 5);
19723 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19724 tmp = fieldFromInstruction(insn, 20, 5);
19725 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19726 tmp = fieldFromInstruction(insn, 15, 5);
19727 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19728 return S;
19729 case 276:
19730 tmp = fieldFromInstruction(insn, 10, 2) << 2;
19731 if (!Check(S, DecodeTRM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19732 tmp = fieldFromInstruction(insn, 20, 5);
19733 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19734 tmp = fieldFromInstruction(insn, 15, 5);
19735 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19736 return S;
19737 case 277:
19738 tmp = fieldFromInstruction(insn, 9, 3) << 1;
19739 if (!Check(S, DecodeTRM2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19740 tmp = fieldFromInstruction(insn, 20, 5);
19741 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19742 tmp = fieldFromInstruction(insn, 15, 5);
19743 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19744 return S;
19745 case 278:
19746 tmp = fieldFromInstruction(insn, 7, 5);
19747 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19748 tmp = fieldFromInstruction(insn, 15, 5);
19749 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19750 tmp = fieldFromInstruction(insn, 20, 5);
19751 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19752 tmp = fieldFromInstruction(insn, 25, 2);
19753 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19754 return S;
19755 case 279:
19756 tmp = fieldFromInstruction(insn, 7, 5);
19757 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19758 tmp = fieldFromInstruction(insn, 15, 5);
19759 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19760 tmp = fieldFromInstruction(insn, 15, 5);
19761 if (!Check(S, decodeTHMemIdxRs1Operand(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; }
19762 tmp = fieldFromInstruction(insn, 20, 5);
19763 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19764 tmp = fieldFromInstruction(insn, 25, 2);
19765 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19766 return S;
19767 case 280:
19768 tmp = fieldFromInstruction(insn, 7, 5);
19769 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19770 tmp = fieldFromInstruction(insn, 20, 5);
19771 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19772 tmp = fieldFromInstruction(insn, 15, 5);
19773 if (!Check(S, decodeTHMemPairRs1Operand(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; }
19774 tmp = fieldFromInstruction(insn, 25, 2);
19775 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19776 if (!Check(Out&: S, In: decodeFixedImmOperand<3>(Inst&: MI, Decoder)))
19777 return MCDisassembler::Fail;
19778 return S;
19779 case 281:
19780 tmp = fieldFromInstruction(insn, 7, 5);
19781 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19782 tmp = fieldFromInstruction(insn, 20, 5);
19783 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19784 tmp = fieldFromInstruction(insn, 15, 5);
19785 if (!Check(S, decodeTHMemPairRs1Operand(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; }
19786 tmp = fieldFromInstruction(insn, 25, 2);
19787 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19788 if (!Check(Out&: S, In: decodeFixedImmOperand<4>(Inst&: MI, Decoder)))
19789 return MCDisassembler::Fail;
19790 return S;
19791 case 282:
19792 tmp = fieldFromInstruction(insn, 15, 5);
19793 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19794 tmp = fieldFromInstruction(insn, 7, 5);
19795 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19796 tmp = fieldFromInstruction(insn, 15, 5);
19797 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19798 tmp = fieldFromInstruction(insn, 20, 5);
19799 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19800 tmp = fieldFromInstruction(insn, 25, 2);
19801 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19802 return S;
19803 case 283:
19804 tmp = fieldFromInstruction(insn, 7, 5);
19805 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19806 tmp = fieldFromInstruction(insn, 20, 5);
19807 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19808 tmp = fieldFromInstruction(insn, 15, 5);
19809 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19810 tmp = fieldFromInstruction(insn, 25, 2);
19811 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19812 if (!Check(Out&: S, In: decodeFixedImmOperand<3>(Inst&: MI, Decoder)))
19813 return MCDisassembler::Fail;
19814 return S;
19815 case 284:
19816 tmp = fieldFromInstruction(insn, 7, 5);
19817 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19818 tmp = fieldFromInstruction(insn, 20, 5);
19819 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19820 tmp = fieldFromInstruction(insn, 15, 5);
19821 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19822 tmp = fieldFromInstruction(insn, 25, 2);
19823 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19824 if (!Check(Out&: S, In: decodeFixedImmOperand<4>(Inst&: MI, Decoder)))
19825 return MCDisassembler::Fail;
19826 return S;
19827 case 285:
19828 tmp = fieldFromInstruction(insn, 7, 5);
19829 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19830 tmp = fieldFromInstruction(insn, 15, 5);
19831 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19832 tmp = fieldFromInstruction(insn, 20, 5);
19833 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19834 tmp = fieldFromInstruction(insn, 25, 2);
19835 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19836 return S;
19837 case 286:
19838 tmp = fieldFromInstruction(insn, 7, 5);
19839 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19840 tmp = fieldFromInstruction(insn, 15, 5);
19841 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19842 tmp = fieldFromInstruction(insn, 20, 5);
19843 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19844 tmp = fieldFromInstruction(insn, 25, 2);
19845 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19846 return S;
19847 case 287:
19848 tmp = fieldFromInstruction(insn, 7, 5);
19849 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19850 tmp = fieldFromInstruction(insn, 15, 5);
19851 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19852 tmp = fieldFromInstruction(insn, 20, 11);
19853 if (!Check(S, decodeUImmOperand<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19854 return S;
19855 case 288:
19856 tmp = fieldFromInstruction(insn, 7, 5);
19857 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19858 tmp = fieldFromInstruction(insn, 7, 5);
19859 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19860 tmp = fieldFromInstruction(insn, 15, 5);
19861 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19862 tmp = fieldFromInstruction(insn, 20, 11);
19863 if (!Check(S, decodeSImmOperand<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19864 return S;
19865 case 289:
19866 tmp = fieldFromInstruction(insn, 7, 5);
19867 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19868 tmp = fieldFromInstruction(insn, 7, 5);
19869 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19870 tmp = fieldFromInstruction(insn, 15, 5);
19871 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19872 tmp = fieldFromInstruction(insn, 25, 5);
19873 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19874 tmp = fieldFromInstruction(insn, 20, 5);
19875 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19876 return S;
19877 case 290:
19878 tmp = fieldFromInstruction(insn, 7, 5);
19879 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19880 tmp = fieldFromInstruction(insn, 7, 5);
19881 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19882 tmp = fieldFromInstruction(insn, 15, 5);
19883 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19884 tmp = fieldFromInstruction(insn, 25, 5);
19885 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19886 tmp = fieldFromInstruction(insn, 20, 5);
19887 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19888 return S;
19889 case 291:
19890 tmp = fieldFromInstruction(insn, 7, 5);
19891 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19892 tmp = fieldFromInstruction(insn, 15, 5);
19893 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19894 tmp = fieldFromInstruction(insn, 25, 5);
19895 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19896 tmp = fieldFromInstruction(insn, 20, 5);
19897 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19898 return S;
19899 case 292:
19900 tmp = fieldFromInstruction(insn, 7, 5);
19901 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19902 tmp = fieldFromInstruction(insn, 15, 5);
19903 if (!Check(S, DecodeGPRNoX31RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19904 tmp = fieldFromInstruction(insn, 25, 5);
19905 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19906 tmp = fieldFromInstruction(insn, 20, 5);
19907 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19908 return S;
19909 case 293:
19910 tmp = fieldFromInstruction(insn, 7, 5);
19911 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19912 tmp = fieldFromInstruction(insn, 15, 5);
19913 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19914 return S;
19915 case 294:
19916 tmp = fieldFromInstruction(insn, 7, 5);
19917 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19918 tmp = fieldFromInstruction(insn, 7, 5);
19919 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19920 tmp = fieldFromInstruction(insn, 15, 5);
19921 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19922 tmp = fieldFromInstruction(insn, 20, 5);
19923 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19924 return S;
19925 case 295:
19926 tmp = fieldFromInstruction(insn, 7, 5);
19927 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19928 tmp = fieldFromInstruction(insn, 15, 5);
19929 if (!Check(S, DecodeGPRNoX31RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19930 tmp = fieldFromInstruction(insn, 20, 5);
19931 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19932 return S;
19933 case 296:
19934 tmp = fieldFromInstruction(insn, 7, 5);
19935 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19936 tmp = fieldFromInstruction(insn, 15, 5);
19937 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19938 tmp = fieldFromInstruction(insn, 20, 5);
19939 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19940 return S;
19941 case 297:
19942 tmp = fieldFromInstruction(insn, 7, 5);
19943 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19944 tmp = fieldFromInstruction(insn, 15, 5);
19945 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19946 tmp = fieldFromInstruction(insn, 20, 5);
19947 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19948 return S;
19949 case 298:
19950 tmp = fieldFromInstruction(insn, 7, 5);
19951 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19952 tmp = fieldFromInstruction(insn, 15, 5);
19953 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19954 tmp = fieldFromInstruction(insn, 20, 5);
19955 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19956 tmp = fieldFromInstruction(insn, 25, 5);
19957 if (!Check(S, decodeUImmOperand<5, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19958 return S;
19959 case 299:
19960 tmp = fieldFromInstruction(insn, 7, 5);
19961 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19962 tmp = fieldFromInstruction(insn, 15, 5);
19963 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19964 tmp = fieldFromInstruction(insn, 20, 12) << 2;
19965 if (!Check(S, decodeUImmOperand<14>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19966 return S;
19967 case 300:
19968 tmp = fieldFromInstruction(insn, 7, 5);
19969 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19970 tmp = fieldFromInstruction(insn, 7, 5);
19971 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19972 tmp = fieldFromInstruction(insn, 15, 5);
19973 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19974 tmp = fieldFromInstruction(insn, 20, 12);
19975 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19976 return S;
19977 case 301:
19978 tmp = fieldFromInstruction(insn, 7, 5);
19979 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19980 tmp = fieldFromInstruction(insn, 15, 5);
19981 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19982 tmp = fieldFromInstruction(insn, 20, 5);
19983 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19984 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19985 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19986 return S;
19987 case 302:
19988 tmp = fieldFromInstruction(insn, 7, 5);
19989 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19990 tmp = fieldFromInstruction(insn, 15, 5);
19991 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19992 tmp = fieldFromInstruction(insn, 20, 5);
19993 if (!Check(S, decodeUImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19994 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19995 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19996 return S;
19997 case 303:
19998 tmp = fieldFromInstruction(insn, 7, 5);
19999 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20000 tmp = fieldFromInstruction(insn, 15, 5);
20001 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20002 tmp = fieldFromInstruction(insn, 20, 5);
20003 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20004 tmp = fieldFromInstruction(insn, 25, 3);
20005 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20006 return S;
20007 case 304:
20008 tmp = fieldFromInstruction(insn, 20, 5);
20009 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20010 return S;
20011 case 305:
20012 tmp = fieldFromInstruction(insn, 20, 8);
20013 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20014 return S;
20015 case 306:
20016 tmp = fieldFromInstruction(insn, 7, 5);
20017 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20018 tmp = 0x0;
20019 tmp |= fieldFromInstruction(insn, 12, 4) << 15;
20020 tmp |= fieldFromInstruction(insn, 16, 15);
20021 tmp |= fieldFromInstruction(insn, 31, 1) << 19;
20022 if (!Check(S, decodeSImmOperand<20>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20023 return S;
20024 case 307:
20025 tmp = fieldFromInstruction(insn, 7, 5);
20026 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20027 tmp = fieldFromInstruction(insn, 15, 5);
20028 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20029 tmp = fieldFromInstruction(insn, 20, 5);
20030 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20031 tmp = fieldFromInstruction(insn, 25, 5) << 2;
20032 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20033 return S;
20034 case 308:
20035 tmp = fieldFromInstruction(insn, 7, 5);
20036 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20037 tmp = fieldFromInstruction(insn, 15, 5);
20038 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20039 tmp = fieldFromInstruction(insn, 20, 5);
20040 if (!Check(S, decodeUImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20041 tmp = fieldFromInstruction(insn, 25, 5) << 2;
20042 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20043 return S;
20044 case 309:
20045 tmp = fieldFromInstruction(insn, 7, 5);
20046 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20047 tmp = fieldFromInstruction(insn, 7, 5);
20048 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20049 tmp = fieldFromInstruction(insn, 15, 5);
20050 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20051 tmp = fieldFromInstruction(insn, 20, 5);
20052 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20053 tmp = fieldFromInstruction(insn, 27, 5);
20054 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20055 return S;
20056 case 310:
20057 tmp = fieldFromInstruction(insn, 7, 5);
20058 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20059 tmp = fieldFromInstruction(insn, 7, 5);
20060 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20061 tmp = fieldFromInstruction(insn, 15, 5);
20062 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20063 tmp = fieldFromInstruction(insn, 20, 5);
20064 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20065 tmp = fieldFromInstruction(insn, 27, 5);
20066 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20067 return S;
20068 case 311:
20069 tmp = fieldFromInstruction(insn, 7, 5);
20070 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20071 tmp = fieldFromInstruction(insn, 7, 5);
20072 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20073 tmp = fieldFromInstruction(insn, 15, 5);
20074 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20075 tmp = fieldFromInstruction(insn, 20, 5);
20076 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20077 tmp = fieldFromInstruction(insn, 27, 5);
20078 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20079 return S;
20080 case 312:
20081 tmp = fieldFromInstruction(insn, 7, 5);
20082 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20083 tmp = fieldFromInstruction(insn, 7, 5);
20084 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20085 tmp = fieldFromInstruction(insn, 15, 5);
20086 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20087 tmp = fieldFromInstruction(insn, 20, 5);
20088 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20089 tmp = fieldFromInstruction(insn, 27, 5);
20090 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20091 return S;
20092 case 313:
20093 tmp = fieldFromInstruction(insn, 7, 5);
20094 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20095 tmp = fieldFromInstruction(insn, 7, 5);
20096 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20097 tmp = fieldFromInstruction(insn, 15, 5);
20098 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20099 tmp = fieldFromInstruction(insn, 20, 5);
20100 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20101 tmp = fieldFromInstruction(insn, 27, 5);
20102 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20103 return S;
20104 case 314:
20105 tmp = fieldFromInstruction(insn, 7, 5);
20106 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20107 tmp = fieldFromInstruction(insn, 7, 5);
20108 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20109 tmp = fieldFromInstruction(insn, 15, 5);
20110 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20111 tmp = fieldFromInstruction(insn, 20, 5);
20112 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20113 tmp = fieldFromInstruction(insn, 27, 5);
20114 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20115 return S;
20116 case 315:
20117 tmp = fieldFromInstruction(insn, 7, 5);
20118 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20119 tmp = fieldFromInstruction(insn, 7, 5);
20120 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20121 tmp = fieldFromInstruction(insn, 15, 5);
20122 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20123 tmp = fieldFromInstruction(insn, 20, 5);
20124 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20125 tmp = fieldFromInstruction(insn, 27, 5);
20126 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20127 return S;
20128 case 316:
20129 tmp = fieldFromInstruction(insn, 7, 5);
20130 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20131 tmp = fieldFromInstruction(insn, 7, 5);
20132 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20133 tmp = fieldFromInstruction(insn, 15, 5);
20134 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20135 tmp = fieldFromInstruction(insn, 20, 5);
20136 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20137 tmp = fieldFromInstruction(insn, 27, 5);
20138 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20139 return S;
20140 case 317:
20141 tmp = fieldFromInstruction(insn, 7, 5);
20142 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20143 tmp = fieldFromInstruction(insn, 15, 5);
20144 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20145 tmp = fieldFromInstruction(insn, 20, 5);
20146 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20147 return S;
20148 case 318:
20149 tmp = fieldFromInstruction(insn, 7, 5);
20150 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20151 tmp = fieldFromInstruction(insn, 15, 5);
20152 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20153 tmp = fieldFromInstruction(insn, 20, 5);
20154 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20155 return S;
20156 case 319:
20157 tmp = fieldFromInstruction(insn, 15, 10);
20158 if (!Check(S, decodeUImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20159 return S;
20160 case 320:
20161 tmp = fieldFromInstruction(insn, 15, 5);
20162 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20163 tmp = fieldFromInstruction(insn, 20, 5);
20164 if (!Check(S, decodeSImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20165 tmp = 0x0;
20166 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20167 tmp |= fieldFromInstruction(insn, 8, 4);
20168 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20169 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20170 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20171 return S;
20172 case 321:
20173 tmp = fieldFromInstruction(insn, 15, 5);
20174 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20175 tmp = fieldFromInstruction(insn, 20, 5);
20176 if (!Check(S, decodeUImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20177 tmp = 0x0;
20178 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20179 tmp |= fieldFromInstruction(insn, 8, 4);
20180 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20181 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20182 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20183 return S;
20184 case 322:
20185 tmp = fieldFromInstruction(insn, 7, 5);
20186 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20187 tmp = fieldFromInstruction(insn, 15, 5);
20188 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20189 tmp = fieldFromInstruction(insn, 12, 3);
20190 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20191 return S;
20192 case 323:
20193 tmp = fieldFromInstruction(insn, 7, 5);
20194 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20195 tmp = fieldFromInstruction(insn, 15, 5);
20196 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20197 tmp = fieldFromInstruction(insn, 12, 3);
20198 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20199 return S;
20200 case 324:
20201 tmp = fieldFromInstruction(insn, 7, 5);
20202 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20203 tmp = fieldFromInstruction(insn, 15, 5);
20204 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20205 tmp = fieldFromInstruction(insn, 20, 5);
20206 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20207 tmp = fieldFromInstruction(insn, 27, 5);
20208 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20209 tmp = fieldFromInstruction(insn, 12, 3);
20210 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20211 return S;
20212 case 325:
20213 tmp = fieldFromInstruction(insn, 7, 5);
20214 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20215 tmp = fieldFromInstruction(insn, 15, 5);
20216 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20217 tmp = fieldFromInstruction(insn, 20, 5);
20218 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20219 tmp = fieldFromInstruction(insn, 12, 3);
20220 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20221 return S;
20222 case 326:
20223 tmp = fieldFromInstruction(insn, 7, 5);
20224 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20225 tmp = fieldFromInstruction(insn, 15, 5);
20226 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20227 tmp = fieldFromInstruction(insn, 20, 5);
20228 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20229 return S;
20230 case 327:
20231 tmp = fieldFromInstruction(insn, 7, 5);
20232 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20233 tmp = fieldFromInstruction(insn, 15, 5);
20234 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20235 tmp = fieldFromInstruction(insn, 12, 3);
20236 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20237 return S;
20238 case 328:
20239 tmp = fieldFromInstruction(insn, 7, 5);
20240 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20241 tmp = fieldFromInstruction(insn, 15, 5);
20242 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20243 tmp = fieldFromInstruction(insn, 12, 3);
20244 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20245 return S;
20246 case 329:
20247 tmp = fieldFromInstruction(insn, 7, 5);
20248 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20249 tmp = fieldFromInstruction(insn, 15, 5);
20250 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20251 tmp = fieldFromInstruction(insn, 12, 3);
20252 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20253 return S;
20254 case 330:
20255 tmp = fieldFromInstruction(insn, 7, 5);
20256 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20257 tmp = fieldFromInstruction(insn, 15, 5);
20258 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20259 tmp = fieldFromInstruction(insn, 20, 5);
20260 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20261 return S;
20262 case 331:
20263 tmp = fieldFromInstruction(insn, 7, 5);
20264 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20265 tmp = fieldFromInstruction(insn, 15, 5);
20266 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20267 tmp = fieldFromInstruction(insn, 12, 3);
20268 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20269 return S;
20270 case 332:
20271 tmp = fieldFromInstruction(insn, 7, 5);
20272 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20273 tmp = fieldFromInstruction(insn, 15, 5);
20274 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20275 tmp = fieldFromInstruction(insn, 12, 3);
20276 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20277 return S;
20278 case 333:
20279 tmp = fieldFromInstruction(insn, 7, 5);
20280 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20281 tmp = fieldFromInstruction(insn, 15, 5);
20282 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20283 return S;
20284 case 334:
20285 tmp = fieldFromInstruction(insn, 7, 5);
20286 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20287 tmp = fieldFromInstruction(insn, 15, 5);
20288 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20289 tmp = fieldFromInstruction(insn, 20, 5);
20290 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20291 tmp = fieldFromInstruction(insn, 27, 5);
20292 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20293 tmp = fieldFromInstruction(insn, 12, 3);
20294 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20295 return S;
20296 case 335:
20297 tmp = fieldFromInstruction(insn, 7, 5);
20298 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20299 tmp = fieldFromInstruction(insn, 15, 5);
20300 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20301 tmp = fieldFromInstruction(insn, 20, 5);
20302 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20303 tmp = fieldFromInstruction(insn, 27, 5);
20304 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20305 tmp = fieldFromInstruction(insn, 12, 3);
20306 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20307 return S;
20308 case 336:
20309 tmp = fieldFromInstruction(insn, 7, 5);
20310 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20311 tmp = fieldFromInstruction(insn, 15, 5);
20312 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20313 tmp = fieldFromInstruction(insn, 20, 5);
20314 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20315 tmp = fieldFromInstruction(insn, 27, 5);
20316 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20317 tmp = fieldFromInstruction(insn, 12, 3);
20318 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20319 return S;
20320 case 337:
20321 tmp = fieldFromInstruction(insn, 7, 5);
20322 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20323 tmp = fieldFromInstruction(insn, 15, 5);
20324 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20325 tmp = fieldFromInstruction(insn, 20, 5);
20326 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20327 tmp = fieldFromInstruction(insn, 12, 3);
20328 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20329 return S;
20330 case 338:
20331 tmp = fieldFromInstruction(insn, 7, 5);
20332 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20333 tmp = fieldFromInstruction(insn, 15, 5);
20334 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20335 tmp = fieldFromInstruction(insn, 20, 5);
20336 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20337 tmp = fieldFromInstruction(insn, 12, 3);
20338 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20339 return S;
20340 case 339:
20341 tmp = fieldFromInstruction(insn, 7, 5);
20342 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20343 tmp = fieldFromInstruction(insn, 15, 5);
20344 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20345 tmp = fieldFromInstruction(insn, 20, 5);
20346 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20347 tmp = fieldFromInstruction(insn, 12, 3);
20348 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20349 return S;
20350 case 340:
20351 tmp = fieldFromInstruction(insn, 7, 5);
20352 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20353 tmp = fieldFromInstruction(insn, 15, 5);
20354 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20355 tmp = fieldFromInstruction(insn, 20, 5);
20356 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20357 return S;
20358 case 341:
20359 tmp = fieldFromInstruction(insn, 7, 5);
20360 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20361 tmp = fieldFromInstruction(insn, 15, 5);
20362 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20363 tmp = fieldFromInstruction(insn, 20, 5);
20364 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20365 return S;
20366 case 342:
20367 tmp = fieldFromInstruction(insn, 7, 5);
20368 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20369 tmp = fieldFromInstruction(insn, 15, 5);
20370 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20371 tmp = fieldFromInstruction(insn, 12, 3);
20372 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20373 return S;
20374 case 343:
20375 tmp = fieldFromInstruction(insn, 7, 5);
20376 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20377 tmp = fieldFromInstruction(insn, 15, 5);
20378 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20379 tmp = fieldFromInstruction(insn, 12, 3);
20380 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20381 return S;
20382 case 344:
20383 tmp = fieldFromInstruction(insn, 7, 5);
20384 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20385 tmp = fieldFromInstruction(insn, 15, 5);
20386 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20387 tmp = fieldFromInstruction(insn, 12, 3);
20388 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20389 return S;
20390 case 345:
20391 tmp = fieldFromInstruction(insn, 7, 5);
20392 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20393 tmp = fieldFromInstruction(insn, 15, 5);
20394 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20395 tmp = fieldFromInstruction(insn, 12, 3);
20396 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20397 return S;
20398 case 346:
20399 tmp = fieldFromInstruction(insn, 7, 5);
20400 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20401 tmp = fieldFromInstruction(insn, 15, 5);
20402 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20403 tmp = fieldFromInstruction(insn, 12, 3);
20404 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20405 return S;
20406 case 347:
20407 tmp = fieldFromInstruction(insn, 7, 5);
20408 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20409 tmp = fieldFromInstruction(insn, 15, 5);
20410 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20411 tmp = fieldFromInstruction(insn, 12, 3);
20412 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20413 return S;
20414 case 348:
20415 tmp = fieldFromInstruction(insn, 7, 5);
20416 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20417 tmp = fieldFromInstruction(insn, 15, 5);
20418 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20419 tmp = fieldFromInstruction(insn, 12, 3);
20420 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20421 return S;
20422 case 349:
20423 tmp = fieldFromInstruction(insn, 7, 5);
20424 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20425 tmp = fieldFromInstruction(insn, 15, 5);
20426 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20427 tmp = fieldFromInstruction(insn, 12, 3);
20428 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20429 return S;
20430 case 350:
20431 tmp = fieldFromInstruction(insn, 7, 5);
20432 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20433 tmp = fieldFromInstruction(insn, 15, 5);
20434 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20435 tmp = fieldFromInstruction(insn, 12, 3);
20436 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20437 return S;
20438 case 351:
20439 tmp = fieldFromInstruction(insn, 7, 5);
20440 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20441 tmp = fieldFromInstruction(insn, 15, 5);
20442 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20443 tmp = fieldFromInstruction(insn, 20, 5);
20444 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20445 return S;
20446 case 352:
20447 tmp = fieldFromInstruction(insn, 7, 5);
20448 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20449 tmp = fieldFromInstruction(insn, 15, 5);
20450 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20451 tmp = fieldFromInstruction(insn, 20, 5);
20452 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20453 return S;
20454 case 353:
20455 tmp = fieldFromInstruction(insn, 7, 5);
20456 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20457 tmp = fieldFromInstruction(insn, 15, 5);
20458 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20459 return S;
20460 case 354:
20461 tmp = fieldFromInstruction(insn, 7, 5);
20462 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20463 tmp = fieldFromInstruction(insn, 15, 5);
20464 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20465 return S;
20466 }
20467}
20468static const uint8_t DecoderTableXqci48[368] = {
20469 48, // 0: BitWidth 48
20470 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
20471 0, 15, // 4: case 0x0: {
20472 OPC_CheckPredicate, 201, 1, // 6: check predicate 201
20473 OPC_CheckField, 15, 1, 0, // 9: check Inst[15] == 0x0
20474 OPC_CheckField, 0, 7, 31, // 13: check Inst[6:0] == 0x1f
20475 OPC_Decode, 242, 122, 0, // 17: decode to QC_E_LI using decoder 0
20476 // 17: }
20477 1, 29, // 21: case 0x1: {
20478 OPC_SwitchField, 15, 1, // 23: switch Inst[15] {
20479 0, 11, // 26: case 0x0: {
20480 OPC_CheckPredicate, 216, 1, // 28: check predicate 216
20481 OPC_CheckField, 0, 7, 31, // 31: check Inst[6:0] == 0x1f
20482 OPC_Decode, 249, 122, 1, // 35: decode to QC_E_XORAI using decoder 1
20483 // 35: }
20484 1, 0, // 39: case 0x1: {
20485 OPC_CheckPredicate, 216, 1, // 41: check predicate 216
20486 OPC_CheckField, 0, 7, 31, // 44: check Inst[6:0] == 0x1f
20487 OPC_Decode, 244, 122, 1, // 48: decode to QC_E_ORAI using decoder 1
20488 // 48: }
20489 // 48: } // switch Inst[15]
20490 // 48: }
20491 2, 29, // 52: case 0x2: {
20492 OPC_SwitchField, 15, 1, // 54: switch Inst[15] {
20493 0, 11, // 57: case 0x0: {
20494 OPC_CheckPredicate, 216, 1, // 59: check predicate 216
20495 OPC_CheckField, 0, 7, 31, // 62: check Inst[6:0] == 0x1f
20496 OPC_Decode, 226, 122, 1, // 66: decode to QC_E_ADDAI using decoder 1
20497 // 66: }
20498 1, 0, // 70: case 0x1: {
20499 OPC_CheckPredicate, 216, 1, // 72: check predicate 216
20500 OPC_CheckField, 0, 7, 31, // 75: check Inst[6:0] == 0x1f
20501 OPC_Decode, 228, 122, 1, // 79: decode to QC_E_ANDAI using decoder 1
20502 // 79: }
20503 // 79: } // switch Inst[15]
20504 // 79: }
20505 3, 55, // 83: case 0x3: {
20506 OPC_SwitchField, 30, 2, // 85: switch Inst[31:30] {
20507 0, 11, // 88: case 0x0: {
20508 OPC_CheckPredicate, 216, 1, // 90: check predicate 216
20509 OPC_CheckField, 0, 7, 31, // 93: check Inst[6:0] == 0x1f
20510 OPC_Decode, 250, 122, 2, // 97: decode to QC_E_XORI using decoder 2
20511 // 97: }
20512 1, 11, // 101: case 0x1: {
20513 OPC_CheckPredicate, 216, 1, // 103: check predicate 216
20514 OPC_CheckField, 0, 7, 31, // 106: check Inst[6:0] == 0x1f
20515 OPC_Decode, 245, 122, 2, // 110: decode to QC_E_ORI using decoder 2
20516 // 110: }
20517 2, 11, // 114: case 0x2: {
20518 OPC_CheckPredicate, 216, 1, // 116: check predicate 216
20519 OPC_CheckField, 0, 7, 31, // 119: check Inst[6:0] == 0x1f
20520 OPC_Decode, 227, 122, 2, // 123: decode to QC_E_ADDI using decoder 2
20521 // 123: }
20522 3, 0, // 127: case 0x3: {
20523 OPC_CheckPredicate, 216, 1, // 129: check predicate 216
20524 OPC_CheckField, 0, 7, 31, // 132: check Inst[6:0] == 0x1f
20525 OPC_Decode, 229, 122, 2, // 136: decode to QC_E_ANDI using decoder 2
20526 // 136: }
20527 // 136: } // switch Inst[31:30]
20528 // 136: }
20529 4, 112, // 140: case 0x4: {
20530 OPC_SwitchField, 20, 5, // 142: switch Inst[24:20] {
20531 0, 29, // 145: case 0x0: {
20532 OPC_SwitchField, 15, 2, // 147: switch Inst[16:15] {
20533 0, 11, // 150: case 0x0: {
20534 OPC_CheckPredicate, 217, 1, // 152: check predicate 217
20535 OPC_CheckField, 0, 7, 31, // 155: check Inst[6:0] == 0x1f
20536 OPC_Decode, 236, 122, 3, // 159: decode to QC_E_J using decoder 3
20537 // 159: }
20538 1, 0, // 163: case 0x1: {
20539 OPC_CheckPredicate, 217, 1, // 165: check predicate 217
20540 OPC_CheckField, 0, 7, 31, // 168: check Inst[6:0] == 0x1f
20541 OPC_Decode, 237, 122, 3, // 172: decode to QC_E_JAL using decoder 3
20542 // 172: }
20543 // 172: } // switch Inst[16:15]
20544 // 172: }
20545 24, 11, // 176: case 0x18: {
20546 OPC_CheckPredicate, 205, 1, // 178: check predicate 205
20547 OPC_CheckField, 0, 7, 31, // 181: check Inst[6:0] == 0x1f
20548 OPC_Decode, 230, 122, 4, // 185: decode to QC_E_BEQI using decoder 4
20549 // 185: }
20550 25, 11, // 189: case 0x19: {
20551 OPC_CheckPredicate, 205, 1, // 191: check predicate 205
20552 OPC_CheckField, 0, 7, 31, // 194: check Inst[6:0] == 0x1f
20553 OPC_Decode, 235, 122, 4, // 198: decode to QC_E_BNEI using decoder 4
20554 // 198: }
20555 28, 11, // 202: case 0x1c: {
20556 OPC_CheckPredicate, 205, 1, // 204: check predicate 205
20557 OPC_CheckField, 0, 7, 31, // 207: check Inst[6:0] == 0x1f
20558 OPC_Decode, 233, 122, 4, // 211: decode to QC_E_BLTI using decoder 4
20559 // 211: }
20560 29, 11, // 215: case 0x1d: {
20561 OPC_CheckPredicate, 205, 1, // 217: check predicate 205
20562 OPC_CheckField, 0, 7, 31, // 220: check Inst[6:0] == 0x1f
20563 OPC_Decode, 231, 122, 4, // 224: decode to QC_E_BGEI using decoder 4
20564 // 224: }
20565 30, 11, // 228: case 0x1e: {
20566 OPC_CheckPredicate, 205, 1, // 230: check predicate 205
20567 OPC_CheckField, 0, 7, 31, // 233: check Inst[6:0] == 0x1f
20568 OPC_Decode, 234, 122, 5, // 237: decode to QC_E_BLTUI using decoder 5
20569 // 237: }
20570 31, 0, // 241: case 0x1f: {
20571 OPC_CheckPredicate, 205, 1, // 243: check predicate 205
20572 OPC_CheckField, 0, 7, 31, // 246: check Inst[6:0] == 0x1f
20573 OPC_Decode, 232, 122, 5, // 250: decode to QC_E_BGEUI using decoder 5
20574 // 250: }
20575 // 250: } // switch Inst[24:20]
20576 // 250: }
20577 5, 55, // 254: case 0x5: {
20578 OPC_SwitchField, 30, 2, // 256: switch Inst[31:30] {
20579 0, 11, // 259: case 0x0: {
20580 OPC_CheckPredicate, 218, 1, // 261: check predicate 218
20581 OPC_CheckField, 0, 7, 31, // 264: check Inst[6:0] == 0x1f
20582 OPC_Decode, 238, 122, 6, // 268: decode to QC_E_LB using decoder 6
20583 // 268: }
20584 1, 11, // 272: case 0x1: {
20585 OPC_CheckPredicate, 218, 1, // 274: check predicate 218
20586 OPC_CheckField, 0, 7, 31, // 277: check Inst[6:0] == 0x1f
20587 OPC_Decode, 239, 122, 6, // 281: decode to QC_E_LBU using decoder 6
20588 // 281: }
20589 2, 11, // 285: case 0x2: {
20590 OPC_CheckPredicate, 218, 1, // 287: check predicate 218
20591 OPC_CheckField, 0, 7, 31, // 290: check Inst[6:0] == 0x1f
20592 OPC_Decode, 240, 122, 6, // 294: decode to QC_E_LH using decoder 6
20593 // 294: }
20594 3, 0, // 298: case 0x3: {
20595 OPC_CheckPredicate, 218, 1, // 300: check predicate 218
20596 OPC_CheckField, 0, 7, 31, // 303: check Inst[6:0] == 0x1f
20597 OPC_Decode, 241, 122, 6, // 307: decode to QC_E_LHU using decoder 6
20598 // 307: }
20599 // 307: } // switch Inst[31:30]
20600 // 307: }
20601 6, 0, // 311: case 0x6: {
20602 OPC_SwitchField, 30, 2, // 313: switch Inst[31:30] {
20603 0, 11, // 316: case 0x0: {
20604 OPC_CheckPredicate, 218, 1, // 318: check predicate 218
20605 OPC_CheckField, 0, 7, 31, // 321: check Inst[6:0] == 0x1f
20606 OPC_Decode, 243, 122, 6, // 325: decode to QC_E_LW using decoder 6
20607 // 325: }
20608 1, 11, // 329: case 0x1: {
20609 OPC_CheckPredicate, 218, 1, // 331: check predicate 218
20610 OPC_CheckField, 0, 7, 31, // 334: check Inst[6:0] == 0x1f
20611 OPC_Decode, 246, 122, 7, // 338: decode to QC_E_SB using decoder 7
20612 // 338: }
20613 2, 11, // 342: case 0x2: {
20614 OPC_CheckPredicate, 218, 1, // 344: check predicate 218
20615 OPC_CheckField, 0, 7, 31, // 347: check Inst[6:0] == 0x1f
20616 OPC_Decode, 247, 122, 7, // 351: decode to QC_E_SH using decoder 7
20617 // 351: }
20618 3, 0, // 355: case 0x3: {
20619 OPC_CheckPredicate, 218, 1, // 357: check predicate 218
20620 OPC_CheckField, 0, 7, 31, // 360: check Inst[6:0] == 0x1f
20621 OPC_Decode, 248, 122, 7, // 364: decode to QC_E_SW using decoder 7
20622 // 364: }
20623 // 364: } // switch Inst[31:30]
20624 // 364: }
20625 // 364: } // switch Inst[14:12]
20626};
20627// Handling 8 cases.
20628template <typename InsnType>
20629static std::enable_if_t<InsnBitWidth<InsnType> == 48, DecodeStatus>
20630decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
20631 DecodeComplete = true;
20632 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
20633 TmpType tmp;
20634 switch (Idx) {
20635 default: llvm_unreachable("Invalid decoder index!");
20636 case 0:
20637 tmp = fieldFromInstruction(insn, 7, 5);
20638 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20639 tmp = fieldFromInstruction(insn, 16, 32);
20640 if (!Check(S, decodeSImmOperand<32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20641 return S;
20642 case 1:
20643 tmp = fieldFromInstruction(insn, 7, 5);
20644 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20645 tmp = fieldFromInstruction(insn, 7, 5);
20646 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20647 tmp = fieldFromInstruction(insn, 16, 32);
20648 if (!Check(S, decodeSImmOperand<32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20649 return S;
20650 case 2:
20651 tmp = fieldFromInstruction(insn, 7, 5);
20652 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20653 tmp = fieldFromInstruction(insn, 15, 5);
20654 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20655 tmp = 0x0;
20656 tmp |= fieldFromInstruction(insn, 20, 10);
20657 tmp |= fieldFromInstruction(insn, 32, 16) << 10;
20658 if (!Check(S, decodeSImmOperand<26>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20659 return S;
20660 case 3:
20661 tmp = 0x0;
20662 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20663 tmp |= fieldFromInstruction(insn, 8, 4);
20664 tmp |= fieldFromInstruction(insn, 17, 3) << 12;
20665 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20666 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20667 tmp |= fieldFromInstruction(insn, 32, 16) << 15;
20668 if (!Check(S, decodeSImmOperandAndLslN<32, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20669 return S;
20670 case 4:
20671 tmp = fieldFromInstruction(insn, 15, 5);
20672 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20673 tmp = fieldFromInstruction(insn, 32, 16);
20674 if (!Check(S, decodeSImmNonZeroOperand<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20675 tmp = 0x0;
20676 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20677 tmp |= fieldFromInstruction(insn, 8, 4);
20678 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20679 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20680 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20681 return S;
20682 case 5:
20683 tmp = fieldFromInstruction(insn, 15, 5);
20684 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20685 tmp = fieldFromInstruction(insn, 32, 16);
20686 if (!Check(S, decodeUImmNonZeroOperand<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20687 tmp = 0x0;
20688 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20689 tmp |= fieldFromInstruction(insn, 8, 4);
20690 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20691 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20692 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20693 return S;
20694 case 6:
20695 tmp = fieldFromInstruction(insn, 7, 5);
20696 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20697 tmp = fieldFromInstruction(insn, 15, 5);
20698 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20699 tmp = 0x0;
20700 tmp |= fieldFromInstruction(insn, 20, 10);
20701 tmp |= fieldFromInstruction(insn, 32, 16) << 10;
20702 if (!Check(S, decodeSImmOperand<26>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20703 return S;
20704 case 7:
20705 tmp = fieldFromInstruction(insn, 20, 5);
20706 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20707 tmp = fieldFromInstruction(insn, 15, 5);
20708 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20709 tmp = 0x0;
20710 tmp |= fieldFromInstruction(insn, 7, 5);
20711 tmp |= fieldFromInstruction(insn, 25, 5) << 5;
20712 tmp |= fieldFromInstruction(insn, 32, 16) << 10;
20713 if (!Check(S, decodeSImmOperand<26>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20714 return S;
20715 }
20716}
20717static bool checkDecoderPredicate(unsigned Idx, const FeatureBitset &FB) {
20718 switch (Idx) {
20719 default: llvm_unreachable("Invalid index!");
20720 case 0:
20721 return FB[RISCV::FeatureStdExtZca];
20722 case 1:
20723 return FB[RISCV::FeatureStdExtZcd];
20724 case 2:
20725 return FB[RISCV::FeatureStdExtZca] && FB[RISCV::Feature64Bit];
20726 case 3:
20727 return FB[RISCV::FeatureStdExtZcmop];
20728 case 4:
20729 return FB[RISCV::FeatureStdExtZcb];
20730 case 5:
20731 return FB[RISCV::FeatureStdExtZcb] && FB[RISCV::FeatureStdExtZmmul];
20732 case 6:
20733 return FB[RISCV::FeatureStdExtZcb] && FB[RISCV::FeatureStdExtZbb];
20734 case 7:
20735 return FB[RISCV::FeatureStdExtZcb] && FB[RISCV::FeatureStdExtZba] && FB[RISCV::Feature64Bit];
20736 case 8:
20737 return FB[RISCV::FeatureStdExtZcf] && !(FB[RISCV::Feature64Bit]);
20738 case 9:
20739 return FB[RISCV::FeatureStdExtZca] && !(FB[RISCV::Feature64Bit]);
20740 case 10:
20741 return FB[RISCV::FeatureVendorXqccmi] && !(FB[RISCV::Feature64Bit]);
20742 case 11:
20743 return FB[RISCV::FeatureVendorXqccmp];
20744 case 12:
20745 return FB[RISCV::FeatureVendorXqccmt];
20746 case 13:
20747 return FB[RISCV::FeatureVendorXqciint] && !(FB[RISCV::Feature64Bit]);
20748 case 14:
20749 return FB[RISCV::FeatureVendorXqcibm] && !(FB[RISCV::Feature64Bit]);
20750 case 15:
20751 return FB[RISCV::FeatureVendorXqciac] && !(FB[RISCV::Feature64Bit]);
20752 case 16:
20753 return FB[RISCV::FeatureVendorXqcisync] && !(FB[RISCV::Feature64Bit]);
20754 case 17:
20755 return FB[RISCV::FeatureVendorXqcicm] && !(FB[RISCV::Feature64Bit]);
20756 case 18:
20757 return FB[RISCV::FeatureVendorXwchc];
20758 case 19:
20759 return FB[RISCV::FeatureStdExtZclsd] && !(FB[RISCV::Feature64Bit]);
20760 case 20:
20761 return FB[RISCV::FeatureStdExtZcmt];
20762 case 21:
20763 return FB[RISCV::FeatureStdExtZcmp];
20764 case 22:
20765 return FB[RISCV::Feature64Bit];
20766 case 23:
20767 return FB[RISCV::FeatureStdExtZve32x];
20768 case 24:
20769 return FB[RISCV::FeatureStdExtZfh] || FB[RISCV::FeatureStdExtZfhmin] || FB[RISCV::FeatureStdExtZfbfmin];
20770 case 25:
20771 return FB[RISCV::FeatureStdExtF];
20772 case 26:
20773 return FB[RISCV::FeatureStdExtD];
20774 case 27:
20775 return FB[RISCV::FeatureStdExtQ];
20776 case 28:
20777 return FB[RISCV::FeatureStdExtZve64x];
20778 case 29:
20779 return FB[RISCV::Feature64Bit] && FB[RISCV::FeatureStdExtZve64x];
20780 case 30:
20781 return FB[RISCV::FeatureStdExtZve64x] && FB[RISCV::Feature64Bit];
20782 case 31:
20783 return FB[RISCV::FeatureStdExtZvvmtls];
20784 case 32:
20785 return FB[RISCV::FeatureStdExtZvvmttls];
20786 case 33:
20787 return FB[RISCV::FeatureStdExtZicbom];
20788 case 34:
20789 return FB[RISCV::FeatureStdExtZicboz];
20790 case 35:
20791 return FB[RISCV::FeatureStdExtZbkb] && !(FB[RISCV::Feature64Bit]);
20792 case 36:
20793 return FB[RISCV::FeatureStdExtZknh];
20794 case 37:
20795 return FB[RISCV::FeatureStdExtZknh] && FB[RISCV::Feature64Bit];
20796 case 38:
20797 return FB[RISCV::FeatureStdExtZksh];
20798 case 39:
20799 return FB[RISCV::FeatureStdExtZbs];
20800 case 40:
20801 return FB[RISCV::FeatureStdExtZknd] && FB[RISCV::Feature64Bit];
20802 case 41:
20803 return (FB[RISCV::FeatureStdExtZknd] || FB[RISCV::FeatureStdExtZkne]) && FB[RISCV::Feature64Bit];
20804 case 42:
20805 return FB[RISCV::FeatureStdExtZbb];
20806 case 43:
20807 return FB[RISCV::FeatureStdExtP];
20808 case 44:
20809 return FB[RISCV::FeatureStdExtZbb] || FB[RISCV::FeatureStdExtZbkb];
20810 case 45:
20811 return FB[RISCV::FeatureStdExtZbkb];
20812 case 46:
20813 return (FB[RISCV::FeatureStdExtZbb] || FB[RISCV::FeatureStdExtZbkb]) && !(FB[RISCV::Feature64Bit]);
20814 case 47:
20815 return FB[RISCV::FeatureStdExtP] && !(FB[RISCV::Feature64Bit]);
20816 case 48:
20817 return FB[RISCV::FeatureStdExtP] && FB[RISCV::Feature64Bit];
20818 case 49:
20819 return (FB[RISCV::FeatureStdExtZbb] || FB[RISCV::FeatureStdExtZbkb]) && FB[RISCV::Feature64Bit];
20820 case 50:
20821 return FB[RISCV::FeatureStdExtZba] && FB[RISCV::Feature64Bit];
20822 case 51:
20823 return FB[RISCV::FeatureStdExtZbb] && FB[RISCV::Feature64Bit];
20824 case 52:
20825 return FB[RISCV::FeatureStdExtZabha];
20826 case 53:
20827 return FB[RISCV::FeatureStdExtZaamo];
20828 case 54:
20829 return FB[RISCV::FeatureStdExtZaamo] && FB[RISCV::Feature64Bit];
20830 case 55:
20831 return FB[RISCV::FeatureStdExtZalrsc];
20832 case 56:
20833 return FB[RISCV::FeatureStdExtZalrsc] && FB[RISCV::Feature64Bit];
20834 case 57:
20835 return FB[RISCV::FeatureStdExtZabha] && FB[RISCV::FeatureStdExtZacas];
20836 case 58:
20837 return FB[RISCV::FeatureStdExtZacas];
20838 case 59:
20839 return FB[RISCV::FeatureStdExtZacas] && FB[RISCV::Feature64Bit];
20840 case 60:
20841 return FB[RISCV::FeatureStdExtZalasr];
20842 case 61:
20843 return FB[RISCV::FeatureStdExtZalasr] && FB[RISCV::Feature64Bit];
20844 case 62:
20845 return FB[RISCV::FeatureStdExtZicfiss];
20846 case 63:
20847 return FB[RISCV::FeatureStdExtZicfiss] && FB[RISCV::Feature64Bit];
20848 case 64:
20849 return FB[RISCV::FeatureStdExtZilx];
20850 case 65:
20851 return FB[RISCV::FeatureStdExtZilx] && FB[RISCV::Feature64Bit];
20852 case 66:
20853 return FB[RISCV::FeatureStdExtZmmul];
20854 case 67:
20855 return FB[RISCV::FeatureStdExtM];
20856 case 68:
20857 return FB[RISCV::FeatureStdExtZbkb] || FB[RISCV::FeatureStdExtP];
20858 case 69:
20859 return FB[RISCV::FeatureStdExtZbkc];
20860 case 70:
20861 return FB[RISCV::FeatureStdExtZbc];
20862 case 71:
20863 return FB[RISCV::FeatureStdExtZicond];
20864 case 72:
20865 return FB[RISCV::FeatureStdExtZknh] && !(FB[RISCV::Feature64Bit]);
20866 case 73:
20867 return FB[RISCV::FeatureStdExtZba];
20868 case 74:
20869 return FB[RISCV::FeatureStdExtZkne] && !(FB[RISCV::Feature64Bit]);
20870 case 75:
20871 return FB[RISCV::FeatureStdExtZbkx];
20872 case 76:
20873 return FB[RISCV::FeatureStdExtZknd] && !(FB[RISCV::Feature64Bit]);
20874 case 77:
20875 return FB[RISCV::FeatureStdExtZksed];
20876 case 78:
20877 return FB[RISCV::FeatureStdExtZkne] && FB[RISCV::Feature64Bit];
20878 case 79:
20879 return FB[RISCV::FeatureStdExtZmmul] && FB[RISCV::Feature64Bit];
20880 case 80:
20881 return FB[RISCV::FeatureStdExtM] && FB[RISCV::Feature64Bit];
20882 case 81:
20883 return FB[RISCV::FeatureStdExtZbkb] && FB[RISCV::Feature64Bit];
20884 case 82:
20885 return FB[RISCV::FeatureStdExtZfh];
20886 case 83:
20887 return FB[RISCV::FeatureStdExtZfa];
20888 case 84:
20889 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtD];
20890 case 85:
20891 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtZfh];
20892 case 86:
20893 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtQ];
20894 case 87:
20895 return FB[RISCV::FeatureStdExtZfhmin];
20896 case 88:
20897 return FB[RISCV::FeatureStdExtZfbfmin];
20898 case 89:
20899 return FB[RISCV::FeatureStdExtZfhmin] && FB[RISCV::FeatureStdExtD];
20900 case 90:
20901 return FB[RISCV::FeatureStdExtZfhmin] && FB[RISCV::FeatureStdExtQ];
20902 case 91:
20903 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtD] && !(FB[RISCV::Feature64Bit]);
20904 case 92:
20905 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtQ] && FB[RISCV::Feature64Bit];
20906 case 93:
20907 return FB[RISCV::FeatureStdExtF] && FB[RISCV::Feature64Bit];
20908 case 94:
20909 return FB[RISCV::FeatureStdExtD] && FB[RISCV::Feature64Bit];
20910 case 95:
20911 return FB[RISCV::FeatureStdExtZfh] && FB[RISCV::Feature64Bit];
20912 case 96:
20913 return FB[RISCV::FeatureStdExtQ] && FB[RISCV::Feature64Bit];
20914 case 97:
20915 return FB[RISCV::FeatureStdExtZfa] && (FB[RISCV::FeatureStdExtZfh] || FB[RISCV::FeatureStdExtZvfh]);
20916 case 98:
20917 return FB[RISCV::FeatureStdExtZvkb];
20918 case 99:
20919 return FB[RISCV::FeatureStdExtZvzip];
20920 case 100:
20921 return FB[RISCV::FeatureStdExtZvbb];
20922 case 101:
20923 return FB[RISCV::FeatureStdExtZvvmm];
20924 case 102:
20925 return FB[RISCV::FeatureStdExtZvvfmm];
20926 case 103:
20927 return FB[RISCV::FeatureStdExtZvabd];
20928 case 104:
20929 return FB[RISCV::FeatureStdExtZve32f];
20930 case 105:
20931 return FB[RISCV::FeatureStdExtZvfbfmin] || FB[RISCV::FeatureStdExtZvfofp8min];
20932 case 106:
20933 return FB[RISCV::FeatureStdExtZvfofp8min];
20934 case 107:
20935 return FB[RISCV::FeatureStdExtZvfbfwma];
20936 case 108:
20937 return FB[RISCV::FeatureStdExtZvbc] || FB[RISCV::FeatureStdExtZvbc32e];
20938 case 109:
20939 return FB[RISCV::FeatureStdExtZvdot4a8i];
20940 case 110:
20941 return FB[RISCV::FeatureStdExtZibi];
20942 case 111:
20943 return FB[RISCV::FeatureStdExtZawrs];
20944 case 112:
20945 return FB[RISCV::FeatureStdExtSmctr] || FB[RISCV::FeatureStdExtSsctr];
20946 case 113:
20947 return FB[RISCV::FeatureStdExtSsip];
20948 case 114:
20949 return FB[RISCV::FeatureStdExtSscsps];
20950 case 115:
20951 return FB[RISCV::FeatureStdExtSvinval];
20952 case 116:
20953 return FB[RISCV::FeatureStdExtH];
20954 case 117:
20955 return FB[RISCV::FeatureStdExtSvinval] && FB[RISCV::FeatureStdExtH];
20956 case 118:
20957 return FB[RISCV::FeatureStdExtSmip];
20958 case 119:
20959 return FB[RISCV::FeatureStdExtSmcsps];
20960 case 120:
20961 return FB[RISCV::FeatureStdExtSmrnmi];
20962 case 121:
20963 return FB[RISCV::Feature64Bit] && FB[RISCV::FeatureStdExtH];
20964 case 122:
20965 return FB[RISCV::FeatureStdExtZimop];
20966 case 123:
20967 return FB[RISCV::FeatureStdExtZvksh];
20968 case 124:
20969 return FB[RISCV::FeatureStdExtZvksed];
20970 case 125:
20971 return FB[RISCV::FeatureStdExtZvkned];
20972 case 126:
20973 return FB[RISCV::FeatureStdExtZvkgs];
20974 case 127:
20975 return FB[RISCV::FeatureStdExtZvfwdota16bf];
20976 case 128:
20977 return FB[RISCV::FeatureStdExtZvqwdota8i] || FB[RISCV::FeatureStdExtZvqwdota16i];
20978 case 129:
20979 return FB[RISCV::FeatureStdExtZvfqwdota8f];
20980 case 130:
20981 return FB[RISCV::FeatureStdExtZvkg];
20982 case 131:
20983 return FB[RISCV::FeatureStdExtZvfbdota32f];
20984 case 132:
20985 return FB[RISCV::FeatureStdExtZvfwbdota16bf];
20986 case 133:
20987 return FB[RISCV::FeatureStdExtZvknha];
20988 case 134:
20989 return FB[RISCV::FeatureStdExtZvqwbdota8i] || FB[RISCV::FeatureStdExtZvqwbdota16i];
20990 case 135:
20991 return FB[RISCV::FeatureStdExtZvfqwbdota8f];
20992 case 136:
20993 return FB[RISCV::FeatureStdExtY] || FB[RISCV::FeatureStdExtZyhybrid];
20994 case 137:
20995 return FB[RISCV::FeatureStdExtZyhybrid];
20996 case 138:
20997 return FB[RISCV::FeatureStdExtZilsd] && !(FB[RISCV::Feature64Bit]);
20998 case 139:
20999 return FB[RISCV::FeatureStdExtZacas] && !(FB[RISCV::Feature64Bit]);
21000 case 140:
21001 return FB[RISCV::FeatureVendorXAIFET];
21002 case 141:
21003 return FB[RISCV::FeatureVendorXAndesPerf];
21004 case 142:
21005 return FB[RISCV::FeatureVendorXAndesVBFHCvt];
21006 case 143:
21007 return FB[RISCV::FeatureVendorXAndesBFHCvt];
21008 case 144:
21009 return FB[RISCV::FeatureVendorXAndesVSIntH] && FB[RISCV::FeatureStdExtZve32f];
21010 case 145:
21011 return FB[RISCV::FeatureVendorXAndesVSIntH];
21012 case 146:
21013 return FB[RISCV::FeatureVendorXAndesVSIntLoad];
21014 case 147:
21015 return FB[RISCV::FeatureVendorXAndesVPackFPH];
21016 case 148:
21017 return FB[RISCV::FeatureVendorXAndesPerf] && FB[RISCV::Feature64Bit];
21018 case 149:
21019 return FB[RISCV::FeatureVendorXAndesVDot];
21020 case 150:
21021 return FB[RISCV::FeatureVendorXCVmem] && !(FB[RISCV::Feature64Bit]);
21022 case 151:
21023 return FB[RISCV::FeatureVendorXCVbitmanip] && !(FB[RISCV::Feature64Bit]);
21024 case 152:
21025 return FB[RISCV::FeatureVendorXCVsimd] && !(FB[RISCV::Feature64Bit]);
21026 case 153:
21027 return FB[RISCV::FeatureVendorXCValu] && !(FB[RISCV::Feature64Bit]);
21028 case 154:
21029 return FB[RISCV::FeatureVendorXCVelw] && !(FB[RISCV::Feature64Bit]);
21030 case 155:
21031 return FB[RISCV::FeatureVendorXCVmac] && !(FB[RISCV::Feature64Bit]);
21032 case 156:
21033 return FB[RISCV::FeatureVendorXCVbi] && !(FB[RISCV::Feature64Bit]);
21034 case 157:
21035 return FB[RISCV::FeatureVendorXMIPSCBOP];
21036 case 158:
21037 return FB[RISCV::FeatureVendorXMIPSEXECTL];
21038 case 159:
21039 return FB[RISCV::FeatureVendorXMIPSCMov];
21040 case 160:
21041 return FB[RISCV::FeatureVendorXMIPSLSP] && FB[RISCV::Feature64Bit];
21042 case 161:
21043 return FB[RISCV::FeatureVendorXMIPSLSP];
21044 case 162:
21045 return FB[RISCV::FeatureVendorXSMTVDotII] && FB[RISCV::Feature64Bit];
21046 case 163:
21047 return FB[RISCV::FeatureVendorXSMTVDot] && FB[RISCV::Feature64Bit];
21048 case 164:
21049 return FB[RISCV::FeatureVendorXSfcease];
21050 case 165:
21051 return FB[RISCV::FeatureVendorXSiFivecflushdlone];
21052 case 166:
21053 return FB[RISCV::FeatureVendorXSiFivecdiscarddlone];
21054 case 167:
21055 return FB[RISCV::FeatureVendorXSfvcp];
21056 case 168:
21057 return FB[RISCV::FeatureVendorXSfmmbase];
21058 case 169:
21059 return FB[RISCV::FeatureVendorXSfvfexpa];
21060 case 170:
21061 return FB[RISCV::FeatureVendorXSfvfbfexp16e] || FB[RISCV::FeatureVendorXSfvfexp16e] || FB[RISCV::FeatureVendorXSfvfexp32e];
21062 case 171:
21063 return FB[RISCV::FeatureVendorXSfvfnrclipxfqf];
21064 case 172:
21065 return FB[RISCV::FeatureVendorXSfvqmaccdod];
21066 case 173:
21067 return FB[RISCV::FeatureVendorXSfmm32a8i];
21068 case 174:
21069 return FB[RISCV::FeatureVendorXSfvfwmaccqqq];
21070 case 175:
21071 return FB[RISCV::FeatureVendorXSfmm32a16f] || FB[RISCV::FeatureVendorXSfmm32a32f] || FB[RISCV::FeatureVendorXSfmm64a64f];
21072 case 176:
21073 return FB[RISCV::FeatureVendorXSfmm32a8f];
21074 case 177:
21075 return FB[RISCV::FeatureVendorXSfvqmaccqoq];
21076 case 178:
21077 return FB[RISCV::FeatureVendorXTHeadCmo];
21078 case 179:
21079 return FB[RISCV::FeatureVendorXTHeadSync];
21080 case 180:
21081 return FB[RISCV::FeatureVendorXTHeadBa];
21082 case 181:
21083 return FB[RISCV::FeatureVendorXTHeadBb];
21084 case 182:
21085 return FB[RISCV::FeatureVendorXTHeadBb] && FB[RISCV::Feature64Bit];
21086 case 183:
21087 return FB[RISCV::FeatureVendorXTHeadMac];
21088 case 184:
21089 return FB[RISCV::FeatureVendorXTHeadMac] && FB[RISCV::Feature64Bit];
21090 case 185:
21091 return FB[RISCV::FeatureVendorXTHeadCondMov];
21092 case 186:
21093 return FB[RISCV::FeatureVendorXTHeadBs];
21094 case 187:
21095 return FB[RISCV::FeatureVendorXTHeadMemIdx];
21096 case 188:
21097 return FB[RISCV::FeatureVendorXTHeadMemIdx] && FB[RISCV::Feature64Bit];
21098 case 189:
21099 return FB[RISCV::FeatureVendorXTHeadMemPair];
21100 case 190:
21101 return FB[RISCV::FeatureVendorXTHeadMemPair] && FB[RISCV::Feature64Bit];
21102 case 191:
21103 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtF];
21104 case 192:
21105 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtF] && FB[RISCV::Feature64Bit];
21106 case 193:
21107 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtD];
21108 case 194:
21109 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtD] && FB[RISCV::Feature64Bit];
21110 case 195:
21111 return FB[RISCV::FeatureVendorXTHeadVdot];
21112 case 196:
21113 return FB[RISCV::FeatureVendorXqcia] && !(FB[RISCV::Feature64Bit]);
21114 case 197:
21115 return FB[RISCV::FeatureVendorXqciio] && !(FB[RISCV::Feature64Bit]);
21116 case 198:
21117 return FB[RISCV::FeatureVendorXqcilsm] && !(FB[RISCV::Feature64Bit]);
21118 case 199:
21119 return FB[RISCV::FeatureVendorXqcisls] && !(FB[RISCV::Feature64Bit]);
21120 case 200:
21121 return FB[RISCV::FeatureVendorXqcisim] && !(FB[RISCV::Feature64Bit]);
21122 case 201:
21123 return FB[RISCV::FeatureVendorXqcili] && !(FB[RISCV::Feature64Bit]);
21124 case 202:
21125 return FB[RISCV::FeatureVendorXqcicli] && !(FB[RISCV::Feature64Bit]);
21126 case 203:
21127 return FB[RISCV::FeatureVendorXqcics] && !(FB[RISCV::Feature64Bit]);
21128 case 204:
21129 return FB[RISCV::FeatureVendorXqcicsr] && !(FB[RISCV::Feature64Bit]);
21130 case 205:
21131 return FB[RISCV::FeatureVendorXqcibi] && !(FB[RISCV::Feature64Bit]);
21132 case 206:
21133 return FB[RISCV::FeatureStdExtZhinxmin] && FB[RISCV::FeatureStdExtZdinx] && !(FB[RISCV::Feature64Bit]);
21134 case 207:
21135 return FB[RISCV::FeatureStdExtZdinx] && !(FB[RISCV::Feature64Bit]);
21136 case 208:
21137 return FB[RISCV::FeatureStdExtZfinx];
21138 case 209:
21139 return FB[RISCV::FeatureStdExtZdinx] && FB[RISCV::Feature64Bit];
21140 case 210:
21141 return FB[RISCV::FeatureStdExtZhinx];
21142 case 211:
21143 return FB[RISCV::FeatureStdExtZhinxmin];
21144 case 212:
21145 return FB[RISCV::FeatureStdExtZhinxmin] && FB[RISCV::FeatureStdExtZdinx] && FB[RISCV::Feature64Bit];
21146 case 213:
21147 return FB[RISCV::FeatureStdExtZfinx] && FB[RISCV::Feature64Bit];
21148 case 214:
21149 return FB[RISCV::FeatureStdExtZdinx] && FB[RISCV::Feature64Bit] && FB[RISCV::Feature64Bit];
21150 case 215:
21151 return FB[RISCV::FeatureStdExtZhinx] && FB[RISCV::Feature64Bit];
21152 case 216:
21153 return FB[RISCV::FeatureVendorXqcilia] && !(FB[RISCV::Feature64Bit]);
21154 case 217:
21155 return FB[RISCV::FeatureVendorXqcilb] && !(FB[RISCV::Feature64Bit]);
21156 case 218:
21157 return FB[RISCV::FeatureVendorXqcilo] && !(FB[RISCV::Feature64Bit]);
21158 }
21159}
21160
21161
21162template <typename InsnType>
21163static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
21164 InsnType insn, uint64_t Address,
21165 const MCDisassembler *DisAsm,
21166 const MCSubtargetInfo &STI) {
21167 const FeatureBitset &Bits = STI.getFeatureBits();
21168 const uint8_t *Ptr = DecodeTable;
21169
21170 [[maybe_unused]] uint32_t BitWidth = decodeULEB128AndIncUnsafe(p&: Ptr);
21171 assert(InsnBitWidth<InsnType> == BitWidth &&
21172 "Table and instruction bitwidth mismatch");
21173
21174 SmallVector<const uint8_t *, 8> ScopeStack;
21175 DecodeStatus S = MCDisassembler::Success;
21176 while (true) {
21177 ptrdiff_t Loc = Ptr - DecodeTable;
21178 const uint8_t DecoderOp = *Ptr++;
21179 switch (DecoderOp) {
21180 default:
21181 errs() << Loc << ": Unexpected decode table opcode: "
21182 << (int)DecoderOp << '\n';
21183 return MCDisassembler::Fail;
21184 case OPC_Scope: {
21185 unsigned NumToSkip = decodeULEB128AndIncUnsafe(p&: Ptr);
21186 const uint8_t *SkipTo = Ptr + NumToSkip;
21187 ScopeStack.push_back(Elt: SkipTo);
21188 LLVM_DEBUG(dbgs() << Loc << ": OPC_Scope(" << SkipTo - DecodeTable
21189 << ")\n");
21190 continue;
21191 }
21192 case OPC_SwitchField: {
21193 // Decode the start value.
21194 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
21195 unsigned Len = *Ptr++;
21196 uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
21197 uint64_t CaseValue;
21198 unsigned CaseSize;
21199 while (true) {
21200 CaseValue = decodeULEB128AndIncUnsafe(p&: Ptr);
21201 CaseSize = decodeULEB128AndIncUnsafe(p&: Ptr);
21202 if (FieldValue <= CaseValue || !CaseSize)
21203 break;
21204 Ptr += CaseSize;
21205 }
21206 if (FieldValue == CaseValue) {
21207 LLVM_DEBUG(dbgs() << Loc << ": OPC_SwitchField(" << Start << ", " << Len
21208 << "): " << FieldValue << '\n');
21209 continue;
21210 }
21211 break;
21212 }
21213 case OPC_CheckField: {
21214 // Decode the start value.
21215 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
21216 unsigned Len = *Ptr;
21217 uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
21218 // Decode the field value.
21219 unsigned PtrLen = 0;
21220 uint64_t ExpectedValue = decodeULEB128(p: ++Ptr, n: &PtrLen);
21221 Ptr += PtrLen;
21222 bool Failed = ExpectedValue != FieldValue;
21223
21224 LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckField(" << Start << ", " << Len
21225 << ", " << ExpectedValue << "): FieldValue = "
21226 << FieldValue << ", ExpectedValue = " << ExpectedValue
21227 << ": " << (Failed ? "FAIL, " : "PASS\n"););
21228 if (!Failed)
21229 continue;
21230 break;
21231 }
21232 case OPC_CheckPredicate: {
21233 // Decode the Predicate Index value.
21234 unsigned PIdx = decodeULEB128AndIncUnsafe(p&: Ptr);
21235 // Check the predicate.
21236 bool Failed = !checkDecoderPredicate(Idx: PIdx, FB: Bits);
21237
21238 LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckPredicate(" << PIdx << "): "
21239 << (Failed ? "FAIL, " : "PASS\n"););
21240 if (!Failed)
21241 continue;
21242 break;
21243 }
21244 case OPC_Decode: {
21245 // Decode the Opcode value.
21246 unsigned Opc = decodeULEB128AndIncUnsafe(p&: Ptr);
21247 unsigned DecodeIdx = decodeULEB128AndIncUnsafe(p&: Ptr);
21248
21249 MI.clear();
21250 MI.setOpcode(Opc);
21251 bool DecodeComplete;
21252 S = decodeToMCInst(DecodeIdx, S, insn, MI, Address, DisAsm,
21253 DecodeComplete);
21254 LLVM_DEBUG(dbgs() << Loc << ": OPC_Decode: opcode " << Opc
21255 << ", using decoder " << DecodeIdx << ": "
21256 << (S ? "PASS, " : "FAIL, "));
21257
21258 if (DecodeComplete) {
21259 LLVM_DEBUG(dbgs() << "decoding complete\n");
21260 return S;
21261 }
21262 assert(S == MCDisassembler::Fail);
21263 // Reset decode status. This also drops a SoftFail status that could be
21264 // set before the decode attempt.
21265 S = MCDisassembler::Success;
21266 break;
21267 }
21268 }
21269 if (ScopeStack.empty()) {
21270 LLVM_DEBUG(dbgs() << "returning Fail\n");
21271 return MCDisassembler::Fail;
21272 }
21273 Ptr = ScopeStack.pop_back_val();
21274 LLVM_DEBUG(dbgs() << "continuing at " << Ptr - DecodeTable << '\n');
21275 }
21276 llvm_unreachable("bogosity detected in disassembler state machine!");
21277}
21278
21279
21280} // namespace
21281