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, 140, 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, 202, 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, 244, 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, 245, 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, 200, 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, 129, 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, 210, 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, 203, 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, 211, 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, 232, 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, 230, 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, 233, 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, 223, 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, 133, 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, 239, 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, 132, 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, 240, 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, 241, 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, 236, 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, 237, 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, 238, 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, 201, 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, 231, 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, 224, 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, 222, 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, 228, 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, 227, 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, 248, 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, 255, 113, 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, 131, 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, 130, 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, 206, 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, 134, 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, 135, 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, 141, 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, 204, 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, 247, 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, 242, 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, 205, 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, 142, 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, 253, 113, 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, 143, 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, 254, 113, 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, 144, 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, 246, 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, 221, 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, 243, 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, 209, 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, 220, 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, 199, 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, 214, 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, 218, 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, 215, 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, 136, 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, 207, 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, 137, 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, 249, 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, 208, 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, 250, 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, 212, 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, 216, 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, 219, 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, 213, 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, 217, 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, 175, 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, 179, 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, 178, 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, 183, 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, 184, 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, 180, 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, 182, 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, 181, 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, 177, 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, 176, 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, 198, 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, 199, 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, 202, 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, 201, 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, 200, 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, 193, 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, 195, 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, 194, 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, 196, 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, 205, 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, 192, 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, 197, 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, 203, 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, 206, 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, 207, 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, 208, 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, 190, 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, 209, 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, 191, 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, 204, 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, 193, 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, 195, 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, 194, 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, 196, 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, 198, 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, 200, 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, 197, 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, 199, 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, 226, 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, 225, 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, 252, 110, 38, // 44: decode to CM_JT using decoder 38
652 // 44: } else try {
653 OPC_CheckPredicate, 20, // 48: check predicate 20
654 OPC_Decode, 251, 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, 254, 110, 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, 253, 110, 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, 130, 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, 255, 110, 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, 129, 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, 128, 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, 252, 113, 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, 251, 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[20934] = {
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, 221, 116, 0, // 11: decode to LB using decoder 0
1176 // 11: }
1177 1, 4, // 15: case 0x1: {
1178 OPC_Decode, 229, 116, 0, // 17: decode to LH using decoder 0
1179 // 17: }
1180 2, 4, // 21: case 0x2: {
1181 OPC_Decode, 243, 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, 225, 116, 0, // 31: decode to LD using decoder 0
1186 // 31: }
1187 4, 4, // 35: case 0x4: {
1188 OPC_Decode, 222, 116, 0, // 37: decode to LBU using decoder 0
1189 // 37: }
1190 5, 4, // 41: case 0x5: {
1191 OPC_Decode, 230, 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, 244, 116, 0, // 51: decode to LWU using decoder 0
1196 // 51: }
1197 // 51: } // switch Inst[14:12]
1198 // 51: }
1199 7, 195, 14, // 55: case 0x7: {
1200 OPC_SwitchField, 12, 3, // 58: switch Inst[14:12] {
1201 0, 197, 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, 220, 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, 200, 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, 221, 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, 219, 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, 217, 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, 129, 128, 1, 4, // 125: decode to VLSE8_V using decoder 4
1232 // 125: }
1233 3, 6, // 130: case 0x3: {
1234 OPC_CheckPredicate, 23, // 132: check predicate 23
1235 OPC_Decode, 225, 127, 3, // 134: decode to VLOXEI8_V using decoder 3
1236 // 134: }
1237 8, 33, // 138: case 0x8: {
1238 OPC_SwitchField, 20, 5, // 140: switch Inst[24:20] {
1239 0, 7, // 143: case 0x0: {
1240 OPC_CheckPredicate, 23, // 145: check predicate 23
1241 OPC_Decode, 137, 128, 1, 1, // 147: decode to VLSEG2E8_V using decoder 1
1242 // 147: }
1243 8, 10, // 152: case 0x8: {
1244 OPC_CheckPredicate, 23, // 154: check predicate 23
1245 OPC_CheckField, 25, 1, 1, // 156: check Inst[25] == 0x1
1246 OPC_Decode, 204, 127, 5, // 160: decode to VL2RE8_V using decoder 5
1247 // 160: }
1248 16, 0, // 164: case 0x10: {
1249 OPC_CheckPredicate, 23, // 166: check predicate 23
1250 OPC_Decode, 136, 128, 1, 1, // 168: decode to VLSEG2E8FF_V using decoder 1
1251 // 168: }
1252 // 168: } // switch Inst[24:20]
1253 // 168: }
1254 9, 7, // 173: case 0x9: {
1255 OPC_CheckPredicate, 23, // 175: check predicate 23
1256 OPC_Decode, 221, 128, 1, 3, // 177: decode to VLUXSEG2EI8_V using decoder 3
1257 // 177: }
1258 10, 7, // 182: case 0xa: {
1259 OPC_CheckPredicate, 23, // 184: check predicate 23
1260 OPC_Decode, 189, 128, 1, 4, // 186: decode to VLSSEG2E8_V using decoder 4
1261 // 186: }
1262 11, 6, // 191: case 0xb: {
1263 OPC_CheckPredicate, 23, // 193: check predicate 23
1264 OPC_Decode, 229, 127, 3, // 195: decode to VLOXSEG2EI8_V using decoder 3
1265 // 195: }
1266 16, 21, // 199: case 0x10: {
1267 OPC_SwitchField, 20, 5, // 201: switch Inst[24:20] {
1268 0, 7, // 204: case 0x0: {
1269 OPC_CheckPredicate, 23, // 206: check predicate 23
1270 OPC_Decode, 145, 128, 1, 1, // 208: decode to VLSEG3E8_V using decoder 1
1271 // 208: }
1272 16, 0, // 213: case 0x10: {
1273 OPC_CheckPredicate, 23, // 215: check predicate 23
1274 OPC_Decode, 144, 128, 1, 1, // 217: decode to VLSEG3E8FF_V using decoder 1
1275 // 217: }
1276 // 217: } // switch Inst[24:20]
1277 // 217: }
1278 17, 7, // 222: case 0x11: {
1279 OPC_CheckPredicate, 23, // 224: check predicate 23
1280 OPC_Decode, 225, 128, 1, 3, // 226: decode to VLUXSEG3EI8_V using decoder 3
1281 // 226: }
1282 18, 7, // 231: case 0x12: {
1283 OPC_CheckPredicate, 23, // 233: check predicate 23
1284 OPC_Decode, 193, 128, 1, 4, // 235: decode to VLSSEG3E8_V using decoder 4
1285 // 235: }
1286 19, 6, // 240: case 0x13: {
1287 OPC_CheckPredicate, 23, // 242: check predicate 23
1288 OPC_Decode, 233, 127, 3, // 244: decode to VLOXSEG3EI8_V using decoder 3
1289 // 244: }
1290 24, 33, // 248: case 0x18: {
1291 OPC_SwitchField, 20, 5, // 250: switch Inst[24:20] {
1292 0, 7, // 253: case 0x0: {
1293 OPC_CheckPredicate, 23, // 255: check predicate 23
1294 OPC_Decode, 153, 128, 1, 1, // 257: decode to VLSEG4E8_V using decoder 1
1295 // 257: }
1296 8, 10, // 262: case 0x8: {
1297 OPC_CheckPredicate, 23, // 264: check predicate 23
1298 OPC_CheckField, 25, 1, 1, // 266: check Inst[25] == 0x1
1299 OPC_Decode, 208, 127, 6, // 270: decode to VL4RE8_V using decoder 6
1300 // 270: }
1301 16, 0, // 274: case 0x10: {
1302 OPC_CheckPredicate, 23, // 276: check predicate 23
1303 OPC_Decode, 152, 128, 1, 1, // 278: decode to VLSEG4E8FF_V using decoder 1
1304 // 278: }
1305 // 278: } // switch Inst[24:20]
1306 // 278: }
1307 25, 7, // 283: case 0x19: {
1308 OPC_CheckPredicate, 23, // 285: check predicate 23
1309 OPC_Decode, 229, 128, 1, 3, // 287: decode to VLUXSEG4EI8_V using decoder 3
1310 // 287: }
1311 26, 7, // 292: case 0x1a: {
1312 OPC_CheckPredicate, 23, // 294: check predicate 23
1313 OPC_Decode, 197, 128, 1, 4, // 296: decode to VLSSEG4E8_V using decoder 4
1314 // 296: }
1315 27, 6, // 301: case 0x1b: {
1316 OPC_CheckPredicate, 23, // 303: check predicate 23
1317 OPC_Decode, 237, 127, 3, // 305: decode to VLOXSEG4EI8_V using decoder 3
1318 // 305: }
1319 32, 21, // 309: case 0x20: {
1320 OPC_SwitchField, 20, 5, // 311: switch Inst[24:20] {
1321 0, 7, // 314: case 0x0: {
1322 OPC_CheckPredicate, 23, // 316: check predicate 23
1323 OPC_Decode, 161, 128, 1, 1, // 318: decode to VLSEG5E8_V using decoder 1
1324 // 318: }
1325 16, 0, // 323: case 0x10: {
1326 OPC_CheckPredicate, 23, // 325: check predicate 23
1327 OPC_Decode, 160, 128, 1, 1, // 327: decode to VLSEG5E8FF_V using decoder 1
1328 // 327: }
1329 // 327: } // switch Inst[24:20]
1330 // 327: }
1331 33, 7, // 332: case 0x21: {
1332 OPC_CheckPredicate, 23, // 334: check predicate 23
1333 OPC_Decode, 233, 128, 1, 3, // 336: decode to VLUXSEG5EI8_V using decoder 3
1334 // 336: }
1335 34, 7, // 341: case 0x22: {
1336 OPC_CheckPredicate, 23, // 343: check predicate 23
1337 OPC_Decode, 201, 128, 1, 4, // 345: decode to VLSSEG5E8_V using decoder 4
1338 // 345: }
1339 35, 6, // 350: case 0x23: {
1340 OPC_CheckPredicate, 23, // 352: check predicate 23
1341 OPC_Decode, 241, 127, 3, // 354: decode to VLOXSEG5EI8_V using decoder 3
1342 // 354: }
1343 40, 21, // 358: case 0x28: {
1344 OPC_SwitchField, 20, 5, // 360: switch Inst[24:20] {
1345 0, 7, // 363: case 0x0: {
1346 OPC_CheckPredicate, 23, // 365: check predicate 23
1347 OPC_Decode, 169, 128, 1, 1, // 367: decode to VLSEG6E8_V using decoder 1
1348 // 367: }
1349 16, 0, // 372: case 0x10: {
1350 OPC_CheckPredicate, 23, // 374: check predicate 23
1351 OPC_Decode, 168, 128, 1, 1, // 376: decode to VLSEG6E8FF_V using decoder 1
1352 // 376: }
1353 // 376: } // switch Inst[24:20]
1354 // 376: }
1355 41, 7, // 381: case 0x29: {
1356 OPC_CheckPredicate, 23, // 383: check predicate 23
1357 OPC_Decode, 237, 128, 1, 3, // 385: decode to VLUXSEG6EI8_V using decoder 3
1358 // 385: }
1359 42, 7, // 390: case 0x2a: {
1360 OPC_CheckPredicate, 23, // 392: check predicate 23
1361 OPC_Decode, 205, 128, 1, 4, // 394: decode to VLSSEG6E8_V using decoder 4
1362 // 394: }
1363 43, 6, // 399: case 0x2b: {
1364 OPC_CheckPredicate, 23, // 401: check predicate 23
1365 OPC_Decode, 245, 127, 3, // 403: decode to VLOXSEG6EI8_V using decoder 3
1366 // 403: }
1367 48, 21, // 407: case 0x30: {
1368 OPC_SwitchField, 20, 5, // 409: switch Inst[24:20] {
1369 0, 7, // 412: case 0x0: {
1370 OPC_CheckPredicate, 23, // 414: check predicate 23
1371 OPC_Decode, 177, 128, 1, 1, // 416: decode to VLSEG7E8_V using decoder 1
1372 // 416: }
1373 16, 0, // 421: case 0x10: {
1374 OPC_CheckPredicate, 23, // 423: check predicate 23
1375 OPC_Decode, 176, 128, 1, 1, // 425: decode to VLSEG7E8FF_V using decoder 1
1376 // 425: }
1377 // 425: } // switch Inst[24:20]
1378 // 425: }
1379 49, 7, // 430: case 0x31: {
1380 OPC_CheckPredicate, 23, // 432: check predicate 23
1381 OPC_Decode, 241, 128, 1, 3, // 434: decode to VLUXSEG7EI8_V using decoder 3
1382 // 434: }
1383 50, 7, // 439: case 0x32: {
1384 OPC_CheckPredicate, 23, // 441: check predicate 23
1385 OPC_Decode, 209, 128, 1, 4, // 443: decode to VLSSEG7E8_V using decoder 4
1386 // 443: }
1387 51, 6, // 448: case 0x33: {
1388 OPC_CheckPredicate, 23, // 450: check predicate 23
1389 OPC_Decode, 249, 127, 3, // 452: decode to VLOXSEG7EI8_V using decoder 3
1390 // 452: }
1391 56, 33, // 456: case 0x38: {
1392 OPC_SwitchField, 20, 5, // 458: switch Inst[24:20] {
1393 0, 7, // 461: case 0x0: {
1394 OPC_CheckPredicate, 23, // 463: check predicate 23
1395 OPC_Decode, 185, 128, 1, 1, // 465: decode to VLSEG8E8_V using decoder 1
1396 // 465: }
1397 8, 10, // 470: case 0x8: {
1398 OPC_CheckPredicate, 23, // 472: check predicate 23
1399 OPC_CheckField, 25, 1, 1, // 474: check Inst[25] == 0x1
1400 OPC_Decode, 212, 127, 7, // 478: decode to VL8RE8_V using decoder 7
1401 // 478: }
1402 16, 0, // 482: case 0x10: {
1403 OPC_CheckPredicate, 23, // 484: check predicate 23
1404 OPC_Decode, 184, 128, 1, 1, // 486: decode to VLSEG8E8FF_V using decoder 1
1405 // 486: }
1406 // 486: } // switch Inst[24:20]
1407 // 486: }
1408 57, 7, // 491: case 0x39: {
1409 OPC_CheckPredicate, 23, // 493: check predicate 23
1410 OPC_Decode, 245, 128, 1, 3, // 495: decode to VLUXSEG8EI8_V using decoder 3
1411 // 495: }
1412 58, 7, // 500: case 0x3a: {
1413 OPC_CheckPredicate, 23, // 502: check predicate 23
1414 OPC_Decode, 213, 128, 1, 4, // 504: decode to VLSSEG8E8_V using decoder 4
1415 // 504: }
1416 59, 0, // 509: case 0x3b: {
1417 OPC_CheckPredicate, 23, // 511: check predicate 23
1418 OPC_Decode, 253, 127, 3, // 513: decode to VLOXSEG8EI8_V using decoder 3
1419 // 513: }
1420 // 513: } // switch Inst[31:26]
1421 // 513: }
1422 1, 6, // 517: case 0x1: {
1423 OPC_CheckPredicate, 24, // 519: check predicate 24
1424 OPC_Decode, 157, 115, 8, // 521: decode to FLH using decoder 8
1425 // 521: }
1426 2, 6, // 525: case 0x2: {
1427 OPC_CheckPredicate, 25, // 527: check predicate 25
1428 OPC_Decode, 175, 115, 9, // 529: decode to FLW using decoder 9
1429 // 529: }
1430 3, 6, // 533: case 0x3: {
1431 OPC_CheckPredicate, 26, // 535: check predicate 26
1432 OPC_Decode, 144, 115, 10, // 537: decode to FLD using decoder 10
1433 // 537: }
1434 4, 6, // 541: case 0x4: {
1435 OPC_CheckPredicate, 27, // 543: check predicate 27
1436 OPC_Decode, 162, 115, 11, // 545: decode to FLQ using decoder 11
1437 // 545: }
1438 5, 184, 3, // 549: case 0x5: {
1439 OPC_SwitchField, 26, 6, // 552: switch Inst[31:26] {
1440 0, 31, // 555: case 0x0: {
1441 OPC_SwitchField, 20, 5, // 557: switch Inst[24:20] {
1442 0, 6, // 560: case 0x0: {
1443 OPC_CheckPredicate, 23, // 562: check predicate 23
1444 OPC_Decode, 214, 127, 1, // 564: decode to VLE16_V using decoder 1
1445 // 564: }
1446 8, 10, // 568: case 0x8: {
1447 OPC_CheckPredicate, 23, // 570: check predicate 23
1448 OPC_CheckField, 25, 1, 1, // 572: check Inst[25] == 0x1
1449 OPC_Decode, 197, 127, 2, // 576: decode to VL1RE16_V using decoder 2
1450 // 576: }
1451 16, 0, // 580: case 0x10: {
1452 OPC_CheckPredicate, 23, // 582: check predicate 23
1453 OPC_Decode, 213, 127, 1, // 584: decode to VLE16FF_V using decoder 1
1454 // 584: }
1455 // 584: } // switch Inst[24:20]
1456 // 584: }
1457 1, 7, // 588: case 0x1: {
1458 OPC_CheckPredicate, 23, // 590: check predicate 23
1459 OPC_Decode, 214, 128, 1, 3, // 592: decode to VLUXEI16_V using decoder 3
1460 // 592: }
1461 2, 6, // 597: case 0x2: {
1462 OPC_CheckPredicate, 23, // 599: check predicate 23
1463 OPC_Decode, 254, 127, 4, // 601: decode to VLSE16_V using decoder 4
1464 // 601: }
1465 3, 6, // 605: case 0x3: {
1466 OPC_CheckPredicate, 23, // 607: check predicate 23
1467 OPC_Decode, 222, 127, 3, // 609: decode to VLOXEI16_V using decoder 3
1468 // 609: }
1469 8, 33, // 613: case 0x8: {
1470 OPC_SwitchField, 20, 5, // 615: switch Inst[24:20] {
1471 0, 7, // 618: case 0x0: {
1472 OPC_CheckPredicate, 23, // 620: check predicate 23
1473 OPC_Decode, 131, 128, 1, 1, // 622: decode to VLSEG2E16_V using decoder 1
1474 // 622: }
1475 8, 10, // 627: case 0x8: {
1476 OPC_CheckPredicate, 23, // 629: check predicate 23
1477 OPC_CheckField, 25, 1, 1, // 631: check Inst[25] == 0x1
1478 OPC_Decode, 201, 127, 5, // 635: decode to VL2RE16_V using decoder 5
1479 // 635: }
1480 16, 0, // 639: case 0x10: {
1481 OPC_CheckPredicate, 23, // 641: check predicate 23
1482 OPC_Decode, 130, 128, 1, 1, // 643: decode to VLSEG2E16FF_V using decoder 1
1483 // 643: }
1484 // 643: } // switch Inst[24:20]
1485 // 643: }
1486 9, 7, // 648: case 0x9: {
1487 OPC_CheckPredicate, 23, // 650: check predicate 23
1488 OPC_Decode, 218, 128, 1, 3, // 652: decode to VLUXSEG2EI16_V using decoder 3
1489 // 652: }
1490 10, 7, // 657: case 0xa: {
1491 OPC_CheckPredicate, 23, // 659: check predicate 23
1492 OPC_Decode, 186, 128, 1, 4, // 661: decode to VLSSEG2E16_V using decoder 4
1493 // 661: }
1494 11, 6, // 666: case 0xb: {
1495 OPC_CheckPredicate, 23, // 668: check predicate 23
1496 OPC_Decode, 226, 127, 3, // 670: decode to VLOXSEG2EI16_V using decoder 3
1497 // 670: }
1498 16, 21, // 674: case 0x10: {
1499 OPC_SwitchField, 20, 5, // 676: switch Inst[24:20] {
1500 0, 7, // 679: case 0x0: {
1501 OPC_CheckPredicate, 23, // 681: check predicate 23
1502 OPC_Decode, 139, 128, 1, 1, // 683: decode to VLSEG3E16_V using decoder 1
1503 // 683: }
1504 16, 0, // 688: case 0x10: {
1505 OPC_CheckPredicate, 23, // 690: check predicate 23
1506 OPC_Decode, 138, 128, 1, 1, // 692: decode to VLSEG3E16FF_V using decoder 1
1507 // 692: }
1508 // 692: } // switch Inst[24:20]
1509 // 692: }
1510 17, 7, // 697: case 0x11: {
1511 OPC_CheckPredicate, 23, // 699: check predicate 23
1512 OPC_Decode, 222, 128, 1, 3, // 701: decode to VLUXSEG3EI16_V using decoder 3
1513 // 701: }
1514 18, 7, // 706: case 0x12: {
1515 OPC_CheckPredicate, 23, // 708: check predicate 23
1516 OPC_Decode, 190, 128, 1, 4, // 710: decode to VLSSEG3E16_V using decoder 4
1517 // 710: }
1518 19, 6, // 715: case 0x13: {
1519 OPC_CheckPredicate, 23, // 717: check predicate 23
1520 OPC_Decode, 230, 127, 3, // 719: decode to VLOXSEG3EI16_V using decoder 3
1521 // 719: }
1522 24, 33, // 723: case 0x18: {
1523 OPC_SwitchField, 20, 5, // 725: switch Inst[24:20] {
1524 0, 7, // 728: case 0x0: {
1525 OPC_CheckPredicate, 23, // 730: check predicate 23
1526 OPC_Decode, 147, 128, 1, 1, // 732: decode to VLSEG4E16_V using decoder 1
1527 // 732: }
1528 8, 10, // 737: case 0x8: {
1529 OPC_CheckPredicate, 23, // 739: check predicate 23
1530 OPC_CheckField, 25, 1, 1, // 741: check Inst[25] == 0x1
1531 OPC_Decode, 205, 127, 6, // 745: decode to VL4RE16_V using decoder 6
1532 // 745: }
1533 16, 0, // 749: case 0x10: {
1534 OPC_CheckPredicate, 23, // 751: check predicate 23
1535 OPC_Decode, 146, 128, 1, 1, // 753: decode to VLSEG4E16FF_V using decoder 1
1536 // 753: }
1537 // 753: } // switch Inst[24:20]
1538 // 753: }
1539 25, 7, // 758: case 0x19: {
1540 OPC_CheckPredicate, 23, // 760: check predicate 23
1541 OPC_Decode, 226, 128, 1, 3, // 762: decode to VLUXSEG4EI16_V using decoder 3
1542 // 762: }
1543 26, 7, // 767: case 0x1a: {
1544 OPC_CheckPredicate, 23, // 769: check predicate 23
1545 OPC_Decode, 194, 128, 1, 4, // 771: decode to VLSSEG4E16_V using decoder 4
1546 // 771: }
1547 27, 6, // 776: case 0x1b: {
1548 OPC_CheckPredicate, 23, // 778: check predicate 23
1549 OPC_Decode, 234, 127, 3, // 780: decode to VLOXSEG4EI16_V using decoder 3
1550 // 780: }
1551 32, 21, // 784: case 0x20: {
1552 OPC_SwitchField, 20, 5, // 786: switch Inst[24:20] {
1553 0, 7, // 789: case 0x0: {
1554 OPC_CheckPredicate, 23, // 791: check predicate 23
1555 OPC_Decode, 155, 128, 1, 1, // 793: decode to VLSEG5E16_V using decoder 1
1556 // 793: }
1557 16, 0, // 798: case 0x10: {
1558 OPC_CheckPredicate, 23, // 800: check predicate 23
1559 OPC_Decode, 154, 128, 1, 1, // 802: decode to VLSEG5E16FF_V using decoder 1
1560 // 802: }
1561 // 802: } // switch Inst[24:20]
1562 // 802: }
1563 33, 7, // 807: case 0x21: {
1564 OPC_CheckPredicate, 23, // 809: check predicate 23
1565 OPC_Decode, 230, 128, 1, 3, // 811: decode to VLUXSEG5EI16_V using decoder 3
1566 // 811: }
1567 34, 7, // 816: case 0x22: {
1568 OPC_CheckPredicate, 23, // 818: check predicate 23
1569 OPC_Decode, 198, 128, 1, 4, // 820: decode to VLSSEG5E16_V using decoder 4
1570 // 820: }
1571 35, 6, // 825: case 0x23: {
1572 OPC_CheckPredicate, 23, // 827: check predicate 23
1573 OPC_Decode, 238, 127, 3, // 829: decode to VLOXSEG5EI16_V using decoder 3
1574 // 829: }
1575 40, 21, // 833: case 0x28: {
1576 OPC_SwitchField, 20, 5, // 835: switch Inst[24:20] {
1577 0, 7, // 838: case 0x0: {
1578 OPC_CheckPredicate, 23, // 840: check predicate 23
1579 OPC_Decode, 163, 128, 1, 1, // 842: decode to VLSEG6E16_V using decoder 1
1580 // 842: }
1581 16, 0, // 847: case 0x10: {
1582 OPC_CheckPredicate, 23, // 849: check predicate 23
1583 OPC_Decode, 162, 128, 1, 1, // 851: decode to VLSEG6E16FF_V using decoder 1
1584 // 851: }
1585 // 851: } // switch Inst[24:20]
1586 // 851: }
1587 41, 7, // 856: case 0x29: {
1588 OPC_CheckPredicate, 23, // 858: check predicate 23
1589 OPC_Decode, 234, 128, 1, 3, // 860: decode to VLUXSEG6EI16_V using decoder 3
1590 // 860: }
1591 42, 7, // 865: case 0x2a: {
1592 OPC_CheckPredicate, 23, // 867: check predicate 23
1593 OPC_Decode, 202, 128, 1, 4, // 869: decode to VLSSEG6E16_V using decoder 4
1594 // 869: }
1595 43, 6, // 874: case 0x2b: {
1596 OPC_CheckPredicate, 23, // 876: check predicate 23
1597 OPC_Decode, 242, 127, 3, // 878: decode to VLOXSEG6EI16_V using decoder 3
1598 // 878: }
1599 48, 21, // 882: case 0x30: {
1600 OPC_SwitchField, 20, 5, // 884: switch Inst[24:20] {
1601 0, 7, // 887: case 0x0: {
1602 OPC_CheckPredicate, 23, // 889: check predicate 23
1603 OPC_Decode, 171, 128, 1, 1, // 891: decode to VLSEG7E16_V using decoder 1
1604 // 891: }
1605 16, 0, // 896: case 0x10: {
1606 OPC_CheckPredicate, 23, // 898: check predicate 23
1607 OPC_Decode, 170, 128, 1, 1, // 900: decode to VLSEG7E16FF_V using decoder 1
1608 // 900: }
1609 // 900: } // switch Inst[24:20]
1610 // 900: }
1611 49, 7, // 905: case 0x31: {
1612 OPC_CheckPredicate, 23, // 907: check predicate 23
1613 OPC_Decode, 238, 128, 1, 3, // 909: decode to VLUXSEG7EI16_V using decoder 3
1614 // 909: }
1615 50, 7, // 914: case 0x32: {
1616 OPC_CheckPredicate, 23, // 916: check predicate 23
1617 OPC_Decode, 206, 128, 1, 4, // 918: decode to VLSSEG7E16_V using decoder 4
1618 // 918: }
1619 51, 6, // 923: case 0x33: {
1620 OPC_CheckPredicate, 23, // 925: check predicate 23
1621 OPC_Decode, 246, 127, 3, // 927: decode to VLOXSEG7EI16_V using decoder 3
1622 // 927: }
1623 56, 33, // 931: case 0x38: {
1624 OPC_SwitchField, 20, 5, // 933: switch Inst[24:20] {
1625 0, 7, // 936: case 0x0: {
1626 OPC_CheckPredicate, 23, // 938: check predicate 23
1627 OPC_Decode, 179, 128, 1, 1, // 940: decode to VLSEG8E16_V using decoder 1
1628 // 940: }
1629 8, 10, // 945: case 0x8: {
1630 OPC_CheckPredicate, 23, // 947: check predicate 23
1631 OPC_CheckField, 25, 1, 1, // 949: check Inst[25] == 0x1
1632 OPC_Decode, 209, 127, 7, // 953: decode to VL8RE16_V using decoder 7
1633 // 953: }
1634 16, 0, // 957: case 0x10: {
1635 OPC_CheckPredicate, 23, // 959: check predicate 23
1636 OPC_Decode, 178, 128, 1, 1, // 961: decode to VLSEG8E16FF_V using decoder 1
1637 // 961: }
1638 // 961: } // switch Inst[24:20]
1639 // 961: }
1640 57, 7, // 966: case 0x39: {
1641 OPC_CheckPredicate, 23, // 968: check predicate 23
1642 OPC_Decode, 242, 128, 1, 3, // 970: decode to VLUXSEG8EI16_V using decoder 3
1643 // 970: }
1644 58, 7, // 975: case 0x3a: {
1645 OPC_CheckPredicate, 23, // 977: check predicate 23
1646 OPC_Decode, 210, 128, 1, 4, // 979: decode to VLSSEG8E16_V using decoder 4
1647 // 979: }
1648 59, 0, // 984: case 0x3b: {
1649 OPC_CheckPredicate, 23, // 986: check predicate 23
1650 OPC_Decode, 250, 127, 3, // 988: decode to VLOXSEG8EI16_V using decoder 3
1651 // 988: }
1652 // 988: } // switch Inst[31:26]
1653 // 988: }
1654 6, 184, 3, // 992: case 0x6: {
1655 OPC_SwitchField, 26, 6, // 995: switch Inst[31:26] {
1656 0, 31, // 998: case 0x0: {
1657 OPC_SwitchField, 20, 5, // 1000: switch Inst[24:20] {
1658 0, 6, // 1003: case 0x0: {
1659 OPC_CheckPredicate, 23, // 1005: check predicate 23
1660 OPC_Decode, 216, 127, 1, // 1007: decode to VLE32_V using decoder 1
1661 // 1007: }
1662 8, 10, // 1011: case 0x8: {
1663 OPC_CheckPredicate, 23, // 1013: check predicate 23
1664 OPC_CheckField, 25, 1, 1, // 1015: check Inst[25] == 0x1
1665 OPC_Decode, 198, 127, 2, // 1019: decode to VL1RE32_V using decoder 2
1666 // 1019: }
1667 16, 0, // 1023: case 0x10: {
1668 OPC_CheckPredicate, 23, // 1025: check predicate 23
1669 OPC_Decode, 215, 127, 1, // 1027: decode to VLE32FF_V using decoder 1
1670 // 1027: }
1671 // 1027: } // switch Inst[24:20]
1672 // 1027: }
1673 1, 7, // 1031: case 0x1: {
1674 OPC_CheckPredicate, 23, // 1033: check predicate 23
1675 OPC_Decode, 215, 128, 1, 3, // 1035: decode to VLUXEI32_V using decoder 3
1676 // 1035: }
1677 2, 6, // 1040: case 0x2: {
1678 OPC_CheckPredicate, 23, // 1042: check predicate 23
1679 OPC_Decode, 255, 127, 4, // 1044: decode to VLSE32_V using decoder 4
1680 // 1044: }
1681 3, 6, // 1048: case 0x3: {
1682 OPC_CheckPredicate, 23, // 1050: check predicate 23
1683 OPC_Decode, 223, 127, 3, // 1052: decode to VLOXEI32_V using decoder 3
1684 // 1052: }
1685 8, 33, // 1056: case 0x8: {
1686 OPC_SwitchField, 20, 5, // 1058: switch Inst[24:20] {
1687 0, 7, // 1061: case 0x0: {
1688 OPC_CheckPredicate, 23, // 1063: check predicate 23
1689 OPC_Decode, 133, 128, 1, 1, // 1065: decode to VLSEG2E32_V using decoder 1
1690 // 1065: }
1691 8, 10, // 1070: case 0x8: {
1692 OPC_CheckPredicate, 23, // 1072: check predicate 23
1693 OPC_CheckField, 25, 1, 1, // 1074: check Inst[25] == 0x1
1694 OPC_Decode, 202, 127, 5, // 1078: decode to VL2RE32_V using decoder 5
1695 // 1078: }
1696 16, 0, // 1082: case 0x10: {
1697 OPC_CheckPredicate, 23, // 1084: check predicate 23
1698 OPC_Decode, 132, 128, 1, 1, // 1086: decode to VLSEG2E32FF_V using decoder 1
1699 // 1086: }
1700 // 1086: } // switch Inst[24:20]
1701 // 1086: }
1702 9, 7, // 1091: case 0x9: {
1703 OPC_CheckPredicate, 23, // 1093: check predicate 23
1704 OPC_Decode, 219, 128, 1, 3, // 1095: decode to VLUXSEG2EI32_V using decoder 3
1705 // 1095: }
1706 10, 7, // 1100: case 0xa: {
1707 OPC_CheckPredicate, 23, // 1102: check predicate 23
1708 OPC_Decode, 187, 128, 1, 4, // 1104: decode to VLSSEG2E32_V using decoder 4
1709 // 1104: }
1710 11, 6, // 1109: case 0xb: {
1711 OPC_CheckPredicate, 23, // 1111: check predicate 23
1712 OPC_Decode, 227, 127, 3, // 1113: decode to VLOXSEG2EI32_V using decoder 3
1713 // 1113: }
1714 16, 21, // 1117: case 0x10: {
1715 OPC_SwitchField, 20, 5, // 1119: switch Inst[24:20] {
1716 0, 7, // 1122: case 0x0: {
1717 OPC_CheckPredicate, 23, // 1124: check predicate 23
1718 OPC_Decode, 141, 128, 1, 1, // 1126: decode to VLSEG3E32_V using decoder 1
1719 // 1126: }
1720 16, 0, // 1131: case 0x10: {
1721 OPC_CheckPredicate, 23, // 1133: check predicate 23
1722 OPC_Decode, 140, 128, 1, 1, // 1135: decode to VLSEG3E32FF_V using decoder 1
1723 // 1135: }
1724 // 1135: } // switch Inst[24:20]
1725 // 1135: }
1726 17, 7, // 1140: case 0x11: {
1727 OPC_CheckPredicate, 23, // 1142: check predicate 23
1728 OPC_Decode, 223, 128, 1, 3, // 1144: decode to VLUXSEG3EI32_V using decoder 3
1729 // 1144: }
1730 18, 7, // 1149: case 0x12: {
1731 OPC_CheckPredicate, 23, // 1151: check predicate 23
1732 OPC_Decode, 191, 128, 1, 4, // 1153: decode to VLSSEG3E32_V using decoder 4
1733 // 1153: }
1734 19, 6, // 1158: case 0x13: {
1735 OPC_CheckPredicate, 23, // 1160: check predicate 23
1736 OPC_Decode, 231, 127, 3, // 1162: decode to VLOXSEG3EI32_V using decoder 3
1737 // 1162: }
1738 24, 33, // 1166: case 0x18: {
1739 OPC_SwitchField, 20, 5, // 1168: switch Inst[24:20] {
1740 0, 7, // 1171: case 0x0: {
1741 OPC_CheckPredicate, 23, // 1173: check predicate 23
1742 OPC_Decode, 149, 128, 1, 1, // 1175: decode to VLSEG4E32_V using decoder 1
1743 // 1175: }
1744 8, 10, // 1180: case 0x8: {
1745 OPC_CheckPredicate, 23, // 1182: check predicate 23
1746 OPC_CheckField, 25, 1, 1, // 1184: check Inst[25] == 0x1
1747 OPC_Decode, 206, 127, 6, // 1188: decode to VL4RE32_V using decoder 6
1748 // 1188: }
1749 16, 0, // 1192: case 0x10: {
1750 OPC_CheckPredicate, 23, // 1194: check predicate 23
1751 OPC_Decode, 148, 128, 1, 1, // 1196: decode to VLSEG4E32FF_V using decoder 1
1752 // 1196: }
1753 // 1196: } // switch Inst[24:20]
1754 // 1196: }
1755 25, 7, // 1201: case 0x19: {
1756 OPC_CheckPredicate, 23, // 1203: check predicate 23
1757 OPC_Decode, 227, 128, 1, 3, // 1205: decode to VLUXSEG4EI32_V using decoder 3
1758 // 1205: }
1759 26, 7, // 1210: case 0x1a: {
1760 OPC_CheckPredicate, 23, // 1212: check predicate 23
1761 OPC_Decode, 195, 128, 1, 4, // 1214: decode to VLSSEG4E32_V using decoder 4
1762 // 1214: }
1763 27, 6, // 1219: case 0x1b: {
1764 OPC_CheckPredicate, 23, // 1221: check predicate 23
1765 OPC_Decode, 235, 127, 3, // 1223: decode to VLOXSEG4EI32_V using decoder 3
1766 // 1223: }
1767 32, 21, // 1227: case 0x20: {
1768 OPC_SwitchField, 20, 5, // 1229: switch Inst[24:20] {
1769 0, 7, // 1232: case 0x0: {
1770 OPC_CheckPredicate, 23, // 1234: check predicate 23
1771 OPC_Decode, 157, 128, 1, 1, // 1236: decode to VLSEG5E32_V using decoder 1
1772 // 1236: }
1773 16, 0, // 1241: case 0x10: {
1774 OPC_CheckPredicate, 23, // 1243: check predicate 23
1775 OPC_Decode, 156, 128, 1, 1, // 1245: decode to VLSEG5E32FF_V using decoder 1
1776 // 1245: }
1777 // 1245: } // switch Inst[24:20]
1778 // 1245: }
1779 33, 7, // 1250: case 0x21: {
1780 OPC_CheckPredicate, 23, // 1252: check predicate 23
1781 OPC_Decode, 231, 128, 1, 3, // 1254: decode to VLUXSEG5EI32_V using decoder 3
1782 // 1254: }
1783 34, 7, // 1259: case 0x22: {
1784 OPC_CheckPredicate, 23, // 1261: check predicate 23
1785 OPC_Decode, 199, 128, 1, 4, // 1263: decode to VLSSEG5E32_V using decoder 4
1786 // 1263: }
1787 35, 6, // 1268: case 0x23: {
1788 OPC_CheckPredicate, 23, // 1270: check predicate 23
1789 OPC_Decode, 239, 127, 3, // 1272: decode to VLOXSEG5EI32_V using decoder 3
1790 // 1272: }
1791 40, 21, // 1276: case 0x28: {
1792 OPC_SwitchField, 20, 5, // 1278: switch Inst[24:20] {
1793 0, 7, // 1281: case 0x0: {
1794 OPC_CheckPredicate, 23, // 1283: check predicate 23
1795 OPC_Decode, 165, 128, 1, 1, // 1285: decode to VLSEG6E32_V using decoder 1
1796 // 1285: }
1797 16, 0, // 1290: case 0x10: {
1798 OPC_CheckPredicate, 23, // 1292: check predicate 23
1799 OPC_Decode, 164, 128, 1, 1, // 1294: decode to VLSEG6E32FF_V using decoder 1
1800 // 1294: }
1801 // 1294: } // switch Inst[24:20]
1802 // 1294: }
1803 41, 7, // 1299: case 0x29: {
1804 OPC_CheckPredicate, 23, // 1301: check predicate 23
1805 OPC_Decode, 235, 128, 1, 3, // 1303: decode to VLUXSEG6EI32_V using decoder 3
1806 // 1303: }
1807 42, 7, // 1308: case 0x2a: {
1808 OPC_CheckPredicate, 23, // 1310: check predicate 23
1809 OPC_Decode, 203, 128, 1, 4, // 1312: decode to VLSSEG6E32_V using decoder 4
1810 // 1312: }
1811 43, 6, // 1317: case 0x2b: {
1812 OPC_CheckPredicate, 23, // 1319: check predicate 23
1813 OPC_Decode, 243, 127, 3, // 1321: decode to VLOXSEG6EI32_V using decoder 3
1814 // 1321: }
1815 48, 21, // 1325: case 0x30: {
1816 OPC_SwitchField, 20, 5, // 1327: switch Inst[24:20] {
1817 0, 7, // 1330: case 0x0: {
1818 OPC_CheckPredicate, 23, // 1332: check predicate 23
1819 OPC_Decode, 173, 128, 1, 1, // 1334: decode to VLSEG7E32_V using decoder 1
1820 // 1334: }
1821 16, 0, // 1339: case 0x10: {
1822 OPC_CheckPredicate, 23, // 1341: check predicate 23
1823 OPC_Decode, 172, 128, 1, 1, // 1343: decode to VLSEG7E32FF_V using decoder 1
1824 // 1343: }
1825 // 1343: } // switch Inst[24:20]
1826 // 1343: }
1827 49, 7, // 1348: case 0x31: {
1828 OPC_CheckPredicate, 23, // 1350: check predicate 23
1829 OPC_Decode, 239, 128, 1, 3, // 1352: decode to VLUXSEG7EI32_V using decoder 3
1830 // 1352: }
1831 50, 7, // 1357: case 0x32: {
1832 OPC_CheckPredicate, 23, // 1359: check predicate 23
1833 OPC_Decode, 207, 128, 1, 4, // 1361: decode to VLSSEG7E32_V using decoder 4
1834 // 1361: }
1835 51, 6, // 1366: case 0x33: {
1836 OPC_CheckPredicate, 23, // 1368: check predicate 23
1837 OPC_Decode, 247, 127, 3, // 1370: decode to VLOXSEG7EI32_V using decoder 3
1838 // 1370: }
1839 56, 33, // 1374: case 0x38: {
1840 OPC_SwitchField, 20, 5, // 1376: switch Inst[24:20] {
1841 0, 7, // 1379: case 0x0: {
1842 OPC_CheckPredicate, 23, // 1381: check predicate 23
1843 OPC_Decode, 181, 128, 1, 1, // 1383: decode to VLSEG8E32_V using decoder 1
1844 // 1383: }
1845 8, 10, // 1388: case 0x8: {
1846 OPC_CheckPredicate, 23, // 1390: check predicate 23
1847 OPC_CheckField, 25, 1, 1, // 1392: check Inst[25] == 0x1
1848 OPC_Decode, 210, 127, 7, // 1396: decode to VL8RE32_V using decoder 7
1849 // 1396: }
1850 16, 0, // 1400: case 0x10: {
1851 OPC_CheckPredicate, 23, // 1402: check predicate 23
1852 OPC_Decode, 180, 128, 1, 1, // 1404: decode to VLSEG8E32FF_V using decoder 1
1853 // 1404: }
1854 // 1404: } // switch Inst[24:20]
1855 // 1404: }
1856 57, 7, // 1409: case 0x39: {
1857 OPC_CheckPredicate, 23, // 1411: check predicate 23
1858 OPC_Decode, 243, 128, 1, 3, // 1413: decode to VLUXSEG8EI32_V using decoder 3
1859 // 1413: }
1860 58, 7, // 1418: case 0x3a: {
1861 OPC_CheckPredicate, 23, // 1420: check predicate 23
1862 OPC_Decode, 211, 128, 1, 4, // 1422: decode to VLSSEG8E32_V using decoder 4
1863 // 1422: }
1864 59, 0, // 1427: case 0x3b: {
1865 OPC_CheckPredicate, 23, // 1429: check predicate 23
1866 OPC_Decode, 251, 127, 3, // 1431: decode to VLOXSEG8EI32_V using decoder 3
1867 // 1431: }
1868 // 1431: } // switch Inst[31:26]
1869 // 1431: }
1870 7, 0, // 1435: case 0x7: {
1871 OPC_SwitchField, 26, 3, // 1437: switch Inst[28:26] {
1872 0, 233, 1, // 1440: case 0x0: {
1873 OPC_SwitchField, 29, 3, // 1443: switch Inst[31:29] {
1874 0, 31, // 1446: case 0x0: {
1875 OPC_SwitchField, 20, 5, // 1448: switch Inst[24:20] {
1876 0, 6, // 1451: case 0x0: {
1877 OPC_CheckPredicate, 28, // 1453: check predicate 28
1878 OPC_Decode, 218, 127, 1, // 1455: decode to VLE64_V using decoder 1
1879 // 1455: }
1880 8, 10, // 1459: case 0x8: {
1881 OPC_CheckPredicate, 28, // 1461: check predicate 28
1882 OPC_CheckField, 25, 1, 1, // 1463: check Inst[25] == 0x1
1883 OPC_Decode, 199, 127, 2, // 1467: decode to VL1RE64_V using decoder 2
1884 // 1467: }
1885 16, 0, // 1471: case 0x10: {
1886 OPC_CheckPredicate, 28, // 1473: check predicate 28
1887 OPC_Decode, 217, 127, 1, // 1475: decode to VLE64FF_V using decoder 1
1888 // 1475: }
1889 // 1475: } // switch Inst[24:20]
1890 // 1475: }
1891 1, 33, // 1479: case 0x1: {
1892 OPC_SwitchField, 20, 5, // 1481: switch Inst[24:20] {
1893 0, 7, // 1484: case 0x0: {
1894 OPC_CheckPredicate, 28, // 1486: check predicate 28
1895 OPC_Decode, 135, 128, 1, 1, // 1488: decode to VLSEG2E64_V using decoder 1
1896 // 1488: }
1897 8, 10, // 1493: case 0x8: {
1898 OPC_CheckPredicate, 28, // 1495: check predicate 28
1899 OPC_CheckField, 25, 1, 1, // 1497: check Inst[25] == 0x1
1900 OPC_Decode, 203, 127, 5, // 1501: decode to VL2RE64_V using decoder 5
1901 // 1501: }
1902 16, 0, // 1505: case 0x10: {
1903 OPC_CheckPredicate, 28, // 1507: check predicate 28
1904 OPC_Decode, 134, 128, 1, 1, // 1509: decode to VLSEG2E64FF_V using decoder 1
1905 // 1509: }
1906 // 1509: } // switch Inst[24:20]
1907 // 1509: }
1908 2, 21, // 1514: case 0x2: {
1909 OPC_SwitchField, 20, 5, // 1516: switch Inst[24:20] {
1910 0, 7, // 1519: case 0x0: {
1911 OPC_CheckPredicate, 28, // 1521: check predicate 28
1912 OPC_Decode, 143, 128, 1, 1, // 1523: decode to VLSEG3E64_V using decoder 1
1913 // 1523: }
1914 16, 0, // 1528: case 0x10: {
1915 OPC_CheckPredicate, 28, // 1530: check predicate 28
1916 OPC_Decode, 142, 128, 1, 1, // 1532: decode to VLSEG3E64FF_V using decoder 1
1917 // 1532: }
1918 // 1532: } // switch Inst[24:20]
1919 // 1532: }
1920 3, 33, // 1537: case 0x3: {
1921 OPC_SwitchField, 20, 5, // 1539: switch Inst[24:20] {
1922 0, 7, // 1542: case 0x0: {
1923 OPC_CheckPredicate, 28, // 1544: check predicate 28
1924 OPC_Decode, 151, 128, 1, 1, // 1546: decode to VLSEG4E64_V using decoder 1
1925 // 1546: }
1926 8, 10, // 1551: case 0x8: {
1927 OPC_CheckPredicate, 28, // 1553: check predicate 28
1928 OPC_CheckField, 25, 1, 1, // 1555: check Inst[25] == 0x1
1929 OPC_Decode, 207, 127, 6, // 1559: decode to VL4RE64_V using decoder 6
1930 // 1559: }
1931 16, 0, // 1563: case 0x10: {
1932 OPC_CheckPredicate, 28, // 1565: check predicate 28
1933 OPC_Decode, 150, 128, 1, 1, // 1567: decode to VLSEG4E64FF_V using decoder 1
1934 // 1567: }
1935 // 1567: } // switch Inst[24:20]
1936 // 1567: }
1937 4, 21, // 1572: case 0x4: {
1938 OPC_SwitchField, 20, 5, // 1574: switch Inst[24:20] {
1939 0, 7, // 1577: case 0x0: {
1940 OPC_CheckPredicate, 28, // 1579: check predicate 28
1941 OPC_Decode, 159, 128, 1, 1, // 1581: decode to VLSEG5E64_V using decoder 1
1942 // 1581: }
1943 16, 0, // 1586: case 0x10: {
1944 OPC_CheckPredicate, 28, // 1588: check predicate 28
1945 OPC_Decode, 158, 128, 1, 1, // 1590: decode to VLSEG5E64FF_V using decoder 1
1946 // 1590: }
1947 // 1590: } // switch Inst[24:20]
1948 // 1590: }
1949 5, 21, // 1595: case 0x5: {
1950 OPC_SwitchField, 20, 5, // 1597: switch Inst[24:20] {
1951 0, 7, // 1600: case 0x0: {
1952 OPC_CheckPredicate, 28, // 1602: check predicate 28
1953 OPC_Decode, 167, 128, 1, 1, // 1604: decode to VLSEG6E64_V using decoder 1
1954 // 1604: }
1955 16, 0, // 1609: case 0x10: {
1956 OPC_CheckPredicate, 28, // 1611: check predicate 28
1957 OPC_Decode, 166, 128, 1, 1, // 1613: decode to VLSEG6E64FF_V using decoder 1
1958 // 1613: }
1959 // 1613: } // switch Inst[24:20]
1960 // 1613: }
1961 6, 21, // 1618: case 0x6: {
1962 OPC_SwitchField, 20, 5, // 1620: switch Inst[24:20] {
1963 0, 7, // 1623: case 0x0: {
1964 OPC_CheckPredicate, 28, // 1625: check predicate 28
1965 OPC_Decode, 175, 128, 1, 1, // 1627: decode to VLSEG7E64_V using decoder 1
1966 // 1627: }
1967 16, 0, // 1632: case 0x10: {
1968 OPC_CheckPredicate, 28, // 1634: check predicate 28
1969 OPC_Decode, 174, 128, 1, 1, // 1636: decode to VLSEG7E64FF_V using decoder 1
1970 // 1636: }
1971 // 1636: } // switch Inst[24:20]
1972 // 1636: }
1973 7, 0, // 1641: case 0x7: {
1974 OPC_SwitchField, 20, 5, // 1643: switch Inst[24:20] {
1975 0, 7, // 1646: case 0x0: {
1976 OPC_CheckPredicate, 28, // 1648: check predicate 28
1977 OPC_Decode, 183, 128, 1, 1, // 1650: decode to VLSEG8E64_V using decoder 1
1978 // 1650: }
1979 8, 10, // 1655: case 0x8: {
1980 OPC_CheckPredicate, 28, // 1657: check predicate 28
1981 OPC_CheckField, 25, 1, 1, // 1659: check Inst[25] == 0x1
1982 OPC_Decode, 211, 127, 7, // 1663: decode to VL8RE64_V using decoder 7
1983 // 1663: }
1984 16, 0, // 1667: case 0x10: {
1985 OPC_CheckPredicate, 28, // 1669: check predicate 28
1986 OPC_Decode, 182, 128, 1, 1, // 1671: decode to VLSEG8E64FF_V using decoder 1
1987 // 1671: }
1988 // 1671: } // switch Inst[24:20]
1989 // 1671: }
1990 // 1671: } // switch Inst[31:29]
1991 // 1671: }
1992 1, 75, // 1676: case 0x1: {
1993 OPC_SwitchField, 29, 3, // 1678: switch Inst[31:29] {
1994 0, 7, // 1681: case 0x0: {
1995 OPC_CheckPredicate, 29, // 1683: check predicate 29
1996 OPC_Decode, 216, 128, 1, 3, // 1685: decode to VLUXEI64_V using decoder 3
1997 // 1685: }
1998 1, 7, // 1690: case 0x1: {
1999 OPC_CheckPredicate, 30, // 1692: check predicate 30
2000 OPC_Decode, 220, 128, 1, 3, // 1694: decode to VLUXSEG2EI64_V using decoder 3
2001 // 1694: }
2002 2, 7, // 1699: case 0x2: {
2003 OPC_CheckPredicate, 30, // 1701: check predicate 30
2004 OPC_Decode, 224, 128, 1, 3, // 1703: decode to VLUXSEG3EI64_V using decoder 3
2005 // 1703: }
2006 3, 7, // 1708: case 0x3: {
2007 OPC_CheckPredicate, 30, // 1710: check predicate 30
2008 OPC_Decode, 228, 128, 1, 3, // 1712: decode to VLUXSEG4EI64_V using decoder 3
2009 // 1712: }
2010 4, 7, // 1717: case 0x4: {
2011 OPC_CheckPredicate, 30, // 1719: check predicate 30
2012 OPC_Decode, 232, 128, 1, 3, // 1721: decode to VLUXSEG5EI64_V using decoder 3
2013 // 1721: }
2014 5, 7, // 1726: case 0x5: {
2015 OPC_CheckPredicate, 30, // 1728: check predicate 30
2016 OPC_Decode, 236, 128, 1, 3, // 1730: decode to VLUXSEG6EI64_V using decoder 3
2017 // 1730: }
2018 6, 7, // 1735: case 0x6: {
2019 OPC_CheckPredicate, 30, // 1737: check predicate 30
2020 OPC_Decode, 240, 128, 1, 3, // 1739: decode to VLUXSEG7EI64_V using decoder 3
2021 // 1739: }
2022 7, 0, // 1744: case 0x7: {
2023 OPC_CheckPredicate, 30, // 1746: check predicate 30
2024 OPC_Decode, 244, 128, 1, 3, // 1748: decode to VLUXSEG8EI64_V using decoder 3
2025 // 1748: }
2026 // 1748: } // switch Inst[31:29]
2027 // 1748: }
2028 2, 75, // 1753: case 0x2: {
2029 OPC_SwitchField, 29, 3, // 1755: switch Inst[31:29] {
2030 0, 7, // 1758: case 0x0: {
2031 OPC_CheckPredicate, 28, // 1760: check predicate 28
2032 OPC_Decode, 128, 128, 1, 4, // 1762: decode to VLSE64_V using decoder 4
2033 // 1762: }
2034 1, 7, // 1767: case 0x1: {
2035 OPC_CheckPredicate, 28, // 1769: check predicate 28
2036 OPC_Decode, 188, 128, 1, 4, // 1771: decode to VLSSEG2E64_V using decoder 4
2037 // 1771: }
2038 2, 7, // 1776: case 0x2: {
2039 OPC_CheckPredicate, 28, // 1778: check predicate 28
2040 OPC_Decode, 192, 128, 1, 4, // 1780: decode to VLSSEG3E64_V using decoder 4
2041 // 1780: }
2042 3, 7, // 1785: case 0x3: {
2043 OPC_CheckPredicate, 28, // 1787: check predicate 28
2044 OPC_Decode, 196, 128, 1, 4, // 1789: decode to VLSSEG4E64_V using decoder 4
2045 // 1789: }
2046 4, 7, // 1794: case 0x4: {
2047 OPC_CheckPredicate, 28, // 1796: check predicate 28
2048 OPC_Decode, 200, 128, 1, 4, // 1798: decode to VLSSEG5E64_V using decoder 4
2049 // 1798: }
2050 5, 7, // 1803: case 0x5: {
2051 OPC_CheckPredicate, 28, // 1805: check predicate 28
2052 OPC_Decode, 204, 128, 1, 4, // 1807: decode to VLSSEG6E64_V using decoder 4
2053 // 1807: }
2054 6, 7, // 1812: case 0x6: {
2055 OPC_CheckPredicate, 28, // 1814: check predicate 28
2056 OPC_Decode, 208, 128, 1, 4, // 1816: decode to VLSSEG7E64_V using decoder 4
2057 // 1816: }
2058 7, 0, // 1821: case 0x7: {
2059 OPC_CheckPredicate, 28, // 1823: check predicate 28
2060 OPC_Decode, 212, 128, 1, 4, // 1825: decode to VLSSEG8E64_V using decoder 4
2061 // 1825: }
2062 // 1825: } // switch Inst[31:29]
2063 // 1825: }
2064 3, 67, // 1830: case 0x3: {
2065 OPC_SwitchField, 29, 3, // 1832: switch Inst[31:29] {
2066 0, 6, // 1835: case 0x0: {
2067 OPC_CheckPredicate, 29, // 1837: check predicate 29
2068 OPC_Decode, 224, 127, 3, // 1839: decode to VLOXEI64_V using decoder 3
2069 // 1839: }
2070 1, 6, // 1843: case 0x1: {
2071 OPC_CheckPredicate, 30, // 1845: check predicate 30
2072 OPC_Decode, 228, 127, 3, // 1847: decode to VLOXSEG2EI64_V using decoder 3
2073 // 1847: }
2074 2, 6, // 1851: case 0x2: {
2075 OPC_CheckPredicate, 30, // 1853: check predicate 30
2076 OPC_Decode, 232, 127, 3, // 1855: decode to VLOXSEG3EI64_V using decoder 3
2077 // 1855: }
2078 3, 6, // 1859: case 0x3: {
2079 OPC_CheckPredicate, 30, // 1861: check predicate 30
2080 OPC_Decode, 236, 127, 3, // 1863: decode to VLOXSEG4EI64_V using decoder 3
2081 // 1863: }
2082 4, 6, // 1867: case 0x4: {
2083 OPC_CheckPredicate, 30, // 1869: check predicate 30
2084 OPC_Decode, 240, 127, 3, // 1871: decode to VLOXSEG5EI64_V using decoder 3
2085 // 1871: }
2086 5, 6, // 1875: case 0x5: {
2087 OPC_CheckPredicate, 30, // 1877: check predicate 30
2088 OPC_Decode, 244, 127, 3, // 1879: decode to VLOXSEG6EI64_V using decoder 3
2089 // 1879: }
2090 6, 6, // 1883: case 0x6: {
2091 OPC_CheckPredicate, 30, // 1885: check predicate 30
2092 OPC_Decode, 248, 127, 3, // 1887: decode to VLOXSEG7EI64_V using decoder 3
2093 // 1887: }
2094 7, 0, // 1891: case 0x7: {
2095 OPC_CheckPredicate, 30, // 1893: check predicate 30
2096 OPC_Decode, 252, 127, 3, // 1895: decode to VLOXSEG8EI64_V using decoder 3
2097 // 1895: }
2098 // 1895: } // switch Inst[31:29]
2099 // 1895: }
2100 4, 7, // 1899: case 0x4: {
2101 OPC_CheckPredicate, 31, // 1901: check predicate 31
2102 OPC_Decode, 207, 129, 1, 12, // 1903: decode to VMTL_V using decoder 12
2103 // 1903: }
2104 5, 0, // 1908: case 0x5: {
2105 OPC_CheckPredicate, 32, // 1910: check predicate 32
2106 OPC_Decode, 209, 129, 1, 12, // 1912: decode to VMTTL_V using decoder 12
2107 // 1912: }
2108 // 1912: } // switch Inst[28:26]
2109 // 1912: }
2110 // 1912: } // switch Inst[14:12]
2111 // 1912: }
2112 15, 76, // 1917: case 0xf: {
2113 OPC_SwitchField, 7, 8, // 1919: switch Inst[14:7] {
2114 0, 24, // 1922: case 0x0: {
2115 OPC_SwitchField, 28, 4, // 1924: switch Inst[31:28] {
2116 0, 8, // 1927: case 0x0: {
2117 OPC_CheckField, 15, 5, 0, // 1929: check Inst[19:15] == 0x0
2118 OPC_Decode, 133, 115, 13, // 1933: decode to FENCE using decoder 13
2119 // 1933: }
2120 8, 0, // 1937: case 0x8: {
2121 OPC_CheckField, 15, 13, 224, 12, // 1939: check Inst[27:15] == 0x660
2122 OPC_Decode, 135, 115, 14, // 1944: decode to FENCE_TSO using decoder 14
2123 // 1944: }
2124 // 1944: } // switch Inst[31:28]
2125 // 1944: }
2126 32, 8, // 1948: case 0x20: {
2127 OPC_CheckField, 15, 17, 0, // 1950: check Inst[31:15] == 0x0
2128 OPC_Decode, 134, 115, 14, // 1954: decode to FENCE_I using decoder 14
2129 // 1954: }
2130 64, 0, // 1958: case 0x40: {
2131 OPC_SwitchField, 20, 12, // 1960: switch Inst[31:20] {
2132 0, 6, // 1963: case 0x0: {
2133 OPC_CheckPredicate, 33, // 1965: check predicate 33
2134 OPC_Decode, 242, 110, 15, // 1967: decode to CBO_INVAL using decoder 15
2135 // 1967: }
2136 1, 6, // 1971: case 0x1: {
2137 OPC_CheckPredicate, 33, // 1973: check predicate 33
2138 OPC_Decode, 240, 110, 15, // 1975: decode to CBO_CLEAN using decoder 15
2139 // 1975: }
2140 2, 6, // 1979: case 0x2: {
2141 OPC_CheckPredicate, 33, // 1981: check predicate 33
2142 OPC_Decode, 241, 110, 15, // 1983: decode to CBO_FLUSH using decoder 15
2143 // 1983: }
2144 4, 0, // 1987: case 0x4: {
2145 OPC_CheckPredicate, 34, // 1989: check predicate 34
2146 OPC_Decode, 243, 110, 15, // 1991: decode to CBO_ZERO using decoder 15
2147 // 1991: }
2148 // 1991: } // switch Inst[31:20]
2149 // 1991: }
2150 // 1991: } // switch Inst[14:7]
2151 // 1991: }
2152 19, 149, 3, // 1995: case 0x13: {
2153 OPC_SwitchField, 12, 3, // 1998: switch Inst[14:12] {
2154 0, 4, // 2001: case 0x0: {
2155 OPC_Decode, 205, 107, 0, // 2003: decode to ADDI using decoder 0
2156 // 2003: }
2157 1, 217, 1, // 2007: case 0x1: {
2158 OPC_SwitchField, 26, 6, // 2010: switch Inst[31:26] {
2159 0, 4, // 2013: case 0x0: {
2160 OPC_Decode, 214, 124, 16, // 2015: decode to SLLI using decoder 16
2161 // 2015: }
2162 2, 11, // 2019: case 0x2: {
2163 OPC_CheckPredicate, 35, // 2021: check predicate 35
2164 OPC_CheckField, 20, 6, 15, // 2023: check Inst[25:20] == 0xf
2165 OPC_Decode, 190, 132, 1, 17, // 2027: decode to ZIP_RV32 using decoder 17
2166 // 2027: }
2167 4, 83, // 2032: case 0x4: {
2168 OPC_SwitchField, 20, 6, // 2034: switch Inst[25:20] {
2169 0, 6, // 2037: case 0x0: {
2170 OPC_CheckPredicate, 36, // 2039: check predicate 36
2171 OPC_Decode, 193, 124, 17, // 2041: decode to SHA256SUM0 using decoder 17
2172 // 2041: }
2173 1, 6, // 2045: case 0x1: {
2174 OPC_CheckPredicate, 36, // 2047: check predicate 36
2175 OPC_Decode, 194, 124, 17, // 2049: decode to SHA256SUM1 using decoder 17
2176 // 2049: }
2177 2, 6, // 2053: case 0x2: {
2178 OPC_CheckPredicate, 36, // 2055: check predicate 36
2179 OPC_Decode, 191, 124, 17, // 2057: decode to SHA256SIG0 using decoder 17
2180 // 2057: }
2181 3, 6, // 2061: case 0x3: {
2182 OPC_CheckPredicate, 36, // 2063: check predicate 36
2183 OPC_Decode, 192, 124, 17, // 2065: decode to SHA256SIG1 using decoder 17
2184 // 2065: }
2185 4, 6, // 2069: case 0x4: {
2186 OPC_CheckPredicate, 37, // 2071: check predicate 37
2187 OPC_Decode, 201, 124, 17, // 2073: decode to SHA512SUM0 using decoder 17
2188 // 2073: }
2189 5, 6, // 2077: case 0x5: {
2190 OPC_CheckPredicate, 37, // 2079: check predicate 37
2191 OPC_Decode, 203, 124, 17, // 2081: decode to SHA512SUM1 using decoder 17
2192 // 2081: }
2193 6, 6, // 2085: case 0x6: {
2194 OPC_CheckPredicate, 37, // 2087: check predicate 37
2195 OPC_Decode, 195, 124, 17, // 2089: decode to SHA512SIG0 using decoder 17
2196 // 2089: }
2197 7, 6, // 2093: case 0x7: {
2198 OPC_CheckPredicate, 37, // 2095: check predicate 37
2199 OPC_Decode, 198, 124, 17, // 2097: decode to SHA512SIG1 using decoder 17
2200 // 2097: }
2201 8, 6, // 2101: case 0x8: {
2202 OPC_CheckPredicate, 38, // 2103: check predicate 38
2203 OPC_Decode, 223, 124, 17, // 2105: decode to SM3P0 using decoder 17
2204 // 2105: }
2205 9, 0, // 2109: case 0x9: {
2206 OPC_CheckPredicate, 38, // 2111: check predicate 38
2207 OPC_Decode, 224, 124, 17, // 2113: decode to SM3P1 using decoder 17
2208 // 2113: }
2209 // 2113: } // switch Inst[25:20]
2210 // 2113: }
2211 10, 6, // 2117: case 0xa: {
2212 OPC_CheckPredicate, 39, // 2119: check predicate 39
2213 OPC_Decode, 239, 110, 16, // 2121: decode to BSETI using decoder 16
2214 // 2121: }
2215 12, 23, // 2125: case 0xc: {
2216 OPC_SwitchField, 24, 2, // 2127: switch Inst[25:24] {
2217 0, 10, // 2130: case 0x0: {
2218 OPC_CheckPredicate, 40, // 2132: check predicate 40
2219 OPC_CheckField, 20, 4, 0, // 2134: check Inst[23:20] == 0x0
2220 OPC_Decode, 217, 107, 17, // 2138: decode to AES64IM using decoder 17
2221 // 2138: }
2222 1, 0, // 2142: case 0x1: {
2223 OPC_CheckPredicate, 41, // 2144: check predicate 41
2224 OPC_Decode, 218, 107, 18, // 2146: decode to AES64KS1I using decoder 18
2225 // 2146: }
2226 // 2146: } // switch Inst[25:24]
2227 // 2146: }
2228 18, 6, // 2150: case 0x12: {
2229 OPC_CheckPredicate, 39, // 2152: check predicate 39
2230 OPC_Decode, 224, 110, 16, // 2154: decode to BCLRI using decoder 16
2231 // 2154: }
2232 24, 59, // 2158: case 0x18: {
2233 OPC_SwitchField, 20, 6, // 2160: switch Inst[25:20] {
2234 0, 6, // 2163: case 0x0: {
2235 OPC_CheckPredicate, 42, // 2165: check predicate 42
2236 OPC_Decode, 249, 110, 17, // 2167: decode to CLZ using decoder 17
2237 // 2167: }
2238 1, 6, // 2171: case 0x1: {
2239 OPC_CheckPredicate, 42, // 2173: check predicate 42
2240 OPC_Decode, 139, 111, 17, // 2175: decode to CTZ using decoder 17
2241 // 2175: }
2242 2, 6, // 2179: case 0x2: {
2243 OPC_CheckPredicate, 42, // 2181: check predicate 42
2244 OPC_Decode, 131, 111, 17, // 2183: decode to CPOP using decoder 17
2245 // 2183: }
2246 3, 6, // 2187: case 0x3: {
2247 OPC_CheckPredicate, 43, // 2189: check predicate 43
2248 OPC_Decode, 247, 110, 17, // 2191: decode to CLS using decoder 17
2249 // 2191: }
2250 4, 6, // 2195: case 0x4: {
2251 OPC_CheckPredicate, 42, // 2197: check predicate 42
2252 OPC_Decode, 238, 123, 17, // 2199: decode to SEXT_B using decoder 17
2253 // 2199: }
2254 5, 6, // 2203: case 0x5: {
2255 OPC_CheckPredicate, 42, // 2205: check predicate 42
2256 OPC_Decode, 239, 123, 17, // 2207: decode to SEXT_H using decoder 17
2257 // 2207: }
2258 7, 0, // 2211: case 0x7: {
2259 OPC_CheckPredicate, 43, // 2213: check predicate 43
2260 OPC_Decode, 201, 107, 17, // 2215: decode to ABS using decoder 17
2261 // 2215: }
2262 // 2215: } // switch Inst[25:20]
2263 // 2215: }
2264 26, 0, // 2219: case 0x1a: {
2265 OPC_CheckPredicate, 39, // 2221: check predicate 39
2266 OPC_Decode, 232, 110, 16, // 2223: decode to BINVI using decoder 16
2267 // 2223: }
2268 // 2223: } // switch Inst[31:26]
2269 // 2223: }
2270 2, 4, // 2227: case 0x2: {
2271 OPC_Decode, 219, 124, 0, // 2229: decode to SLTI using decoder 0
2272 // 2229: }
2273 3, 4, // 2233: case 0x3: {
2274 OPC_Decode, 220, 124, 0, // 2235: decode to SLTIU using decoder 0
2275 // 2235: }
2276 4, 5, // 2239: case 0x4: {
2277 OPC_Decode, 159, 132, 1, 0, // 2241: decode to XORI using decoder 0
2278 // 2241: }
2279 5, 108, // 2246: case 0x5: {
2280 OPC_SwitchField, 26, 6, // 2248: switch Inst[31:26] {
2281 0, 4, // 2251: case 0x0: {
2282 OPC_Decode, 251, 124, 16, // 2253: decode to SRLI using decoder 16
2283 // 2253: }
2284 2, 10, // 2257: case 0x2: {
2285 OPC_CheckPredicate, 35, // 2259: check predicate 35
2286 OPC_CheckField, 20, 6, 15, // 2261: check Inst[25:20] == 0xf
2287 OPC_Decode, 139, 126, 17, // 2265: decode to UNZIP_RV32 using decoder 17
2288 // 2265: }
2289 10, 10, // 2269: case 0xa: {
2290 OPC_CheckPredicate, 42, // 2271: check predicate 42
2291 OPC_CheckField, 20, 6, 7, // 2273: check Inst[25:20] == 0x7
2292 OPC_Decode, 207, 118, 17, // 2277: decode to ORC_B using decoder 17
2293 // 2277: }
2294 16, 4, // 2281: case 0x10: {
2295 OPC_Decode, 244, 124, 16, // 2283: decode to SRAI using decoder 16
2296 // 2283: }
2297 18, 6, // 2287: case 0x12: {
2298 OPC_CheckPredicate, 39, // 2289: check predicate 39
2299 OPC_Decode, 228, 110, 16, // 2291: decode to BEXTI using decoder 16
2300 // 2291: }
2301 24, 6, // 2295: case 0x18: {
2302 OPC_CheckPredicate, 44, // 2297: check predicate 44
2303 OPC_Decode, 213, 123, 16, // 2299: decode to RORI using decoder 16
2304 // 2299: }
2305 26, 0, // 2303: case 0x1a: {
2306 OPC_SwitchField, 20, 6, // 2305: switch Inst[25:20] {
2307 7, 6, // 2308: case 0x7: {
2308 OPC_CheckPredicate, 45, // 2310: check predicate 45
2309 OPC_Decode, 237, 110, 17, // 2312: decode to BREV8 using decoder 17
2310 // 2312: }
2311 24, 6, // 2316: case 0x18: {
2312 OPC_CheckPredicate, 46, // 2318: check predicate 46
2313 OPC_Decode, 206, 123, 17, // 2320: decode to REV8_RV32 using decoder 17
2314 // 2320: }
2315 31, 6, // 2324: case 0x1f: {
2316 OPC_CheckPredicate, 47, // 2326: check predicate 47
2317 OPC_Decode, 208, 123, 17, // 2328: decode to REV_RV32 using decoder 17
2318 // 2328: }
2319 48, 6, // 2332: case 0x30: {
2320 OPC_CheckPredicate, 48, // 2334: check predicate 48
2321 OPC_Decode, 205, 123, 17, // 2336: decode to REV16_RV64 using decoder 17
2322 // 2336: }
2323 56, 6, // 2340: case 0x38: {
2324 OPC_CheckPredicate, 49, // 2342: check predicate 49
2325 OPC_Decode, 207, 123, 17, // 2344: decode to REV8_RV64 using decoder 17
2326 // 2344: }
2327 63, 0, // 2348: case 0x3f: {
2328 OPC_CheckPredicate, 48, // 2350: check predicate 48
2329 OPC_Decode, 209, 123, 17, // 2352: decode to REV_RV64 using decoder 17
2330 // 2352: }
2331 // 2352: } // switch Inst[25:20]
2332 // 2352: }
2333 // 2352: } // switch Inst[31:26]
2334 // 2352: }
2335 6, 39, // 2356: case 0x6: {
2336 OPC_Scope, 33, // 2358: try {
2337 OPC_SwitchField, 20, 5, // 2360: switch Inst[24:20] {
2338 0, 8, // 2363: case 0x0: {
2339 OPC_CheckField, 7, 5, 0, // 2365: check Inst[11:7] == 0x0
2340 OPC_Decode, 131, 121, 19, // 2369: decode to PREFETCH_I using decoder 19
2341 // 2369: }
2342 1, 8, // 2373: case 0x1: {
2343 OPC_CheckField, 7, 5, 0, // 2375: check Inst[11:7] == 0x0
2344 OPC_Decode, 132, 121, 19, // 2379: decode to PREFETCH_R using decoder 19
2345 // 2379: }
2346 3, 0, // 2383: case 0x3: {
2347 OPC_CheckField, 7, 5, 0, // 2385: check Inst[11:7] == 0x0
2348 OPC_Decode, 133, 121, 19, // 2389: decode to PREFETCH_W using decoder 19
2349 // 2389: }
2350 // 2389: } // switch Inst[24:20]
2351 // 2389: } else try {
2352 OPC_Decode, 208, 118, 0, // 2393: decode to ORI using decoder 0
2353 // 2393: }
2354 // 2393: }
2355 7, 0, // 2397: case 0x7: {
2356 OPC_Decode, 218, 110, 0, // 2399: decode to ANDI using decoder 0
2357 // 2399: }
2358 // 2399: } // switch Inst[14:12]
2359 // 2399: }
2360 23, 4, // 2403: case 0x17: {
2361 OPC_Decode, 222, 110, 20, // 2405: decode to AUIPC using decoder 20
2362 // 2405: }
2363 27, 195, 35, // 2409: case 0x1b: {
2364 OPC_SwitchField, 12, 3, // 2412: switch Inst[14:12] {
2365 0, 6, // 2415: case 0x0: {
2366 OPC_CheckPredicate, 22, // 2417: check predicate 22
2367 OPC_Decode, 206, 107, 0, // 2419: decode to ADDIW using decoder 0
2368 // 2419: }
2369 1, 68, // 2423: case 0x1: {
2370 OPC_SwitchField, 26, 6, // 2425: switch Inst[31:26] {
2371 0, 10, // 2428: case 0x0: {
2372 OPC_CheckPredicate, 22, // 2430: check predicate 22
2373 OPC_CheckField, 25, 1, 0, // 2432: check Inst[25] == 0x0
2374 OPC_Decode, 215, 124, 21, // 2436: decode to SLLIW using decoder 21
2375 // 2436: }
2376 2, 6, // 2440: case 0x2: {
2377 OPC_CheckPredicate, 50, // 2442: check predicate 50
2378 OPC_Decode, 216, 124, 16, // 2444: decode to SLLI_UW using decoder 16
2379 // 2444: }
2380 24, 0, // 2448: case 0x18: {
2381 OPC_SwitchField, 20, 6, // 2450: switch Inst[25:20] {
2382 0, 6, // 2453: case 0x0: {
2383 OPC_CheckPredicate, 51, // 2455: check predicate 51
2384 OPC_Decode, 250, 110, 17, // 2457: decode to CLZW using decoder 17
2385 // 2457: }
2386 1, 6, // 2461: case 0x1: {
2387 OPC_CheckPredicate, 51, // 2463: check predicate 51
2388 OPC_Decode, 140, 111, 17, // 2465: decode to CTZW using decoder 17
2389 // 2465: }
2390 2, 6, // 2469: case 0x2: {
2391 OPC_CheckPredicate, 51, // 2471: check predicate 51
2392 OPC_Decode, 132, 111, 17, // 2473: decode to CPOPW using decoder 17
2393 // 2473: }
2394 3, 6, // 2477: case 0x3: {
2395 OPC_CheckPredicate, 48, // 2479: check predicate 48
2396 OPC_Decode, 248, 110, 17, // 2481: decode to CLSW using decoder 17
2397 // 2481: }
2398 7, 0, // 2485: case 0x7: {
2399 OPC_CheckPredicate, 48, // 2487: check predicate 48
2400 OPC_Decode, 202, 107, 17, // 2489: decode to ABSW using decoder 17
2401 // 2489: }
2402 // 2489: } // switch Inst[25:20]
2403 // 2489: }
2404 // 2489: } // switch Inst[31:26]
2405 // 2489: }
2406 2, 209, 10, // 2493: case 0x2: {
2407 OPC_SwitchField, 26, 6, // 2496: switch Inst[31:26] {
2408 0, 50, // 2499: case 0x0: {
2409 OPC_SwitchField, 7, 1, // 2501: switch Inst[7] {
2410 0, 23, // 2504: case 0x0: {
2411 OPC_SwitchField, 25, 1, // 2506: switch Inst[25] {
2412 0, 10, // 2509: case 0x0: {
2413 OPC_CheckPredicate, 47, // 2511: check predicate 47
2414 OPC_CheckField, 24, 1, 1, // 2513: check Inst[24] == 0x1
2415 OPC_Decode, 152, 122, 22, // 2517: decode to PWSLLI_B using decoder 22
2416 // 2517: }
2417 1, 0, // 2521: case 0x1: {
2418 OPC_CheckPredicate, 47, // 2523: check predicate 47
2419 OPC_Decode, 153, 122, 23, // 2525: decode to PWSLLI_H using decoder 23
2420 // 2525: }
2421 // 2525: } // switch Inst[25]
2422 // 2525: }
2423 1, 0, // 2529: case 0x1: {
2424 OPC_SwitchField, 25, 1, // 2531: switch Inst[25] {
2425 0, 6, // 2534: case 0x0: {
2426 OPC_CheckPredicate, 47, // 2536: check predicate 47
2427 OPC_Decode, 138, 122, 24, // 2538: decode to PWADD_H using decoder 24
2428 // 2538: }
2429 1, 0, // 2542: case 0x1: {
2430 OPC_CheckPredicate, 47, // 2544: check predicate 47
2431 OPC_Decode, 134, 132, 1, 24, // 2546: decode to WADD using decoder 24
2432 // 2546: }
2433 // 2546: } // switch Inst[25]
2434 // 2546: }
2435 // 2546: } // switch Inst[7]
2436 // 2546: }
2437 1, 33, // 2551: case 0x1: {
2438 OPC_SwitchField, 7, 1, // 2553: switch Inst[7] {
2439 0, 7, // 2556: case 0x0: {
2440 OPC_CheckPredicate, 47, // 2558: check predicate 47
2441 OPC_Decode, 150, 132, 1, 25, // 2560: decode to WSLLI using decoder 25
2442 // 2560: }
2443 1, 0, // 2565: case 0x1: {
2444 OPC_SwitchField, 25, 1, // 2567: switch Inst[25] {
2445 0, 6, // 2570: case 0x0: {
2446 OPC_CheckPredicate, 47, // 2572: check predicate 47
2447 OPC_Decode, 137, 122, 24, // 2574: decode to PWADD_B using decoder 24
2448 // 2574: }
2449 1, 0, // 2578: case 0x1: {
2450 OPC_CheckPredicate, 47, // 2580: check predicate 47
2451 OPC_Decode, 180, 119, 24, // 2582: decode to PM2WADD_H using decoder 24
2452 // 2582: }
2453 // 2582: } // switch Inst[25]
2454 // 2582: }
2455 // 2582: } // switch Inst[7]
2456 // 2582: }
2457 2, 46, // 2586: case 0x2: {
2458 OPC_SwitchField, 7, 1, // 2588: switch Inst[7] {
2459 0, 19, // 2591: case 0x0: {
2460 OPC_SwitchField, 25, 1, // 2593: switch Inst[25] {
2461 0, 6, // 2596: case 0x0: {
2462 OPC_CheckPredicate, 47, // 2598: check predicate 47
2463 OPC_Decode, 154, 122, 24, // 2600: decode to PWSLL_BS using decoder 24
2464 // 2600: }
2465 1, 0, // 2604: case 0x1: {
2466 OPC_CheckPredicate, 47, // 2606: check predicate 47
2467 OPC_Decode, 155, 122, 24, // 2608: decode to PWSLL_HS using decoder 24
2468 // 2608: }
2469 // 2608: } // switch Inst[25]
2470 // 2608: }
2471 1, 0, // 2612: case 0x1: {
2472 OPC_SwitchField, 25, 1, // 2614: switch Inst[25] {
2473 0, 6, // 2617: case 0x0: {
2474 OPC_CheckPredicate, 47, // 2619: check predicate 47
2475 OPC_Decode, 134, 122, 26, // 2621: decode to PWADDA_H using decoder 26
2476 // 2621: }
2477 1, 0, // 2625: case 0x1: {
2478 OPC_CheckPredicate, 47, // 2627: check predicate 47
2479 OPC_Decode, 135, 132, 1, 26, // 2629: decode to WADDA using decoder 26
2480 // 2629: }
2481 // 2629: } // switch Inst[25]
2482 // 2629: }
2483 // 2629: } // switch Inst[7]
2484 // 2629: }
2485 3, 37, // 2634: case 0x3: {
2486 OPC_SwitchField, 7, 1, // 2636: switch Inst[7] {
2487 0, 11, // 2639: case 0x0: {
2488 OPC_CheckPredicate, 47, // 2641: check predicate 47
2489 OPC_CheckField, 25, 1, 1, // 2643: check Inst[25] == 0x1
2490 OPC_Decode, 149, 132, 1, 24, // 2647: decode to WSLL using decoder 24
2491 // 2647: }
2492 1, 0, // 2652: case 0x1: {
2493 OPC_SwitchField, 25, 1, // 2654: switch Inst[25] {
2494 0, 6, // 2657: case 0x0: {
2495 OPC_CheckPredicate, 47, // 2659: check predicate 47
2496 OPC_Decode, 133, 122, 26, // 2661: decode to PWADDA_B using decoder 26
2497 // 2661: }
2498 1, 0, // 2665: case 0x1: {
2499 OPC_CheckPredicate, 47, // 2667: check predicate 47
2500 OPC_Decode, 176, 119, 26, // 2669: decode to PM2WADDA_H using decoder 26
2501 // 2669: }
2502 // 2669: } // switch Inst[25]
2503 // 2669: }
2504 // 2669: } // switch Inst[7]
2505 // 2669: }
2506 4, 28, // 2673: case 0x4: {
2507 OPC_SwitchField, 25, 1, // 2675: switch Inst[25] {
2508 0, 10, // 2678: case 0x0: {
2509 OPC_CheckPredicate, 47, // 2680: check predicate 47
2510 OPC_CheckField, 7, 1, 1, // 2682: check Inst[7] == 0x1
2511 OPC_Decode, 136, 122, 24, // 2686: decode to PWADDU_H using decoder 24
2512 // 2686: }
2513 1, 0, // 2690: case 0x1: {
2514 OPC_CheckPredicate, 47, // 2692: check predicate 47
2515 OPC_CheckField, 7, 1, 1, // 2694: check Inst[7] == 0x1
2516 OPC_Decode, 137, 132, 1, 24, // 2698: decode to WADDU using decoder 24
2517 // 2698: }
2518 // 2698: } // switch Inst[25]
2519 // 2698: }
2520 5, 27, // 2703: case 0x5: {
2521 OPC_SwitchField, 25, 1, // 2705: switch Inst[25] {
2522 0, 10, // 2708: case 0x0: {
2523 OPC_CheckPredicate, 47, // 2710: check predicate 47
2524 OPC_CheckField, 7, 1, 1, // 2712: check Inst[7] == 0x1
2525 OPC_Decode, 135, 122, 24, // 2716: decode to PWADDU_B using decoder 24
2526 // 2716: }
2527 1, 0, // 2720: case 0x1: {
2528 OPC_CheckPredicate, 47, // 2722: check predicate 47
2529 OPC_CheckField, 7, 1, 1, // 2724: check Inst[7] == 0x1
2530 OPC_Decode, 181, 119, 24, // 2728: decode to PM2WADD_HX using decoder 24
2531 // 2728: }
2532 // 2728: } // switch Inst[25]
2533 // 2728: }
2534 6, 28, // 2732: case 0x6: {
2535 OPC_SwitchField, 25, 1, // 2734: switch Inst[25] {
2536 0, 10, // 2737: case 0x0: {
2537 OPC_CheckPredicate, 47, // 2739: check predicate 47
2538 OPC_CheckField, 7, 1, 1, // 2741: check Inst[7] == 0x1
2539 OPC_Decode, 132, 122, 26, // 2745: decode to PWADDAU_H using decoder 26
2540 // 2745: }
2541 1, 0, // 2749: case 0x1: {
2542 OPC_CheckPredicate, 47, // 2751: check predicate 47
2543 OPC_CheckField, 7, 1, 1, // 2753: check Inst[7] == 0x1
2544 OPC_Decode, 136, 132, 1, 26, // 2757: decode to WADDAU using decoder 26
2545 // 2757: }
2546 // 2757: } // switch Inst[25]
2547 // 2757: }
2548 7, 27, // 2762: case 0x7: {
2549 OPC_SwitchField, 25, 1, // 2764: switch Inst[25] {
2550 0, 10, // 2767: case 0x0: {
2551 OPC_CheckPredicate, 47, // 2769: check predicate 47
2552 OPC_CheckField, 7, 1, 1, // 2771: check Inst[7] == 0x1
2553 OPC_Decode, 131, 122, 26, // 2775: decode to PWADDAU_B using decoder 26
2554 // 2775: }
2555 1, 0, // 2779: case 0x1: {
2556 OPC_CheckPredicate, 47, // 2781: check predicate 47
2557 OPC_CheckField, 7, 1, 1, // 2783: check Inst[7] == 0x1
2558 OPC_Decode, 177, 119, 26, // 2787: decode to PM2WADDA_HX using decoder 26
2559 // 2787: }
2560 // 2787: } // switch Inst[25]
2561 // 2787: }
2562 8, 28, // 2791: case 0x8: {
2563 OPC_SwitchField, 25, 1, // 2793: switch Inst[25] {
2564 0, 10, // 2796: case 0x0: {
2565 OPC_CheckPredicate, 47, // 2798: check predicate 47
2566 OPC_CheckField, 7, 1, 1, // 2800: check Inst[7] == 0x1
2567 OPC_Decode, 147, 122, 24, // 2804: decode to PWMUL_H using decoder 24
2568 // 2804: }
2569 1, 0, // 2808: case 0x1: {
2570 OPC_CheckPredicate, 47, // 2810: check predicate 47
2571 OPC_CheckField, 7, 1, 1, // 2812: check Inst[7] == 0x1
2572 OPC_Decode, 142, 132, 1, 24, // 2816: decode to WMUL using decoder 24
2573 // 2816: }
2574 // 2816: } // switch Inst[25]
2575 // 2816: }
2576 9, 27, // 2821: case 0x9: {
2577 OPC_SwitchField, 25, 1, // 2823: switch Inst[25] {
2578 0, 10, // 2826: case 0x0: {
2579 OPC_CheckPredicate, 47, // 2828: check predicate 47
2580 OPC_CheckField, 7, 1, 1, // 2830: check Inst[7] == 0x1
2581 OPC_Decode, 146, 122, 24, // 2834: decode to PWMUL_B using decoder 24
2582 // 2834: }
2583 1, 0, // 2838: case 0x1: {
2584 OPC_CheckPredicate, 47, // 2840: check predicate 47
2585 OPC_CheckField, 7, 1, 1, // 2842: check Inst[7] == 0x1
2586 OPC_Decode, 179, 119, 24, // 2846: decode to PM2WADDU_H using decoder 24
2587 // 2846: }
2588 // 2846: } // switch Inst[25]
2589 // 2846: }
2590 10, 28, // 2850: case 0xa: {
2591 OPC_SwitchField, 25, 1, // 2852: switch Inst[25] {
2592 0, 10, // 2855: case 0x0: {
2593 OPC_CheckPredicate, 47, // 2857: check predicate 47
2594 OPC_CheckField, 7, 1, 1, // 2859: check Inst[7] == 0x1
2595 OPC_Decode, 141, 122, 26, // 2863: decode to PWMACC_H using decoder 26
2596 // 2863: }
2597 1, 0, // 2867: case 0x1: {
2598 OPC_CheckPredicate, 47, // 2869: check predicate 47
2599 OPC_CheckField, 7, 1, 1, // 2871: check Inst[7] == 0x1
2600 OPC_Decode, 139, 132, 1, 26, // 2875: decode to WMACC using decoder 26
2601 // 2875: }
2602 // 2875: } // switch Inst[25]
2603 // 2875: }
2604 11, 14, // 2880: case 0xb: {
2605 OPC_CheckPredicate, 47, // 2882: check predicate 47
2606 OPC_CheckField, 25, 1, 1, // 2884: check Inst[25] == 0x1
2607 OPC_CheckField, 7, 1, 1, // 2888: check Inst[7] == 0x1
2608 OPC_Decode, 175, 119, 26, // 2892: decode to PM2WADDAU_H using decoder 26
2609 // 2892: }
2610 12, 37, // 2896: case 0xc: {
2611 OPC_SwitchField, 7, 1, // 2898: switch Inst[7] {
2612 0, 10, // 2901: case 0x0: {
2613 OPC_CheckPredicate, 47, // 2903: check predicate 47
2614 OPC_CheckField, 25, 1, 0, // 2905: check Inst[25] == 0x0
2615 OPC_Decode, 142, 119, 27, // 2909: decode to PLI_DH using decoder 27
2616 // 2909: }
2617 1, 0, // 2913: case 0x1: {
2618 OPC_SwitchField, 25, 1, // 2915: switch Inst[25] {
2619 0, 6, // 2918: case 0x0: {
2620 OPC_CheckPredicate, 47, // 2920: check predicate 47
2621 OPC_Decode, 145, 122, 24, // 2922: decode to PWMULU_H using decoder 24
2622 // 2922: }
2623 1, 0, // 2926: case 0x1: {
2624 OPC_CheckPredicate, 47, // 2928: check predicate 47
2625 OPC_Decode, 144, 132, 1, 24, // 2930: decode to WMULU using decoder 24
2626 // 2930: }
2627 // 2930: } // switch Inst[25]
2628 // 2930: }
2629 // 2930: } // switch Inst[7]
2630 // 2930: }
2631 13, 31, // 2935: case 0xd: {
2632 OPC_SwitchField, 7, 1, // 2937: switch Inst[7] {
2633 0, 14, // 2940: case 0x0: {
2634 OPC_CheckPredicate, 47, // 2942: check predicate 47
2635 OPC_CheckField, 24, 2, 0, // 2944: check Inst[25:24] == 0x0
2636 OPC_CheckField, 15, 1, 0, // 2948: check Inst[15] == 0x0
2637 OPC_Decode, 141, 119, 28, // 2952: decode to PLI_DB using decoder 28
2638 // 2952: }
2639 1, 0, // 2956: case 0x1: {
2640 OPC_CheckPredicate, 47, // 2958: check predicate 47
2641 OPC_CheckField, 25, 1, 0, // 2960: check Inst[25] == 0x0
2642 OPC_Decode, 144, 122, 24, // 2964: decode to PWMULU_B using decoder 24
2643 // 2964: }
2644 // 2964: } // switch Inst[7]
2645 // 2964: }
2646 14, 28, // 2968: case 0xe: {
2647 OPC_SwitchField, 25, 1, // 2970: switch Inst[25] {
2648 0, 10, // 2973: case 0x0: {
2649 OPC_CheckPredicate, 47, // 2975: check predicate 47
2650 OPC_CheckField, 7, 1, 1, // 2977: check Inst[7] == 0x1
2651 OPC_Decode, 140, 122, 26, // 2981: decode to PWMACCU_H using decoder 26
2652 // 2981: }
2653 1, 0, // 2985: case 0x1: {
2654 OPC_CheckPredicate, 47, // 2987: check predicate 47
2655 OPC_CheckField, 7, 1, 1, // 2989: check Inst[7] == 0x1
2656 OPC_Decode, 141, 132, 1, 26, // 2993: decode to WMACCU using decoder 26
2657 // 2993: }
2658 // 2993: } // switch Inst[25]
2659 // 2993: }
2660 16, 50, // 2998: case 0x10: {
2661 OPC_SwitchField, 7, 1, // 3000: switch Inst[7] {
2662 0, 23, // 3003: case 0x0: {
2663 OPC_SwitchField, 25, 1, // 3005: switch Inst[25] {
2664 0, 10, // 3008: case 0x0: {
2665 OPC_CheckPredicate, 47, // 3010: check predicate 47
2666 OPC_CheckField, 24, 1, 1, // 3012: check Inst[24] == 0x1
2667 OPC_Decode, 148, 122, 22, // 3016: decode to PWSLAI_B using decoder 22
2668 // 3016: }
2669 1, 0, // 3020: case 0x1: {
2670 OPC_CheckPredicate, 47, // 3022: check predicate 47
2671 OPC_Decode, 149, 122, 23, // 3024: decode to PWSLAI_H using decoder 23
2672 // 3024: }
2673 // 3024: } // switch Inst[25]
2674 // 3024: }
2675 1, 0, // 3028: case 0x1: {
2676 OPC_SwitchField, 25, 1, // 3030: switch Inst[25] {
2677 0, 6, // 3033: case 0x0: {
2678 OPC_CheckPredicate, 47, // 3035: check predicate 47
2679 OPC_Decode, 163, 122, 24, // 3037: decode to PWSUB_H using decoder 24
2680 // 3037: }
2681 1, 0, // 3041: case 0x1: {
2682 OPC_CheckPredicate, 47, // 3043: check predicate 47
2683 OPC_Decode, 151, 132, 1, 24, // 3045: decode to WSUB using decoder 24
2684 // 3045: }
2685 // 3045: } // switch Inst[25]
2686 // 3045: }
2687 // 3045: } // switch Inst[7]
2688 // 3045: }
2689 17, 33, // 3050: case 0x11: {
2690 OPC_SwitchField, 7, 1, // 3052: switch Inst[7] {
2691 0, 7, // 3055: case 0x0: {
2692 OPC_CheckPredicate, 47, // 3057: check predicate 47
2693 OPC_Decode, 148, 132, 1, 25, // 3059: decode to WSLAI using decoder 25
2694 // 3059: }
2695 1, 0, // 3064: case 0x1: {
2696 OPC_SwitchField, 25, 1, // 3066: switch Inst[25] {
2697 0, 6, // 3069: case 0x0: {
2698 OPC_CheckPredicate, 47, // 3071: check predicate 47
2699 OPC_Decode, 162, 122, 24, // 3073: decode to PWSUB_B using decoder 24
2700 // 3073: }
2701 1, 0, // 3077: case 0x1: {
2702 OPC_CheckPredicate, 47, // 3079: check predicate 47
2703 OPC_Decode, 184, 119, 24, // 3081: decode to PM2WSUB_H using decoder 24
2704 // 3081: }
2705 // 3081: } // switch Inst[25]
2706 // 3081: }
2707 // 3081: } // switch Inst[7]
2708 // 3081: }
2709 18, 46, // 3085: case 0x12: {
2710 OPC_SwitchField, 7, 1, // 3087: switch Inst[7] {
2711 0, 19, // 3090: case 0x0: {
2712 OPC_SwitchField, 25, 1, // 3092: switch Inst[25] {
2713 0, 6, // 3095: case 0x0: {
2714 OPC_CheckPredicate, 47, // 3097: check predicate 47
2715 OPC_Decode, 150, 122, 24, // 3099: decode to PWSLA_BS using decoder 24
2716 // 3099: }
2717 1, 0, // 3103: case 0x1: {
2718 OPC_CheckPredicate, 47, // 3105: check predicate 47
2719 OPC_Decode, 151, 122, 24, // 3107: decode to PWSLA_HS using decoder 24
2720 // 3107: }
2721 // 3107: } // switch Inst[25]
2722 // 3107: }
2723 1, 0, // 3111: case 0x1: {
2724 OPC_SwitchField, 25, 1, // 3113: switch Inst[25] {
2725 0, 6, // 3116: case 0x0: {
2726 OPC_CheckPredicate, 47, // 3118: check predicate 47
2727 OPC_Decode, 159, 122, 26, // 3120: decode to PWSUBA_H using decoder 26
2728 // 3120: }
2729 1, 0, // 3124: case 0x1: {
2730 OPC_CheckPredicate, 47, // 3126: check predicate 47
2731 OPC_Decode, 152, 132, 1, 26, // 3128: decode to WSUBA using decoder 26
2732 // 3128: }
2733 // 3128: } // switch Inst[25]
2734 // 3128: }
2735 // 3128: } // switch Inst[7]
2736 // 3128: }
2737 19, 37, // 3133: case 0x13: {
2738 OPC_SwitchField, 7, 1, // 3135: switch Inst[7] {
2739 0, 11, // 3138: case 0x0: {
2740 OPC_CheckPredicate, 47, // 3140: check predicate 47
2741 OPC_CheckField, 25, 1, 1, // 3142: check Inst[25] == 0x1
2742 OPC_Decode, 147, 132, 1, 24, // 3146: decode to WSLA using decoder 24
2743 // 3146: }
2744 1, 0, // 3151: case 0x1: {
2745 OPC_SwitchField, 25, 1, // 3153: switch Inst[25] {
2746 0, 6, // 3156: case 0x0: {
2747 OPC_CheckPredicate, 47, // 3158: check predicate 47
2748 OPC_Decode, 158, 122, 26, // 3160: decode to PWSUBA_B using decoder 26
2749 // 3160: }
2750 1, 0, // 3164: case 0x1: {
2751 OPC_CheckPredicate, 47, // 3166: check predicate 47
2752 OPC_Decode, 182, 119, 26, // 3168: decode to PM2WSUBA_H using decoder 26
2753 // 3168: }
2754 // 3168: } // switch Inst[25]
2755 // 3168: }
2756 // 3168: } // switch Inst[7]
2757 // 3168: }
2758 20, 28, // 3172: case 0x14: {
2759 OPC_SwitchField, 25, 1, // 3174: switch Inst[25] {
2760 0, 10, // 3177: case 0x0: {
2761 OPC_CheckPredicate, 47, // 3179: check predicate 47
2762 OPC_CheckField, 7, 1, 1, // 3181: check Inst[7] == 0x1
2763 OPC_Decode, 161, 122, 24, // 3185: decode to PWSUBU_H using decoder 24
2764 // 3185: }
2765 1, 0, // 3189: case 0x1: {
2766 OPC_CheckPredicate, 47, // 3191: check predicate 47
2767 OPC_CheckField, 7, 1, 1, // 3193: check Inst[7] == 0x1
2768 OPC_Decode, 154, 132, 1, 24, // 3197: decode to WSUBU using decoder 24
2769 // 3197: }
2770 // 3197: } // switch Inst[25]
2771 // 3197: }
2772 21, 27, // 3202: case 0x15: {
2773 OPC_SwitchField, 25, 1, // 3204: switch Inst[25] {
2774 0, 10, // 3207: case 0x0: {
2775 OPC_CheckPredicate, 47, // 3209: check predicate 47
2776 OPC_CheckField, 7, 1, 1, // 3211: check Inst[7] == 0x1
2777 OPC_Decode, 160, 122, 24, // 3215: decode to PWSUBU_B using decoder 24
2778 // 3215: }
2779 1, 0, // 3219: case 0x1: {
2780 OPC_CheckPredicate, 47, // 3221: check predicate 47
2781 OPC_CheckField, 7, 1, 1, // 3223: check Inst[7] == 0x1
2782 OPC_Decode, 185, 119, 24, // 3227: decode to PM2WSUB_HX using decoder 24
2783 // 3227: }
2784 // 3227: } // switch Inst[25]
2785 // 3227: }
2786 22, 28, // 3231: case 0x16: {
2787 OPC_SwitchField, 25, 1, // 3233: switch Inst[25] {
2788 0, 10, // 3236: case 0x0: {
2789 OPC_CheckPredicate, 47, // 3238: check predicate 47
2790 OPC_CheckField, 7, 1, 1, // 3240: check Inst[7] == 0x1
2791 OPC_Decode, 157, 122, 26, // 3244: decode to PWSUBAU_H using decoder 26
2792 // 3244: }
2793 1, 0, // 3248: case 0x1: {
2794 OPC_CheckPredicate, 47, // 3250: check predicate 47
2795 OPC_CheckField, 7, 1, 1, // 3252: check Inst[7] == 0x1
2796 OPC_Decode, 153, 132, 1, 26, // 3256: decode to WSUBAU using decoder 26
2797 // 3256: }
2798 // 3256: } // switch Inst[25]
2799 // 3256: }
2800 23, 27, // 3261: case 0x17: {
2801 OPC_SwitchField, 25, 1, // 3263: switch Inst[25] {
2802 0, 10, // 3266: case 0x0: {
2803 OPC_CheckPredicate, 47, // 3268: check predicate 47
2804 OPC_CheckField, 7, 1, 1, // 3270: check Inst[7] == 0x1
2805 OPC_Decode, 156, 122, 26, // 3274: decode to PWSUBAU_B using decoder 26
2806 // 3274: }
2807 1, 0, // 3278: case 0x1: {
2808 OPC_CheckPredicate, 47, // 3280: check predicate 47
2809 OPC_CheckField, 7, 1, 1, // 3282: check Inst[7] == 0x1
2810 OPC_Decode, 183, 119, 26, // 3286: decode to PM2WSUBA_HX using decoder 26
2811 // 3286: }
2812 // 3286: } // switch Inst[25]
2813 // 3286: }
2814 24, 28, // 3290: case 0x18: {
2815 OPC_SwitchField, 25, 1, // 3292: switch Inst[25] {
2816 0, 10, // 3295: case 0x0: {
2817 OPC_CheckPredicate, 47, // 3297: check predicate 47
2818 OPC_CheckField, 7, 1, 1, // 3299: check Inst[7] == 0x1
2819 OPC_Decode, 143, 122, 24, // 3303: decode to PWMULSU_H using decoder 24
2820 // 3303: }
2821 1, 0, // 3307: case 0x1: {
2822 OPC_CheckPredicate, 47, // 3309: check predicate 47
2823 OPC_CheckField, 7, 1, 1, // 3311: check Inst[7] == 0x1
2824 OPC_Decode, 143, 132, 1, 24, // 3315: decode to WMULSU using decoder 24
2825 // 3315: }
2826 // 3315: } // switch Inst[25]
2827 // 3315: }
2828 25, 27, // 3320: case 0x19: {
2829 OPC_SwitchField, 25, 1, // 3322: switch Inst[25] {
2830 0, 10, // 3325: case 0x0: {
2831 OPC_CheckPredicate, 47, // 3327: check predicate 47
2832 OPC_CheckField, 7, 1, 1, // 3329: check Inst[7] == 0x1
2833 OPC_Decode, 142, 122, 24, // 3333: decode to PWMULSU_B using decoder 24
2834 // 3333: }
2835 1, 0, // 3337: case 0x1: {
2836 OPC_CheckPredicate, 47, // 3339: check predicate 47
2837 OPC_CheckField, 7, 1, 1, // 3341: check Inst[7] == 0x1
2838 OPC_Decode, 178, 119, 24, // 3345: decode to PM2WADDSU_H using decoder 24
2839 // 3345: }
2840 // 3345: } // switch Inst[25]
2841 // 3345: }
2842 26, 28, // 3349: case 0x1a: {
2843 OPC_SwitchField, 25, 1, // 3351: switch Inst[25] {
2844 0, 10, // 3354: case 0x0: {
2845 OPC_CheckPredicate, 47, // 3356: check predicate 47
2846 OPC_CheckField, 7, 1, 1, // 3358: check Inst[7] == 0x1
2847 OPC_Decode, 139, 122, 26, // 3362: decode to PWMACCSU_H using decoder 26
2848 // 3362: }
2849 1, 0, // 3366: case 0x1: {
2850 OPC_CheckPredicate, 47, // 3368: check predicate 47
2851 OPC_CheckField, 7, 1, 1, // 3370: check Inst[7] == 0x1
2852 OPC_Decode, 140, 132, 1, 26, // 3374: decode to WMACCSU using decoder 26
2853 // 3374: }
2854 // 3374: } // switch Inst[25]
2855 // 3374: }
2856 27, 14, // 3379: case 0x1b: {
2857 OPC_CheckPredicate, 47, // 3381: check predicate 47
2858 OPC_CheckField, 25, 1, 1, // 3383: check Inst[25] == 0x1
2859 OPC_CheckField, 7, 1, 1, // 3387: check Inst[7] == 0x1
2860 OPC_Decode, 174, 119, 26, // 3391: decode to PM2WADDASU_H using decoder 26
2861 // 3391: }
2862 28, 14, // 3395: case 0x1c: {
2863 OPC_CheckPredicate, 47, // 3397: check predicate 47
2864 OPC_CheckField, 25, 1, 0, // 3399: check Inst[25] == 0x0
2865 OPC_CheckField, 7, 1, 0, // 3403: check Inst[7] == 0x0
2866 OPC_Decode, 145, 119, 29, // 3407: decode to PLUI_DH using decoder 29
2867 // 3407: }
2868 30, 47, // 3411: case 0x1e: {
2869 OPC_SwitchField, 7, 1, // 3413: switch Inst[7] {
2870 0, 21, // 3416: case 0x0: {
2871 OPC_SwitchField, 25, 1, // 3418: switch Inst[25] {
2872 0, 7, // 3421: case 0x0: {
2873 OPC_CheckPredicate, 47, // 3423: check predicate 47
2874 OPC_Decode, 156, 132, 1, 24, // 3425: decode to WZIP8P using decoder 24
2875 // 3425: }
2876 1, 0, // 3430: case 0x1: {
2877 OPC_CheckPredicate, 47, // 3432: check predicate 47
2878 OPC_Decode, 155, 132, 1, 24, // 3434: decode to WZIP16P using decoder 24
2879 // 3434: }
2880 // 3434: } // switch Inst[25]
2881 // 3434: }
2882 1, 0, // 3439: case 0x1: {
2883 OPC_SwitchField, 25, 1, // 3441: switch Inst[25] {
2884 0, 6, // 3444: case 0x0: {
2885 OPC_CheckPredicate, 47, // 3446: check predicate 47
2886 OPC_Decode, 137, 120, 26, // 3448: decode to PMQWACC_H using decoder 26
2887 // 3448: }
2888 1, 0, // 3452: case 0x1: {
2889 OPC_CheckPredicate, 47, // 3454: check predicate 47
2890 OPC_Decode, 236, 117, 26, // 3456: decode to MQWACC using decoder 26
2891 // 3456: }
2892 // 3456: } // switch Inst[25]
2893 // 3456: }
2894 // 3456: } // switch Inst[7]
2895 // 3456: }
2896 31, 27, // 3460: case 0x1f: {
2897 OPC_SwitchField, 25, 1, // 3462: switch Inst[25] {
2898 0, 10, // 3465: case 0x0: {
2899 OPC_CheckPredicate, 47, // 3467: check predicate 47
2900 OPC_CheckField, 7, 1, 1, // 3469: check Inst[7] == 0x1
2901 OPC_Decode, 136, 120, 26, // 3473: decode to PMQRWACC_H using decoder 26
2902 // 3473: }
2903 1, 0, // 3477: case 0x1: {
2904 OPC_CheckPredicate, 47, // 3479: check predicate 47
2905 OPC_CheckField, 7, 1, 1, // 3481: check Inst[7] == 0x1
2906 OPC_Decode, 235, 117, 26, // 3485: decode to MQRWACC using decoder 26
2907 // 3485: }
2908 // 3485: } // switch Inst[25]
2909 // 3485: }
2910 32, 36, // 3489: case 0x20: {
2911 OPC_SwitchField, 25, 1, // 3491: switch Inst[25] {
2912 0, 23, // 3494: case 0x0: {
2913 OPC_SwitchField, 24, 1, // 3496: switch Inst[24] {
2914 0, 10, // 3499: case 0x0: {
2915 OPC_CheckPredicate, 43, // 3501: check predicate 43
2916 OPC_CheckField, 23, 1, 1, // 3503: check Inst[23] == 0x1
2917 OPC_Decode, 170, 121, 30, // 3507: decode to PSLLI_B using decoder 30
2918 // 3507: }
2919 1, 0, // 3511: case 0x1: {
2920 OPC_CheckPredicate, 43, // 3513: check predicate 43
2921 OPC_Decode, 174, 121, 18, // 3515: decode to PSLLI_H using decoder 18
2922 // 3515: }
2923 // 3515: } // switch Inst[24]
2924 // 3515: }
2925 1, 0, // 3519: case 0x1: {
2926 OPC_CheckPredicate, 48, // 3521: check predicate 48
2927 OPC_Decode, 175, 121, 21, // 3523: decode to PSLLI_W using decoder 21
2928 // 3523: }
2929 // 3523: } // switch Inst[25]
2930 // 3523: }
2931 34, 19, // 3527: case 0x22: {
2932 OPC_SwitchField, 25, 1, // 3529: switch Inst[25] {
2933 0, 6, // 3532: case 0x0: {
2934 OPC_CheckPredicate, 43, // 3534: check predicate 43
2935 OPC_Decode, 180, 121, 31, // 3536: decode to PSLL_HS using decoder 31
2936 // 3536: }
2937 1, 0, // 3540: case 0x1: {
2938 OPC_CheckPredicate, 48, // 3542: check predicate 48
2939 OPC_Decode, 181, 121, 31, // 3544: decode to PSLL_WS using decoder 31
2940 // 3544: }
2941 // 3544: } // switch Inst[25]
2942 // 3544: }
2943 35, 10, // 3548: case 0x23: {
2944 OPC_CheckPredicate, 43, // 3550: check predicate 43
2945 OPC_CheckField, 25, 1, 0, // 3552: check Inst[25] == 0x0
2946 OPC_Decode, 176, 121, 31, // 3556: decode to PSLL_BS using decoder 31
2947 // 3556: }
2948 38, 19, // 3560: case 0x26: {
2949 OPC_SwitchField, 25, 1, // 3562: switch Inst[25] {
2950 0, 6, // 3565: case 0x0: {
2951 OPC_CheckPredicate, 43, // 3567: check predicate 43
2952 OPC_Decode, 247, 118, 31, // 3569: decode to PADD_HS using decoder 31
2953 // 3569: }
2954 1, 0, // 3573: case 0x1: {
2955 OPC_CheckPredicate, 48, // 3575: check predicate 48
2956 OPC_Decode, 249, 118, 31, // 3577: decode to PADD_WS using decoder 31
2957 // 3577: }
2958 // 3577: } // switch Inst[25]
2959 // 3577: }
2960 39, 10, // 3581: case 0x27: {
2961 OPC_CheckPredicate, 43, // 3583: check predicate 43
2962 OPC_CheckField, 25, 1, 0, // 3585: check Inst[25] == 0x0
2963 OPC_Decode, 239, 118, 31, // 3589: decode to PADD_BS using decoder 31
2964 // 3589: }
2965 42, 19, // 3593: case 0x2a: {
2966 OPC_SwitchField, 25, 1, // 3595: switch Inst[25] {
2967 0, 6, // 3598: case 0x0: {
2968 OPC_CheckPredicate, 43, // 3600: check predicate 43
2969 OPC_Decode, 231, 121, 31, // 3602: decode to PSSHL_HS using decoder 31
2970 // 3602: }
2971 1, 0, // 3606: case 0x1: {
2972 OPC_CheckPredicate, 48, // 3608: check predicate 48
2973 OPC_Decode, 232, 121, 31, // 3610: decode to PSSHL_WS using decoder 31
2974 // 3610: }
2975 // 3610: } // switch Inst[25]
2976 // 3610: }
2977 43, 10, // 3614: case 0x2b: {
2978 OPC_CheckPredicate, 48, // 3616: check predicate 48
2979 OPC_CheckField, 25, 1, 1, // 3618: check Inst[25] == 0x1
2980 OPC_Decode, 206, 124, 31, // 3622: decode to SHL using decoder 31
2981 // 3622: }
2982 44, 19, // 3626: case 0x2c: {
2983 OPC_SwitchField, 25, 1, // 3628: switch Inst[25] {
2984 0, 6, // 3631: case 0x0: {
2985 OPC_CheckPredicate, 43, // 3633: check predicate 43
2986 OPC_Decode, 143, 119, 32, // 3635: decode to PLI_H using decoder 32
2987 // 3635: }
2988 1, 0, // 3639: case 0x1: {
2989 OPC_CheckPredicate, 48, // 3641: check predicate 48
2990 OPC_Decode, 144, 119, 32, // 3643: decode to PLI_W using decoder 32
2991 // 3643: }
2992 // 3643: } // switch Inst[25]
2993 // 3643: }
2994 45, 14, // 3647: case 0x2d: {
2995 OPC_CheckPredicate, 43, // 3649: check predicate 43
2996 OPC_CheckField, 24, 2, 0, // 3651: check Inst[25:24] == 0x0
2997 OPC_CheckField, 15, 1, 0, // 3655: check Inst[15] == 0x0
2998 OPC_Decode, 140, 119, 33, // 3659: decode to PLI_B using decoder 33
2999 // 3659: }
3000 46, 19, // 3663: case 0x2e: {
3001 OPC_SwitchField, 25, 1, // 3665: switch Inst[25] {
3002 0, 6, // 3668: case 0x0: {
3003 OPC_CheckPredicate, 43, // 3670: check predicate 43
3004 OPC_Decode, 227, 121, 31, // 3672: decode to PSSHLR_HS using decoder 31
3005 // 3672: }
3006 1, 0, // 3676: case 0x1: {
3007 OPC_CheckPredicate, 48, // 3678: check predicate 48
3008 OPC_Decode, 228, 121, 31, // 3680: decode to PSSHLR_WS using decoder 31
3009 // 3680: }
3010 // 3680: } // switch Inst[25]
3011 // 3680: }
3012 47, 10, // 3684: case 0x2f: {
3013 OPC_CheckPredicate, 48, // 3686: check predicate 48
3014 OPC_CheckField, 25, 1, 1, // 3688: check Inst[25] == 0x1
3015 OPC_Decode, 207, 124, 31, // 3692: decode to SHLR using decoder 31
3016 // 3692: }
3017 52, 23, // 3696: case 0x34: {
3018 OPC_SwitchField, 25, 1, // 3698: switch Inst[25] {
3019 0, 10, // 3701: case 0x0: {
3020 OPC_CheckPredicate, 43, // 3703: check predicate 43
3021 OPC_CheckField, 24, 1, 1, // 3705: check Inst[24] == 0x1
3022 OPC_Decode, 235, 121, 18, // 3709: decode to PSSLAI_H using decoder 18
3023 // 3709: }
3024 1, 0, // 3713: case 0x1: {
3025 OPC_CheckPredicate, 48, // 3715: check predicate 48
3026 OPC_Decode, 236, 121, 21, // 3717: decode to PSSLAI_W using decoder 21
3027 // 3717: }
3028 // 3717: } // switch Inst[25]
3029 // 3717: }
3030 56, 35, // 3721: case 0x38: {
3031 OPC_SwitchField, 20, 6, // 3723: switch Inst[25:20] {
3032 4, 6, // 3726: case 0x4: {
3033 OPC_CheckPredicate, 43, // 3728: check predicate 43
3034 OPC_Decode, 163, 121, 17, // 3730: decode to PSEXT_H_B using decoder 17
3035 // 3730: }
3036 7, 6, // 3734: case 0x7: {
3037 OPC_CheckPredicate, 43, // 3736: check predicate 43
3038 OPC_Decode, 137, 121, 17, // 3738: decode to PSABS_H using decoder 17
3039 // 3738: }
3040 36, 6, // 3742: case 0x24: {
3041 OPC_CheckPredicate, 48, // 3744: check predicate 48
3042 OPC_Decode, 164, 121, 17, // 3746: decode to PSEXT_W_B using decoder 17
3043 // 3746: }
3044 37, 0, // 3750: case 0x25: {
3045 OPC_CheckPredicate, 48, // 3752: check predicate 48
3046 OPC_Decode, 165, 121, 17, // 3754: decode to PSEXT_W_H using decoder 17
3047 // 3754: }
3048 // 3754: } // switch Inst[25:20]
3049 // 3754: }
3050 57, 10, // 3758: case 0x39: {
3051 OPC_CheckPredicate, 43, // 3760: check predicate 43
3052 OPC_CheckField, 20, 6, 7, // 3762: check Inst[25:20] == 0x7
3053 OPC_Decode, 134, 121, 17, // 3766: decode to PSABS_B using decoder 17
3054 // 3766: }
3055 58, 19, // 3770: case 0x3a: {
3056 OPC_SwitchField, 25, 1, // 3772: switch Inst[25] {
3057 0, 6, // 3775: case 0x0: {
3058 OPC_CheckPredicate, 43, // 3777: check predicate 43
3059 OPC_Decode, 223, 121, 31, // 3779: decode to PSSHA_HS using decoder 31
3060 // 3779: }
3061 1, 0, // 3783: case 0x1: {
3062 OPC_CheckPredicate, 48, // 3785: check predicate 48
3063 OPC_Decode, 224, 121, 31, // 3787: decode to PSSHA_WS using decoder 31
3064 // 3787: }
3065 // 3787: } // switch Inst[25]
3066 // 3787: }
3067 59, 10, // 3791: case 0x3b: {
3068 OPC_CheckPredicate, 48, // 3793: check predicate 48
3069 OPC_CheckField, 25, 1, 1, // 3795: check Inst[25] == 0x1
3070 OPC_Decode, 190, 124, 31, // 3799: decode to SHA using decoder 31
3071 // 3799: }
3072 60, 19, // 3803: case 0x3c: {
3073 OPC_SwitchField, 25, 1, // 3805: switch Inst[25] {
3074 0, 6, // 3808: case 0x0: {
3075 OPC_CheckPredicate, 43, // 3810: check predicate 43
3076 OPC_Decode, 146, 119, 34, // 3812: decode to PLUI_H using decoder 34
3077 // 3812: }
3078 1, 0, // 3816: case 0x1: {
3079 OPC_CheckPredicate, 48, // 3818: check predicate 48
3080 OPC_Decode, 147, 119, 34, // 3820: decode to PLUI_W using decoder 34
3081 // 3820: }
3082 // 3820: } // switch Inst[25]
3083 // 3820: }
3084 62, 19, // 3824: case 0x3e: {
3085 OPC_SwitchField, 25, 1, // 3826: switch Inst[25] {
3086 0, 6, // 3829: case 0x0: {
3087 OPC_CheckPredicate, 43, // 3831: check predicate 43
3088 OPC_Decode, 219, 121, 31, // 3833: decode to PSSHAR_HS using decoder 31
3089 // 3833: }
3090 1, 0, // 3837: case 0x1: {
3091 OPC_CheckPredicate, 48, // 3839: check predicate 48
3092 OPC_Decode, 220, 121, 31, // 3841: decode to PSSHAR_WS using decoder 31
3093 // 3841: }
3094 // 3841: } // switch Inst[25]
3095 // 3841: }
3096 63, 0, // 3845: case 0x3f: {
3097 OPC_CheckPredicate, 48, // 3847: check predicate 48
3098 OPC_CheckField, 25, 1, 1, // 3849: check Inst[25] == 0x1
3099 OPC_Decode, 205, 124, 31, // 3853: decode to SHAR using decoder 31
3100 // 3853: }
3101 // 3853: } // switch Inst[31:26]
3102 // 3853: }
3103 4, 226, 7, // 3857: case 0x4: {
3104 OPC_SwitchField, 26, 6, // 3860: switch Inst[31:26] {
3105 0, 31, // 3863: case 0x0: {
3106 OPC_SwitchField, 25, 1, // 3865: switch Inst[25] {
3107 0, 14, // 3868: case 0x0: {
3108 OPC_CheckPredicate, 47, // 3870: check predicate 47
3109 OPC_CheckField, 24, 1, 1, // 3872: check Inst[24] == 0x1
3110 OPC_CheckField, 15, 1, 1, // 3876: check Inst[15] == 0x1
3111 OPC_Decode, 226, 120, 35, // 3880: decode to PNSRLI_B using decoder 35
3112 // 3880: }
3113 1, 0, // 3884: case 0x1: {
3114 OPC_CheckPredicate, 47, // 3886: check predicate 47
3115 OPC_CheckField, 15, 1, 1, // 3888: check Inst[15] == 0x1
3116 OPC_Decode, 227, 120, 36, // 3892: decode to PNSRLI_H using decoder 36
3117 // 3892: }
3118 // 3892: } // switch Inst[25]
3119 // 3892: }
3120 1, 10, // 3896: case 0x1: {
3121 OPC_CheckPredicate, 47, // 3898: check predicate 47
3122 OPC_CheckField, 15, 1, 1, // 3900: check Inst[15] == 0x1
3123 OPC_Decode, 205, 118, 37, // 3904: decode to NSRLI using decoder 37
3124 // 3904: }
3125 2, 27, // 3908: case 0x2: {
3126 OPC_SwitchField, 25, 1, // 3910: switch Inst[25] {
3127 0, 10, // 3913: case 0x0: {
3128 OPC_CheckPredicate, 47, // 3915: check predicate 47
3129 OPC_CheckField, 15, 1, 1, // 3917: check Inst[15] == 0x1
3130 OPC_Decode, 228, 120, 38, // 3921: decode to PNSRL_BS using decoder 38
3131 // 3921: }
3132 1, 0, // 3925: case 0x1: {
3133 OPC_CheckPredicate, 47, // 3927: check predicate 47
3134 OPC_CheckField, 15, 1, 1, // 3929: check Inst[15] == 0x1
3135 OPC_Decode, 229, 120, 38, // 3933: decode to PNSRL_HS using decoder 38
3136 // 3933: }
3137 // 3933: } // switch Inst[25]
3138 // 3933: }
3139 3, 14, // 3937: case 0x3: {
3140 OPC_CheckPredicate, 47, // 3939: check predicate 47
3141 OPC_CheckField, 25, 1, 1, // 3941: check Inst[25] == 0x1
3142 OPC_CheckField, 15, 1, 1, // 3945: check Inst[15] == 0x1
3143 OPC_Decode, 204, 118, 38, // 3949: decode to NSRL using decoder 38
3144 // 3949: }
3145 6, 14, // 3953: case 0x6: {
3146 OPC_CheckPredicate, 47, // 3955: check predicate 47
3147 OPC_CheckField, 25, 1, 0, // 3957: check Inst[25] == 0x0
3148 OPC_CheckField, 15, 1, 0, // 3961: check Inst[15] == 0x0
3149 OPC_Decode, 128, 121, 38, // 3965: decode to PREDSUM_DHS using decoder 38
3150 // 3965: }
3151 7, 14, // 3969: case 0x7: {
3152 OPC_CheckPredicate, 47, // 3971: check predicate 47
3153 OPC_CheckField, 25, 1, 0, // 3973: check Inst[25] == 0x0
3154 OPC_CheckField, 15, 1, 0, // 3977: check Inst[15] == 0x0
3155 OPC_Decode, 255, 120, 38, // 3981: decode to PREDSUM_DBS using decoder 38
3156 // 3981: }
3157 8, 31, // 3985: case 0x8: {
3158 OPC_SwitchField, 25, 1, // 3987: switch Inst[25] {
3159 0, 14, // 3990: case 0x0: {
3160 OPC_CheckPredicate, 47, // 3992: check predicate 47
3161 OPC_CheckField, 24, 1, 1, // 3994: check Inst[24] == 0x1
3162 OPC_CheckField, 15, 1, 1, // 3998: check Inst[15] == 0x1
3163 OPC_Decode, 196, 120, 35, // 4002: decode to PNCLIPIU_B using decoder 35
3164 // 4002: }
3165 1, 0, // 4006: case 0x1: {
3166 OPC_CheckPredicate, 47, // 4008: check predicate 47
3167 OPC_CheckField, 15, 1, 1, // 4010: check Inst[15] == 0x1
3168 OPC_Decode, 197, 120, 36, // 4014: decode to PNCLIPIU_H using decoder 36
3169 // 4014: }
3170 // 4014: } // switch Inst[25]
3171 // 4014: }
3172 9, 10, // 4018: case 0x9: {
3173 OPC_CheckPredicate, 47, // 4020: check predicate 47
3174 OPC_CheckField, 15, 1, 1, // 4022: check Inst[15] == 0x1
3175 OPC_Decode, 147, 118, 37, // 4026: decode to NCLIPIU using decoder 37
3176 // 4026: }
3177 10, 27, // 4030: case 0xa: {
3178 OPC_SwitchField, 25, 1, // 4032: switch Inst[25] {
3179 0, 10, // 4035: case 0x0: {
3180 OPC_CheckPredicate, 47, // 4037: check predicate 47
3181 OPC_CheckField, 15, 1, 1, // 4039: check Inst[15] == 0x1
3182 OPC_Decode, 214, 120, 38, // 4043: decode to PNCLIPU_BS using decoder 38
3183 // 4043: }
3184 1, 0, // 4047: case 0x1: {
3185 OPC_CheckPredicate, 47, // 4049: check predicate 47
3186 OPC_CheckField, 15, 1, 1, // 4051: check Inst[15] == 0x1
3187 OPC_Decode, 215, 120, 38, // 4055: decode to PNCLIPU_HS using decoder 38
3188 // 4055: }
3189 // 4055: } // switch Inst[25]
3190 // 4055: }
3191 11, 14, // 4059: case 0xb: {
3192 OPC_CheckPredicate, 47, // 4061: check predicate 47
3193 OPC_CheckField, 25, 1, 1, // 4063: check Inst[25] == 0x1
3194 OPC_CheckField, 15, 1, 1, // 4067: check Inst[15] == 0x1
3195 OPC_Decode, 152, 118, 38, // 4071: decode to NCLIPU using decoder 38
3196 // 4071: }
3197 12, 31, // 4075: case 0xc: {
3198 OPC_SwitchField, 25, 1, // 4077: switch Inst[25] {
3199 0, 14, // 4080: case 0x0: {
3200 OPC_CheckPredicate, 47, // 4082: check predicate 47
3201 OPC_CheckField, 24, 1, 1, // 4084: check Inst[24] == 0x1
3202 OPC_CheckField, 15, 1, 1, // 4088: check Inst[15] == 0x1
3203 OPC_Decode, 203, 120, 35, // 4092: decode to PNCLIPRIU_B using decoder 35
3204 // 4092: }
3205 1, 0, // 4096: case 0x1: {
3206 OPC_CheckPredicate, 47, // 4098: check predicate 47
3207 OPC_CheckField, 15, 1, 1, // 4100: check Inst[15] == 0x1
3208 OPC_Decode, 204, 120, 36, // 4104: decode to PNCLIPRIU_H using decoder 36
3209 // 4104: }
3210 // 4104: } // switch Inst[25]
3211 // 4104: }
3212 13, 10, // 4108: case 0xd: {
3213 OPC_CheckPredicate, 47, // 4110: check predicate 47
3214 OPC_CheckField, 15, 1, 1, // 4112: check Inst[15] == 0x1
3215 OPC_Decode, 150, 118, 37, // 4116: decode to NCLIPRIU using decoder 37
3216 // 4116: }
3217 14, 36, // 4120: case 0xe: {
3218 OPC_SwitchField, 15, 1, // 4122: switch Inst[15] {
3219 0, 10, // 4125: case 0x0: {
3220 OPC_CheckPredicate, 47, // 4127: check predicate 47
3221 OPC_CheckField, 25, 1, 0, // 4129: check Inst[25] == 0x0
3222 OPC_Decode, 251, 120, 38, // 4133: decode to PREDSUMU_DHS using decoder 38
3223 // 4133: }
3224 1, 0, // 4137: case 0x1: {
3225 OPC_SwitchField, 25, 1, // 4139: switch Inst[25] {
3226 0, 6, // 4142: case 0x0: {
3227 OPC_CheckPredicate, 47, // 4144: check predicate 47
3228 OPC_Decode, 207, 120, 38, // 4146: decode to PNCLIPRU_BS using decoder 38
3229 // 4146: }
3230 1, 0, // 4150: case 0x1: {
3231 OPC_CheckPredicate, 47, // 4152: check predicate 47
3232 OPC_Decode, 208, 120, 38, // 4154: decode to PNCLIPRU_HS using decoder 38
3233 // 4154: }
3234 // 4154: } // switch Inst[25]
3235 // 4154: }
3236 // 4154: } // switch Inst[15]
3237 // 4154: }
3238 15, 27, // 4158: case 0xf: {
3239 OPC_SwitchField, 15, 1, // 4160: switch Inst[15] {
3240 0, 10, // 4163: case 0x0: {
3241 OPC_CheckPredicate, 47, // 4165: check predicate 47
3242 OPC_CheckField, 25, 1, 0, // 4167: check Inst[25] == 0x0
3243 OPC_Decode, 250, 120, 38, // 4171: decode to PREDSUMU_DBS using decoder 38
3244 // 4171: }
3245 1, 0, // 4175: case 0x1: {
3246 OPC_CheckPredicate, 47, // 4177: check predicate 47
3247 OPC_CheckField, 25, 1, 1, // 4179: check Inst[25] == 0x1
3248 OPC_Decode, 151, 118, 38, // 4183: decode to NCLIPRU using decoder 38
3249 // 4183: }
3250 // 4183: } // switch Inst[15]
3251 // 4183: }
3252 16, 31, // 4187: case 0x10: {
3253 OPC_SwitchField, 25, 1, // 4189: switch Inst[25] {
3254 0, 14, // 4192: case 0x0: {
3255 OPC_CheckPredicate, 47, // 4194: check predicate 47
3256 OPC_CheckField, 24, 1, 1, // 4196: check Inst[24] == 0x1
3257 OPC_CheckField, 15, 1, 1, // 4200: check Inst[15] == 0x1
3258 OPC_Decode, 218, 120, 35, // 4204: decode to PNSRAI_B using decoder 35
3259 // 4204: }
3260 1, 0, // 4208: case 0x1: {
3261 OPC_CheckPredicate, 47, // 4210: check predicate 47
3262 OPC_CheckField, 15, 1, 1, // 4212: check Inst[15] == 0x1
3263 OPC_Decode, 219, 120, 36, // 4216: decode to PNSRAI_H using decoder 36
3264 // 4216: }
3265 // 4216: } // switch Inst[25]
3266 // 4216: }
3267 17, 10, // 4220: case 0x11: {
3268 OPC_CheckPredicate, 47, // 4222: check predicate 47
3269 OPC_CheckField, 15, 1, 1, // 4224: check Inst[15] == 0x1
3270 OPC_Decode, 201, 118, 37, // 4228: decode to NSRAI using decoder 37
3271 // 4228: }
3272 18, 27, // 4232: case 0x12: {
3273 OPC_SwitchField, 25, 1, // 4234: switch Inst[25] {
3274 0, 10, // 4237: case 0x0: {
3275 OPC_CheckPredicate, 47, // 4239: check predicate 47
3276 OPC_CheckField, 15, 1, 1, // 4241: check Inst[15] == 0x1
3277 OPC_Decode, 224, 120, 38, // 4245: decode to PNSRA_BS using decoder 38
3278 // 4245: }
3279 1, 0, // 4249: case 0x1: {
3280 OPC_CheckPredicate, 47, // 4251: check predicate 47
3281 OPC_CheckField, 15, 1, 1, // 4253: check Inst[15] == 0x1
3282 OPC_Decode, 225, 120, 38, // 4257: decode to PNSRA_HS using decoder 38
3283 // 4257: }
3284 // 4257: } // switch Inst[25]
3285 // 4257: }
3286 19, 14, // 4261: case 0x13: {
3287 OPC_CheckPredicate, 47, // 4263: check predicate 47
3288 OPC_CheckField, 25, 1, 1, // 4265: check Inst[25] == 0x1
3289 OPC_CheckField, 15, 1, 1, // 4269: check Inst[15] == 0x1
3290 OPC_Decode, 200, 118, 38, // 4273: decode to NSRA using decoder 38
3291 // 4273: }
3292 20, 31, // 4277: case 0x14: {
3293 OPC_SwitchField, 25, 1, // 4279: switch Inst[25] {
3294 0, 14, // 4282: case 0x0: {
3295 OPC_CheckPredicate, 47, // 4284: check predicate 47
3296 OPC_CheckField, 24, 1, 1, // 4286: check Inst[24] == 0x1
3297 OPC_CheckField, 15, 1, 1, // 4290: check Inst[15] == 0x1
3298 OPC_Decode, 220, 120, 35, // 4294: decode to PNSRARI_B using decoder 35
3299 // 4294: }
3300 1, 0, // 4298: case 0x1: {
3301 OPC_CheckPredicate, 47, // 4300: check predicate 47
3302 OPC_CheckField, 15, 1, 1, // 4302: check Inst[15] == 0x1
3303 OPC_Decode, 221, 120, 36, // 4306: decode to PNSRARI_H using decoder 36
3304 // 4306: }
3305 // 4306: } // switch Inst[25]
3306 // 4306: }
3307 21, 10, // 4310: case 0x15: {
3308 OPC_CheckPredicate, 47, // 4312: check predicate 47
3309 OPC_CheckField, 15, 1, 1, // 4314: check Inst[15] == 0x1
3310 OPC_Decode, 203, 118, 37, // 4318: decode to NSRARI using decoder 37
3311 // 4318: }
3312 22, 27, // 4322: case 0x16: {
3313 OPC_SwitchField, 25, 1, // 4324: switch Inst[25] {
3314 0, 10, // 4327: case 0x0: {
3315 OPC_CheckPredicate, 47, // 4329: check predicate 47
3316 OPC_CheckField, 15, 1, 1, // 4331: check Inst[15] == 0x1
3317 OPC_Decode, 222, 120, 38, // 4335: decode to PNSRAR_BS using decoder 38
3318 // 4335: }
3319 1, 0, // 4339: case 0x1: {
3320 OPC_CheckPredicate, 47, // 4341: check predicate 47
3321 OPC_CheckField, 15, 1, 1, // 4343: check Inst[15] == 0x1
3322 OPC_Decode, 223, 120, 38, // 4347: decode to PNSRAR_HS using decoder 38
3323 // 4347: }
3324 // 4347: } // switch Inst[25]
3325 // 4347: }
3326 23, 14, // 4351: case 0x17: {
3327 OPC_CheckPredicate, 47, // 4353: check predicate 47
3328 OPC_CheckField, 25, 1, 1, // 4355: check Inst[25] == 0x1
3329 OPC_CheckField, 15, 1, 1, // 4359: check Inst[15] == 0x1
3330 OPC_Decode, 202, 118, 38, // 4363: decode to NSRAR using decoder 38
3331 // 4363: }
3332 24, 31, // 4367: case 0x18: {
3333 OPC_SwitchField, 25, 1, // 4369: switch Inst[25] {
3334 0, 14, // 4372: case 0x0: {
3335 OPC_CheckPredicate, 47, // 4374: check predicate 47
3336 OPC_CheckField, 24, 1, 1, // 4376: check Inst[24] == 0x1
3337 OPC_CheckField, 15, 1, 1, // 4380: check Inst[15] == 0x1
3338 OPC_Decode, 198, 120, 35, // 4384: decode to PNCLIPI_B using decoder 35
3339 // 4384: }
3340 1, 0, // 4388: case 0x1: {
3341 OPC_CheckPredicate, 47, // 4390: check predicate 47
3342 OPC_CheckField, 15, 1, 1, // 4392: check Inst[15] == 0x1
3343 OPC_Decode, 199, 120, 36, // 4396: decode to PNCLIPI_H using decoder 36
3344 // 4396: }
3345 // 4396: } // switch Inst[25]
3346 // 4396: }
3347 25, 10, // 4400: case 0x19: {
3348 OPC_CheckPredicate, 47, // 4402: check predicate 47
3349 OPC_CheckField, 15, 1, 1, // 4404: check Inst[15] == 0x1
3350 OPC_Decode, 146, 118, 37, // 4408: decode to NCLIPI using decoder 37
3351 // 4408: }
3352 26, 27, // 4412: case 0x1a: {
3353 OPC_SwitchField, 25, 1, // 4414: switch Inst[25] {
3354 0, 10, // 4417: case 0x0: {
3355 OPC_CheckPredicate, 47, // 4419: check predicate 47
3356 OPC_CheckField, 15, 1, 1, // 4421: check Inst[15] == 0x1
3357 OPC_Decode, 216, 120, 38, // 4425: decode to PNCLIP_BS using decoder 38
3358 // 4425: }
3359 1, 0, // 4429: case 0x1: {
3360 OPC_CheckPredicate, 47, // 4431: check predicate 47
3361 OPC_CheckField, 15, 1, 1, // 4433: check Inst[15] == 0x1
3362 OPC_Decode, 217, 120, 38, // 4437: decode to PNCLIP_HS using decoder 38
3363 // 4437: }
3364 // 4437: } // switch Inst[25]
3365 // 4437: }
3366 27, 14, // 4441: case 0x1b: {
3367 OPC_CheckPredicate, 47, // 4443: check predicate 47
3368 OPC_CheckField, 25, 1, 1, // 4445: check Inst[25] == 0x1
3369 OPC_CheckField, 15, 1, 1, // 4449: check Inst[15] == 0x1
3370 OPC_Decode, 145, 118, 38, // 4453: decode to NCLIP using decoder 38
3371 // 4453: }
3372 28, 31, // 4457: case 0x1c: {
3373 OPC_SwitchField, 25, 1, // 4459: switch Inst[25] {
3374 0, 14, // 4462: case 0x0: {
3375 OPC_CheckPredicate, 47, // 4464: check predicate 47
3376 OPC_CheckField, 24, 1, 1, // 4466: check Inst[24] == 0x1
3377 OPC_CheckField, 15, 1, 1, // 4470: check Inst[15] == 0x1
3378 OPC_Decode, 205, 120, 35, // 4474: decode to PNCLIPRI_B using decoder 35
3379 // 4474: }
3380 1, 0, // 4478: case 0x1: {
3381 OPC_CheckPredicate, 47, // 4480: check predicate 47
3382 OPC_CheckField, 15, 1, 1, // 4482: check Inst[15] == 0x1
3383 OPC_Decode, 206, 120, 36, // 4486: decode to PNCLIPRI_H using decoder 36
3384 // 4486: }
3385 // 4486: } // switch Inst[25]
3386 // 4486: }
3387 29, 10, // 4490: case 0x1d: {
3388 OPC_CheckPredicate, 47, // 4492: check predicate 47
3389 OPC_CheckField, 15, 1, 1, // 4494: check Inst[15] == 0x1
3390 OPC_Decode, 149, 118, 37, // 4498: decode to NCLIPRI using decoder 37
3391 // 4498: }
3392 30, 27, // 4502: case 0x1e: {
3393 OPC_SwitchField, 25, 1, // 4504: switch Inst[25] {
3394 0, 10, // 4507: case 0x0: {
3395 OPC_CheckPredicate, 47, // 4509: check predicate 47
3396 OPC_CheckField, 15, 1, 1, // 4511: check Inst[15] == 0x1
3397 OPC_Decode, 209, 120, 38, // 4515: decode to PNCLIPR_BS using decoder 38
3398 // 4515: }
3399 1, 0, // 4519: case 0x1: {
3400 OPC_CheckPredicate, 47, // 4521: check predicate 47
3401 OPC_CheckField, 15, 1, 1, // 4523: check Inst[15] == 0x1
3402 OPC_Decode, 210, 120, 38, // 4527: decode to PNCLIPR_HS using decoder 38
3403 // 4527: }
3404 // 4527: } // switch Inst[25]
3405 // 4527: }
3406 31, 14, // 4531: case 0x1f: {
3407 OPC_CheckPredicate, 47, // 4533: check predicate 47
3408 OPC_CheckField, 25, 1, 1, // 4535: check Inst[25] == 0x1
3409 OPC_CheckField, 15, 1, 1, // 4539: check Inst[15] == 0x1
3410 OPC_Decode, 148, 118, 38, // 4543: decode to NCLIPR using decoder 38
3411 // 4543: }
3412 32, 36, // 4547: case 0x20: {
3413 OPC_SwitchField, 25, 1, // 4549: switch Inst[25] {
3414 0, 23, // 4552: case 0x0: {
3415 OPC_SwitchField, 24, 1, // 4554: switch Inst[24] {
3416 0, 10, // 4557: case 0x0: {
3417 OPC_CheckPredicate, 43, // 4559: check predicate 43
3418 OPC_CheckField, 23, 1, 1, // 4561: check Inst[23] == 0x1
3419 OPC_Decode, 198, 121, 30, // 4565: decode to PSRLI_B using decoder 30
3420 // 4565: }
3421 1, 0, // 4569: case 0x1: {
3422 OPC_CheckPredicate, 43, // 4571: check predicate 43
3423 OPC_Decode, 202, 121, 18, // 4573: decode to PSRLI_H using decoder 18
3424 // 4573: }
3425 // 4573: } // switch Inst[24]
3426 // 4573: }
3427 1, 0, // 4577: case 0x1: {
3428 OPC_CheckPredicate, 48, // 4579: check predicate 48
3429 OPC_Decode, 203, 121, 21, // 4581: decode to PSRLI_W using decoder 21
3430 // 4581: }
3431 // 4581: } // switch Inst[25]
3432 // 4581: }
3433 34, 19, // 4585: case 0x22: {
3434 OPC_SwitchField, 25, 1, // 4587: switch Inst[25] {
3435 0, 6, // 4590: case 0x0: {
3436 OPC_CheckPredicate, 43, // 4592: check predicate 43
3437 OPC_Decode, 208, 121, 31, // 4594: decode to PSRL_HS using decoder 31
3438 // 4594: }
3439 1, 0, // 4598: case 0x1: {
3440 OPC_CheckPredicate, 48, // 4600: check predicate 48
3441 OPC_Decode, 209, 121, 31, // 4602: decode to PSRL_WS using decoder 31
3442 // 4602: }
3443 // 4602: } // switch Inst[25]
3444 // 4602: }
3445 35, 10, // 4606: case 0x23: {
3446 OPC_CheckPredicate, 43, // 4608: check predicate 43
3447 OPC_CheckField, 25, 1, 0, // 4610: check Inst[25] == 0x0
3448 OPC_Decode, 204, 121, 31, // 4614: decode to PSRL_BS using decoder 31
3449 // 4614: }
3450 38, 19, // 4618: case 0x26: {
3451 OPC_SwitchField, 25, 1, // 4620: switch Inst[25] {
3452 0, 6, // 4623: case 0x0: {
3453 OPC_CheckPredicate, 43, // 4625: check predicate 43
3454 OPC_Decode, 129, 121, 31, // 4627: decode to PREDSUM_HS using decoder 31
3455 // 4627: }
3456 1, 0, // 4631: case 0x1: {
3457 OPC_CheckPredicate, 48, // 4633: check predicate 48
3458 OPC_Decode, 130, 121, 31, // 4635: decode to PREDSUM_WS using decoder 31
3459 // 4635: }
3460 // 4635: } // switch Inst[25]
3461 // 4635: }
3462 39, 10, // 4639: case 0x27: {
3463 OPC_CheckPredicate, 43, // 4641: check predicate 43
3464 OPC_CheckField, 25, 1, 0, // 4643: check Inst[25] == 0x0
3465 OPC_Decode, 254, 120, 31, // 4647: decode to PREDSUM_BS using decoder 31
3466 // 4647: }
3467 40, 23, // 4651: case 0x28: {
3468 OPC_SwitchField, 25, 1, // 4653: switch Inst[25] {
3469 0, 10, // 4656: case 0x0: {
3470 OPC_CheckPredicate, 43, // 4658: check predicate 43
3471 OPC_CheckField, 24, 1, 1, // 4660: check Inst[24] == 0x1
3472 OPC_Decode, 129, 122, 18, // 4664: decode to PUSATI_H using decoder 18
3473 // 4664: }
3474 1, 0, // 4668: case 0x1: {
3475 OPC_CheckPredicate, 48, // 4670: check predicate 48
3476 OPC_Decode, 130, 122, 21, // 4672: decode to PUSATI_W using decoder 21
3477 // 4672: }
3478 // 4672: } // switch Inst[25]
3479 // 4672: }
3480 41, 6, // 4676: case 0x29: {
3481 OPC_CheckPredicate, 48, // 4678: check predicate 48
3482 OPC_Decode, 141, 126, 39, // 4680: decode to USATI_RV64 using decoder 39
3483 // 4680: }
3484 46, 19, // 4684: case 0x2e: {
3485 OPC_SwitchField, 25, 1, // 4686: switch Inst[25] {
3486 0, 6, // 4689: case 0x0: {
3487 OPC_CheckPredicate, 43, // 4691: check predicate 43
3488 OPC_Decode, 252, 120, 31, // 4693: decode to PREDSUMU_HS using decoder 31
3489 // 4693: }
3490 1, 0, // 4697: case 0x1: {
3491 OPC_CheckPredicate, 48, // 4699: check predicate 48
3492 OPC_Decode, 253, 120, 31, // 4701: decode to PREDSUMU_WS using decoder 31
3493 // 4701: }
3494 // 4701: } // switch Inst[25]
3495 // 4701: }
3496 47, 10, // 4705: case 0x2f: {
3497 OPC_CheckPredicate, 43, // 4707: check predicate 43
3498 OPC_CheckField, 25, 1, 0, // 4709: check Inst[25] == 0x0
3499 OPC_Decode, 249, 120, 31, // 4713: decode to PREDSUMU_BS using decoder 31
3500 // 4713: }
3501 48, 36, // 4717: case 0x30: {
3502 OPC_SwitchField, 25, 1, // 4719: switch Inst[25] {
3503 0, 23, // 4722: case 0x0: {
3504 OPC_SwitchField, 24, 1, // 4724: switch Inst[24] {
3505 0, 10, // 4727: case 0x0: {
3506 OPC_CheckPredicate, 43, // 4729: check predicate 43
3507 OPC_CheckField, 23, 1, 1, // 4731: check Inst[23] == 0x1
3508 OPC_Decode, 182, 121, 30, // 4735: decode to PSRAI_B using decoder 30
3509 // 4735: }
3510 1, 0, // 4739: case 0x1: {
3511 OPC_CheckPredicate, 43, // 4741: check predicate 43
3512 OPC_Decode, 186, 121, 18, // 4743: decode to PSRAI_H using decoder 18
3513 // 4743: }
3514 // 4743: } // switch Inst[24]
3515 // 4743: }
3516 1, 0, // 4747: case 0x1: {
3517 OPC_CheckPredicate, 48, // 4749: check predicate 48
3518 OPC_Decode, 187, 121, 21, // 4751: decode to PSRAI_W using decoder 21
3519 // 4751: }
3520 // 4751: } // switch Inst[25]
3521 // 4751: }
3522 50, 19, // 4755: case 0x32: {
3523 OPC_SwitchField, 25, 1, // 4757: switch Inst[25] {
3524 0, 6, // 4760: case 0x0: {
3525 OPC_CheckPredicate, 43, // 4762: check predicate 43
3526 OPC_Decode, 196, 121, 31, // 4764: decode to PSRA_HS using decoder 31
3527 // 4764: }
3528 1, 0, // 4768: case 0x1: {
3529 OPC_CheckPredicate, 48, // 4770: check predicate 48
3530 OPC_Decode, 197, 121, 31, // 4772: decode to PSRA_WS using decoder 31
3531 // 4772: }
3532 // 4772: } // switch Inst[25]
3533 // 4772: }
3534 51, 10, // 4776: case 0x33: {
3535 OPC_CheckPredicate, 43, // 4778: check predicate 43
3536 OPC_CheckField, 25, 1, 0, // 4780: check Inst[25] == 0x0
3537 OPC_Decode, 192, 121, 31, // 4784: decode to PSRA_BS using decoder 31
3538 // 4784: }
3539 52, 23, // 4788: case 0x34: {
3540 OPC_SwitchField, 25, 1, // 4790: switch Inst[25] {
3541 0, 10, // 4793: case 0x0: {
3542 OPC_CheckPredicate, 43, // 4795: check predicate 43
3543 OPC_CheckField, 24, 1, 1, // 4797: check Inst[24] == 0x1
3544 OPC_Decode, 190, 121, 18, // 4801: decode to PSRARI_H using decoder 18
3545 // 4801: }
3546 1, 0, // 4805: case 0x1: {
3547 OPC_CheckPredicate, 48, // 4807: check predicate 48
3548 OPC_Decode, 191, 121, 21, // 4809: decode to PSRARI_W using decoder 21
3549 // 4809: }
3550 // 4809: } // switch Inst[25]
3551 // 4809: }
3552 53, 6, // 4813: case 0x35: {
3553 OPC_CheckPredicate, 48, // 4815: check predicate 48
3554 OPC_Decode, 247, 124, 39, // 4817: decode to SRARI_RV64 using decoder 39
3555 // 4817: }
3556 56, 23, // 4821: case 0x38: {
3557 OPC_SwitchField, 25, 1, // 4823: switch Inst[25] {
3558 0, 10, // 4826: case 0x0: {
3559 OPC_CheckPredicate, 43, // 4828: check predicate 43
3560 OPC_CheckField, 24, 1, 1, // 4830: check Inst[24] == 0x1
3561 OPC_Decode, 155, 121, 40, // 4834: decode to PSATI_H using decoder 40
3562 // 4834: }
3563 1, 0, // 4838: case 0x1: {
3564 OPC_CheckPredicate, 48, // 4840: check predicate 48
3565 OPC_Decode, 156, 121, 41, // 4842: decode to PSATI_W using decoder 41
3566 // 4842: }
3567 // 4842: } // switch Inst[25]
3568 // 4842: }
3569 57, 0, // 4846: case 0x39: {
3570 OPC_CheckPredicate, 48, // 4848: check predicate 48
3571 OPC_Decode, 219, 123, 42, // 4850: decode to SATI_RV64 using decoder 42
3572 // 4850: }
3573 // 4850: } // switch Inst[31:26]
3574 // 4850: }
3575 5, 27, // 4854: case 0x5: {
3576 OPC_SwitchField, 25, 7, // 4856: switch Inst[31:25] {
3577 0, 6, // 4859: case 0x0: {
3578 OPC_CheckPredicate, 22, // 4861: check predicate 22
3579 OPC_Decode, 252, 124, 21, // 4863: decode to SRLIW using decoder 21
3580 // 4863: }
3581 32, 6, // 4867: case 0x20: {
3582 OPC_CheckPredicate, 22, // 4869: check predicate 22
3583 OPC_Decode, 245, 124, 21, // 4871: decode to SRAIW using decoder 21
3584 // 4871: }
3585 48, 0, // 4875: case 0x30: {
3586 OPC_CheckPredicate, 49, // 4877: check predicate 49
3587 OPC_Decode, 214, 123, 21, // 4879: decode to RORIW using decoder 21
3588 // 4879: }
3589 // 4879: } // switch Inst[31:25]
3590 // 4879: }
3591 6, 0, // 4883: case 0x6: {
3592 OPC_SwitchField, 25, 7, // 4885: switch Inst[31:25] {
3593 0, 69, // 4888: case 0x0: {
3594 OPC_SwitchField, 15, 1, // 4890: switch Inst[15] {
3595 0, 31, // 4893: case 0x0: {
3596 OPC_SwitchField, 24, 1, // 4895: switch Inst[24] {
3597 0, 14, // 4898: case 0x0: {
3598 OPC_CheckPredicate, 47, // 4900: check predicate 47
3599 OPC_CheckField, 23, 1, 1, // 4902: check Inst[23] == 0x1
3600 OPC_CheckField, 7, 1, 0, // 4906: check Inst[7] == 0x0
3601 OPC_Decode, 171, 121, 43, // 4910: decode to PSLLI_DB using decoder 43
3602 // 4910: }
3603 1, 0, // 4914: case 0x1: {
3604 OPC_CheckPredicate, 47, // 4916: check predicate 47
3605 OPC_CheckField, 7, 1, 0, // 4918: check Inst[7] == 0x0
3606 OPC_Decode, 172, 121, 44, // 4922: decode to PSLLI_DH using decoder 44
3607 // 4922: }
3608 // 4922: } // switch Inst[24]
3609 // 4922: }
3610 1, 0, // 4926: case 0x1: {
3611 OPC_SwitchField, 24, 1, // 4928: switch Inst[24] {
3612 0, 14, // 4931: case 0x0: {
3613 OPC_CheckPredicate, 47, // 4933: check predicate 47
3614 OPC_CheckField, 23, 1, 1, // 4935: check Inst[23] == 0x1
3615 OPC_CheckField, 7, 1, 0, // 4939: check Inst[7] == 0x0
3616 OPC_Decode, 199, 121, 43, // 4943: decode to PSRLI_DB using decoder 43
3617 // 4943: }
3618 1, 0, // 4947: case 0x1: {
3619 OPC_CheckPredicate, 47, // 4949: check predicate 47
3620 OPC_CheckField, 7, 1, 0, // 4951: check Inst[7] == 0x0
3621 OPC_Decode, 200, 121, 44, // 4955: decode to PSRLI_DH using decoder 44
3622 // 4955: }
3623 // 4955: } // switch Inst[24]
3624 // 4955: }
3625 // 4955: } // switch Inst[15]
3626 // 4955: }
3627 1, 27, // 4959: case 0x1: {
3628 OPC_SwitchField, 15, 1, // 4961: switch Inst[15] {
3629 0, 10, // 4964: case 0x0: {
3630 OPC_CheckPredicate, 47, // 4966: check predicate 47
3631 OPC_CheckField, 7, 1, 0, // 4968: check Inst[7] == 0x0
3632 OPC_Decode, 173, 121, 45, // 4972: decode to PSLLI_DW using decoder 45
3633 // 4972: }
3634 1, 0, // 4976: case 0x1: {
3635 OPC_CheckPredicate, 47, // 4978: check predicate 47
3636 OPC_CheckField, 7, 1, 0, // 4980: check Inst[7] == 0x0
3637 OPC_Decode, 201, 121, 45, // 4984: decode to PSRLI_DW using decoder 45
3638 // 4984: }
3639 // 4984: } // switch Inst[15]
3640 // 4984: }
3641 4, 27, // 4988: case 0x4: {
3642 OPC_SwitchField, 15, 1, // 4990: switch Inst[15] {
3643 0, 10, // 4993: case 0x0: {
3644 OPC_CheckPredicate, 47, // 4995: check predicate 47
3645 OPC_CheckField, 7, 1, 0, // 4997: check Inst[7] == 0x0
3646 OPC_Decode, 178, 121, 46, // 5001: decode to PSLL_DHS using decoder 46
3647 // 5001: }
3648 1, 0, // 5005: case 0x1: {
3649 OPC_CheckPredicate, 47, // 5007: check predicate 47
3650 OPC_CheckField, 7, 1, 0, // 5009: check Inst[7] == 0x0
3651 OPC_Decode, 206, 121, 46, // 5013: decode to PSRL_DHS using decoder 46
3652 // 5013: }
3653 // 5013: } // switch Inst[15]
3654 // 5013: }
3655 5, 27, // 5017: case 0x5: {
3656 OPC_SwitchField, 15, 1, // 5019: switch Inst[15] {
3657 0, 10, // 5022: case 0x0: {
3658 OPC_CheckPredicate, 47, // 5024: check predicate 47
3659 OPC_CheckField, 7, 1, 0, // 5026: check Inst[7] == 0x0
3660 OPC_Decode, 179, 121, 46, // 5030: decode to PSLL_DWS using decoder 46
3661 // 5030: }
3662 1, 0, // 5034: case 0x1: {
3663 OPC_CheckPredicate, 47, // 5036: check predicate 47
3664 OPC_CheckField, 7, 1, 0, // 5038: check Inst[7] == 0x0
3665 OPC_Decode, 207, 121, 46, // 5042: decode to PSRL_DWS using decoder 46
3666 // 5042: }
3667 // 5042: } // switch Inst[15]
3668 // 5042: }
3669 6, 27, // 5046: case 0x6: {
3670 OPC_SwitchField, 15, 1, // 5048: switch Inst[15] {
3671 0, 10, // 5051: case 0x0: {
3672 OPC_CheckPredicate, 47, // 5053: check predicate 47
3673 OPC_CheckField, 7, 1, 0, // 5055: check Inst[7] == 0x0
3674 OPC_Decode, 177, 121, 46, // 5059: decode to PSLL_DBS using decoder 46
3675 // 5059: }
3676 1, 0, // 5063: case 0x1: {
3677 OPC_CheckPredicate, 47, // 5065: check predicate 47
3678 OPC_CheckField, 7, 1, 0, // 5067: check Inst[7] == 0x0
3679 OPC_Decode, 205, 121, 46, // 5071: decode to PSRL_DBS using decoder 46
3680 // 5071: }
3681 // 5071: } // switch Inst[15]
3682 // 5071: }
3683 12, 14, // 5075: case 0xc: {
3684 OPC_CheckPredicate, 47, // 5077: check predicate 47
3685 OPC_CheckField, 15, 1, 0, // 5079: check Inst[15] == 0x0
3686 OPC_CheckField, 7, 1, 0, // 5083: check Inst[7] == 0x0
3687 OPC_Decode, 243, 118, 46, // 5087: decode to PADD_DHS using decoder 46
3688 // 5087: }
3689 13, 14, // 5091: case 0xd: {
3690 OPC_CheckPredicate, 47, // 5093: check predicate 47
3691 OPC_CheckField, 15, 1, 0, // 5095: check Inst[15] == 0x0
3692 OPC_CheckField, 7, 1, 0, // 5099: check Inst[7] == 0x0
3693 OPC_Decode, 245, 118, 46, // 5103: decode to PADD_DWS using decoder 46
3694 // 5103: }
3695 14, 14, // 5107: case 0xe: {
3696 OPC_CheckPredicate, 47, // 5109: check predicate 47
3697 OPC_CheckField, 15, 1, 0, // 5111: check Inst[15] == 0x0
3698 OPC_CheckField, 7, 1, 0, // 5115: check Inst[7] == 0x0
3699 OPC_Decode, 241, 118, 46, // 5119: decode to PADD_DBS using decoder 46
3700 // 5119: }
3701 16, 18, // 5123: case 0x10: {
3702 OPC_CheckPredicate, 47, // 5125: check predicate 47
3703 OPC_CheckField, 24, 1, 1, // 5127: check Inst[24] == 0x1
3704 OPC_CheckField, 15, 1, 1, // 5131: check Inst[15] == 0x1
3705 OPC_CheckField, 7, 1, 0, // 5135: check Inst[7] == 0x0
3706 OPC_Decode, 255, 121, 44, // 5139: decode to PUSATI_DH using decoder 44
3707 // 5139: }
3708 17, 14, // 5143: case 0x11: {
3709 OPC_CheckPredicate, 47, // 5145: check predicate 47
3710 OPC_CheckField, 15, 1, 1, // 5147: check Inst[15] == 0x1
3711 OPC_CheckField, 7, 1, 0, // 5151: check Inst[7] == 0x0
3712 OPC_Decode, 128, 122, 45, // 5155: decode to PUSATI_DW using decoder 45
3713 // 5155: }
3714 20, 14, // 5159: case 0x14: {
3715 OPC_CheckPredicate, 47, // 5161: check predicate 47
3716 OPC_CheckField, 15, 1, 0, // 5163: check Inst[15] == 0x0
3717 OPC_CheckField, 7, 1, 0, // 5167: check Inst[7] == 0x0
3718 OPC_Decode, 229, 121, 46, // 5171: decode to PSSHL_DHS using decoder 46
3719 // 5171: }
3720 21, 14, // 5175: case 0x15: {
3721 OPC_CheckPredicate, 47, // 5177: check predicate 47
3722 OPC_CheckField, 15, 1, 0, // 5179: check Inst[15] == 0x0
3723 OPC_CheckField, 7, 1, 0, // 5183: check Inst[7] == 0x0
3724 OPC_Decode, 230, 121, 46, // 5187: decode to PSSHL_DWS using decoder 46
3725 // 5187: }
3726 28, 14, // 5191: case 0x1c: {
3727 OPC_CheckPredicate, 47, // 5193: check predicate 47
3728 OPC_CheckField, 15, 1, 0, // 5195: check Inst[15] == 0x0
3729 OPC_CheckField, 7, 1, 0, // 5199: check Inst[7] == 0x0
3730 OPC_Decode, 225, 121, 46, // 5203: decode to PSSHLR_DHS using decoder 46
3731 // 5203: }
3732 29, 14, // 5207: case 0x1d: {
3733 OPC_CheckPredicate, 47, // 5209: check predicate 47
3734 OPC_CheckField, 15, 1, 0, // 5211: check Inst[15] == 0x0
3735 OPC_CheckField, 7, 1, 0, // 5215: check Inst[7] == 0x0
3736 OPC_Decode, 226, 121, 46, // 5219: decode to PSSHLR_DWS using decoder 46
3737 // 5219: }
3738 32, 39, // 5223: case 0x20: {
3739 OPC_SwitchField, 24, 1, // 5225: switch Inst[24] {
3740 0, 18, // 5228: case 0x0: {
3741 OPC_CheckPredicate, 47, // 5230: check predicate 47
3742 OPC_CheckField, 23, 1, 1, // 5232: check Inst[23] == 0x1
3743 OPC_CheckField, 15, 1, 1, // 5236: check Inst[15] == 0x1
3744 OPC_CheckField, 7, 1, 0, // 5240: check Inst[7] == 0x0
3745 OPC_Decode, 183, 121, 43, // 5244: decode to PSRAI_DB using decoder 43
3746 // 5244: }
3747 1, 0, // 5248: case 0x1: {
3748 OPC_CheckPredicate, 47, // 5250: check predicate 47
3749 OPC_CheckField, 15, 1, 1, // 5252: check Inst[15] == 0x1
3750 OPC_CheckField, 7, 1, 0, // 5256: check Inst[7] == 0x0
3751 OPC_Decode, 184, 121, 44, // 5260: decode to PSRAI_DH using decoder 44
3752 // 5260: }
3753 // 5260: } // switch Inst[24]
3754 // 5260: }
3755 33, 14, // 5264: case 0x21: {
3756 OPC_CheckPredicate, 47, // 5266: check predicate 47
3757 OPC_CheckField, 15, 1, 1, // 5268: check Inst[15] == 0x1
3758 OPC_CheckField, 7, 1, 0, // 5272: check Inst[7] == 0x0
3759 OPC_Decode, 185, 121, 45, // 5276: decode to PSRAI_DW using decoder 45
3760 // 5276: }
3761 36, 14, // 5280: case 0x24: {
3762 OPC_CheckPredicate, 47, // 5282: check predicate 47
3763 OPC_CheckField, 15, 1, 1, // 5284: check Inst[15] == 0x1
3764 OPC_CheckField, 7, 1, 0, // 5288: check Inst[7] == 0x0
3765 OPC_Decode, 194, 121, 46, // 5292: decode to PSRA_DHS using decoder 46
3766 // 5292: }
3767 37, 14, // 5296: case 0x25: {
3768 OPC_CheckPredicate, 47, // 5298: check predicate 47
3769 OPC_CheckField, 15, 1, 1, // 5300: check Inst[15] == 0x1
3770 OPC_CheckField, 7, 1, 0, // 5304: check Inst[7] == 0x0
3771 OPC_Decode, 195, 121, 46, // 5308: decode to PSRA_DWS using decoder 46
3772 // 5308: }
3773 38, 14, // 5312: case 0x26: {
3774 OPC_CheckPredicate, 47, // 5314: check predicate 47
3775 OPC_CheckField, 15, 1, 1, // 5316: check Inst[15] == 0x1
3776 OPC_CheckField, 7, 1, 0, // 5320: check Inst[7] == 0x0
3777 OPC_Decode, 193, 121, 46, // 5324: decode to PSRA_DBS using decoder 46
3778 // 5324: }
3779 40, 35, // 5328: case 0x28: {
3780 OPC_SwitchField, 15, 1, // 5330: switch Inst[15] {
3781 0, 14, // 5333: case 0x0: {
3782 OPC_CheckPredicate, 47, // 5335: check predicate 47
3783 OPC_CheckField, 24, 1, 1, // 5337: check Inst[24] == 0x1
3784 OPC_CheckField, 7, 1, 0, // 5341: check Inst[7] == 0x0
3785 OPC_Decode, 233, 121, 44, // 5345: decode to PSSLAI_DH using decoder 44
3786 // 5345: }
3787 1, 0, // 5349: case 0x1: {
3788 OPC_CheckPredicate, 47, // 5351: check predicate 47
3789 OPC_CheckField, 24, 1, 1, // 5353: check Inst[24] == 0x1
3790 OPC_CheckField, 7, 1, 0, // 5357: check Inst[7] == 0x0
3791 OPC_Decode, 188, 121, 44, // 5361: decode to PSRARI_DH using decoder 44
3792 // 5361: }
3793 // 5361: } // switch Inst[15]
3794 // 5361: }
3795 41, 27, // 5365: case 0x29: {
3796 OPC_SwitchField, 15, 1, // 5367: switch Inst[15] {
3797 0, 10, // 5370: case 0x0: {
3798 OPC_CheckPredicate, 47, // 5372: check predicate 47
3799 OPC_CheckField, 7, 1, 0, // 5374: check Inst[7] == 0x0
3800 OPC_Decode, 234, 121, 45, // 5378: decode to PSSLAI_DW using decoder 45
3801 // 5378: }
3802 1, 0, // 5382: case 0x1: {
3803 OPC_CheckPredicate, 47, // 5384: check predicate 47
3804 OPC_CheckField, 7, 1, 0, // 5386: check Inst[7] == 0x0
3805 OPC_Decode, 189, 121, 45, // 5390: decode to PSRARI_DW using decoder 45
3806 // 5390: }
3807 // 5390: } // switch Inst[15]
3808 // 5390: }
3809 48, 48, // 5394: case 0x30: {
3810 OPC_SwitchField, 15, 1, // 5396: switch Inst[15] {
3811 0, 27, // 5399: case 0x0: {
3812 OPC_SwitchField, 20, 5, // 5401: switch Inst[24:20] {
3813 4, 10, // 5404: case 0x4: {
3814 OPC_CheckPredicate, 47, // 5406: check predicate 47
3815 OPC_CheckField, 7, 1, 0, // 5408: check Inst[7] == 0x0
3816 OPC_Decode, 160, 121, 47, // 5412: decode to PSEXT_DH_B using decoder 47
3817 // 5412: }
3818 7, 0, // 5416: case 0x7: {
3819 OPC_CheckPredicate, 47, // 5418: check predicate 47
3820 OPC_CheckField, 7, 1, 0, // 5420: check Inst[7] == 0x0
3821 OPC_Decode, 136, 121, 47, // 5424: decode to PSABS_DH using decoder 47
3822 // 5424: }
3823 // 5424: } // switch Inst[24:20]
3824 // 5424: }
3825 1, 0, // 5428: case 0x1: {
3826 OPC_CheckPredicate, 47, // 5430: check predicate 47
3827 OPC_CheckField, 24, 1, 1, // 5432: check Inst[24] == 0x1
3828 OPC_CheckField, 7, 1, 0, // 5436: check Inst[7] == 0x0
3829 OPC_Decode, 153, 121, 48, // 5440: decode to PSATI_DH using decoder 48
3830 // 5440: }
3831 // 5440: } // switch Inst[15]
3832 // 5440: }
3833 49, 44, // 5444: case 0x31: {
3834 OPC_SwitchField, 15, 1, // 5446: switch Inst[15] {
3835 0, 27, // 5449: case 0x0: {
3836 OPC_SwitchField, 20, 5, // 5451: switch Inst[24:20] {
3837 4, 10, // 5454: case 0x4: {
3838 OPC_CheckPredicate, 47, // 5456: check predicate 47
3839 OPC_CheckField, 7, 1, 0, // 5458: check Inst[7] == 0x0
3840 OPC_Decode, 161, 121, 47, // 5462: decode to PSEXT_DW_B using decoder 47
3841 // 5462: }
3842 5, 0, // 5466: case 0x5: {
3843 OPC_CheckPredicate, 47, // 5468: check predicate 47
3844 OPC_CheckField, 7, 1, 0, // 5470: check Inst[7] == 0x0
3845 OPC_Decode, 162, 121, 47, // 5474: decode to PSEXT_DW_H using decoder 47
3846 // 5474: }
3847 // 5474: } // switch Inst[24:20]
3848 // 5474: }
3849 1, 0, // 5478: case 0x1: {
3850 OPC_CheckPredicate, 47, // 5480: check predicate 47
3851 OPC_CheckField, 7, 1, 0, // 5482: check Inst[7] == 0x0
3852 OPC_Decode, 154, 121, 49, // 5486: decode to PSATI_DW using decoder 49
3853 // 5486: }
3854 // 5486: } // switch Inst[15]
3855 // 5486: }
3856 50, 18, // 5490: case 0x32: {
3857 OPC_CheckPredicate, 47, // 5492: check predicate 47
3858 OPC_CheckField, 20, 5, 7, // 5494: check Inst[24:20] == 0x7
3859 OPC_CheckField, 15, 1, 0, // 5498: check Inst[15] == 0x0
3860 OPC_CheckField, 7, 1, 0, // 5502: check Inst[7] == 0x0
3861 OPC_Decode, 135, 121, 47, // 5506: decode to PSABS_DB using decoder 47
3862 // 5506: }
3863 52, 14, // 5510: case 0x34: {
3864 OPC_CheckPredicate, 47, // 5512: check predicate 47
3865 OPC_CheckField, 15, 1, 0, // 5514: check Inst[15] == 0x0
3866 OPC_CheckField, 7, 1, 0, // 5518: check Inst[7] == 0x0
3867 OPC_Decode, 221, 121, 46, // 5522: decode to PSSHA_DHS using decoder 46
3868 // 5522: }
3869 53, 14, // 5526: case 0x35: {
3870 OPC_CheckPredicate, 47, // 5528: check predicate 47
3871 OPC_CheckField, 15, 1, 0, // 5530: check Inst[15] == 0x0
3872 OPC_CheckField, 7, 1, 0, // 5534: check Inst[7] == 0x0
3873 OPC_Decode, 222, 121, 46, // 5538: decode to PSSHA_DWS using decoder 46
3874 // 5538: }
3875 60, 14, // 5542: case 0x3c: {
3876 OPC_CheckPredicate, 47, // 5544: check predicate 47
3877 OPC_CheckField, 15, 1, 0, // 5546: check Inst[15] == 0x0
3878 OPC_CheckField, 7, 1, 0, // 5550: check Inst[7] == 0x0
3879 OPC_Decode, 217, 121, 46, // 5554: decode to PSSHAR_DHS using decoder 46
3880 // 5554: }
3881 61, 14, // 5558: case 0x3d: {
3882 OPC_CheckPredicate, 47, // 5560: check predicate 47
3883 OPC_CheckField, 15, 1, 0, // 5562: check Inst[15] == 0x0
3884 OPC_CheckField, 7, 1, 0, // 5566: check Inst[7] == 0x0
3885 OPC_Decode, 218, 121, 46, // 5570: decode to PSSHAR_DWS using decoder 46
3886 // 5570: }
3887 64, 48, // 5574: case 0x40: {
3888 OPC_SwitchField, 15, 1, // 5576: switch Inst[15] {
3889 0, 14, // 5579: case 0x0: {
3890 OPC_CheckPredicate, 47, // 5581: check predicate 47
3891 OPC_CheckField, 20, 1, 0, // 5583: check Inst[20] == 0x0
3892 OPC_CheckField, 7, 1, 0, // 5587: check Inst[7] == 0x0
3893 OPC_Decode, 242, 118, 50, // 5591: decode to PADD_DH using decoder 50
3894 // 5591: }
3895 1, 0, // 5595: case 0x1: {
3896 OPC_SwitchField, 20, 1, // 5597: switch Inst[20] {
3897 0, 10, // 5600: case 0x0: {
3898 OPC_CheckPredicate, 47, // 5602: check predicate 47
3899 OPC_CheckField, 7, 1, 0, // 5604: check Inst[7] == 0x0
3900 OPC_Decode, 236, 120, 50, // 5608: decode to PPAIRE_DB using decoder 50
3901 // 5608: }
3902 1, 0, // 5612: case 0x1: {
3903 OPC_CheckPredicate, 47, // 5614: check predicate 47
3904 OPC_CheckField, 7, 1, 0, // 5616: check Inst[7] == 0x0
3905 OPC_Decode, 137, 119, 50, // 5620: decode to PAS_DHX using decoder 50
3906 // 5620: }
3907 // 5620: } // switch Inst[20]
3908 // 5620: }
3909 // 5620: } // switch Inst[15]
3910 // 5620: }
3911 65, 35, // 5624: case 0x41: {
3912 OPC_SwitchField, 15, 1, // 5626: switch Inst[15] {
3913 0, 14, // 5629: case 0x0: {
3914 OPC_CheckPredicate, 47, // 5631: check predicate 47
3915 OPC_CheckField, 20, 1, 0, // 5633: check Inst[20] == 0x0
3916 OPC_CheckField, 7, 1, 0, // 5637: check Inst[7] == 0x0
3917 OPC_Decode, 244, 118, 50, // 5641: decode to PADD_DW using decoder 50
3918 // 5641: }
3919 1, 0, // 5645: case 0x1: {
3920 OPC_CheckPredicate, 47, // 5647: check predicate 47
3921 OPC_CheckField, 20, 1, 0, // 5649: check Inst[20] == 0x0
3922 OPC_CheckField, 7, 1, 0, // 5653: check Inst[7] == 0x0
3923 OPC_Decode, 237, 120, 50, // 5657: decode to PPAIRE_DH using decoder 50
3924 // 5657: }
3925 // 5657: } // switch Inst[15]
3926 // 5657: }
3927 66, 35, // 5661: case 0x42: {
3928 OPC_SwitchField, 15, 1, // 5663: switch Inst[15] {
3929 0, 14, // 5666: case 0x0: {
3930 OPC_CheckPredicate, 47, // 5668: check predicate 47
3931 OPC_CheckField, 20, 1, 0, // 5670: check Inst[20] == 0x0
3932 OPC_CheckField, 7, 1, 0, // 5674: check Inst[7] == 0x0
3933 OPC_Decode, 240, 118, 50, // 5678: decode to PADD_DB using decoder 50
3934 // 5678: }
3935 1, 0, // 5682: case 0x1: {
3936 OPC_CheckPredicate, 47, // 5684: check predicate 47
3937 OPC_CheckField, 20, 1, 1, // 5686: check Inst[20] == 0x1
3938 OPC_CheckField, 7, 1, 0, // 5690: check Inst[7] == 0x0
3939 OPC_Decode, 157, 121, 50, // 5694: decode to PSA_DHX using decoder 50
3940 // 5694: }
3941 // 5694: } // switch Inst[15]
3942 // 5694: }
3943 67, 18, // 5698: case 0x43: {
3944 OPC_CheckPredicate, 47, // 5700: check predicate 47
3945 OPC_CheckField, 20, 1, 0, // 5702: check Inst[20] == 0x0
3946 OPC_CheckField, 15, 1, 0, // 5706: check Inst[15] == 0x0
3947 OPC_CheckField, 7, 1, 0, // 5710: check Inst[7] == 0x0
3948 OPC_Decode, 204, 107, 50, // 5714: decode to ADDD using decoder 50
3949 // 5714: }
3950 72, 48, // 5718: case 0x48: {
3951 OPC_SwitchField, 15, 1, // 5720: switch Inst[15] {
3952 0, 14, // 5723: case 0x0: {
3953 OPC_CheckPredicate, 47, // 5725: check predicate 47
3954 OPC_CheckField, 20, 1, 0, // 5727: check Inst[20] == 0x0
3955 OPC_CheckField, 7, 1, 0, // 5731: check Inst[7] == 0x0
3956 OPC_Decode, 146, 121, 50, // 5735: decode to PSADD_DH using decoder 50
3957 // 5735: }
3958 1, 0, // 5739: case 0x1: {
3959 OPC_SwitchField, 20, 1, // 5741: switch Inst[20] {
3960 0, 10, // 5744: case 0x0: {
3961 OPC_CheckPredicate, 47, // 5746: check predicate 47
3962 OPC_CheckField, 7, 1, 0, // 5748: check Inst[7] == 0x0
3963 OPC_Decode, 231, 120, 50, // 5752: decode to PPAIREO_DB using decoder 50
3964 // 5752: }
3965 1, 0, // 5756: case 0x1: {
3966 OPC_CheckPredicate, 47, // 5758: check predicate 47
3967 OPC_CheckField, 7, 1, 0, // 5760: check Inst[7] == 0x0
3968 OPC_Decode, 150, 121, 50, // 5764: decode to PSAS_DHX using decoder 50
3969 // 5764: }
3970 // 5764: } // switch Inst[20]
3971 // 5764: }
3972 // 5764: } // switch Inst[15]
3973 // 5764: }
3974 73, 35, // 5768: case 0x49: {
3975 OPC_SwitchField, 15, 1, // 5770: switch Inst[15] {
3976 0, 14, // 5773: case 0x0: {
3977 OPC_CheckPredicate, 47, // 5775: check predicate 47
3978 OPC_CheckField, 20, 1, 0, // 5777: check Inst[20] == 0x0
3979 OPC_CheckField, 7, 1, 0, // 5781: check Inst[7] == 0x0
3980 OPC_Decode, 147, 121, 50, // 5785: decode to PSADD_DW using decoder 50
3981 // 5785: }
3982 1, 0, // 5789: case 0x1: {
3983 OPC_CheckPredicate, 47, // 5791: check predicate 47
3984 OPC_CheckField, 20, 1, 0, // 5793: check Inst[20] == 0x0
3985 OPC_CheckField, 7, 1, 0, // 5797: check Inst[7] == 0x0
3986 OPC_Decode, 232, 120, 50, // 5801: decode to PPAIREO_DH using decoder 50
3987 // 5801: }
3988 // 5801: } // switch Inst[15]
3989 // 5801: }
3990 74, 35, // 5805: case 0x4a: {
3991 OPC_SwitchField, 15, 1, // 5807: switch Inst[15] {
3992 0, 14, // 5810: case 0x0: {
3993 OPC_CheckPredicate, 47, // 5812: check predicate 47
3994 OPC_CheckField, 20, 1, 0, // 5814: check Inst[20] == 0x0
3995 OPC_CheckField, 7, 1, 0, // 5818: check Inst[7] == 0x0
3996 OPC_Decode, 145, 121, 50, // 5822: decode to PSADD_DB using decoder 50
3997 // 5822: }
3998 1, 0, // 5826: case 0x1: {
3999 OPC_CheckPredicate, 47, // 5828: check predicate 47
4000 OPC_CheckField, 20, 1, 1, // 5830: check Inst[20] == 0x1
4001 OPC_CheckField, 7, 1, 0, // 5834: check Inst[7] == 0x0
4002 OPC_Decode, 210, 121, 50, // 5838: decode to PSSA_DHX using decoder 50
4003 // 5838: }
4004 // 5838: } // switch Inst[15]
4005 // 5838: }
4006 76, 35, // 5842: case 0x4c: {
4007 OPC_SwitchField, 15, 1, // 5844: switch Inst[15] {
4008 0, 14, // 5847: case 0x0: {
4009 OPC_CheckPredicate, 47, // 5849: check predicate 47
4010 OPC_CheckField, 20, 1, 0, // 5851: check Inst[20] == 0x0
4011 OPC_CheckField, 7, 1, 0, // 5855: check Inst[7] == 0x0
4012 OPC_Decode, 218, 118, 50, // 5859: decode to PAADD_DH using decoder 50
4013 // 5859: }
4014 1, 0, // 5863: case 0x1: {
4015 OPC_CheckPredicate, 47, // 5865: check predicate 47
4016 OPC_CheckField, 20, 1, 1, // 5867: check Inst[20] == 0x1
4017 OPC_CheckField, 7, 1, 0, // 5871: check Inst[7] == 0x0
4018 OPC_Decode, 222, 118, 50, // 5875: decode to PAAS_DHX using decoder 50
4019 // 5875: }
4020 // 5875: } // switch Inst[15]
4021 // 5875: }
4022 77, 18, // 5879: case 0x4d: {
4023 OPC_CheckPredicate, 47, // 5881: check predicate 47
4024 OPC_CheckField, 20, 1, 0, // 5883: check Inst[20] == 0x0
4025 OPC_CheckField, 15, 1, 0, // 5887: check Inst[15] == 0x0
4026 OPC_CheckField, 7, 1, 0, // 5891: check Inst[7] == 0x0
4027 OPC_Decode, 219, 118, 50, // 5895: decode to PAADD_DW using decoder 50
4028 // 5895: }
4029 78, 35, // 5899: case 0x4e: {
4030 OPC_SwitchField, 15, 1, // 5901: switch Inst[15] {
4031 0, 14, // 5904: case 0x0: {
4032 OPC_CheckPredicate, 47, // 5906: check predicate 47
4033 OPC_CheckField, 20, 1, 0, // 5908: check Inst[20] == 0x0
4034 OPC_CheckField, 7, 1, 0, // 5912: check Inst[7] == 0x0
4035 OPC_Decode, 217, 118, 50, // 5916: decode to PAADD_DB using decoder 50
4036 // 5916: }
4037 1, 0, // 5920: case 0x1: {
4038 OPC_CheckPredicate, 47, // 5922: check predicate 47
4039 OPC_CheckField, 20, 1, 1, // 5924: check Inst[20] == 0x1
4040 OPC_CheckField, 7, 1, 0, // 5928: check Inst[7] == 0x0
4041 OPC_Decode, 250, 118, 50, // 5932: decode to PASA_DHX using decoder 50
4042 // 5932: }
4043 // 5932: } // switch Inst[15]
4044 // 5932: }
4045 80, 35, // 5936: case 0x50: {
4046 OPC_SwitchField, 15, 1, // 5938: switch Inst[15] {
4047 0, 14, // 5941: case 0x0: {
4048 OPC_CheckPredicate, 47, // 5943: check predicate 47
4049 OPC_CheckField, 20, 1, 1, // 5945: check Inst[20] == 0x1
4050 OPC_CheckField, 7, 1, 0, // 5949: check Inst[7] == 0x0
4051 OPC_Decode, 166, 121, 50, // 5953: decode to PSH1ADD_DH using decoder 50
4052 // 5953: }
4053 1, 0, // 5957: case 0x1: {
4054 OPC_CheckPredicate, 47, // 5959: check predicate 47
4055 OPC_CheckField, 20, 1, 0, // 5961: check Inst[20] == 0x0
4056 OPC_CheckField, 7, 1, 0, // 5965: check Inst[7] == 0x0
4057 OPC_Decode, 240, 120, 50, // 5969: decode to PPAIROE_DB using decoder 50
4058 // 5969: }
4059 // 5969: } // switch Inst[15]
4060 // 5969: }
4061 81, 35, // 5973: case 0x51: {
4062 OPC_SwitchField, 15, 1, // 5975: switch Inst[15] {
4063 0, 14, // 5978: case 0x0: {
4064 OPC_CheckPredicate, 47, // 5980: check predicate 47
4065 OPC_CheckField, 20, 1, 1, // 5982: check Inst[20] == 0x1
4066 OPC_CheckField, 7, 1, 0, // 5986: check Inst[7] == 0x0
4067 OPC_Decode, 167, 121, 50, // 5990: decode to PSH1ADD_DW using decoder 50
4068 // 5990: }
4069 1, 0, // 5994: case 0x1: {
4070 OPC_CheckPredicate, 47, // 5996: check predicate 47
4071 OPC_CheckField, 20, 1, 0, // 5998: check Inst[20] == 0x0
4072 OPC_CheckField, 7, 1, 0, // 6002: check Inst[7] == 0x0
4073 OPC_Decode, 241, 120, 50, // 6006: decode to PPAIROE_DH using decoder 50
4074 // 6006: }
4075 // 6006: } // switch Inst[15]
4076 // 6006: }
4077 88, 48, // 6010: case 0x58: {
4078 OPC_SwitchField, 15, 1, // 6012: switch Inst[15] {
4079 0, 27, // 6015: case 0x0: {
4080 OPC_SwitchField, 20, 1, // 6017: switch Inst[20] {
4081 0, 10, // 6020: case 0x0: {
4082 OPC_CheckPredicate, 47, // 6022: check predicate 47
4083 OPC_CheckField, 7, 1, 0, // 6024: check Inst[7] == 0x0
4084 OPC_Decode, 140, 121, 50, // 6028: decode to PSADDU_DH using decoder 50
4085 // 6028: }
4086 1, 0, // 6032: case 0x1: {
4087 OPC_CheckPredicate, 47, // 6034: check predicate 47
4088 OPC_CheckField, 7, 1, 0, // 6036: check Inst[7] == 0x0
4089 OPC_Decode, 213, 121, 50, // 6040: decode to PSSH1SADD_DH using decoder 50
4090 // 6040: }
4091 // 6040: } // switch Inst[20]
4092 // 6040: }
4093 1, 0, // 6044: case 0x1: {
4094 OPC_CheckPredicate, 47, // 6046: check predicate 47
4095 OPC_CheckField, 20, 1, 0, // 6048: check Inst[20] == 0x0
4096 OPC_CheckField, 7, 1, 0, // 6052: check Inst[7] == 0x0
4097 OPC_Decode, 245, 120, 50, // 6056: decode to PPAIRO_DB using decoder 50
4098 // 6056: }
4099 // 6056: } // switch Inst[15]
4100 // 6056: }
4101 89, 48, // 6060: case 0x59: {
4102 OPC_SwitchField, 15, 1, // 6062: switch Inst[15] {
4103 0, 27, // 6065: case 0x0: {
4104 OPC_SwitchField, 20, 1, // 6067: switch Inst[20] {
4105 0, 10, // 6070: case 0x0: {
4106 OPC_CheckPredicate, 47, // 6072: check predicate 47
4107 OPC_CheckField, 7, 1, 0, // 6074: check Inst[7] == 0x0
4108 OPC_Decode, 141, 121, 50, // 6078: decode to PSADDU_DW using decoder 50
4109 // 6078: }
4110 1, 0, // 6082: case 0x1: {
4111 OPC_CheckPredicate, 47, // 6084: check predicate 47
4112 OPC_CheckField, 7, 1, 0, // 6086: check Inst[7] == 0x0
4113 OPC_Decode, 214, 121, 50, // 6090: decode to PSSH1SADD_DW using decoder 50
4114 // 6090: }
4115 // 6090: } // switch Inst[20]
4116 // 6090: }
4117 1, 0, // 6094: case 0x1: {
4118 OPC_CheckPredicate, 47, // 6096: check predicate 47
4119 OPC_CheckField, 20, 1, 0, // 6098: check Inst[20] == 0x0
4120 OPC_CheckField, 7, 1, 0, // 6102: check Inst[7] == 0x0
4121 OPC_Decode, 246, 120, 50, // 6106: decode to PPAIRO_DH using decoder 50
4122 // 6106: }
4123 // 6106: } // switch Inst[15]
4124 // 6106: }
4125 90, 18, // 6110: case 0x5a: {
4126 OPC_CheckPredicate, 47, // 6112: check predicate 47
4127 OPC_CheckField, 20, 1, 0, // 6114: check Inst[20] == 0x0
4128 OPC_CheckField, 15, 1, 0, // 6118: check Inst[15] == 0x0
4129 OPC_CheckField, 7, 1, 0, // 6122: check Inst[7] == 0x0
4130 OPC_Decode, 139, 121, 50, // 6126: decode to PSADDU_DB using decoder 50
4131 // 6126: }
4132 92, 18, // 6130: case 0x5c: {
4133 OPC_CheckPredicate, 47, // 6132: check predicate 47
4134 OPC_CheckField, 20, 1, 0, // 6134: check Inst[20] == 0x0
4135 OPC_CheckField, 15, 1, 0, // 6138: check Inst[15] == 0x0
4136 OPC_CheckField, 7, 1, 0, // 6142: check Inst[7] == 0x0
4137 OPC_Decode, 212, 118, 50, // 6146: decode to PAADDU_DH using decoder 50
4138 // 6146: }
4139 93, 18, // 6150: case 0x5d: {
4140 OPC_CheckPredicate, 47, // 6152: check predicate 47
4141 OPC_CheckField, 20, 1, 0, // 6154: check Inst[20] == 0x0
4142 OPC_CheckField, 15, 1, 0, // 6158: check Inst[15] == 0x0
4143 OPC_CheckField, 7, 1, 0, // 6162: check Inst[7] == 0x0
4144 OPC_Decode, 213, 118, 50, // 6166: decode to PAADDU_DW using decoder 50
4145 // 6166: }
4146 94, 18, // 6170: case 0x5e: {
4147 OPC_CheckPredicate, 47, // 6172: check predicate 47
4148 OPC_CheckField, 20, 1, 0, // 6174: check Inst[20] == 0x0
4149 OPC_CheckField, 15, 1, 0, // 6178: check Inst[15] == 0x0
4150 OPC_CheckField, 7, 1, 0, // 6182: check Inst[7] == 0x0
4151 OPC_Decode, 211, 118, 50, // 6186: decode to PAADDU_DB using decoder 50
4152 // 6186: }
4153 96, 35, // 6190: case 0x60: {
4154 OPC_SwitchField, 15, 1, // 6192: switch Inst[15] {
4155 0, 14, // 6195: case 0x0: {
4156 OPC_CheckPredicate, 47, // 6197: check predicate 47
4157 OPC_CheckField, 20, 1, 0, // 6199: check Inst[20] == 0x0
4158 OPC_CheckField, 7, 1, 0, // 6203: check Inst[7] == 0x0
4159 OPC_Decode, 251, 121, 50, // 6207: decode to PSUB_DH using decoder 50
4160 // 6207: }
4161 1, 0, // 6211: case 0x1: {
4162 OPC_CheckPredicate, 47, // 6213: check predicate 47
4163 OPC_CheckField, 20, 1, 1, // 6215: check Inst[20] == 0x1
4164 OPC_CheckField, 7, 1, 0, // 6219: check Inst[7] == 0x0
4165 OPC_Decode, 140, 120, 50, // 6223: decode to PMSEQ_DH using decoder 50
4166 // 6223: }
4167 // 6223: } // switch Inst[15]
4168 // 6223: }
4169 97, 35, // 6227: case 0x61: {
4170 OPC_SwitchField, 15, 1, // 6229: switch Inst[15] {
4171 0, 14, // 6232: case 0x0: {
4172 OPC_CheckPredicate, 47, // 6234: check predicate 47
4173 OPC_CheckField, 20, 1, 0, // 6236: check Inst[20] == 0x0
4174 OPC_CheckField, 7, 1, 0, // 6240: check Inst[7] == 0x0
4175 OPC_Decode, 252, 121, 50, // 6244: decode to PSUB_DW using decoder 50
4176 // 6244: }
4177 1, 0, // 6248: case 0x1: {
4178 OPC_CheckPredicate, 47, // 6250: check predicate 47
4179 OPC_CheckField, 20, 1, 1, // 6252: check Inst[20] == 0x1
4180 OPC_CheckField, 7, 1, 0, // 6256: check Inst[7] == 0x0
4181 OPC_Decode, 141, 120, 50, // 6260: decode to PMSEQ_DW using decoder 50
4182 // 6260: }
4183 // 6260: } // switch Inst[15]
4184 // 6260: }
4185 98, 35, // 6264: case 0x62: {
4186 OPC_SwitchField, 15, 1, // 6266: switch Inst[15] {
4187 0, 14, // 6269: case 0x0: {
4188 OPC_CheckPredicate, 47, // 6271: check predicate 47
4189 OPC_CheckField, 20, 1, 0, // 6273: check Inst[20] == 0x0
4190 OPC_CheckField, 7, 1, 0, // 6277: check Inst[7] == 0x0
4191 OPC_Decode, 250, 121, 50, // 6281: decode to PSUB_DB using decoder 50
4192 // 6281: }
4193 1, 0, // 6285: case 0x1: {
4194 OPC_CheckPredicate, 47, // 6287: check predicate 47
4195 OPC_CheckField, 20, 1, 1, // 6289: check Inst[20] == 0x1
4196 OPC_CheckField, 7, 1, 0, // 6293: check Inst[7] == 0x0
4197 OPC_Decode, 139, 120, 50, // 6297: decode to PMSEQ_DB using decoder 50
4198 // 6297: }
4199 // 6297: } // switch Inst[15]
4200 // 6297: }
4201 99, 18, // 6301: case 0x63: {
4202 OPC_CheckPredicate, 47, // 6303: check predicate 47
4203 OPC_CheckField, 20, 1, 0, // 6305: check Inst[20] == 0x0
4204 OPC_CheckField, 15, 1, 0, // 6309: check Inst[15] == 0x0
4205 OPC_CheckField, 7, 1, 0, // 6313: check Inst[7] == 0x0
4206 OPC_Decode, 147, 125, 50, // 6317: decode to SUBD using decoder 50
4207 // 6317: }
4208 100, 18, // 6321: case 0x64: {
4209 OPC_CheckPredicate, 47, // 6323: check predicate 47
4210 OPC_CheckField, 20, 1, 0, // 6325: check Inst[20] == 0x0
4211 OPC_CheckField, 15, 1, 0, // 6329: check Inst[15] == 0x0
4212 OPC_CheckField, 7, 1, 0, // 6333: check Inst[7] == 0x0
4213 OPC_Decode, 233, 118, 50, // 6337: decode to PABD_DH using decoder 50
4214 // 6337: }
4215 102, 18, // 6341: case 0x66: {
4216 OPC_CheckPredicate, 47, // 6343: check predicate 47
4217 OPC_CheckField, 20, 1, 0, // 6345: check Inst[20] == 0x0
4218 OPC_CheckField, 15, 1, 0, // 6349: check Inst[15] == 0x0
4219 OPC_CheckField, 7, 1, 0, // 6353: check Inst[7] == 0x0
4220 OPC_Decode, 232, 118, 50, // 6357: decode to PABD_DB using decoder 50
4221 // 6357: }
4222 104, 35, // 6361: case 0x68: {
4223 OPC_SwitchField, 15, 1, // 6363: switch Inst[15] {
4224 0, 14, // 6366: case 0x0: {
4225 OPC_CheckPredicate, 47, // 6368: check predicate 47
4226 OPC_CheckField, 20, 1, 0, // 6370: check Inst[20] == 0x0
4227 OPC_CheckField, 7, 1, 0, // 6374: check Inst[7] == 0x0
4228 OPC_Decode, 245, 121, 50, // 6378: decode to PSSUB_DH using decoder 50
4229 // 6378: }
4230 1, 0, // 6382: case 0x1: {
4231 OPC_CheckPredicate, 47, // 6384: check predicate 47
4232 OPC_CheckField, 20, 1, 1, // 6386: check Inst[20] == 0x1
4233 OPC_CheckField, 7, 1, 0, // 6390: check Inst[7] == 0x0
4234 OPC_Decode, 152, 120, 50, // 6394: decode to PMSLT_DH using decoder 50
4235 // 6394: }
4236 // 6394: } // switch Inst[15]
4237 // 6394: }
4238 105, 35, // 6398: case 0x69: {
4239 OPC_SwitchField, 15, 1, // 6400: switch Inst[15] {
4240 0, 14, // 6403: case 0x0: {
4241 OPC_CheckPredicate, 47, // 6405: check predicate 47
4242 OPC_CheckField, 20, 1, 0, // 6407: check Inst[20] == 0x0
4243 OPC_CheckField, 7, 1, 0, // 6411: check Inst[7] == 0x0
4244 OPC_Decode, 246, 121, 50, // 6415: decode to PSSUB_DW using decoder 50
4245 // 6415: }
4246 1, 0, // 6419: case 0x1: {
4247 OPC_CheckPredicate, 47, // 6421: check predicate 47
4248 OPC_CheckField, 20, 1, 1, // 6423: check Inst[20] == 0x1
4249 OPC_CheckField, 7, 1, 0, // 6427: check Inst[7] == 0x0
4250 OPC_Decode, 153, 120, 50, // 6431: decode to PMSLT_DW using decoder 50
4251 // 6431: }
4252 // 6431: } // switch Inst[15]
4253 // 6431: }
4254 106, 35, // 6435: case 0x6a: {
4255 OPC_SwitchField, 15, 1, // 6437: switch Inst[15] {
4256 0, 14, // 6440: case 0x0: {
4257 OPC_CheckPredicate, 47, // 6442: check predicate 47
4258 OPC_CheckField, 20, 1, 0, // 6444: check Inst[20] == 0x0
4259 OPC_CheckField, 7, 1, 0, // 6448: check Inst[7] == 0x0
4260 OPC_Decode, 244, 121, 50, // 6452: decode to PSSUB_DB using decoder 50
4261 // 6452: }
4262 1, 0, // 6456: case 0x1: {
4263 OPC_CheckPredicate, 47, // 6458: check predicate 47
4264 OPC_CheckField, 20, 1, 1, // 6460: check Inst[20] == 0x1
4265 OPC_CheckField, 7, 1, 0, // 6464: check Inst[7] == 0x0
4266 OPC_Decode, 151, 120, 50, // 6468: decode to PMSLT_DB using decoder 50
4267 // 6468: }
4268 // 6468: } // switch Inst[15]
4269 // 6468: }
4270 108, 35, // 6472: case 0x6c: {
4271 OPC_SwitchField, 15, 1, // 6474: switch Inst[15] {
4272 0, 14, // 6477: case 0x0: {
4273 OPC_CheckPredicate, 47, // 6479: check predicate 47
4274 OPC_CheckField, 20, 1, 0, // 6481: check Inst[20] == 0x0
4275 OPC_CheckField, 7, 1, 0, // 6485: check Inst[7] == 0x0
4276 OPC_Decode, 133, 119, 50, // 6489: decode to PASUB_DH using decoder 50
4277 // 6489: }
4278 1, 0, // 6493: case 0x1: {
4279 OPC_CheckPredicate, 47, // 6495: check predicate 47
4280 OPC_CheckField, 20, 1, 1, // 6497: check Inst[20] == 0x1
4281 OPC_CheckField, 7, 1, 0, // 6501: check Inst[7] == 0x0
4282 OPC_Decode, 146, 120, 50, // 6505: decode to PMSLTU_DH using decoder 50
4283 // 6505: }
4284 // 6505: } // switch Inst[15]
4285 // 6505: }
4286 109, 35, // 6509: case 0x6d: {
4287 OPC_SwitchField, 15, 1, // 6511: switch Inst[15] {
4288 0, 14, // 6514: case 0x0: {
4289 OPC_CheckPredicate, 47, // 6516: check predicate 47
4290 OPC_CheckField, 20, 1, 0, // 6518: check Inst[20] == 0x0
4291 OPC_CheckField, 7, 1, 0, // 6522: check Inst[7] == 0x0
4292 OPC_Decode, 134, 119, 50, // 6526: decode to PASUB_DW using decoder 50
4293 // 6526: }
4294 1, 0, // 6530: case 0x1: {
4295 OPC_CheckPredicate, 47, // 6532: check predicate 47
4296 OPC_CheckField, 20, 1, 1, // 6534: check Inst[20] == 0x1
4297 OPC_CheckField, 7, 1, 0, // 6538: check Inst[7] == 0x0
4298 OPC_Decode, 147, 120, 50, // 6542: decode to PMSLTU_DW using decoder 50
4299 // 6542: }
4300 // 6542: } // switch Inst[15]
4301 // 6542: }
4302 110, 35, // 6546: case 0x6e: {
4303 OPC_SwitchField, 15, 1, // 6548: switch Inst[15] {
4304 0, 14, // 6551: case 0x0: {
4305 OPC_CheckPredicate, 47, // 6553: check predicate 47
4306 OPC_CheckField, 20, 1, 0, // 6555: check Inst[20] == 0x0
4307 OPC_CheckField, 7, 1, 0, // 6559: check Inst[7] == 0x0
4308 OPC_Decode, 132, 119, 50, // 6563: decode to PASUB_DB using decoder 50
4309 // 6563: }
4310 1, 0, // 6567: case 0x1: {
4311 OPC_CheckPredicate, 47, // 6569: check predicate 47
4312 OPC_CheckField, 20, 1, 1, // 6571: check Inst[20] == 0x1
4313 OPC_CheckField, 7, 1, 0, // 6575: check Inst[7] == 0x0
4314 OPC_Decode, 145, 120, 50, // 6579: decode to PMSLTU_DB using decoder 50
4315 // 6579: }
4316 // 6579: } // switch Inst[15]
4317 // 6579: }
4318 112, 18, // 6583: case 0x70: {
4319 OPC_CheckPredicate, 47, // 6585: check predicate 47
4320 OPC_CheckField, 20, 1, 1, // 6587: check Inst[20] == 0x1
4321 OPC_CheckField, 15, 1, 1, // 6591: check Inst[15] == 0x1
4322 OPC_CheckField, 7, 1, 0, // 6595: check Inst[7] == 0x0
4323 OPC_Decode, 246, 119, 50, // 6599: decode to PMIN_DH using decoder 50
4324 // 6599: }
4325 113, 18, // 6603: case 0x71: {
4326 OPC_CheckPredicate, 47, // 6605: check predicate 47
4327 OPC_CheckField, 20, 1, 1, // 6607: check Inst[20] == 0x1
4328 OPC_CheckField, 15, 1, 1, // 6611: check Inst[15] == 0x1
4329 OPC_CheckField, 7, 1, 0, // 6615: check Inst[7] == 0x0
4330 OPC_Decode, 247, 119, 50, // 6619: decode to PMIN_DW using decoder 50
4331 // 6619: }
4332 114, 18, // 6623: case 0x72: {
4333 OPC_CheckPredicate, 47, // 6625: check predicate 47
4334 OPC_CheckField, 20, 1, 1, // 6627: check Inst[20] == 0x1
4335 OPC_CheckField, 15, 1, 1, // 6631: check Inst[15] == 0x1
4336 OPC_CheckField, 7, 1, 0, // 6635: check Inst[7] == 0x0
4337 OPC_Decode, 245, 119, 50, // 6639: decode to PMIN_DB using decoder 50
4338 // 6639: }
4339 116, 35, // 6643: case 0x74: {
4340 OPC_SwitchField, 15, 1, // 6645: switch Inst[15] {
4341 0, 14, // 6648: case 0x0: {
4342 OPC_CheckPredicate, 47, // 6650: check predicate 47
4343 OPC_CheckField, 20, 1, 0, // 6652: check Inst[20] == 0x0
4344 OPC_CheckField, 7, 1, 0, // 6656: check Inst[7] == 0x0
4345 OPC_Decode, 229, 118, 50, // 6660: decode to PABDU_DH using decoder 50
4346 // 6660: }
4347 1, 0, // 6664: case 0x1: {
4348 OPC_CheckPredicate, 47, // 6666: check predicate 47
4349 OPC_CheckField, 20, 1, 1, // 6668: check Inst[20] == 0x1
4350 OPC_CheckField, 7, 1, 0, // 6672: check Inst[7] == 0x0
4351 OPC_Decode, 240, 119, 50, // 6676: decode to PMINU_DH using decoder 50
4352 // 6676: }
4353 // 6676: } // switch Inst[15]
4354 // 6676: }
4355 117, 18, // 6680: case 0x75: {
4356 OPC_CheckPredicate, 47, // 6682: check predicate 47
4357 OPC_CheckField, 20, 1, 1, // 6684: check Inst[20] == 0x1
4358 OPC_CheckField, 15, 1, 1, // 6688: check Inst[15] == 0x1
4359 OPC_CheckField, 7, 1, 0, // 6692: check Inst[7] == 0x0
4360 OPC_Decode, 241, 119, 50, // 6696: decode to PMINU_DW using decoder 50
4361 // 6696: }
4362 118, 35, // 6700: case 0x76: {
4363 OPC_SwitchField, 15, 1, // 6702: switch Inst[15] {
4364 0, 14, // 6705: case 0x0: {
4365 OPC_CheckPredicate, 47, // 6707: check predicate 47
4366 OPC_CheckField, 20, 1, 0, // 6709: check Inst[20] == 0x0
4367 OPC_CheckField, 7, 1, 0, // 6713: check Inst[7] == 0x0
4368 OPC_Decode, 228, 118, 50, // 6717: decode to PABDU_DB using decoder 50
4369 // 6717: }
4370 1, 0, // 6721: case 0x1: {
4371 OPC_CheckPredicate, 47, // 6723: check predicate 47
4372 OPC_CheckField, 20, 1, 1, // 6725: check Inst[20] == 0x1
4373 OPC_CheckField, 7, 1, 0, // 6729: check Inst[7] == 0x0
4374 OPC_Decode, 239, 119, 50, // 6733: decode to PMINU_DB using decoder 50
4375 // 6733: }
4376 // 6733: } // switch Inst[15]
4377 // 6733: }
4378 120, 35, // 6737: case 0x78: {
4379 OPC_SwitchField, 15, 1, // 6739: switch Inst[15] {
4380 0, 14, // 6742: case 0x0: {
4381 OPC_CheckPredicate, 47, // 6744: check predicate 47
4382 OPC_CheckField, 20, 1, 0, // 6746: check Inst[20] == 0x0
4383 OPC_CheckField, 7, 1, 0, // 6750: check Inst[7] == 0x0
4384 OPC_Decode, 239, 121, 50, // 6754: decode to PSSUBU_DH using decoder 50
4385 // 6754: }
4386 1, 0, // 6758: case 0x1: {
4387 OPC_CheckPredicate, 47, // 6760: check predicate 47
4388 OPC_CheckField, 20, 1, 1, // 6762: check Inst[20] == 0x1
4389 OPC_CheckField, 7, 1, 0, // 6766: check Inst[7] == 0x0
4390 OPC_Decode, 214, 119, 50, // 6770: decode to PMAX_DH using decoder 50
4391 // 6770: }
4392 // 6770: } // switch Inst[15]
4393 // 6770: }
4394 121, 35, // 6774: case 0x79: {
4395 OPC_SwitchField, 15, 1, // 6776: switch Inst[15] {
4396 0, 14, // 6779: case 0x0: {
4397 OPC_CheckPredicate, 47, // 6781: check predicate 47
4398 OPC_CheckField, 20, 1, 0, // 6783: check Inst[20] == 0x0
4399 OPC_CheckField, 7, 1, 0, // 6787: check Inst[7] == 0x0
4400 OPC_Decode, 240, 121, 50, // 6791: decode to PSSUBU_DW using decoder 50
4401 // 6791: }
4402 1, 0, // 6795: case 0x1: {
4403 OPC_CheckPredicate, 47, // 6797: check predicate 47
4404 OPC_CheckField, 20, 1, 1, // 6799: check Inst[20] == 0x1
4405 OPC_CheckField, 7, 1, 0, // 6803: check Inst[7] == 0x0
4406 OPC_Decode, 215, 119, 50, // 6807: decode to PMAX_DW using decoder 50
4407 // 6807: }
4408 // 6807: } // switch Inst[15]
4409 // 6807: }
4410 122, 35, // 6811: case 0x7a: {
4411 OPC_SwitchField, 15, 1, // 6813: switch Inst[15] {
4412 0, 14, // 6816: case 0x0: {
4413 OPC_CheckPredicate, 47, // 6818: check predicate 47
4414 OPC_CheckField, 20, 1, 0, // 6820: check Inst[20] == 0x0
4415 OPC_CheckField, 7, 1, 0, // 6824: check Inst[7] == 0x0
4416 OPC_Decode, 238, 121, 50, // 6828: decode to PSSUBU_DB using decoder 50
4417 // 6828: }
4418 1, 0, // 6832: case 0x1: {
4419 OPC_CheckPredicate, 47, // 6834: check predicate 47
4420 OPC_CheckField, 20, 1, 1, // 6836: check Inst[20] == 0x1
4421 OPC_CheckField, 7, 1, 0, // 6840: check Inst[7] == 0x0
4422 OPC_Decode, 213, 119, 50, // 6844: decode to PMAX_DB using decoder 50
4423 // 6844: }
4424 // 6844: } // switch Inst[15]
4425 // 6844: }
4426 124, 35, // 6848: case 0x7c: {
4427 OPC_SwitchField, 15, 1, // 6850: switch Inst[15] {
4428 0, 14, // 6853: case 0x0: {
4429 OPC_CheckPredicate, 47, // 6855: check predicate 47
4430 OPC_CheckField, 20, 1, 0, // 6857: check Inst[20] == 0x0
4431 OPC_CheckField, 7, 1, 0, // 6861: check Inst[7] == 0x0
4432 OPC_Decode, 255, 118, 50, // 6865: decode to PASUBU_DH using decoder 50
4433 // 6865: }
4434 1, 0, // 6869: case 0x1: {
4435 OPC_CheckPredicate, 47, // 6871: check predicate 47
4436 OPC_CheckField, 20, 1, 1, // 6873: check Inst[20] == 0x1
4437 OPC_CheckField, 7, 1, 0, // 6877: check Inst[7] == 0x0
4438 OPC_Decode, 208, 119, 50, // 6881: decode to PMAXU_DH using decoder 50
4439 // 6881: }
4440 // 6881: } // switch Inst[15]
4441 // 6881: }
4442 125, 35, // 6885: case 0x7d: {
4443 OPC_SwitchField, 15, 1, // 6887: switch Inst[15] {
4444 0, 14, // 6890: case 0x0: {
4445 OPC_CheckPredicate, 47, // 6892: check predicate 47
4446 OPC_CheckField, 20, 1, 0, // 6894: check Inst[20] == 0x0
4447 OPC_CheckField, 7, 1, 0, // 6898: check Inst[7] == 0x0
4448 OPC_Decode, 128, 119, 50, // 6902: decode to PASUBU_DW using decoder 50
4449 // 6902: }
4450 1, 0, // 6906: case 0x1: {
4451 OPC_CheckPredicate, 47, // 6908: check predicate 47
4452 OPC_CheckField, 20, 1, 1, // 6910: check Inst[20] == 0x1
4453 OPC_CheckField, 7, 1, 0, // 6914: check Inst[7] == 0x0
4454 OPC_Decode, 209, 119, 50, // 6918: decode to PMAXU_DW using decoder 50
4455 // 6918: }
4456 // 6918: } // switch Inst[15]
4457 // 6918: }
4458 126, 0, // 6922: case 0x7e: {
4459 OPC_SwitchField, 15, 1, // 6924: switch Inst[15] {
4460 0, 14, // 6927: case 0x0: {
4461 OPC_CheckPredicate, 47, // 6929: check predicate 47
4462 OPC_CheckField, 20, 1, 0, // 6931: check Inst[20] == 0x0
4463 OPC_CheckField, 7, 1, 0, // 6935: check Inst[7] == 0x0
4464 OPC_Decode, 254, 118, 50, // 6939: decode to PASUBU_DB using decoder 50
4465 // 6939: }
4466 1, 0, // 6943: case 0x1: {
4467 OPC_CheckPredicate, 47, // 6945: check predicate 47
4468 OPC_CheckField, 20, 1, 1, // 6947: check Inst[20] == 0x1
4469 OPC_CheckField, 7, 1, 0, // 6951: check Inst[7] == 0x0
4470 OPC_Decode, 207, 119, 50, // 6955: decode to PMAXU_DB using decoder 50
4471 // 6955: }
4472 // 6955: } // switch Inst[15]
4473 // 6955: }
4474 // 6955: } // switch Inst[31:25]
4475 // 6955: }
4476 // 6955: } // switch Inst[14:12]
4477 // 6955: }
4478 35, 29, // 6959: case 0x23: {
4479 OPC_SwitchField, 12, 3, // 6961: switch Inst[14:12] {
4480 0, 4, // 6964: case 0x0: {
4481 OPC_Decode, 220, 123, 51, // 6966: decode to SB using decoder 51
4482 // 6966: }
4483 1, 4, // 6970: case 0x1: {
4484 OPC_Decode, 183, 124, 51, // 6972: decode to SH using decoder 51
4485 // 6972: }
4486 2, 4, // 6976: case 0x2: {
4487 OPC_Decode, 149, 125, 51, // 6978: decode to SW using decoder 51
4488 // 6978: }
4489 3, 0, // 6982: case 0x3: {
4490 OPC_CheckPredicate, 22, // 6984: check predicate 22
4491 OPC_Decode, 234, 123, 51, // 6986: decode to SD using decoder 51
4492 // 6986: }
4493 // 6986: } // switch Inst[14:12]
4494 // 6986: }
4495 39, 165, 11, // 6990: case 0x27: {
4496 OPC_SwitchField, 12, 3, // 6993: switch Inst[14:12] {
4497 0, 136, 3, // 6996: case 0x0: {
4498 OPC_SwitchField, 26, 6, // 6999: switch Inst[31:26] {
4499 0, 38, // 7002: case 0x0: {
4500 OPC_SwitchField, 20, 5, // 7004: switch Inst[24:20] {
4501 0, 7, // 7007: case 0x0: {
4502 OPC_CheckPredicate, 23, // 7009: check predicate 23
4503 OPC_Decode, 172, 130, 1, 1, // 7011: decode to VSE8_V using decoder 1
4504 // 7011: }
4505 8, 11, // 7016: case 0x8: {
4506 OPC_CheckPredicate, 23, // 7018: check predicate 23
4507 OPC_CheckField, 25, 1, 1, // 7020: check Inst[25] == 0x1
4508 OPC_Decode, 157, 130, 1, 2, // 7024: decode to VS1R_V using decoder 2
4509 // 7024: }
4510 11, 0, // 7029: case 0xb: {
4511 OPC_CheckPredicate, 23, // 7031: check predicate 23
4512 OPC_CheckField, 25, 1, 1, // 7033: check Inst[25] == 0x1
4513 OPC_Decode, 198, 130, 1, 2, // 7037: decode to VSM_V using decoder 2
4514 // 7037: }
4515 // 7037: } // switch Inst[24:20]
4516 // 7037: }
4517 1, 7, // 7042: case 0x1: {
4518 OPC_CheckPredicate, 23, // 7044: check predicate 23
4519 OPC_Decode, 184, 131, 1, 3, // 7046: decode to VSUXEI8_V using decoder 3
4520 // 7046: }
4521 2, 7, // 7051: case 0x2: {
4522 OPC_CheckPredicate, 23, // 7053: check predicate 23
4523 OPC_Decode, 240, 130, 1, 4, // 7055: decode to VSSE8_V using decoder 4
4524 // 7055: }
4525 3, 7, // 7060: case 0x3: {
4526 OPC_CheckPredicate, 23, // 7062: check predicate 23
4527 OPC_Decode, 202, 130, 1, 3, // 7064: decode to VSOXEI8_V using decoder 3
4528 // 7064: }
4529 8, 25, // 7069: case 0x8: {
4530 OPC_SwitchField, 20, 5, // 7071: switch Inst[24:20] {
4531 0, 7, // 7074: case 0x0: {
4532 OPC_CheckPredicate, 23, // 7076: check predicate 23
4533 OPC_Decode, 244, 130, 1, 1, // 7078: decode to VSSEG2E8_V using decoder 1
4534 // 7078: }
4535 8, 0, // 7083: case 0x8: {
4536 OPC_CheckPredicate, 23, // 7085: check predicate 23
4537 OPC_CheckField, 25, 1, 1, // 7087: check Inst[25] == 0x1
4538 OPC_Decode, 158, 130, 1, 5, // 7091: decode to VS2R_V using decoder 5
4539 // 7091: }
4540 // 7091: } // switch Inst[24:20]
4541 // 7091: }
4542 9, 7, // 7096: case 0x9: {
4543 OPC_CheckPredicate, 23, // 7098: check predicate 23
4544 OPC_Decode, 188, 131, 1, 3, // 7100: decode to VSUXSEG2EI8_V using decoder 3
4545 // 7100: }
4546 10, 7, // 7105: case 0xa: {
4547 OPC_CheckPredicate, 23, // 7107: check predicate 23
4548 OPC_Decode, 150, 131, 1, 4, // 7109: decode to VSSSEG2E8_V using decoder 4
4549 // 7109: }
4550 11, 7, // 7114: case 0xb: {
4551 OPC_CheckPredicate, 23, // 7116: check predicate 23
4552 OPC_Decode, 206, 130, 1, 3, // 7118: decode to VSOXSEG2EI8_V using decoder 3
4553 // 7118: }
4554 16, 11, // 7123: case 0x10: {
4555 OPC_CheckPredicate, 23, // 7125: check predicate 23
4556 OPC_CheckField, 20, 5, 0, // 7127: check Inst[24:20] == 0x0
4557 OPC_Decode, 248, 130, 1, 1, // 7131: decode to VSSEG3E8_V using decoder 1
4558 // 7131: }
4559 17, 7, // 7136: case 0x11: {
4560 OPC_CheckPredicate, 23, // 7138: check predicate 23
4561 OPC_Decode, 192, 131, 1, 3, // 7140: decode to VSUXSEG3EI8_V using decoder 3
4562 // 7140: }
4563 18, 7, // 7145: case 0x12: {
4564 OPC_CheckPredicate, 23, // 7147: check predicate 23
4565 OPC_Decode, 154, 131, 1, 4, // 7149: decode to VSSSEG3E8_V using decoder 4
4566 // 7149: }
4567 19, 7, // 7154: case 0x13: {
4568 OPC_CheckPredicate, 23, // 7156: check predicate 23
4569 OPC_Decode, 210, 130, 1, 3, // 7158: decode to VSOXSEG3EI8_V using decoder 3
4570 // 7158: }
4571 24, 25, // 7163: case 0x18: {
4572 OPC_SwitchField, 20, 5, // 7165: switch Inst[24:20] {
4573 0, 7, // 7168: case 0x0: {
4574 OPC_CheckPredicate, 23, // 7170: check predicate 23
4575 OPC_Decode, 252, 130, 1, 1, // 7172: decode to VSSEG4E8_V using decoder 1
4576 // 7172: }
4577 8, 0, // 7177: case 0x8: {
4578 OPC_CheckPredicate, 23, // 7179: check predicate 23
4579 OPC_CheckField, 25, 1, 1, // 7181: check Inst[25] == 0x1
4580 OPC_Decode, 159, 130, 1, 6, // 7185: decode to VS4R_V using decoder 6
4581 // 7185: }
4582 // 7185: } // switch Inst[24:20]
4583 // 7185: }
4584 25, 7, // 7190: case 0x19: {
4585 OPC_CheckPredicate, 23, // 7192: check predicate 23
4586 OPC_Decode, 196, 131, 1, 3, // 7194: decode to VSUXSEG4EI8_V using decoder 3
4587 // 7194: }
4588 26, 7, // 7199: case 0x1a: {
4589 OPC_CheckPredicate, 23, // 7201: check predicate 23
4590 OPC_Decode, 158, 131, 1, 4, // 7203: decode to VSSSEG4E8_V using decoder 4
4591 // 7203: }
4592 27, 7, // 7208: case 0x1b: {
4593 OPC_CheckPredicate, 23, // 7210: check predicate 23
4594 OPC_Decode, 214, 130, 1, 3, // 7212: decode to VSOXSEG4EI8_V using decoder 3
4595 // 7212: }
4596 32, 11, // 7217: case 0x20: {
4597 OPC_CheckPredicate, 23, // 7219: check predicate 23
4598 OPC_CheckField, 20, 5, 0, // 7221: check Inst[24:20] == 0x0
4599 OPC_Decode, 128, 131, 1, 1, // 7225: decode to VSSEG5E8_V using decoder 1
4600 // 7225: }
4601 33, 7, // 7230: case 0x21: {
4602 OPC_CheckPredicate, 23, // 7232: check predicate 23
4603 OPC_Decode, 200, 131, 1, 3, // 7234: decode to VSUXSEG5EI8_V using decoder 3
4604 // 7234: }
4605 34, 7, // 7239: case 0x22: {
4606 OPC_CheckPredicate, 23, // 7241: check predicate 23
4607 OPC_Decode, 162, 131, 1, 4, // 7243: decode to VSSSEG5E8_V using decoder 4
4608 // 7243: }
4609 35, 7, // 7248: case 0x23: {
4610 OPC_CheckPredicate, 23, // 7250: check predicate 23
4611 OPC_Decode, 218, 130, 1, 3, // 7252: decode to VSOXSEG5EI8_V using decoder 3
4612 // 7252: }
4613 40, 11, // 7257: case 0x28: {
4614 OPC_CheckPredicate, 23, // 7259: check predicate 23
4615 OPC_CheckField, 20, 5, 0, // 7261: check Inst[24:20] == 0x0
4616 OPC_Decode, 132, 131, 1, 1, // 7265: decode to VSSEG6E8_V using decoder 1
4617 // 7265: }
4618 41, 7, // 7270: case 0x29: {
4619 OPC_CheckPredicate, 23, // 7272: check predicate 23
4620 OPC_Decode, 204, 131, 1, 3, // 7274: decode to VSUXSEG6EI8_V using decoder 3
4621 // 7274: }
4622 42, 7, // 7279: case 0x2a: {
4623 OPC_CheckPredicate, 23, // 7281: check predicate 23
4624 OPC_Decode, 166, 131, 1, 4, // 7283: decode to VSSSEG6E8_V using decoder 4
4625 // 7283: }
4626 43, 7, // 7288: case 0x2b: {
4627 OPC_CheckPredicate, 23, // 7290: check predicate 23
4628 OPC_Decode, 222, 130, 1, 3, // 7292: decode to VSOXSEG6EI8_V using decoder 3
4629 // 7292: }
4630 48, 11, // 7297: case 0x30: {
4631 OPC_CheckPredicate, 23, // 7299: check predicate 23
4632 OPC_CheckField, 20, 5, 0, // 7301: check Inst[24:20] == 0x0
4633 OPC_Decode, 136, 131, 1, 1, // 7305: decode to VSSEG7E8_V using decoder 1
4634 // 7305: }
4635 49, 7, // 7310: case 0x31: {
4636 OPC_CheckPredicate, 23, // 7312: check predicate 23
4637 OPC_Decode, 208, 131, 1, 3, // 7314: decode to VSUXSEG7EI8_V using decoder 3
4638 // 7314: }
4639 50, 7, // 7319: case 0x32: {
4640 OPC_CheckPredicate, 23, // 7321: check predicate 23
4641 OPC_Decode, 170, 131, 1, 4, // 7323: decode to VSSSEG7E8_V using decoder 4
4642 // 7323: }
4643 51, 7, // 7328: case 0x33: {
4644 OPC_CheckPredicate, 23, // 7330: check predicate 23
4645 OPC_Decode, 226, 130, 1, 3, // 7332: decode to VSOXSEG7EI8_V using decoder 3
4646 // 7332: }
4647 56, 25, // 7337: case 0x38: {
4648 OPC_SwitchField, 20, 5, // 7339: switch Inst[24:20] {
4649 0, 7, // 7342: case 0x0: {
4650 OPC_CheckPredicate, 23, // 7344: check predicate 23
4651 OPC_Decode, 140, 131, 1, 1, // 7346: decode to VSSEG8E8_V using decoder 1
4652 // 7346: }
4653 8, 0, // 7351: case 0x8: {
4654 OPC_CheckPredicate, 23, // 7353: check predicate 23
4655 OPC_CheckField, 25, 1, 1, // 7355: check Inst[25] == 0x1
4656 OPC_Decode, 160, 130, 1, 7, // 7359: decode to VS8R_V using decoder 7
4657 // 7359: }
4658 // 7359: } // switch Inst[24:20]
4659 // 7359: }
4660 57, 7, // 7364: case 0x39: {
4661 OPC_CheckPredicate, 23, // 7366: check predicate 23
4662 OPC_Decode, 212, 131, 1, 3, // 7368: decode to VSUXSEG8EI8_V using decoder 3
4663 // 7368: }
4664 58, 7, // 7373: case 0x3a: {
4665 OPC_CheckPredicate, 23, // 7375: check predicate 23
4666 OPC_Decode, 174, 131, 1, 4, // 7377: decode to VSSSEG8E8_V using decoder 4
4667 // 7377: }
4668 59, 0, // 7382: case 0x3b: {
4669 OPC_CheckPredicate, 23, // 7384: check predicate 23
4670 OPC_Decode, 230, 130, 1, 3, // 7386: decode to VSOXSEG8EI8_V using decoder 3
4671 // 7386: }
4672 // 7386: } // switch Inst[31:26]
4673 // 7386: }
4674 1, 6, // 7391: case 0x1: {
4675 OPC_CheckPredicate, 24, // 7393: check predicate 24
4676 OPC_Decode, 156, 116, 52, // 7395: decode to FSH using decoder 52
4677 // 7395: }
4678 2, 6, // 7399: case 0x2: {
4679 OPC_CheckPredicate, 25, // 7401: check predicate 25
4680 OPC_Decode, 174, 116, 53, // 7403: decode to FSW using decoder 53
4681 // 7403: }
4682 3, 6, // 7407: case 0x3: {
4683 OPC_CheckPredicate, 26, // 7409: check predicate 26
4684 OPC_Decode, 131, 116, 54, // 7411: decode to FSD using decoder 54
4685 // 7411: }
4686 4, 6, // 7415: case 0x4: {
4687 OPC_CheckPredicate, 27, // 7417: check predicate 27
4688 OPC_Decode, 157, 116, 55, // 7419: decode to FSQ using decoder 55
4689 // 7419: }
4690 5, 195, 2, // 7423: case 0x5: {
4691 OPC_SwitchField, 26, 6, // 7426: switch Inst[31:26] {
4692 0, 11, // 7429: case 0x0: {
4693 OPC_CheckPredicate, 23, // 7431: check predicate 23
4694 OPC_CheckField, 20, 5, 0, // 7433: check Inst[24:20] == 0x0
4695 OPC_Decode, 169, 130, 1, 1, // 7437: decode to VSE16_V using decoder 1
4696 // 7437: }
4697 1, 7, // 7442: case 0x1: {
4698 OPC_CheckPredicate, 23, // 7444: check predicate 23
4699 OPC_Decode, 181, 131, 1, 3, // 7446: decode to VSUXEI16_V using decoder 3
4700 // 7446: }
4701 2, 7, // 7451: case 0x2: {
4702 OPC_CheckPredicate, 23, // 7453: check predicate 23
4703 OPC_Decode, 237, 130, 1, 4, // 7455: decode to VSSE16_V using decoder 4
4704 // 7455: }
4705 3, 7, // 7460: case 0x3: {
4706 OPC_CheckPredicate, 23, // 7462: check predicate 23
4707 OPC_Decode, 199, 130, 1, 3, // 7464: decode to VSOXEI16_V using decoder 3
4708 // 7464: }
4709 8, 11, // 7469: case 0x8: {
4710 OPC_CheckPredicate, 23, // 7471: check predicate 23
4711 OPC_CheckField, 20, 5, 0, // 7473: check Inst[24:20] == 0x0
4712 OPC_Decode, 241, 130, 1, 1, // 7477: decode to VSSEG2E16_V using decoder 1
4713 // 7477: }
4714 9, 7, // 7482: case 0x9: {
4715 OPC_CheckPredicate, 23, // 7484: check predicate 23
4716 OPC_Decode, 185, 131, 1, 3, // 7486: decode to VSUXSEG2EI16_V using decoder 3
4717 // 7486: }
4718 10, 7, // 7491: case 0xa: {
4719 OPC_CheckPredicate, 23, // 7493: check predicate 23
4720 OPC_Decode, 147, 131, 1, 4, // 7495: decode to VSSSEG2E16_V using decoder 4
4721 // 7495: }
4722 11, 7, // 7500: case 0xb: {
4723 OPC_CheckPredicate, 23, // 7502: check predicate 23
4724 OPC_Decode, 203, 130, 1, 3, // 7504: decode to VSOXSEG2EI16_V using decoder 3
4725 // 7504: }
4726 16, 11, // 7509: case 0x10: {
4727 OPC_CheckPredicate, 23, // 7511: check predicate 23
4728 OPC_CheckField, 20, 5, 0, // 7513: check Inst[24:20] == 0x0
4729 OPC_Decode, 245, 130, 1, 1, // 7517: decode to VSSEG3E16_V using decoder 1
4730 // 7517: }
4731 17, 7, // 7522: case 0x11: {
4732 OPC_CheckPredicate, 23, // 7524: check predicate 23
4733 OPC_Decode, 189, 131, 1, 3, // 7526: decode to VSUXSEG3EI16_V using decoder 3
4734 // 7526: }
4735 18, 7, // 7531: case 0x12: {
4736 OPC_CheckPredicate, 23, // 7533: check predicate 23
4737 OPC_Decode, 151, 131, 1, 4, // 7535: decode to VSSSEG3E16_V using decoder 4
4738 // 7535: }
4739 19, 7, // 7540: case 0x13: {
4740 OPC_CheckPredicate, 23, // 7542: check predicate 23
4741 OPC_Decode, 207, 130, 1, 3, // 7544: decode to VSOXSEG3EI16_V using decoder 3
4742 // 7544: }
4743 24, 11, // 7549: case 0x18: {
4744 OPC_CheckPredicate, 23, // 7551: check predicate 23
4745 OPC_CheckField, 20, 5, 0, // 7553: check Inst[24:20] == 0x0
4746 OPC_Decode, 249, 130, 1, 1, // 7557: decode to VSSEG4E16_V using decoder 1
4747 // 7557: }
4748 25, 7, // 7562: case 0x19: {
4749 OPC_CheckPredicate, 23, // 7564: check predicate 23
4750 OPC_Decode, 193, 131, 1, 3, // 7566: decode to VSUXSEG4EI16_V using decoder 3
4751 // 7566: }
4752 26, 7, // 7571: case 0x1a: {
4753 OPC_CheckPredicate, 23, // 7573: check predicate 23
4754 OPC_Decode, 155, 131, 1, 4, // 7575: decode to VSSSEG4E16_V using decoder 4
4755 // 7575: }
4756 27, 7, // 7580: case 0x1b: {
4757 OPC_CheckPredicate, 23, // 7582: check predicate 23
4758 OPC_Decode, 211, 130, 1, 3, // 7584: decode to VSOXSEG4EI16_V using decoder 3
4759 // 7584: }
4760 32, 11, // 7589: case 0x20: {
4761 OPC_CheckPredicate, 23, // 7591: check predicate 23
4762 OPC_CheckField, 20, 5, 0, // 7593: check Inst[24:20] == 0x0
4763 OPC_Decode, 253, 130, 1, 1, // 7597: decode to VSSEG5E16_V using decoder 1
4764 // 7597: }
4765 33, 7, // 7602: case 0x21: {
4766 OPC_CheckPredicate, 23, // 7604: check predicate 23
4767 OPC_Decode, 197, 131, 1, 3, // 7606: decode to VSUXSEG5EI16_V using decoder 3
4768 // 7606: }
4769 34, 7, // 7611: case 0x22: {
4770 OPC_CheckPredicate, 23, // 7613: check predicate 23
4771 OPC_Decode, 159, 131, 1, 4, // 7615: decode to VSSSEG5E16_V using decoder 4
4772 // 7615: }
4773 35, 7, // 7620: case 0x23: {
4774 OPC_CheckPredicate, 23, // 7622: check predicate 23
4775 OPC_Decode, 215, 130, 1, 3, // 7624: decode to VSOXSEG5EI16_V using decoder 3
4776 // 7624: }
4777 40, 11, // 7629: case 0x28: {
4778 OPC_CheckPredicate, 23, // 7631: check predicate 23
4779 OPC_CheckField, 20, 5, 0, // 7633: check Inst[24:20] == 0x0
4780 OPC_Decode, 129, 131, 1, 1, // 7637: decode to VSSEG6E16_V using decoder 1
4781 // 7637: }
4782 41, 7, // 7642: case 0x29: {
4783 OPC_CheckPredicate, 23, // 7644: check predicate 23
4784 OPC_Decode, 201, 131, 1, 3, // 7646: decode to VSUXSEG6EI16_V using decoder 3
4785 // 7646: }
4786 42, 7, // 7651: case 0x2a: {
4787 OPC_CheckPredicate, 23, // 7653: check predicate 23
4788 OPC_Decode, 163, 131, 1, 4, // 7655: decode to VSSSEG6E16_V using decoder 4
4789 // 7655: }
4790 43, 7, // 7660: case 0x2b: {
4791 OPC_CheckPredicate, 23, // 7662: check predicate 23
4792 OPC_Decode, 219, 130, 1, 3, // 7664: decode to VSOXSEG6EI16_V using decoder 3
4793 // 7664: }
4794 48, 11, // 7669: case 0x30: {
4795 OPC_CheckPredicate, 23, // 7671: check predicate 23
4796 OPC_CheckField, 20, 5, 0, // 7673: check Inst[24:20] == 0x0
4797 OPC_Decode, 133, 131, 1, 1, // 7677: decode to VSSEG7E16_V using decoder 1
4798 // 7677: }
4799 49, 7, // 7682: case 0x31: {
4800 OPC_CheckPredicate, 23, // 7684: check predicate 23
4801 OPC_Decode, 205, 131, 1, 3, // 7686: decode to VSUXSEG7EI16_V using decoder 3
4802 // 7686: }
4803 50, 7, // 7691: case 0x32: {
4804 OPC_CheckPredicate, 23, // 7693: check predicate 23
4805 OPC_Decode, 167, 131, 1, 4, // 7695: decode to VSSSEG7E16_V using decoder 4
4806 // 7695: }
4807 51, 7, // 7700: case 0x33: {
4808 OPC_CheckPredicate, 23, // 7702: check predicate 23
4809 OPC_Decode, 223, 130, 1, 3, // 7704: decode to VSOXSEG7EI16_V using decoder 3
4810 // 7704: }
4811 56, 11, // 7709: case 0x38: {
4812 OPC_CheckPredicate, 23, // 7711: check predicate 23
4813 OPC_CheckField, 20, 5, 0, // 7713: check Inst[24:20] == 0x0
4814 OPC_Decode, 137, 131, 1, 1, // 7717: decode to VSSEG8E16_V using decoder 1
4815 // 7717: }
4816 57, 7, // 7722: case 0x39: {
4817 OPC_CheckPredicate, 23, // 7724: check predicate 23
4818 OPC_Decode, 209, 131, 1, 3, // 7726: decode to VSUXSEG8EI16_V using decoder 3
4819 // 7726: }
4820 58, 7, // 7731: case 0x3a: {
4821 OPC_CheckPredicate, 23, // 7733: check predicate 23
4822 OPC_Decode, 171, 131, 1, 4, // 7735: decode to VSSSEG8E16_V using decoder 4
4823 // 7735: }
4824 59, 0, // 7740: case 0x3b: {
4825 OPC_CheckPredicate, 23, // 7742: check predicate 23
4826 OPC_Decode, 227, 130, 1, 3, // 7744: decode to VSOXSEG8EI16_V using decoder 3
4827 // 7744: }
4828 // 7744: } // switch Inst[31:26]
4829 // 7744: }
4830 6, 195, 2, // 7749: case 0x6: {
4831 OPC_SwitchField, 26, 6, // 7752: switch Inst[31:26] {
4832 0, 11, // 7755: case 0x0: {
4833 OPC_CheckPredicate, 23, // 7757: check predicate 23
4834 OPC_CheckField, 20, 5, 0, // 7759: check Inst[24:20] == 0x0
4835 OPC_Decode, 170, 130, 1, 1, // 7763: decode to VSE32_V using decoder 1
4836 // 7763: }
4837 1, 7, // 7768: case 0x1: {
4838 OPC_CheckPredicate, 23, // 7770: check predicate 23
4839 OPC_Decode, 182, 131, 1, 3, // 7772: decode to VSUXEI32_V using decoder 3
4840 // 7772: }
4841 2, 7, // 7777: case 0x2: {
4842 OPC_CheckPredicate, 23, // 7779: check predicate 23
4843 OPC_Decode, 238, 130, 1, 4, // 7781: decode to VSSE32_V using decoder 4
4844 // 7781: }
4845 3, 7, // 7786: case 0x3: {
4846 OPC_CheckPredicate, 23, // 7788: check predicate 23
4847 OPC_Decode, 200, 130, 1, 3, // 7790: decode to VSOXEI32_V using decoder 3
4848 // 7790: }
4849 8, 11, // 7795: case 0x8: {
4850 OPC_CheckPredicate, 23, // 7797: check predicate 23
4851 OPC_CheckField, 20, 5, 0, // 7799: check Inst[24:20] == 0x0
4852 OPC_Decode, 242, 130, 1, 1, // 7803: decode to VSSEG2E32_V using decoder 1
4853 // 7803: }
4854 9, 7, // 7808: case 0x9: {
4855 OPC_CheckPredicate, 23, // 7810: check predicate 23
4856 OPC_Decode, 186, 131, 1, 3, // 7812: decode to VSUXSEG2EI32_V using decoder 3
4857 // 7812: }
4858 10, 7, // 7817: case 0xa: {
4859 OPC_CheckPredicate, 23, // 7819: check predicate 23
4860 OPC_Decode, 148, 131, 1, 4, // 7821: decode to VSSSEG2E32_V using decoder 4
4861 // 7821: }
4862 11, 7, // 7826: case 0xb: {
4863 OPC_CheckPredicate, 23, // 7828: check predicate 23
4864 OPC_Decode, 204, 130, 1, 3, // 7830: decode to VSOXSEG2EI32_V using decoder 3
4865 // 7830: }
4866 16, 11, // 7835: case 0x10: {
4867 OPC_CheckPredicate, 23, // 7837: check predicate 23
4868 OPC_CheckField, 20, 5, 0, // 7839: check Inst[24:20] == 0x0
4869 OPC_Decode, 246, 130, 1, 1, // 7843: decode to VSSEG3E32_V using decoder 1
4870 // 7843: }
4871 17, 7, // 7848: case 0x11: {
4872 OPC_CheckPredicate, 23, // 7850: check predicate 23
4873 OPC_Decode, 190, 131, 1, 3, // 7852: decode to VSUXSEG3EI32_V using decoder 3
4874 // 7852: }
4875 18, 7, // 7857: case 0x12: {
4876 OPC_CheckPredicate, 23, // 7859: check predicate 23
4877 OPC_Decode, 152, 131, 1, 4, // 7861: decode to VSSSEG3E32_V using decoder 4
4878 // 7861: }
4879 19, 7, // 7866: case 0x13: {
4880 OPC_CheckPredicate, 23, // 7868: check predicate 23
4881 OPC_Decode, 208, 130, 1, 3, // 7870: decode to VSOXSEG3EI32_V using decoder 3
4882 // 7870: }
4883 24, 11, // 7875: case 0x18: {
4884 OPC_CheckPredicate, 23, // 7877: check predicate 23
4885 OPC_CheckField, 20, 5, 0, // 7879: check Inst[24:20] == 0x0
4886 OPC_Decode, 250, 130, 1, 1, // 7883: decode to VSSEG4E32_V using decoder 1
4887 // 7883: }
4888 25, 7, // 7888: case 0x19: {
4889 OPC_CheckPredicate, 23, // 7890: check predicate 23
4890 OPC_Decode, 194, 131, 1, 3, // 7892: decode to VSUXSEG4EI32_V using decoder 3
4891 // 7892: }
4892 26, 7, // 7897: case 0x1a: {
4893 OPC_CheckPredicate, 23, // 7899: check predicate 23
4894 OPC_Decode, 156, 131, 1, 4, // 7901: decode to VSSSEG4E32_V using decoder 4
4895 // 7901: }
4896 27, 7, // 7906: case 0x1b: {
4897 OPC_CheckPredicate, 23, // 7908: check predicate 23
4898 OPC_Decode, 212, 130, 1, 3, // 7910: decode to VSOXSEG4EI32_V using decoder 3
4899 // 7910: }
4900 32, 11, // 7915: case 0x20: {
4901 OPC_CheckPredicate, 23, // 7917: check predicate 23
4902 OPC_CheckField, 20, 5, 0, // 7919: check Inst[24:20] == 0x0
4903 OPC_Decode, 254, 130, 1, 1, // 7923: decode to VSSEG5E32_V using decoder 1
4904 // 7923: }
4905 33, 7, // 7928: case 0x21: {
4906 OPC_CheckPredicate, 23, // 7930: check predicate 23
4907 OPC_Decode, 198, 131, 1, 3, // 7932: decode to VSUXSEG5EI32_V using decoder 3
4908 // 7932: }
4909 34, 7, // 7937: case 0x22: {
4910 OPC_CheckPredicate, 23, // 7939: check predicate 23
4911 OPC_Decode, 160, 131, 1, 4, // 7941: decode to VSSSEG5E32_V using decoder 4
4912 // 7941: }
4913 35, 7, // 7946: case 0x23: {
4914 OPC_CheckPredicate, 23, // 7948: check predicate 23
4915 OPC_Decode, 216, 130, 1, 3, // 7950: decode to VSOXSEG5EI32_V using decoder 3
4916 // 7950: }
4917 40, 11, // 7955: case 0x28: {
4918 OPC_CheckPredicate, 23, // 7957: check predicate 23
4919 OPC_CheckField, 20, 5, 0, // 7959: check Inst[24:20] == 0x0
4920 OPC_Decode, 130, 131, 1, 1, // 7963: decode to VSSEG6E32_V using decoder 1
4921 // 7963: }
4922 41, 7, // 7968: case 0x29: {
4923 OPC_CheckPredicate, 23, // 7970: check predicate 23
4924 OPC_Decode, 202, 131, 1, 3, // 7972: decode to VSUXSEG6EI32_V using decoder 3
4925 // 7972: }
4926 42, 7, // 7977: case 0x2a: {
4927 OPC_CheckPredicate, 23, // 7979: check predicate 23
4928 OPC_Decode, 164, 131, 1, 4, // 7981: decode to VSSSEG6E32_V using decoder 4
4929 // 7981: }
4930 43, 7, // 7986: case 0x2b: {
4931 OPC_CheckPredicate, 23, // 7988: check predicate 23
4932 OPC_Decode, 220, 130, 1, 3, // 7990: decode to VSOXSEG6EI32_V using decoder 3
4933 // 7990: }
4934 48, 11, // 7995: case 0x30: {
4935 OPC_CheckPredicate, 23, // 7997: check predicate 23
4936 OPC_CheckField, 20, 5, 0, // 7999: check Inst[24:20] == 0x0
4937 OPC_Decode, 134, 131, 1, 1, // 8003: decode to VSSEG7E32_V using decoder 1
4938 // 8003: }
4939 49, 7, // 8008: case 0x31: {
4940 OPC_CheckPredicate, 23, // 8010: check predicate 23
4941 OPC_Decode, 206, 131, 1, 3, // 8012: decode to VSUXSEG7EI32_V using decoder 3
4942 // 8012: }
4943 50, 7, // 8017: case 0x32: {
4944 OPC_CheckPredicate, 23, // 8019: check predicate 23
4945 OPC_Decode, 168, 131, 1, 4, // 8021: decode to VSSSEG7E32_V using decoder 4
4946 // 8021: }
4947 51, 7, // 8026: case 0x33: {
4948 OPC_CheckPredicate, 23, // 8028: check predicate 23
4949 OPC_Decode, 224, 130, 1, 3, // 8030: decode to VSOXSEG7EI32_V using decoder 3
4950 // 8030: }
4951 56, 11, // 8035: case 0x38: {
4952 OPC_CheckPredicate, 23, // 8037: check predicate 23
4953 OPC_CheckField, 20, 5, 0, // 8039: check Inst[24:20] == 0x0
4954 OPC_Decode, 138, 131, 1, 1, // 8043: decode to VSSEG8E32_V using decoder 1
4955 // 8043: }
4956 57, 7, // 8048: case 0x39: {
4957 OPC_CheckPredicate, 23, // 8050: check predicate 23
4958 OPC_Decode, 210, 131, 1, 3, // 8052: decode to VSUXSEG8EI32_V using decoder 3
4959 // 8052: }
4960 58, 7, // 8057: case 0x3a: {
4961 OPC_CheckPredicate, 23, // 8059: check predicate 23
4962 OPC_Decode, 172, 131, 1, 4, // 8061: decode to VSSSEG8E32_V using decoder 4
4963 // 8061: }
4964 59, 0, // 8066: case 0x3b: {
4965 OPC_CheckPredicate, 23, // 8068: check predicate 23
4966 OPC_Decode, 228, 130, 1, 3, // 8070: decode to VSOXSEG8EI32_V using decoder 3
4967 // 8070: }
4968 // 8070: } // switch Inst[31:26]
4969 // 8070: }
4970 7, 0, // 8075: case 0x7: {
4971 OPC_SwitchField, 26, 3, // 8077: switch Inst[28:26] {
4972 0, 107, // 8080: case 0x0: {
4973 OPC_SwitchField, 29, 3, // 8082: switch Inst[31:29] {
4974 0, 11, // 8085: case 0x0: {
4975 OPC_CheckPredicate, 28, // 8087: check predicate 28
4976 OPC_CheckField, 20, 5, 0, // 8089: check Inst[24:20] == 0x0
4977 OPC_Decode, 171, 130, 1, 1, // 8093: decode to VSE64_V using decoder 1
4978 // 8093: }
4979 1, 11, // 8098: case 0x1: {
4980 OPC_CheckPredicate, 28, // 8100: check predicate 28
4981 OPC_CheckField, 20, 5, 0, // 8102: check Inst[24:20] == 0x0
4982 OPC_Decode, 243, 130, 1, 1, // 8106: decode to VSSEG2E64_V using decoder 1
4983 // 8106: }
4984 2, 11, // 8111: case 0x2: {
4985 OPC_CheckPredicate, 28, // 8113: check predicate 28
4986 OPC_CheckField, 20, 5, 0, // 8115: check Inst[24:20] == 0x0
4987 OPC_Decode, 247, 130, 1, 1, // 8119: decode to VSSEG3E64_V using decoder 1
4988 // 8119: }
4989 3, 11, // 8124: case 0x3: {
4990 OPC_CheckPredicate, 28, // 8126: check predicate 28
4991 OPC_CheckField, 20, 5, 0, // 8128: check Inst[24:20] == 0x0
4992 OPC_Decode, 251, 130, 1, 1, // 8132: decode to VSSEG4E64_V using decoder 1
4993 // 8132: }
4994 4, 11, // 8137: case 0x4: {
4995 OPC_CheckPredicate, 28, // 8139: check predicate 28
4996 OPC_CheckField, 20, 5, 0, // 8141: check Inst[24:20] == 0x0
4997 OPC_Decode, 255, 130, 1, 1, // 8145: decode to VSSEG5E64_V using decoder 1
4998 // 8145: }
4999 5, 11, // 8150: case 0x5: {
5000 OPC_CheckPredicate, 28, // 8152: check predicate 28
5001 OPC_CheckField, 20, 5, 0, // 8154: check Inst[24:20] == 0x0
5002 OPC_Decode, 131, 131, 1, 1, // 8158: decode to VSSEG6E64_V using decoder 1
5003 // 8158: }
5004 6, 11, // 8163: case 0x6: {
5005 OPC_CheckPredicate, 28, // 8165: check predicate 28
5006 OPC_CheckField, 20, 5, 0, // 8167: check Inst[24:20] == 0x0
5007 OPC_Decode, 135, 131, 1, 1, // 8171: decode to VSSEG7E64_V using decoder 1
5008 // 8171: }
5009 7, 0, // 8176: case 0x7: {
5010 OPC_CheckPredicate, 28, // 8178: check predicate 28
5011 OPC_CheckField, 20, 5, 0, // 8180: check Inst[24:20] == 0x0
5012 OPC_Decode, 139, 131, 1, 1, // 8184: decode to VSSEG8E64_V using decoder 1
5013 // 8184: }
5014 // 8184: } // switch Inst[31:29]
5015 // 8184: }
5016 1, 75, // 8189: case 0x1: {
5017 OPC_SwitchField, 29, 3, // 8191: switch Inst[31:29] {
5018 0, 7, // 8194: case 0x0: {
5019 OPC_CheckPredicate, 29, // 8196: check predicate 29
5020 OPC_Decode, 183, 131, 1, 3, // 8198: decode to VSUXEI64_V using decoder 3
5021 // 8198: }
5022 1, 7, // 8203: case 0x1: {
5023 OPC_CheckPredicate, 30, // 8205: check predicate 30
5024 OPC_Decode, 187, 131, 1, 3, // 8207: decode to VSUXSEG2EI64_V using decoder 3
5025 // 8207: }
5026 2, 7, // 8212: case 0x2: {
5027 OPC_CheckPredicate, 30, // 8214: check predicate 30
5028 OPC_Decode, 191, 131, 1, 3, // 8216: decode to VSUXSEG3EI64_V using decoder 3
5029 // 8216: }
5030 3, 7, // 8221: case 0x3: {
5031 OPC_CheckPredicate, 30, // 8223: check predicate 30
5032 OPC_Decode, 195, 131, 1, 3, // 8225: decode to VSUXSEG4EI64_V using decoder 3
5033 // 8225: }
5034 4, 7, // 8230: case 0x4: {
5035 OPC_CheckPredicate, 30, // 8232: check predicate 30
5036 OPC_Decode, 199, 131, 1, 3, // 8234: decode to VSUXSEG5EI64_V using decoder 3
5037 // 8234: }
5038 5, 7, // 8239: case 0x5: {
5039 OPC_CheckPredicate, 30, // 8241: check predicate 30
5040 OPC_Decode, 203, 131, 1, 3, // 8243: decode to VSUXSEG6EI64_V using decoder 3
5041 // 8243: }
5042 6, 7, // 8248: case 0x6: {
5043 OPC_CheckPredicate, 30, // 8250: check predicate 30
5044 OPC_Decode, 207, 131, 1, 3, // 8252: decode to VSUXSEG7EI64_V using decoder 3
5045 // 8252: }
5046 7, 0, // 8257: case 0x7: {
5047 OPC_CheckPredicate, 30, // 8259: check predicate 30
5048 OPC_Decode, 211, 131, 1, 3, // 8261: decode to VSUXSEG8EI64_V using decoder 3
5049 // 8261: }
5050 // 8261: } // switch Inst[31:29]
5051 // 8261: }
5052 2, 75, // 8266: case 0x2: {
5053 OPC_SwitchField, 29, 3, // 8268: switch Inst[31:29] {
5054 0, 7, // 8271: case 0x0: {
5055 OPC_CheckPredicate, 28, // 8273: check predicate 28
5056 OPC_Decode, 239, 130, 1, 4, // 8275: decode to VSSE64_V using decoder 4
5057 // 8275: }
5058 1, 7, // 8280: case 0x1: {
5059 OPC_CheckPredicate, 28, // 8282: check predicate 28
5060 OPC_Decode, 149, 131, 1, 4, // 8284: decode to VSSSEG2E64_V using decoder 4
5061 // 8284: }
5062 2, 7, // 8289: case 0x2: {
5063 OPC_CheckPredicate, 28, // 8291: check predicate 28
5064 OPC_Decode, 153, 131, 1, 4, // 8293: decode to VSSSEG3E64_V using decoder 4
5065 // 8293: }
5066 3, 7, // 8298: case 0x3: {
5067 OPC_CheckPredicate, 28, // 8300: check predicate 28
5068 OPC_Decode, 157, 131, 1, 4, // 8302: decode to VSSSEG4E64_V using decoder 4
5069 // 8302: }
5070 4, 7, // 8307: case 0x4: {
5071 OPC_CheckPredicate, 28, // 8309: check predicate 28
5072 OPC_Decode, 161, 131, 1, 4, // 8311: decode to VSSSEG5E64_V using decoder 4
5073 // 8311: }
5074 5, 7, // 8316: case 0x5: {
5075 OPC_CheckPredicate, 28, // 8318: check predicate 28
5076 OPC_Decode, 165, 131, 1, 4, // 8320: decode to VSSSEG6E64_V using decoder 4
5077 // 8320: }
5078 6, 7, // 8325: case 0x6: {
5079 OPC_CheckPredicate, 28, // 8327: check predicate 28
5080 OPC_Decode, 169, 131, 1, 4, // 8329: decode to VSSSEG7E64_V using decoder 4
5081 // 8329: }
5082 7, 0, // 8334: case 0x7: {
5083 OPC_CheckPredicate, 28, // 8336: check predicate 28
5084 OPC_Decode, 173, 131, 1, 4, // 8338: decode to VSSSEG8E64_V using decoder 4
5085 // 8338: }
5086 // 8338: } // switch Inst[31:29]
5087 // 8338: }
5088 3, 75, // 8343: case 0x3: {
5089 OPC_SwitchField, 29, 3, // 8345: switch Inst[31:29] {
5090 0, 7, // 8348: case 0x0: {
5091 OPC_CheckPredicate, 29, // 8350: check predicate 29
5092 OPC_Decode, 201, 130, 1, 3, // 8352: decode to VSOXEI64_V using decoder 3
5093 // 8352: }
5094 1, 7, // 8357: case 0x1: {
5095 OPC_CheckPredicate, 30, // 8359: check predicate 30
5096 OPC_Decode, 205, 130, 1, 3, // 8361: decode to VSOXSEG2EI64_V using decoder 3
5097 // 8361: }
5098 2, 7, // 8366: case 0x2: {
5099 OPC_CheckPredicate, 30, // 8368: check predicate 30
5100 OPC_Decode, 209, 130, 1, 3, // 8370: decode to VSOXSEG3EI64_V using decoder 3
5101 // 8370: }
5102 3, 7, // 8375: case 0x3: {
5103 OPC_CheckPredicate, 30, // 8377: check predicate 30
5104 OPC_Decode, 213, 130, 1, 3, // 8379: decode to VSOXSEG4EI64_V using decoder 3
5105 // 8379: }
5106 4, 7, // 8384: case 0x4: {
5107 OPC_CheckPredicate, 30, // 8386: check predicate 30
5108 OPC_Decode, 217, 130, 1, 3, // 8388: decode to VSOXSEG5EI64_V using decoder 3
5109 // 8388: }
5110 5, 7, // 8393: case 0x5: {
5111 OPC_CheckPredicate, 30, // 8395: check predicate 30
5112 OPC_Decode, 221, 130, 1, 3, // 8397: decode to VSOXSEG6EI64_V using decoder 3
5113 // 8397: }
5114 6, 7, // 8402: case 0x6: {
5115 OPC_CheckPredicate, 30, // 8404: check predicate 30
5116 OPC_Decode, 225, 130, 1, 3, // 8406: decode to VSOXSEG7EI64_V using decoder 3
5117 // 8406: }
5118 7, 0, // 8411: case 0x7: {
5119 OPC_CheckPredicate, 30, // 8413: check predicate 30
5120 OPC_Decode, 229, 130, 1, 3, // 8415: decode to VSOXSEG8EI64_V using decoder 3
5121 // 8415: }
5122 // 8415: } // switch Inst[31:29]
5123 // 8415: }
5124 4, 7, // 8420: case 0x4: {
5125 OPC_CheckPredicate, 31, // 8422: check predicate 31
5126 OPC_Decode, 208, 129, 1, 12, // 8424: decode to VMTS_V using decoder 12
5127 // 8424: }
5128 5, 0, // 8429: case 0x5: {
5129 OPC_CheckPredicate, 32, // 8431: check predicate 32
5130 OPC_Decode, 210, 129, 1, 12, // 8433: decode to VMTTS_V using decoder 12
5131 // 8433: }
5132 // 8433: } // switch Inst[28:26]
5133 // 8433: }
5134 // 8433: } // switch Inst[14:12]
5135 // 8433: }
5136 47, 226, 16, // 8438: case 0x2f: {
5137 OPC_SwitchField, 25, 7, // 8441: switch Inst[31:25] {
5138 0, 35, // 8444: case 0x0: {
5139 OPC_SwitchField, 12, 3, // 8446: switch Inst[14:12] {
5140 0, 6, // 8449: case 0x0: {
5141 OPC_CheckPredicate, 52, // 8451: check predicate 52
5142 OPC_Decode, 177, 109, 56, // 8453: decode to AMOADD_B using decoder 56
5143 // 8453: }
5144 1, 6, // 8457: case 0x1: {
5145 OPC_CheckPredicate, 52, // 8459: check predicate 52
5146 OPC_Decode, 185, 109, 56, // 8461: decode to AMOADD_H using decoder 56
5147 // 8461: }
5148 2, 6, // 8465: case 0x2: {
5149 OPC_CheckPredicate, 53, // 8467: check predicate 53
5150 OPC_Decode, 189, 109, 56, // 8469: decode to AMOADD_W using decoder 56
5151 // 8469: }
5152 3, 0, // 8473: case 0x3: {
5153 OPC_CheckPredicate, 54, // 8475: check predicate 54
5154 OPC_Decode, 181, 109, 56, // 8477: decode to AMOADD_D using decoder 56
5155 // 8477: }
5156 // 8477: } // switch Inst[14:12]
5157 // 8477: }
5158 1, 35, // 8481: case 0x1: {
5159 OPC_SwitchField, 12, 3, // 8483: switch Inst[14:12] {
5160 0, 6, // 8486: case 0x0: {
5161 OPC_CheckPredicate, 52, // 8488: check predicate 52
5162 OPC_Decode, 180, 109, 56, // 8490: decode to AMOADD_B_RL using decoder 56
5163 // 8490: }
5164 1, 6, // 8494: case 0x1: {
5165 OPC_CheckPredicate, 52, // 8496: check predicate 52
5166 OPC_Decode, 188, 109, 56, // 8498: decode to AMOADD_H_RL using decoder 56
5167 // 8498: }
5168 2, 6, // 8502: case 0x2: {
5169 OPC_CheckPredicate, 53, // 8504: check predicate 53
5170 OPC_Decode, 192, 109, 56, // 8506: decode to AMOADD_W_RL using decoder 56
5171 // 8506: }
5172 3, 0, // 8510: case 0x3: {
5173 OPC_CheckPredicate, 54, // 8512: check predicate 54
5174 OPC_Decode, 184, 109, 56, // 8514: decode to AMOADD_D_RL using decoder 56
5175 // 8514: }
5176 // 8514: } // switch Inst[14:12]
5177 // 8514: }
5178 2, 35, // 8518: case 0x2: {
5179 OPC_SwitchField, 12, 3, // 8520: switch Inst[14:12] {
5180 0, 6, // 8523: case 0x0: {
5181 OPC_CheckPredicate, 52, // 8525: check predicate 52
5182 OPC_Decode, 178, 109, 56, // 8527: decode to AMOADD_B_AQ using decoder 56
5183 // 8527: }
5184 1, 6, // 8531: case 0x1: {
5185 OPC_CheckPredicate, 52, // 8533: check predicate 52
5186 OPC_Decode, 186, 109, 56, // 8535: decode to AMOADD_H_AQ using decoder 56
5187 // 8535: }
5188 2, 6, // 8539: case 0x2: {
5189 OPC_CheckPredicate, 53, // 8541: check predicate 53
5190 OPC_Decode, 190, 109, 56, // 8543: decode to AMOADD_W_AQ using decoder 56
5191 // 8543: }
5192 3, 0, // 8547: case 0x3: {
5193 OPC_CheckPredicate, 54, // 8549: check predicate 54
5194 OPC_Decode, 182, 109, 56, // 8551: decode to AMOADD_D_AQ using decoder 56
5195 // 8551: }
5196 // 8551: } // switch Inst[14:12]
5197 // 8551: }
5198 3, 35, // 8555: case 0x3: {
5199 OPC_SwitchField, 12, 3, // 8557: switch Inst[14:12] {
5200 0, 6, // 8560: case 0x0: {
5201 OPC_CheckPredicate, 52, // 8562: check predicate 52
5202 OPC_Decode, 179, 109, 56, // 8564: decode to AMOADD_B_AQRL using decoder 56
5203 // 8564: }
5204 1, 6, // 8568: case 0x1: {
5205 OPC_CheckPredicate, 52, // 8570: check predicate 52
5206 OPC_Decode, 187, 109, 56, // 8572: decode to AMOADD_H_AQRL using decoder 56
5207 // 8572: }
5208 2, 6, // 8576: case 0x2: {
5209 OPC_CheckPredicate, 53, // 8578: check predicate 53
5210 OPC_Decode, 191, 109, 56, // 8580: decode to AMOADD_W_AQRL using decoder 56
5211 // 8580: }
5212 3, 0, // 8584: case 0x3: {
5213 OPC_CheckPredicate, 54, // 8586: check predicate 54
5214 OPC_Decode, 183, 109, 56, // 8588: decode to AMOADD_D_AQRL using decoder 56
5215 // 8588: }
5216 // 8588: } // switch Inst[14:12]
5217 // 8588: }
5218 4, 35, // 8592: case 0x4: {
5219 OPC_SwitchField, 12, 3, // 8594: switch Inst[14:12] {
5220 0, 6, // 8597: case 0x0: {
5221 OPC_CheckPredicate, 52, // 8599: check predicate 52
5222 OPC_Decode, 185, 110, 56, // 8601: decode to AMOSWAP_B using decoder 56
5223 // 8601: }
5224 1, 6, // 8605: case 0x1: {
5225 OPC_CheckPredicate, 52, // 8607: check predicate 52
5226 OPC_Decode, 193, 110, 56, // 8609: decode to AMOSWAP_H using decoder 56
5227 // 8609: }
5228 2, 6, // 8613: case 0x2: {
5229 OPC_CheckPredicate, 53, // 8615: check predicate 53
5230 OPC_Decode, 197, 110, 56, // 8617: decode to AMOSWAP_W using decoder 56
5231 // 8617: }
5232 3, 0, // 8621: case 0x3: {
5233 OPC_CheckPredicate, 54, // 8623: check predicate 54
5234 OPC_Decode, 189, 110, 56, // 8625: decode to AMOSWAP_D using decoder 56
5235 // 8625: }
5236 // 8625: } // switch Inst[14:12]
5237 // 8625: }
5238 5, 35, // 8629: case 0x5: {
5239 OPC_SwitchField, 12, 3, // 8631: switch Inst[14:12] {
5240 0, 6, // 8634: case 0x0: {
5241 OPC_CheckPredicate, 52, // 8636: check predicate 52
5242 OPC_Decode, 188, 110, 56, // 8638: decode to AMOSWAP_B_RL using decoder 56
5243 // 8638: }
5244 1, 6, // 8642: case 0x1: {
5245 OPC_CheckPredicate, 52, // 8644: check predicate 52
5246 OPC_Decode, 196, 110, 56, // 8646: decode to AMOSWAP_H_RL using decoder 56
5247 // 8646: }
5248 2, 6, // 8650: case 0x2: {
5249 OPC_CheckPredicate, 53, // 8652: check predicate 53
5250 OPC_Decode, 200, 110, 56, // 8654: decode to AMOSWAP_W_RL using decoder 56
5251 // 8654: }
5252 3, 0, // 8658: case 0x3: {
5253 OPC_CheckPredicate, 54, // 8660: check predicate 54
5254 OPC_Decode, 192, 110, 56, // 8662: decode to AMOSWAP_D_RL using decoder 56
5255 // 8662: }
5256 // 8662: } // switch Inst[14:12]
5257 // 8662: }
5258 6, 35, // 8666: case 0x6: {
5259 OPC_SwitchField, 12, 3, // 8668: switch Inst[14:12] {
5260 0, 6, // 8671: case 0x0: {
5261 OPC_CheckPredicate, 52, // 8673: check predicate 52
5262 OPC_Decode, 186, 110, 56, // 8675: decode to AMOSWAP_B_AQ using decoder 56
5263 // 8675: }
5264 1, 6, // 8679: case 0x1: {
5265 OPC_CheckPredicate, 52, // 8681: check predicate 52
5266 OPC_Decode, 194, 110, 56, // 8683: decode to AMOSWAP_H_AQ using decoder 56
5267 // 8683: }
5268 2, 6, // 8687: case 0x2: {
5269 OPC_CheckPredicate, 53, // 8689: check predicate 53
5270 OPC_Decode, 198, 110, 56, // 8691: decode to AMOSWAP_W_AQ using decoder 56
5271 // 8691: }
5272 3, 0, // 8695: case 0x3: {
5273 OPC_CheckPredicate, 54, // 8697: check predicate 54
5274 OPC_Decode, 190, 110, 56, // 8699: decode to AMOSWAP_D_AQ using decoder 56
5275 // 8699: }
5276 // 8699: } // switch Inst[14:12]
5277 // 8699: }
5278 7, 35, // 8703: case 0x7: {
5279 OPC_SwitchField, 12, 3, // 8705: switch Inst[14:12] {
5280 0, 6, // 8708: case 0x0: {
5281 OPC_CheckPredicate, 52, // 8710: check predicate 52
5282 OPC_Decode, 187, 110, 56, // 8712: decode to AMOSWAP_B_AQRL using decoder 56
5283 // 8712: }
5284 1, 6, // 8716: case 0x1: {
5285 OPC_CheckPredicate, 52, // 8718: check predicate 52
5286 OPC_Decode, 195, 110, 56, // 8720: decode to AMOSWAP_H_AQRL using decoder 56
5287 // 8720: }
5288 2, 6, // 8724: case 0x2: {
5289 OPC_CheckPredicate, 53, // 8726: check predicate 53
5290 OPC_Decode, 199, 110, 56, // 8728: decode to AMOSWAP_W_AQRL using decoder 56
5291 // 8728: }
5292 3, 0, // 8732: case 0x3: {
5293 OPC_CheckPredicate, 54, // 8734: check predicate 54
5294 OPC_Decode, 191, 110, 56, // 8736: decode to AMOSWAP_D_AQRL using decoder 56
5295 // 8736: }
5296 // 8736: } // switch Inst[14:12]
5297 // 8736: }
5298 8, 27, // 8740: case 0x8: {
5299 OPC_SwitchField, 12, 3, // 8742: switch Inst[14:12] {
5300 2, 10, // 8745: case 0x2: {
5301 OPC_CheckPredicate, 55, // 8747: check predicate 55
5302 OPC_CheckField, 20, 5, 0, // 8749: check Inst[24:20] == 0x0
5303 OPC_Decode, 238, 116, 17, // 8753: decode to LR_W using decoder 17
5304 // 8753: }
5305 3, 0, // 8757: case 0x3: {
5306 OPC_CheckPredicate, 56, // 8759: check predicate 56
5307 OPC_CheckField, 20, 5, 0, // 8761: check Inst[24:20] == 0x0
5308 OPC_Decode, 234, 116, 17, // 8765: decode to LR_D using decoder 17
5309 // 8765: }
5310 // 8765: } // switch Inst[14:12]
5311 // 8765: }
5312 9, 27, // 8769: case 0x9: {
5313 OPC_SwitchField, 12, 3, // 8771: switch Inst[14:12] {
5314 2, 10, // 8774: case 0x2: {
5315 OPC_CheckPredicate, 55, // 8776: check predicate 55
5316 OPC_CheckField, 20, 5, 0, // 8778: check Inst[24:20] == 0x0
5317 OPC_Decode, 241, 116, 17, // 8782: decode to LR_W_RL using decoder 17
5318 // 8782: }
5319 3, 0, // 8786: case 0x3: {
5320 OPC_CheckPredicate, 56, // 8788: check predicate 56
5321 OPC_CheckField, 20, 5, 0, // 8790: check Inst[24:20] == 0x0
5322 OPC_Decode, 237, 116, 17, // 8794: decode to LR_D_RL using decoder 17
5323 // 8794: }
5324 // 8794: } // switch Inst[14:12]
5325 // 8794: }
5326 10, 27, // 8798: case 0xa: {
5327 OPC_SwitchField, 12, 3, // 8800: switch Inst[14:12] {
5328 2, 10, // 8803: case 0x2: {
5329 OPC_CheckPredicate, 55, // 8805: check predicate 55
5330 OPC_CheckField, 20, 5, 0, // 8807: check Inst[24:20] == 0x0
5331 OPC_Decode, 239, 116, 17, // 8811: decode to LR_W_AQ using decoder 17
5332 // 8811: }
5333 3, 0, // 8815: case 0x3: {
5334 OPC_CheckPredicate, 56, // 8817: check predicate 56
5335 OPC_CheckField, 20, 5, 0, // 8819: check Inst[24:20] == 0x0
5336 OPC_Decode, 235, 116, 17, // 8823: decode to LR_D_AQ using decoder 17
5337 // 8823: }
5338 // 8823: } // switch Inst[14:12]
5339 // 8823: }
5340 11, 27, // 8827: case 0xb: {
5341 OPC_SwitchField, 12, 3, // 8829: switch Inst[14:12] {
5342 2, 10, // 8832: case 0x2: {
5343 OPC_CheckPredicate, 55, // 8834: check predicate 55
5344 OPC_CheckField, 20, 5, 0, // 8836: check Inst[24:20] == 0x0
5345 OPC_Decode, 240, 116, 17, // 8840: decode to LR_W_AQRL using decoder 17
5346 // 8840: }
5347 3, 0, // 8844: case 0x3: {
5348 OPC_CheckPredicate, 56, // 8846: check predicate 56
5349 OPC_CheckField, 20, 5, 0, // 8848: check Inst[24:20] == 0x0
5350 OPC_Decode, 236, 116, 17, // 8852: decode to LR_D_AQRL using decoder 17
5351 // 8852: }
5352 // 8852: } // switch Inst[14:12]
5353 // 8852: }
5354 12, 19, // 8856: case 0xc: {
5355 OPC_SwitchField, 12, 3, // 8858: switch Inst[14:12] {
5356 2, 6, // 8861: case 0x2: {
5357 OPC_CheckPredicate, 55, // 8863: check predicate 55
5358 OPC_Decode, 230, 123, 56, // 8865: decode to SC_W using decoder 56
5359 // 8865: }
5360 3, 0, // 8869: case 0x3: {
5361 OPC_CheckPredicate, 56, // 8871: check predicate 56
5362 OPC_Decode, 226, 123, 56, // 8873: decode to SC_D using decoder 56
5363 // 8873: }
5364 // 8873: } // switch Inst[14:12]
5365 // 8873: }
5366 13, 19, // 8877: case 0xd: {
5367 OPC_SwitchField, 12, 3, // 8879: switch Inst[14:12] {
5368 2, 6, // 8882: case 0x2: {
5369 OPC_CheckPredicate, 55, // 8884: check predicate 55
5370 OPC_Decode, 233, 123, 56, // 8886: decode to SC_W_RL using decoder 56
5371 // 8886: }
5372 3, 0, // 8890: case 0x3: {
5373 OPC_CheckPredicate, 56, // 8892: check predicate 56
5374 OPC_Decode, 229, 123, 56, // 8894: decode to SC_D_RL using decoder 56
5375 // 8894: }
5376 // 8894: } // switch Inst[14:12]
5377 // 8894: }
5378 14, 19, // 8898: case 0xe: {
5379 OPC_SwitchField, 12, 3, // 8900: switch Inst[14:12] {
5380 2, 6, // 8903: case 0x2: {
5381 OPC_CheckPredicate, 55, // 8905: check predicate 55
5382 OPC_Decode, 231, 123, 56, // 8907: decode to SC_W_AQ using decoder 56
5383 // 8907: }
5384 3, 0, // 8911: case 0x3: {
5385 OPC_CheckPredicate, 56, // 8913: check predicate 56
5386 OPC_Decode, 227, 123, 56, // 8915: decode to SC_D_AQ using decoder 56
5387 // 8915: }
5388 // 8915: } // switch Inst[14:12]
5389 // 8915: }
5390 15, 19, // 8919: case 0xf: {
5391 OPC_SwitchField, 12, 3, // 8921: switch Inst[14:12] {
5392 2, 6, // 8924: case 0x2: {
5393 OPC_CheckPredicate, 55, // 8926: check predicate 55
5394 OPC_Decode, 232, 123, 56, // 8928: decode to SC_W_AQRL using decoder 56
5395 // 8928: }
5396 3, 0, // 8932: case 0x3: {
5397 OPC_CheckPredicate, 56, // 8934: check predicate 56
5398 OPC_Decode, 228, 123, 56, // 8936: decode to SC_D_AQRL using decoder 56
5399 // 8936: }
5400 // 8936: } // switch Inst[14:12]
5401 // 8936: }
5402 16, 35, // 8940: case 0x10: {
5403 OPC_SwitchField, 12, 3, // 8942: switch Inst[14:12] {
5404 0, 6, // 8945: case 0x0: {
5405 OPC_CheckPredicate, 52, // 8947: check predicate 52
5406 OPC_Decode, 201, 110, 56, // 8949: decode to AMOXOR_B using decoder 56
5407 // 8949: }
5408 1, 6, // 8953: case 0x1: {
5409 OPC_CheckPredicate, 52, // 8955: check predicate 52
5410 OPC_Decode, 209, 110, 56, // 8957: decode to AMOXOR_H using decoder 56
5411 // 8957: }
5412 2, 6, // 8961: case 0x2: {
5413 OPC_CheckPredicate, 53, // 8963: check predicate 53
5414 OPC_Decode, 213, 110, 56, // 8965: decode to AMOXOR_W using decoder 56
5415 // 8965: }
5416 3, 0, // 8969: case 0x3: {
5417 OPC_CheckPredicate, 54, // 8971: check predicate 54
5418 OPC_Decode, 205, 110, 56, // 8973: decode to AMOXOR_D using decoder 56
5419 // 8973: }
5420 // 8973: } // switch Inst[14:12]
5421 // 8973: }
5422 17, 35, // 8977: case 0x11: {
5423 OPC_SwitchField, 12, 3, // 8979: switch Inst[14:12] {
5424 0, 6, // 8982: case 0x0: {
5425 OPC_CheckPredicate, 52, // 8984: check predicate 52
5426 OPC_Decode, 204, 110, 56, // 8986: decode to AMOXOR_B_RL using decoder 56
5427 // 8986: }
5428 1, 6, // 8990: case 0x1: {
5429 OPC_CheckPredicate, 52, // 8992: check predicate 52
5430 OPC_Decode, 212, 110, 56, // 8994: decode to AMOXOR_H_RL using decoder 56
5431 // 8994: }
5432 2, 6, // 8998: case 0x2: {
5433 OPC_CheckPredicate, 53, // 9000: check predicate 53
5434 OPC_Decode, 216, 110, 56, // 9002: decode to AMOXOR_W_RL using decoder 56
5435 // 9002: }
5436 3, 0, // 9006: case 0x3: {
5437 OPC_CheckPredicate, 54, // 9008: check predicate 54
5438 OPC_Decode, 208, 110, 56, // 9010: decode to AMOXOR_D_RL using decoder 56
5439 // 9010: }
5440 // 9010: } // switch Inst[14:12]
5441 // 9010: }
5442 18, 35, // 9014: case 0x12: {
5443 OPC_SwitchField, 12, 3, // 9016: switch Inst[14:12] {
5444 0, 6, // 9019: case 0x0: {
5445 OPC_CheckPredicate, 52, // 9021: check predicate 52
5446 OPC_Decode, 202, 110, 56, // 9023: decode to AMOXOR_B_AQ using decoder 56
5447 // 9023: }
5448 1, 6, // 9027: case 0x1: {
5449 OPC_CheckPredicate, 52, // 9029: check predicate 52
5450 OPC_Decode, 210, 110, 56, // 9031: decode to AMOXOR_H_AQ using decoder 56
5451 // 9031: }
5452 2, 6, // 9035: case 0x2: {
5453 OPC_CheckPredicate, 53, // 9037: check predicate 53
5454 OPC_Decode, 214, 110, 56, // 9039: decode to AMOXOR_W_AQ using decoder 56
5455 // 9039: }
5456 3, 0, // 9043: case 0x3: {
5457 OPC_CheckPredicate, 54, // 9045: check predicate 54
5458 OPC_Decode, 206, 110, 56, // 9047: decode to AMOXOR_D_AQ using decoder 56
5459 // 9047: }
5460 // 9047: } // switch Inst[14:12]
5461 // 9047: }
5462 19, 35, // 9051: case 0x13: {
5463 OPC_SwitchField, 12, 3, // 9053: switch Inst[14:12] {
5464 0, 6, // 9056: case 0x0: {
5465 OPC_CheckPredicate, 52, // 9058: check predicate 52
5466 OPC_Decode, 203, 110, 56, // 9060: decode to AMOXOR_B_AQRL using decoder 56
5467 // 9060: }
5468 1, 6, // 9064: case 0x1: {
5469 OPC_CheckPredicate, 52, // 9066: check predicate 52
5470 OPC_Decode, 211, 110, 56, // 9068: decode to AMOXOR_H_AQRL using decoder 56
5471 // 9068: }
5472 2, 6, // 9072: case 0x2: {
5473 OPC_CheckPredicate, 53, // 9074: check predicate 53
5474 OPC_Decode, 215, 110, 56, // 9076: decode to AMOXOR_W_AQRL using decoder 56
5475 // 9076: }
5476 3, 0, // 9080: case 0x3: {
5477 OPC_CheckPredicate, 54, // 9082: check predicate 54
5478 OPC_Decode, 207, 110, 56, // 9084: decode to AMOXOR_D_AQRL using decoder 56
5479 // 9084: }
5480 // 9084: } // switch Inst[14:12]
5481 // 9084: }
5482 20, 43, // 9088: case 0x14: {
5483 OPC_SwitchField, 12, 3, // 9090: switch Inst[14:12] {
5484 0, 6, // 9093: case 0x0: {
5485 OPC_CheckPredicate, 57, // 9095: check predicate 57
5486 OPC_Decode, 209, 109, 57, // 9097: decode to AMOCAS_B using decoder 57
5487 // 9097: }
5488 1, 6, // 9101: case 0x1: {
5489 OPC_CheckPredicate, 57, // 9103: check predicate 57
5490 OPC_Decode, 221, 109, 57, // 9105: decode to AMOCAS_H using decoder 57
5491 // 9105: }
5492 2, 6, // 9109: case 0x2: {
5493 OPC_CheckPredicate, 58, // 9111: check predicate 58
5494 OPC_Decode, 229, 109, 57, // 9113: decode to AMOCAS_W using decoder 57
5495 // 9113: }
5496 3, 6, // 9117: case 0x3: {
5497 OPC_CheckPredicate, 59, // 9119: check predicate 59
5498 OPC_Decode, 217, 109, 57, // 9121: decode to AMOCAS_D_RV64 using decoder 57
5499 // 9121: }
5500 4, 0, // 9125: case 0x4: {
5501 OPC_CheckPredicate, 59, // 9127: check predicate 59
5502 OPC_Decode, 225, 109, 58, // 9129: decode to AMOCAS_Q using decoder 58
5503 // 9129: }
5504 // 9129: } // switch Inst[14:12]
5505 // 9129: }
5506 21, 43, // 9133: case 0x15: {
5507 OPC_SwitchField, 12, 3, // 9135: switch Inst[14:12] {
5508 0, 6, // 9138: case 0x0: {
5509 OPC_CheckPredicate, 57, // 9140: check predicate 57
5510 OPC_Decode, 212, 109, 57, // 9142: decode to AMOCAS_B_RL using decoder 57
5511 // 9142: }
5512 1, 6, // 9146: case 0x1: {
5513 OPC_CheckPredicate, 57, // 9148: check predicate 57
5514 OPC_Decode, 224, 109, 57, // 9150: decode to AMOCAS_H_RL using decoder 57
5515 // 9150: }
5516 2, 6, // 9154: case 0x2: {
5517 OPC_CheckPredicate, 58, // 9156: check predicate 58
5518 OPC_Decode, 232, 109, 57, // 9158: decode to AMOCAS_W_RL using decoder 57
5519 // 9158: }
5520 3, 6, // 9162: case 0x3: {
5521 OPC_CheckPredicate, 59, // 9164: check predicate 59
5522 OPC_Decode, 220, 109, 57, // 9166: decode to AMOCAS_D_RV64_RL using decoder 57
5523 // 9166: }
5524 4, 0, // 9170: case 0x4: {
5525 OPC_CheckPredicate, 59, // 9172: check predicate 59
5526 OPC_Decode, 228, 109, 58, // 9174: decode to AMOCAS_Q_RL using decoder 58
5527 // 9174: }
5528 // 9174: } // switch Inst[14:12]
5529 // 9174: }
5530 22, 43, // 9178: case 0x16: {
5531 OPC_SwitchField, 12, 3, // 9180: switch Inst[14:12] {
5532 0, 6, // 9183: case 0x0: {
5533 OPC_CheckPredicate, 57, // 9185: check predicate 57
5534 OPC_Decode, 210, 109, 57, // 9187: decode to AMOCAS_B_AQ using decoder 57
5535 // 9187: }
5536 1, 6, // 9191: case 0x1: {
5537 OPC_CheckPredicate, 57, // 9193: check predicate 57
5538 OPC_Decode, 222, 109, 57, // 9195: decode to AMOCAS_H_AQ using decoder 57
5539 // 9195: }
5540 2, 6, // 9199: case 0x2: {
5541 OPC_CheckPredicate, 58, // 9201: check predicate 58
5542 OPC_Decode, 230, 109, 57, // 9203: decode to AMOCAS_W_AQ using decoder 57
5543 // 9203: }
5544 3, 6, // 9207: case 0x3: {
5545 OPC_CheckPredicate, 59, // 9209: check predicate 59
5546 OPC_Decode, 218, 109, 57, // 9211: decode to AMOCAS_D_RV64_AQ using decoder 57
5547 // 9211: }
5548 4, 0, // 9215: case 0x4: {
5549 OPC_CheckPredicate, 59, // 9217: check predicate 59
5550 OPC_Decode, 226, 109, 58, // 9219: decode to AMOCAS_Q_AQ using decoder 58
5551 // 9219: }
5552 // 9219: } // switch Inst[14:12]
5553 // 9219: }
5554 23, 43, // 9223: case 0x17: {
5555 OPC_SwitchField, 12, 3, // 9225: switch Inst[14:12] {
5556 0, 6, // 9228: case 0x0: {
5557 OPC_CheckPredicate, 57, // 9230: check predicate 57
5558 OPC_Decode, 211, 109, 57, // 9232: decode to AMOCAS_B_AQRL using decoder 57
5559 // 9232: }
5560 1, 6, // 9236: case 0x1: {
5561 OPC_CheckPredicate, 57, // 9238: check predicate 57
5562 OPC_Decode, 223, 109, 57, // 9240: decode to AMOCAS_H_AQRL using decoder 57
5563 // 9240: }
5564 2, 6, // 9244: case 0x2: {
5565 OPC_CheckPredicate, 58, // 9246: check predicate 58
5566 OPC_Decode, 231, 109, 57, // 9248: decode to AMOCAS_W_AQRL using decoder 57
5567 // 9248: }
5568 3, 6, // 9252: case 0x3: {
5569 OPC_CheckPredicate, 59, // 9254: check predicate 59
5570 OPC_Decode, 219, 109, 57, // 9256: decode to AMOCAS_D_RV64_AQRL using decoder 57
5571 // 9256: }
5572 4, 0, // 9260: case 0x4: {
5573 OPC_CheckPredicate, 59, // 9262: check predicate 59
5574 OPC_Decode, 227, 109, 58, // 9264: decode to AMOCAS_Q_AQRL using decoder 58
5575 // 9264: }
5576 // 9264: } // switch Inst[14:12]
5577 // 9264: }
5578 26, 51, // 9268: case 0x1a: {
5579 OPC_SwitchField, 12, 3, // 9270: switch Inst[14:12] {
5580 0, 10, // 9273: case 0x0: {
5581 OPC_CheckPredicate, 60, // 9275: check predicate 60
5582 OPC_CheckField, 20, 5, 0, // 9277: check Inst[24:20] == 0x0
5583 OPC_Decode, 223, 116, 17, // 9281: decode to LB_AQ using decoder 17
5584 // 9281: }
5585 1, 10, // 9285: case 0x1: {
5586 OPC_CheckPredicate, 60, // 9287: check predicate 60
5587 OPC_CheckField, 20, 5, 0, // 9289: check Inst[24:20] == 0x0
5588 OPC_Decode, 231, 116, 17, // 9293: decode to LH_AQ using decoder 17
5589 // 9293: }
5590 2, 10, // 9297: case 0x2: {
5591 OPC_CheckPredicate, 60, // 9299: check predicate 60
5592 OPC_CheckField, 20, 5, 0, // 9301: check Inst[24:20] == 0x0
5593 OPC_Decode, 245, 116, 17, // 9305: decode to LW_AQ using decoder 17
5594 // 9305: }
5595 3, 0, // 9309: case 0x3: {
5596 OPC_CheckPredicate, 61, // 9311: check predicate 61
5597 OPC_CheckField, 20, 5, 0, // 9313: check Inst[24:20] == 0x0
5598 OPC_Decode, 226, 116, 17, // 9317: decode to LD_AQ using decoder 17
5599 // 9317: }
5600 // 9317: } // switch Inst[14:12]
5601 // 9317: }
5602 27, 51, // 9321: case 0x1b: {
5603 OPC_SwitchField, 12, 3, // 9323: switch Inst[14:12] {
5604 0, 10, // 9326: case 0x0: {
5605 OPC_CheckPredicate, 60, // 9328: check predicate 60
5606 OPC_CheckField, 20, 5, 0, // 9330: check Inst[24:20] == 0x0
5607 OPC_Decode, 224, 116, 17, // 9334: decode to LB_AQRL using decoder 17
5608 // 9334: }
5609 1, 10, // 9338: case 0x1: {
5610 OPC_CheckPredicate, 60, // 9340: check predicate 60
5611 OPC_CheckField, 20, 5, 0, // 9342: check Inst[24:20] == 0x0
5612 OPC_Decode, 232, 116, 17, // 9346: decode to LH_AQRL using decoder 17
5613 // 9346: }
5614 2, 10, // 9350: case 0x2: {
5615 OPC_CheckPredicate, 60, // 9352: check predicate 60
5616 OPC_CheckField, 20, 5, 0, // 9354: check Inst[24:20] == 0x0
5617 OPC_Decode, 246, 116, 17, // 9358: decode to LW_AQRL using decoder 17
5618 // 9358: }
5619 3, 0, // 9362: case 0x3: {
5620 OPC_CheckPredicate, 61, // 9364: check predicate 61
5621 OPC_CheckField, 20, 5, 0, // 9366: check Inst[24:20] == 0x0
5622 OPC_Decode, 227, 116, 17, // 9370: decode to LD_AQRL using decoder 17
5623 // 9370: }
5624 // 9370: } // switch Inst[14:12]
5625 // 9370: }
5626 29, 35, // 9374: case 0x1d: {
5627 OPC_SwitchField, 7, 8, // 9376: switch Inst[14:7] {
5628 0, 6, // 9379: case 0x0: {
5629 OPC_CheckPredicate, 60, // 9381: check predicate 60
5630 OPC_Decode, 222, 123, 59, // 9383: decode to SB_RL using decoder 59
5631 // 9383: }
5632 32, 6, // 9387: case 0x20: {
5633 OPC_CheckPredicate, 60, // 9389: check predicate 60
5634 OPC_Decode, 210, 124, 59, // 9391: decode to SH_RL using decoder 59
5635 // 9391: }
5636 64, 6, // 9395: case 0x40: {
5637 OPC_CheckPredicate, 60, // 9397: check predicate 60
5638 OPC_Decode, 152, 125, 59, // 9399: decode to SW_RL using decoder 59
5639 // 9399: }
5640 96, 0, // 9403: case 0x60: {
5641 OPC_CheckPredicate, 61, // 9405: check predicate 61
5642 OPC_Decode, 236, 123, 59, // 9407: decode to SD_RL using decoder 59
5643 // 9407: }
5644 // 9407: } // switch Inst[14:7]
5645 // 9407: }
5646 31, 35, // 9411: case 0x1f: {
5647 OPC_SwitchField, 7, 8, // 9413: switch Inst[14:7] {
5648 0, 6, // 9416: case 0x0: {
5649 OPC_CheckPredicate, 60, // 9418: check predicate 60
5650 OPC_Decode, 221, 123, 59, // 9420: decode to SB_AQRL using decoder 59
5651 // 9420: }
5652 32, 6, // 9424: case 0x20: {
5653 OPC_CheckPredicate, 60, // 9426: check predicate 60
5654 OPC_Decode, 208, 124, 59, // 9428: decode to SH_AQRL using decoder 59
5655 // 9428: }
5656 64, 6, // 9432: case 0x40: {
5657 OPC_CheckPredicate, 60, // 9434: check predicate 60
5658 OPC_Decode, 150, 125, 59, // 9436: decode to SW_AQRL using decoder 59
5659 // 9436: }
5660 96, 0, // 9440: case 0x60: {
5661 OPC_CheckPredicate, 61, // 9442: check predicate 61
5662 OPC_Decode, 235, 123, 59, // 9444: decode to SD_AQRL using decoder 59
5663 // 9444: }
5664 // 9444: } // switch Inst[14:7]
5665 // 9444: }
5666 32, 35, // 9448: case 0x20: {
5667 OPC_SwitchField, 12, 3, // 9450: switch Inst[14:12] {
5668 0, 6, // 9453: case 0x0: {
5669 OPC_CheckPredicate, 52, // 9455: check predicate 52
5670 OPC_Decode, 169, 110, 56, // 9457: decode to AMOOR_B using decoder 56
5671 // 9457: }
5672 1, 6, // 9461: case 0x1: {
5673 OPC_CheckPredicate, 52, // 9463: check predicate 52
5674 OPC_Decode, 177, 110, 56, // 9465: decode to AMOOR_H using decoder 56
5675 // 9465: }
5676 2, 6, // 9469: case 0x2: {
5677 OPC_CheckPredicate, 53, // 9471: check predicate 53
5678 OPC_Decode, 181, 110, 56, // 9473: decode to AMOOR_W using decoder 56
5679 // 9473: }
5680 3, 0, // 9477: case 0x3: {
5681 OPC_CheckPredicate, 54, // 9479: check predicate 54
5682 OPC_Decode, 173, 110, 56, // 9481: decode to AMOOR_D using decoder 56
5683 // 9481: }
5684 // 9481: } // switch Inst[14:12]
5685 // 9481: }
5686 33, 35, // 9485: case 0x21: {
5687 OPC_SwitchField, 12, 3, // 9487: switch Inst[14:12] {
5688 0, 6, // 9490: case 0x0: {
5689 OPC_CheckPredicate, 52, // 9492: check predicate 52
5690 OPC_Decode, 172, 110, 56, // 9494: decode to AMOOR_B_RL using decoder 56
5691 // 9494: }
5692 1, 6, // 9498: case 0x1: {
5693 OPC_CheckPredicate, 52, // 9500: check predicate 52
5694 OPC_Decode, 180, 110, 56, // 9502: decode to AMOOR_H_RL using decoder 56
5695 // 9502: }
5696 2, 6, // 9506: case 0x2: {
5697 OPC_CheckPredicate, 53, // 9508: check predicate 53
5698 OPC_Decode, 184, 110, 56, // 9510: decode to AMOOR_W_RL using decoder 56
5699 // 9510: }
5700 3, 0, // 9514: case 0x3: {
5701 OPC_CheckPredicate, 54, // 9516: check predicate 54
5702 OPC_Decode, 176, 110, 56, // 9518: decode to AMOOR_D_RL using decoder 56
5703 // 9518: }
5704 // 9518: } // switch Inst[14:12]
5705 // 9518: }
5706 34, 35, // 9522: case 0x22: {
5707 OPC_SwitchField, 12, 3, // 9524: switch Inst[14:12] {
5708 0, 6, // 9527: case 0x0: {
5709 OPC_CheckPredicate, 52, // 9529: check predicate 52
5710 OPC_Decode, 170, 110, 56, // 9531: decode to AMOOR_B_AQ using decoder 56
5711 // 9531: }
5712 1, 6, // 9535: case 0x1: {
5713 OPC_CheckPredicate, 52, // 9537: check predicate 52
5714 OPC_Decode, 178, 110, 56, // 9539: decode to AMOOR_H_AQ using decoder 56
5715 // 9539: }
5716 2, 6, // 9543: case 0x2: {
5717 OPC_CheckPredicate, 53, // 9545: check predicate 53
5718 OPC_Decode, 182, 110, 56, // 9547: decode to AMOOR_W_AQ using decoder 56
5719 // 9547: }
5720 3, 0, // 9551: case 0x3: {
5721 OPC_CheckPredicate, 54, // 9553: check predicate 54
5722 OPC_Decode, 174, 110, 56, // 9555: decode to AMOOR_D_AQ using decoder 56
5723 // 9555: }
5724 // 9555: } // switch Inst[14:12]
5725 // 9555: }
5726 35, 35, // 9559: case 0x23: {
5727 OPC_SwitchField, 12, 3, // 9561: switch Inst[14:12] {
5728 0, 6, // 9564: case 0x0: {
5729 OPC_CheckPredicate, 52, // 9566: check predicate 52
5730 OPC_Decode, 171, 110, 56, // 9568: decode to AMOOR_B_AQRL using decoder 56
5731 // 9568: }
5732 1, 6, // 9572: case 0x1: {
5733 OPC_CheckPredicate, 52, // 9574: check predicate 52
5734 OPC_Decode, 179, 110, 56, // 9576: decode to AMOOR_H_AQRL using decoder 56
5735 // 9576: }
5736 2, 6, // 9580: case 0x2: {
5737 OPC_CheckPredicate, 53, // 9582: check predicate 53
5738 OPC_Decode, 183, 110, 56, // 9584: decode to AMOOR_W_AQRL using decoder 56
5739 // 9584: }
5740 3, 0, // 9588: case 0x3: {
5741 OPC_CheckPredicate, 54, // 9590: check predicate 54
5742 OPC_Decode, 175, 110, 56, // 9592: decode to AMOOR_D_AQRL using decoder 56
5743 // 9592: }
5744 // 9592: } // switch Inst[14:12]
5745 // 9592: }
5746 36, 19, // 9596: case 0x24: {
5747 OPC_SwitchField, 12, 3, // 9598: switch Inst[14:12] {
5748 2, 6, // 9601: case 0x2: {
5749 OPC_CheckPredicate, 62, // 9603: check predicate 62
5750 OPC_Decode, 131, 125, 56, // 9605: decode to SSAMOSWAP_W using decoder 56
5751 // 9605: }
5752 3, 0, // 9609: case 0x3: {
5753 OPC_CheckPredicate, 63, // 9611: check predicate 63
5754 OPC_Decode, 255, 124, 56, // 9613: decode to SSAMOSWAP_D using decoder 56
5755 // 9613: }
5756 // 9613: } // switch Inst[14:12]
5757 // 9613: }
5758 37, 19, // 9617: case 0x25: {
5759 OPC_SwitchField, 12, 3, // 9619: switch Inst[14:12] {
5760 2, 6, // 9622: case 0x2: {
5761 OPC_CheckPredicate, 62, // 9624: check predicate 62
5762 OPC_Decode, 134, 125, 56, // 9626: decode to SSAMOSWAP_W_RL using decoder 56
5763 // 9626: }
5764 3, 0, // 9630: case 0x3: {
5765 OPC_CheckPredicate, 63, // 9632: check predicate 63
5766 OPC_Decode, 130, 125, 56, // 9634: decode to SSAMOSWAP_D_RL using decoder 56
5767 // 9634: }
5768 // 9634: } // switch Inst[14:12]
5769 // 9634: }
5770 38, 19, // 9638: case 0x26: {
5771 OPC_SwitchField, 12, 3, // 9640: switch Inst[14:12] {
5772 2, 6, // 9643: case 0x2: {
5773 OPC_CheckPredicate, 62, // 9645: check predicate 62
5774 OPC_Decode, 132, 125, 56, // 9647: decode to SSAMOSWAP_W_AQ using decoder 56
5775 // 9647: }
5776 3, 0, // 9651: case 0x3: {
5777 OPC_CheckPredicate, 63, // 9653: check predicate 63
5778 OPC_Decode, 128, 125, 56, // 9655: decode to SSAMOSWAP_D_AQ using decoder 56
5779 // 9655: }
5780 // 9655: } // switch Inst[14:12]
5781 // 9655: }
5782 39, 19, // 9659: case 0x27: {
5783 OPC_SwitchField, 12, 3, // 9661: switch Inst[14:12] {
5784 2, 6, // 9664: case 0x2: {
5785 OPC_CheckPredicate, 62, // 9666: check predicate 62
5786 OPC_Decode, 133, 125, 56, // 9668: decode to SSAMOSWAP_W_AQRL using decoder 56
5787 // 9668: }
5788 3, 0, // 9672: case 0x3: {
5789 OPC_CheckPredicate, 63, // 9674: check predicate 63
5790 OPC_Decode, 129, 125, 56, // 9676: decode to SSAMOSWAP_D_AQRL using decoder 56
5791 // 9676: }
5792 // 9676: } // switch Inst[14:12]
5793 // 9676: }
5794 48, 35, // 9680: case 0x30: {
5795 OPC_SwitchField, 12, 3, // 9682: switch Inst[14:12] {
5796 0, 6, // 9685: case 0x0: {
5797 OPC_CheckPredicate, 52, // 9687: check predicate 52
5798 OPC_Decode, 193, 109, 56, // 9689: decode to AMOAND_B using decoder 56
5799 // 9689: }
5800 1, 6, // 9693: case 0x1: {
5801 OPC_CheckPredicate, 52, // 9695: check predicate 52
5802 OPC_Decode, 201, 109, 56, // 9697: decode to AMOAND_H using decoder 56
5803 // 9697: }
5804 2, 6, // 9701: case 0x2: {
5805 OPC_CheckPredicate, 53, // 9703: check predicate 53
5806 OPC_Decode, 205, 109, 56, // 9705: decode to AMOAND_W using decoder 56
5807 // 9705: }
5808 3, 0, // 9709: case 0x3: {
5809 OPC_CheckPredicate, 54, // 9711: check predicate 54
5810 OPC_Decode, 197, 109, 56, // 9713: decode to AMOAND_D using decoder 56
5811 // 9713: }
5812 // 9713: } // switch Inst[14:12]
5813 // 9713: }
5814 49, 35, // 9717: case 0x31: {
5815 OPC_SwitchField, 12, 3, // 9719: switch Inst[14:12] {
5816 0, 6, // 9722: case 0x0: {
5817 OPC_CheckPredicate, 52, // 9724: check predicate 52
5818 OPC_Decode, 196, 109, 56, // 9726: decode to AMOAND_B_RL using decoder 56
5819 // 9726: }
5820 1, 6, // 9730: case 0x1: {
5821 OPC_CheckPredicate, 52, // 9732: check predicate 52
5822 OPC_Decode, 204, 109, 56, // 9734: decode to AMOAND_H_RL using decoder 56
5823 // 9734: }
5824 2, 6, // 9738: case 0x2: {
5825 OPC_CheckPredicate, 53, // 9740: check predicate 53
5826 OPC_Decode, 208, 109, 56, // 9742: decode to AMOAND_W_RL using decoder 56
5827 // 9742: }
5828 3, 0, // 9746: case 0x3: {
5829 OPC_CheckPredicate, 54, // 9748: check predicate 54
5830 OPC_Decode, 200, 109, 56, // 9750: decode to AMOAND_D_RL using decoder 56
5831 // 9750: }
5832 // 9750: } // switch Inst[14:12]
5833 // 9750: }
5834 50, 35, // 9754: case 0x32: {
5835 OPC_SwitchField, 12, 3, // 9756: switch Inst[14:12] {
5836 0, 6, // 9759: case 0x0: {
5837 OPC_CheckPredicate, 52, // 9761: check predicate 52
5838 OPC_Decode, 194, 109, 56, // 9763: decode to AMOAND_B_AQ using decoder 56
5839 // 9763: }
5840 1, 6, // 9767: case 0x1: {
5841 OPC_CheckPredicate, 52, // 9769: check predicate 52
5842 OPC_Decode, 202, 109, 56, // 9771: decode to AMOAND_H_AQ using decoder 56
5843 // 9771: }
5844 2, 6, // 9775: case 0x2: {
5845 OPC_CheckPredicate, 53, // 9777: check predicate 53
5846 OPC_Decode, 206, 109, 56, // 9779: decode to AMOAND_W_AQ using decoder 56
5847 // 9779: }
5848 3, 0, // 9783: case 0x3: {
5849 OPC_CheckPredicate, 54, // 9785: check predicate 54
5850 OPC_Decode, 198, 109, 56, // 9787: decode to AMOAND_D_AQ using decoder 56
5851 // 9787: }
5852 // 9787: } // switch Inst[14:12]
5853 // 9787: }
5854 51, 35, // 9791: case 0x33: {
5855 OPC_SwitchField, 12, 3, // 9793: switch Inst[14:12] {
5856 0, 6, // 9796: case 0x0: {
5857 OPC_CheckPredicate, 52, // 9798: check predicate 52
5858 OPC_Decode, 195, 109, 56, // 9800: decode to AMOAND_B_AQRL using decoder 56
5859 // 9800: }
5860 1, 6, // 9804: case 0x1: {
5861 OPC_CheckPredicate, 52, // 9806: check predicate 52
5862 OPC_Decode, 203, 109, 56, // 9808: decode to AMOAND_H_AQRL using decoder 56
5863 // 9808: }
5864 2, 6, // 9812: case 0x2: {
5865 OPC_CheckPredicate, 53, // 9814: check predicate 53
5866 OPC_Decode, 207, 109, 56, // 9816: decode to AMOAND_W_AQRL using decoder 56
5867 // 9816: }
5868 3, 0, // 9820: case 0x3: {
5869 OPC_CheckPredicate, 54, // 9822: check predicate 54
5870 OPC_Decode, 199, 109, 56, // 9824: decode to AMOAND_D_AQRL using decoder 56
5871 // 9824: }
5872 // 9824: } // switch Inst[14:12]
5873 // 9824: }
5874 64, 35, // 9828: case 0x40: {
5875 OPC_SwitchField, 12, 3, // 9830: switch Inst[14:12] {
5876 0, 6, // 9833: case 0x0: {
5877 OPC_CheckPredicate, 52, // 9835: check predicate 52
5878 OPC_Decode, 153, 110, 56, // 9837: decode to AMOMIN_B using decoder 56
5879 // 9837: }
5880 1, 6, // 9841: case 0x1: {
5881 OPC_CheckPredicate, 52, // 9843: check predicate 52
5882 OPC_Decode, 161, 110, 56, // 9845: decode to AMOMIN_H using decoder 56
5883 // 9845: }
5884 2, 6, // 9849: case 0x2: {
5885 OPC_CheckPredicate, 53, // 9851: check predicate 53
5886 OPC_Decode, 165, 110, 56, // 9853: decode to AMOMIN_W using decoder 56
5887 // 9853: }
5888 3, 0, // 9857: case 0x3: {
5889 OPC_CheckPredicate, 54, // 9859: check predicate 54
5890 OPC_Decode, 157, 110, 56, // 9861: decode to AMOMIN_D using decoder 56
5891 // 9861: }
5892 // 9861: } // switch Inst[14:12]
5893 // 9861: }
5894 65, 35, // 9865: case 0x41: {
5895 OPC_SwitchField, 12, 3, // 9867: switch Inst[14:12] {
5896 0, 6, // 9870: case 0x0: {
5897 OPC_CheckPredicate, 52, // 9872: check predicate 52
5898 OPC_Decode, 156, 110, 56, // 9874: decode to AMOMIN_B_RL using decoder 56
5899 // 9874: }
5900 1, 6, // 9878: case 0x1: {
5901 OPC_CheckPredicate, 52, // 9880: check predicate 52
5902 OPC_Decode, 164, 110, 56, // 9882: decode to AMOMIN_H_RL using decoder 56
5903 // 9882: }
5904 2, 6, // 9886: case 0x2: {
5905 OPC_CheckPredicate, 53, // 9888: check predicate 53
5906 OPC_Decode, 168, 110, 56, // 9890: decode to AMOMIN_W_RL using decoder 56
5907 // 9890: }
5908 3, 0, // 9894: case 0x3: {
5909 OPC_CheckPredicate, 54, // 9896: check predicate 54
5910 OPC_Decode, 160, 110, 56, // 9898: decode to AMOMIN_D_RL using decoder 56
5911 // 9898: }
5912 // 9898: } // switch Inst[14:12]
5913 // 9898: }
5914 66, 35, // 9902: case 0x42: {
5915 OPC_SwitchField, 12, 3, // 9904: switch Inst[14:12] {
5916 0, 6, // 9907: case 0x0: {
5917 OPC_CheckPredicate, 52, // 9909: check predicate 52
5918 OPC_Decode, 154, 110, 56, // 9911: decode to AMOMIN_B_AQ using decoder 56
5919 // 9911: }
5920 1, 6, // 9915: case 0x1: {
5921 OPC_CheckPredicate, 52, // 9917: check predicate 52
5922 OPC_Decode, 162, 110, 56, // 9919: decode to AMOMIN_H_AQ using decoder 56
5923 // 9919: }
5924 2, 6, // 9923: case 0x2: {
5925 OPC_CheckPredicate, 53, // 9925: check predicate 53
5926 OPC_Decode, 166, 110, 56, // 9927: decode to AMOMIN_W_AQ using decoder 56
5927 // 9927: }
5928 3, 0, // 9931: case 0x3: {
5929 OPC_CheckPredicate, 54, // 9933: check predicate 54
5930 OPC_Decode, 158, 110, 56, // 9935: decode to AMOMIN_D_AQ using decoder 56
5931 // 9935: }
5932 // 9935: } // switch Inst[14:12]
5933 // 9935: }
5934 67, 35, // 9939: case 0x43: {
5935 OPC_SwitchField, 12, 3, // 9941: switch Inst[14:12] {
5936 0, 6, // 9944: case 0x0: {
5937 OPC_CheckPredicate, 52, // 9946: check predicate 52
5938 OPC_Decode, 155, 110, 56, // 9948: decode to AMOMIN_B_AQRL using decoder 56
5939 // 9948: }
5940 1, 6, // 9952: case 0x1: {
5941 OPC_CheckPredicate, 52, // 9954: check predicate 52
5942 OPC_Decode, 163, 110, 56, // 9956: decode to AMOMIN_H_AQRL using decoder 56
5943 // 9956: }
5944 2, 6, // 9960: case 0x2: {
5945 OPC_CheckPredicate, 53, // 9962: check predicate 53
5946 OPC_Decode, 167, 110, 56, // 9964: decode to AMOMIN_W_AQRL using decoder 56
5947 // 9964: }
5948 3, 0, // 9968: case 0x3: {
5949 OPC_CheckPredicate, 54, // 9970: check predicate 54
5950 OPC_Decode, 159, 110, 56, // 9972: decode to AMOMIN_D_AQRL using decoder 56
5951 // 9972: }
5952 // 9972: } // switch Inst[14:12]
5953 // 9972: }
5954 72, 43, // 9976: case 0x48: {
5955 OPC_SwitchField, 12, 3, // 9978: switch Inst[14:12] {
5956 1, 6, // 9981: case 0x1: {
5957 OPC_CheckPredicate, 64, // 9983: check predicate 64
5958 OPC_Decode, 249, 116, 56, // 9985: decode to LXH using decoder 56
5959 // 9985: }
5960 2, 6, // 9989: case 0x2: {
5961 OPC_CheckPredicate, 64, // 9991: check predicate 64
5962 OPC_Decode, 137, 117, 56, // 9993: decode to LXW using decoder 56
5963 // 9993: }
5964 3, 6, // 9997: case 0x3: {
5965 OPC_CheckPredicate, 65, // 9999: check predicate 65
5966 OPC_Decode, 248, 116, 56, // 10001: decode to LXD using decoder 56
5967 // 10001: }
5968 5, 6, // 10005: case 0x5: {
5969 OPC_CheckPredicate, 64, // 10007: check predicate 64
5970 OPC_Decode, 250, 116, 56, // 10009: decode to LXHU using decoder 56
5971 // 10009: }
5972 6, 0, // 10013: case 0x6: {
5973 OPC_CheckPredicate, 65, // 10015: check predicate 65
5974 OPC_Decode, 138, 117, 56, // 10017: decode to LXWU using decoder 56
5975 // 10017: }
5976 // 10017: } // switch Inst[14:12]
5977 // 10017: }
5978 80, 35, // 10021: case 0x50: {
5979 OPC_SwitchField, 12, 3, // 10023: switch Inst[14:12] {
5980 0, 6, // 10026: case 0x0: {
5981 OPC_CheckPredicate, 52, // 10028: check predicate 52
5982 OPC_Decode, 249, 109, 56, // 10030: decode to AMOMAX_B using decoder 56
5983 // 10030: }
5984 1, 6, // 10034: case 0x1: {
5985 OPC_CheckPredicate, 52, // 10036: check predicate 52
5986 OPC_Decode, 129, 110, 56, // 10038: decode to AMOMAX_H using decoder 56
5987 // 10038: }
5988 2, 6, // 10042: case 0x2: {
5989 OPC_CheckPredicate, 53, // 10044: check predicate 53
5990 OPC_Decode, 133, 110, 56, // 10046: decode to AMOMAX_W using decoder 56
5991 // 10046: }
5992 3, 0, // 10050: case 0x3: {
5993 OPC_CheckPredicate, 54, // 10052: check predicate 54
5994 OPC_Decode, 253, 109, 56, // 10054: decode to AMOMAX_D using decoder 56
5995 // 10054: }
5996 // 10054: } // switch Inst[14:12]
5997 // 10054: }
5998 81, 35, // 10058: case 0x51: {
5999 OPC_SwitchField, 12, 3, // 10060: switch Inst[14:12] {
6000 0, 6, // 10063: case 0x0: {
6001 OPC_CheckPredicate, 52, // 10065: check predicate 52
6002 OPC_Decode, 252, 109, 56, // 10067: decode to AMOMAX_B_RL using decoder 56
6003 // 10067: }
6004 1, 6, // 10071: case 0x1: {
6005 OPC_CheckPredicate, 52, // 10073: check predicate 52
6006 OPC_Decode, 132, 110, 56, // 10075: decode to AMOMAX_H_RL using decoder 56
6007 // 10075: }
6008 2, 6, // 10079: case 0x2: {
6009 OPC_CheckPredicate, 53, // 10081: check predicate 53
6010 OPC_Decode, 136, 110, 56, // 10083: decode to AMOMAX_W_RL using decoder 56
6011 // 10083: }
6012 3, 0, // 10087: case 0x3: {
6013 OPC_CheckPredicate, 54, // 10089: check predicate 54
6014 OPC_Decode, 128, 110, 56, // 10091: decode to AMOMAX_D_RL using decoder 56
6015 // 10091: }
6016 // 10091: } // switch Inst[14:12]
6017 // 10091: }
6018 82, 35, // 10095: case 0x52: {
6019 OPC_SwitchField, 12, 3, // 10097: switch Inst[14:12] {
6020 0, 6, // 10100: case 0x0: {
6021 OPC_CheckPredicate, 52, // 10102: check predicate 52
6022 OPC_Decode, 250, 109, 56, // 10104: decode to AMOMAX_B_AQ using decoder 56
6023 // 10104: }
6024 1, 6, // 10108: case 0x1: {
6025 OPC_CheckPredicate, 52, // 10110: check predicate 52
6026 OPC_Decode, 130, 110, 56, // 10112: decode to AMOMAX_H_AQ using decoder 56
6027 // 10112: }
6028 2, 6, // 10116: case 0x2: {
6029 OPC_CheckPredicate, 53, // 10118: check predicate 53
6030 OPC_Decode, 134, 110, 56, // 10120: decode to AMOMAX_W_AQ using decoder 56
6031 // 10120: }
6032 3, 0, // 10124: case 0x3: {
6033 OPC_CheckPredicate, 54, // 10126: check predicate 54
6034 OPC_Decode, 254, 109, 56, // 10128: decode to AMOMAX_D_AQ using decoder 56
6035 // 10128: }
6036 // 10128: } // switch Inst[14:12]
6037 // 10128: }
6038 83, 35, // 10132: case 0x53: {
6039 OPC_SwitchField, 12, 3, // 10134: switch Inst[14:12] {
6040 0, 6, // 10137: case 0x0: {
6041 OPC_CheckPredicate, 52, // 10139: check predicate 52
6042 OPC_Decode, 251, 109, 56, // 10141: decode to AMOMAX_B_AQRL using decoder 56
6043 // 10141: }
6044 1, 6, // 10145: case 0x1: {
6045 OPC_CheckPredicate, 52, // 10147: check predicate 52
6046 OPC_Decode, 131, 110, 56, // 10149: decode to AMOMAX_H_AQRL using decoder 56
6047 // 10149: }
6048 2, 6, // 10153: case 0x2: {
6049 OPC_CheckPredicate, 53, // 10155: check predicate 53
6050 OPC_Decode, 135, 110, 56, // 10157: decode to AMOMAX_W_AQRL using decoder 56
6051 // 10157: }
6052 3, 0, // 10161: case 0x3: {
6053 OPC_CheckPredicate, 54, // 10163: check predicate 54
6054 OPC_Decode, 255, 109, 56, // 10165: decode to AMOMAX_D_AQRL using decoder 56
6055 // 10165: }
6056 // 10165: } // switch Inst[14:12]
6057 // 10165: }
6058 96, 35, // 10169: case 0x60: {
6059 OPC_SwitchField, 12, 3, // 10171: switch Inst[14:12] {
6060 0, 6, // 10174: case 0x0: {
6061 OPC_CheckPredicate, 52, // 10176: check predicate 52
6062 OPC_Decode, 137, 110, 56, // 10178: decode to AMOMINU_B using decoder 56
6063 // 10178: }
6064 1, 6, // 10182: case 0x1: {
6065 OPC_CheckPredicate, 52, // 10184: check predicate 52
6066 OPC_Decode, 145, 110, 56, // 10186: decode to AMOMINU_H using decoder 56
6067 // 10186: }
6068 2, 6, // 10190: case 0x2: {
6069 OPC_CheckPredicate, 53, // 10192: check predicate 53
6070 OPC_Decode, 149, 110, 56, // 10194: decode to AMOMINU_W using decoder 56
6071 // 10194: }
6072 3, 0, // 10198: case 0x3: {
6073 OPC_CheckPredicate, 54, // 10200: check predicate 54
6074 OPC_Decode, 141, 110, 56, // 10202: decode to AMOMINU_D using decoder 56
6075 // 10202: }
6076 // 10202: } // switch Inst[14:12]
6077 // 10202: }
6078 97, 35, // 10206: case 0x61: {
6079 OPC_SwitchField, 12, 3, // 10208: switch Inst[14:12] {
6080 0, 6, // 10211: case 0x0: {
6081 OPC_CheckPredicate, 52, // 10213: check predicate 52
6082 OPC_Decode, 140, 110, 56, // 10215: decode to AMOMINU_B_RL using decoder 56
6083 // 10215: }
6084 1, 6, // 10219: case 0x1: {
6085 OPC_CheckPredicate, 52, // 10221: check predicate 52
6086 OPC_Decode, 148, 110, 56, // 10223: decode to AMOMINU_H_RL using decoder 56
6087 // 10223: }
6088 2, 6, // 10227: case 0x2: {
6089 OPC_CheckPredicate, 53, // 10229: check predicate 53
6090 OPC_Decode, 152, 110, 56, // 10231: decode to AMOMINU_W_RL using decoder 56
6091 // 10231: }
6092 3, 0, // 10235: case 0x3: {
6093 OPC_CheckPredicate, 54, // 10237: check predicate 54
6094 OPC_Decode, 144, 110, 56, // 10239: decode to AMOMINU_D_RL using decoder 56
6095 // 10239: }
6096 // 10239: } // switch Inst[14:12]
6097 // 10239: }
6098 98, 35, // 10243: case 0x62: {
6099 OPC_SwitchField, 12, 3, // 10245: switch Inst[14:12] {
6100 0, 6, // 10248: case 0x0: {
6101 OPC_CheckPredicate, 52, // 10250: check predicate 52
6102 OPC_Decode, 138, 110, 56, // 10252: decode to AMOMINU_B_AQ using decoder 56
6103 // 10252: }
6104 1, 6, // 10256: case 0x1: {
6105 OPC_CheckPredicate, 52, // 10258: check predicate 52
6106 OPC_Decode, 146, 110, 56, // 10260: decode to AMOMINU_H_AQ using decoder 56
6107 // 10260: }
6108 2, 6, // 10264: case 0x2: {
6109 OPC_CheckPredicate, 53, // 10266: check predicate 53
6110 OPC_Decode, 150, 110, 56, // 10268: decode to AMOMINU_W_AQ using decoder 56
6111 // 10268: }
6112 3, 0, // 10272: case 0x3: {
6113 OPC_CheckPredicate, 54, // 10274: check predicate 54
6114 OPC_Decode, 142, 110, 56, // 10276: decode to AMOMINU_D_AQ using decoder 56
6115 // 10276: }
6116 // 10276: } // switch Inst[14:12]
6117 // 10276: }
6118 99, 35, // 10280: case 0x63: {
6119 OPC_SwitchField, 12, 3, // 10282: switch Inst[14:12] {
6120 0, 6, // 10285: case 0x0: {
6121 OPC_CheckPredicate, 52, // 10287: check predicate 52
6122 OPC_Decode, 139, 110, 56, // 10289: decode to AMOMINU_B_AQRL using decoder 56
6123 // 10289: }
6124 1, 6, // 10293: case 0x1: {
6125 OPC_CheckPredicate, 52, // 10295: check predicate 52
6126 OPC_Decode, 147, 110, 56, // 10297: decode to AMOMINU_H_AQRL using decoder 56
6127 // 10297: }
6128 2, 6, // 10301: case 0x2: {
6129 OPC_CheckPredicate, 53, // 10303: check predicate 53
6130 OPC_Decode, 151, 110, 56, // 10305: decode to AMOMINU_W_AQRL using decoder 56
6131 // 10305: }
6132 3, 0, // 10309: case 0x3: {
6133 OPC_CheckPredicate, 54, // 10311: check predicate 54
6134 OPC_Decode, 143, 110, 56, // 10313: decode to AMOMINU_D_AQRL using decoder 56
6135 // 10313: }
6136 // 10313: } // switch Inst[14:12]
6137 // 10313: }
6138 104, 59, // 10317: case 0x68: {
6139 OPC_SwitchField, 12, 3, // 10319: switch Inst[14:12] {
6140 0, 6, // 10322: case 0x0: {
6141 OPC_CheckPredicate, 64, // 10324: check predicate 64
6142 OPC_Decode, 251, 116, 56, // 10326: decode to LXSB using decoder 56
6143 // 10326: }
6144 1, 6, // 10330: case 0x1: {
6145 OPC_CheckPredicate, 64, // 10332: check predicate 64
6146 OPC_Decode, 254, 116, 56, // 10334: decode to LXSH using decoder 56
6147 // 10334: }
6148 2, 6, // 10338: case 0x2: {
6149 OPC_CheckPredicate, 64, // 10340: check predicate 64
6150 OPC_Decode, 135, 117, 56, // 10342: decode to LXSW using decoder 56
6151 // 10342: }
6152 3, 6, // 10346: case 0x3: {
6153 OPC_CheckPredicate, 65, // 10348: check predicate 65
6154 OPC_Decode, 253, 116, 56, // 10350: decode to LXSD using decoder 56
6155 // 10350: }
6156 4, 6, // 10354: case 0x4: {
6157 OPC_CheckPredicate, 64, // 10356: check predicate 64
6158 OPC_Decode, 252, 116, 56, // 10358: decode to LXSBU using decoder 56
6159 // 10358: }
6160 5, 6, // 10362: case 0x5: {
6161 OPC_CheckPredicate, 64, // 10364: check predicate 64
6162 OPC_Decode, 255, 116, 56, // 10366: decode to LXSHU using decoder 56
6163 // 10366: }
6164 6, 0, // 10370: case 0x6: {
6165 OPC_CheckPredicate, 65, // 10372: check predicate 65
6166 OPC_Decode, 136, 117, 56, // 10374: decode to LXSWU using decoder 56
6167 // 10374: }
6168 // 10374: } // switch Inst[14:12]
6169 // 10374: }
6170 112, 35, // 10378: case 0x70: {
6171 OPC_SwitchField, 12, 3, // 10380: switch Inst[14:12] {
6172 0, 6, // 10383: case 0x0: {
6173 OPC_CheckPredicate, 52, // 10385: check predicate 52
6174 OPC_Decode, 233, 109, 56, // 10387: decode to AMOMAXU_B using decoder 56
6175 // 10387: }
6176 1, 6, // 10391: case 0x1: {
6177 OPC_CheckPredicate, 52, // 10393: check predicate 52
6178 OPC_Decode, 241, 109, 56, // 10395: decode to AMOMAXU_H using decoder 56
6179 // 10395: }
6180 2, 6, // 10399: case 0x2: {
6181 OPC_CheckPredicate, 53, // 10401: check predicate 53
6182 OPC_Decode, 245, 109, 56, // 10403: decode to AMOMAXU_W using decoder 56
6183 // 10403: }
6184 3, 0, // 10407: case 0x3: {
6185 OPC_CheckPredicate, 54, // 10409: check predicate 54
6186 OPC_Decode, 237, 109, 56, // 10411: decode to AMOMAXU_D using decoder 56
6187 // 10411: }
6188 // 10411: } // switch Inst[14:12]
6189 // 10411: }
6190 113, 35, // 10415: case 0x71: {
6191 OPC_SwitchField, 12, 3, // 10417: switch Inst[14:12] {
6192 0, 6, // 10420: case 0x0: {
6193 OPC_CheckPredicate, 52, // 10422: check predicate 52
6194 OPC_Decode, 236, 109, 56, // 10424: decode to AMOMAXU_B_RL using decoder 56
6195 // 10424: }
6196 1, 6, // 10428: case 0x1: {
6197 OPC_CheckPredicate, 52, // 10430: check predicate 52
6198 OPC_Decode, 244, 109, 56, // 10432: decode to AMOMAXU_H_RL using decoder 56
6199 // 10432: }
6200 2, 6, // 10436: case 0x2: {
6201 OPC_CheckPredicate, 53, // 10438: check predicate 53
6202 OPC_Decode, 248, 109, 56, // 10440: decode to AMOMAXU_W_RL using decoder 56
6203 // 10440: }
6204 3, 0, // 10444: case 0x3: {
6205 OPC_CheckPredicate, 54, // 10446: check predicate 54
6206 OPC_Decode, 240, 109, 56, // 10448: decode to AMOMAXU_D_RL using decoder 56
6207 // 10448: }
6208 // 10448: } // switch Inst[14:12]
6209 // 10448: }
6210 114, 35, // 10452: case 0x72: {
6211 OPC_SwitchField, 12, 3, // 10454: switch Inst[14:12] {
6212 0, 6, // 10457: case 0x0: {
6213 OPC_CheckPredicate, 52, // 10459: check predicate 52
6214 OPC_Decode, 234, 109, 56, // 10461: decode to AMOMAXU_B_AQ using decoder 56
6215 // 10461: }
6216 1, 6, // 10465: case 0x1: {
6217 OPC_CheckPredicate, 52, // 10467: check predicate 52
6218 OPC_Decode, 242, 109, 56, // 10469: decode to AMOMAXU_H_AQ using decoder 56
6219 // 10469: }
6220 2, 6, // 10473: case 0x2: {
6221 OPC_CheckPredicate, 53, // 10475: check predicate 53
6222 OPC_Decode, 246, 109, 56, // 10477: decode to AMOMAXU_W_AQ using decoder 56
6223 // 10477: }
6224 3, 0, // 10481: case 0x3: {
6225 OPC_CheckPredicate, 54, // 10483: check predicate 54
6226 OPC_Decode, 238, 109, 56, // 10485: decode to AMOMAXU_D_AQ using decoder 56
6227 // 10485: }
6228 // 10485: } // switch Inst[14:12]
6229 // 10485: }
6230 115, 35, // 10489: case 0x73: {
6231 OPC_SwitchField, 12, 3, // 10491: switch Inst[14:12] {
6232 0, 6, // 10494: case 0x0: {
6233 OPC_CheckPredicate, 52, // 10496: check predicate 52
6234 OPC_Decode, 235, 109, 56, // 10498: decode to AMOMAXU_B_AQRL using decoder 56
6235 // 10498: }
6236 1, 6, // 10502: case 0x1: {
6237 OPC_CheckPredicate, 52, // 10504: check predicate 52
6238 OPC_Decode, 243, 109, 56, // 10506: decode to AMOMAXU_H_AQRL using decoder 56
6239 // 10506: }
6240 2, 6, // 10510: case 0x2: {
6241 OPC_CheckPredicate, 53, // 10512: check predicate 53
6242 OPC_Decode, 247, 109, 56, // 10514: decode to AMOMAXU_W_AQRL using decoder 56
6243 // 10514: }
6244 3, 0, // 10518: case 0x3: {
6245 OPC_CheckPredicate, 54, // 10520: check predicate 54
6246 OPC_Decode, 239, 109, 56, // 10522: decode to AMOMAXU_D_AQRL using decoder 56
6247 // 10522: }
6248 // 10522: } // switch Inst[14:12]
6249 // 10522: }
6250 120, 0, // 10526: case 0x78: {
6251 OPC_SwitchField, 12, 3, // 10528: switch Inst[14:12] {
6252 0, 6, // 10531: case 0x0: {
6253 OPC_CheckPredicate, 65, // 10533: check predicate 65
6254 OPC_Decode, 128, 117, 56, // 10535: decode to LXSUWB using decoder 56
6255 // 10535: }
6256 1, 6, // 10539: case 0x1: {
6257 OPC_CheckPredicate, 65, // 10541: check predicate 65
6258 OPC_Decode, 131, 117, 56, // 10543: decode to LXSUWH using decoder 56
6259 // 10543: }
6260 2, 6, // 10547: case 0x2: {
6261 OPC_CheckPredicate, 65, // 10549: check predicate 65
6262 OPC_Decode, 133, 117, 56, // 10551: decode to LXSUWW using decoder 56
6263 // 10551: }
6264 3, 6, // 10555: case 0x3: {
6265 OPC_CheckPredicate, 65, // 10557: check predicate 65
6266 OPC_Decode, 130, 117, 56, // 10559: decode to LXSUWD using decoder 56
6267 // 10559: }
6268 4, 6, // 10563: case 0x4: {
6269 OPC_CheckPredicate, 65, // 10565: check predicate 65
6270 OPC_Decode, 129, 117, 56, // 10567: decode to LXSUWBU using decoder 56
6271 // 10567: }
6272 5, 6, // 10571: case 0x5: {
6273 OPC_CheckPredicate, 65, // 10573: check predicate 65
6274 OPC_Decode, 132, 117, 56, // 10575: decode to LXSUWHU using decoder 56
6275 // 10575: }
6276 6, 0, // 10579: case 0x6: {
6277 OPC_CheckPredicate, 65, // 10581: check predicate 65
6278 OPC_Decode, 134, 117, 56, // 10583: decode to LXSUWWU using decoder 56
6279 // 10583: }
6280 // 10583: } // switch Inst[14:12]
6281 // 10583: }
6282 // 10583: } // switch Inst[31:25]
6283 // 10583: }
6284 51, 138, 6, // 10587: case 0x33: {
6285 OPC_SwitchField, 25, 5, // 10590: switch Inst[29:25] {
6286 0, 126, // 10593: case 0x0: {
6287 OPC_SwitchField, 12, 3, // 10595: switch Inst[14:12] {
6288 0, 15, // 10598: case 0x0: {
6289 OPC_SwitchField, 30, 2, // 10600: switch Inst[31:30] {
6290 0, 4, // 10603: case 0x0: {
6291 OPC_Decode, 203, 107, 31, // 10605: decode to ADD using decoder 31
6292 // 10605: }
6293 1, 0, // 10609: case 0x1: {
6294 OPC_Decode, 146, 125, 31, // 10611: decode to SUB using decoder 31
6295 // 10611: }
6296 // 10611: } // switch Inst[31:30]
6297 // 10611: }
6298 1, 8, // 10615: case 0x1: {
6299 OPC_CheckField, 30, 2, 0, // 10617: check Inst[31:30] == 0x0
6300 OPC_Decode, 213, 124, 31, // 10621: decode to SLL using decoder 31
6301 // 10621: }
6302 2, 8, // 10625: case 0x2: {
6303 OPC_CheckField, 30, 2, 0, // 10627: check Inst[31:30] == 0x0
6304 OPC_Decode, 218, 124, 31, // 10631: decode to SLT using decoder 31
6305 // 10631: }
6306 3, 8, // 10635: case 0x3: {
6307 OPC_CheckField, 30, 2, 0, // 10637: check Inst[31:30] == 0x0
6308 OPC_Decode, 221, 124, 31, // 10641: decode to SLTU using decoder 31
6309 // 10641: }
6310 4, 19, // 10645: case 0x4: {
6311 OPC_SwitchField, 30, 2, // 10647: switch Inst[31:30] {
6312 0, 5, // 10650: case 0x0: {
6313 OPC_Decode, 158, 132, 1, 31, // 10652: decode to XOR using decoder 31
6314 // 10652: }
6315 1, 0, // 10657: case 0x1: {
6316 OPC_CheckPredicate, 44, // 10659: check predicate 44
6317 OPC_Decode, 157, 132, 1, 31, // 10661: decode to XNOR using decoder 31
6318 // 10661: }
6319 // 10661: } // switch Inst[31:30]
6320 // 10661: }
6321 5, 15, // 10666: case 0x5: {
6322 OPC_SwitchField, 30, 2, // 10668: switch Inst[31:30] {
6323 0, 4, // 10671: case 0x0: {
6324 OPC_Decode, 250, 124, 31, // 10673: decode to SRL using decoder 31
6325 // 10673: }
6326 1, 0, // 10677: case 0x1: {
6327 OPC_Decode, 243, 124, 31, // 10679: decode to SRA using decoder 31
6328 // 10679: }
6329 // 10679: } // switch Inst[31:30]
6330 // 10679: }
6331 6, 17, // 10683: case 0x6: {
6332 OPC_SwitchField, 30, 2, // 10685: switch Inst[31:30] {
6333 0, 4, // 10688: case 0x0: {
6334 OPC_Decode, 206, 118, 31, // 10690: decode to OR using decoder 31
6335 // 10690: }
6336 1, 0, // 10694: case 0x1: {
6337 OPC_CheckPredicate, 44, // 10696: check predicate 44
6338 OPC_Decode, 209, 118, 31, // 10698: decode to ORN using decoder 31
6339 // 10698: }
6340 // 10698: } // switch Inst[31:30]
6341 // 10698: }
6342 7, 0, // 10702: case 0x7: {
6343 OPC_SwitchField, 30, 2, // 10704: switch Inst[31:30] {
6344 0, 4, // 10707: case 0x0: {
6345 OPC_Decode, 217, 110, 31, // 10709: decode to AND using decoder 31
6346 // 10709: }
6347 1, 0, // 10713: case 0x1: {
6348 OPC_CheckPredicate, 44, // 10715: check predicate 44
6349 OPC_Decode, 219, 110, 31, // 10717: decode to ANDN using decoder 31
6350 // 10717: }
6351 // 10717: } // switch Inst[31:30]
6352 // 10717: }
6353 // 10717: } // switch Inst[14:12]
6354 // 10717: }
6355 1, 99, // 10721: case 0x1: {
6356 OPC_SwitchField, 12, 3, // 10723: switch Inst[14:12] {
6357 0, 10, // 10726: case 0x0: {
6358 OPC_CheckPredicate, 66, // 10728: check predicate 66
6359 OPC_CheckField, 30, 2, 0, // 10730: check Inst[31:30] == 0x0
6360 OPC_Decode, 241, 117, 31, // 10734: decode to MUL using decoder 31
6361 // 10734: }
6362 1, 10, // 10738: case 0x1: {
6363 OPC_CheckPredicate, 66, // 10740: check predicate 66
6364 OPC_CheckField, 30, 2, 0, // 10742: check Inst[31:30] == 0x0
6365 OPC_Decode, 242, 117, 31, // 10746: decode to MULH using decoder 31
6366 // 10746: }
6367 2, 10, // 10750: case 0x2: {
6368 OPC_CheckPredicate, 66, // 10752: check predicate 66
6369 OPC_CheckField, 30, 2, 0, // 10754: check Inst[31:30] == 0x0
6370 OPC_Decode, 246, 117, 31, // 10758: decode to MULHSU using decoder 31
6371 // 10758: }
6372 3, 10, // 10762: case 0x3: {
6373 OPC_CheckPredicate, 66, // 10764: check predicate 66
6374 OPC_CheckField, 30, 2, 0, // 10766: check Inst[31:30] == 0x0
6375 OPC_Decode, 249, 117, 31, // 10770: decode to MULHU using decoder 31
6376 // 10770: }
6377 4, 10, // 10774: case 0x4: {
6378 OPC_CheckPredicate, 67, // 10776: check predicate 67
6379 OPC_CheckField, 30, 2, 0, // 10778: check Inst[31:30] == 0x0
6380 OPC_Decode, 145, 114, 31, // 10782: decode to DIV using decoder 31
6381 // 10782: }
6382 5, 10, // 10786: case 0x5: {
6383 OPC_CheckPredicate, 67, // 10788: check predicate 67
6384 OPC_CheckField, 30, 2, 0, // 10790: check Inst[31:30] == 0x0
6385 OPC_Decode, 146, 114, 31, // 10794: decode to DIVU using decoder 31
6386 // 10794: }
6387 6, 10, // 10798: case 0x6: {
6388 OPC_CheckPredicate, 67, // 10800: check predicate 67
6389 OPC_CheckField, 30, 2, 0, // 10802: check Inst[31:30] == 0x0
6390 OPC_Decode, 201, 123, 31, // 10806: decode to REM using decoder 31
6391 // 10806: }
6392 7, 0, // 10810: case 0x7: {
6393 OPC_CheckPredicate, 67, // 10812: check predicate 67
6394 OPC_CheckField, 30, 2, 0, // 10814: check Inst[31:30] == 0x0
6395 OPC_Decode, 202, 123, 31, // 10818: decode to REMU using decoder 31
6396 // 10818: }
6397 // 10818: } // switch Inst[14:12]
6398 // 10818: }
6399 4, 64, // 10822: case 0x4: {
6400 OPC_SwitchField, 12, 3, // 10824: switch Inst[14:12] {
6401 1, 10, // 10827: case 0x1: {
6402 OPC_CheckPredicate, 39, // 10829: check predicate 39
6403 OPC_CheckField, 30, 2, 1, // 10831: check Inst[31:30] == 0x1
6404 OPC_Decode, 223, 110, 31, // 10835: decode to BCLR using decoder 31
6405 // 10835: }
6406 4, 23, // 10839: case 0x4: {
6407 OPC_CheckField, 30, 2, 0, // 10841: check Inst[31:30] == 0x0
6408 OPC_Scope, 11, // 10845: try {
6409 OPC_CheckField, 20, 5, 0, // 10847: check Inst[24:20] == 0x0
6410 OPC_CheckPredicate, 46, // 10851: check predicate 46
6411 OPC_Decode, 184, 132, 1, 17, // 10853: decode to ZEXT_H_RV32 using decoder 17
6412 // 10853: } else try {
6413 OPC_CheckPredicate, 68, // 10858: check predicate 68
6414 OPC_Decode, 235, 118, 31, // 10860: decode to PACK using decoder 31
6415 // 10860: }
6416 // 10860: }
6417 5, 10, // 10864: case 0x5: {
6418 OPC_CheckPredicate, 39, // 10866: check predicate 39
6419 OPC_CheckField, 30, 2, 1, // 10868: check Inst[31:30] == 0x1
6420 OPC_Decode, 227, 110, 31, // 10872: decode to BEXT using decoder 31
6421 // 10872: }
6422 7, 0, // 10876: case 0x7: {
6423 OPC_CheckPredicate, 45, // 10878: check predicate 45
6424 OPC_CheckField, 30, 2, 0, // 10880: check Inst[31:30] == 0x0
6425 OPC_Decode, 236, 118, 31, // 10884: decode to PACKH using decoder 31
6426 // 10884: }
6427 // 10884: } // switch Inst[14:12]
6428 // 10884: }
6429 5, 87, // 10888: case 0x5: {
6430 OPC_SwitchField, 12, 3, // 10890: switch Inst[14:12] {
6431 1, 10, // 10893: case 0x1: {
6432 OPC_CheckPredicate, 69, // 10895: check predicate 69
6433 OPC_CheckField, 30, 2, 0, // 10897: check Inst[31:30] == 0x0
6434 OPC_Decode, 244, 110, 31, // 10901: decode to CLMUL using decoder 31
6435 // 10901: }
6436 2, 10, // 10905: case 0x2: {
6437 OPC_CheckPredicate, 70, // 10907: check predicate 70
6438 OPC_CheckField, 30, 2, 0, // 10909: check Inst[31:30] == 0x0
6439 OPC_Decode, 246, 110, 31, // 10913: decode to CLMULR using decoder 31
6440 // 10913: }
6441 3, 10, // 10917: case 0x3: {
6442 OPC_CheckPredicate, 69, // 10919: check predicate 69
6443 OPC_CheckField, 30, 2, 0, // 10921: check Inst[31:30] == 0x0
6444 OPC_Decode, 245, 110, 31, // 10925: decode to CLMULH using decoder 31
6445 // 10925: }
6446 4, 10, // 10929: case 0x4: {
6447 OPC_CheckPredicate, 42, // 10931: check predicate 42
6448 OPC_CheckField, 30, 2, 0, // 10933: check Inst[31:30] == 0x0
6449 OPC_Decode, 170, 117, 31, // 10937: decode to MIN using decoder 31
6450 // 10937: }
6451 5, 10, // 10941: case 0x5: {
6452 OPC_CheckPredicate, 42, // 10943: check predicate 42
6453 OPC_CheckField, 30, 2, 0, // 10945: check Inst[31:30] == 0x0
6454 OPC_Decode, 171, 117, 31, // 10949: decode to MINU using decoder 31
6455 // 10949: }
6456 6, 10, // 10953: case 0x6: {
6457 OPC_CheckPredicate, 42, // 10955: check predicate 42
6458 OPC_CheckField, 30, 2, 0, // 10957: check Inst[31:30] == 0x0
6459 OPC_Decode, 155, 117, 31, // 10961: decode to MAX using decoder 31
6460 // 10961: }
6461 7, 0, // 10965: case 0x7: {
6462 OPC_CheckPredicate, 42, // 10967: check predicate 42
6463 OPC_CheckField, 30, 2, 0, // 10969: check Inst[31:30] == 0x0
6464 OPC_Decode, 156, 117, 31, // 10973: decode to MAXU using decoder 31
6465 // 10973: }
6466 // 10973: } // switch Inst[14:12]
6467 // 10973: }
6468 7, 27, // 10977: case 0x7: {
6469 OPC_SwitchField, 12, 3, // 10979: switch Inst[14:12] {
6470 5, 10, // 10982: case 0x5: {
6471 OPC_CheckPredicate, 71, // 10984: check predicate 71
6472 OPC_CheckField, 30, 2, 0, // 10986: check Inst[31:30] == 0x0
6473 OPC_Decode, 197, 113, 31, // 10990: decode to CZERO_EQZ using decoder 31
6474 // 10990: }
6475 7, 0, // 10994: case 0x7: {
6476 OPC_CheckPredicate, 71, // 10996: check predicate 71
6477 OPC_CheckField, 30, 2, 0, // 10998: check Inst[31:30] == 0x0
6478 OPC_Decode, 198, 113, 31, // 11002: decode to CZERO_NEZ using decoder 31
6479 // 11002: }
6480 // 11002: } // switch Inst[14:12]
6481 // 11002: }
6482 8, 14, // 11006: case 0x8: {
6483 OPC_CheckPredicate, 72, // 11008: check predicate 72
6484 OPC_CheckField, 30, 2, 1, // 11010: check Inst[31:30] == 0x1
6485 OPC_CheckField, 12, 3, 0, // 11014: check Inst[14:12] == 0x0
6486 OPC_Decode, 202, 124, 31, // 11018: decode to SHA512SUM0R using decoder 31
6487 // 11018: }
6488 9, 14, // 11022: case 0x9: {
6489 OPC_CheckPredicate, 72, // 11024: check predicate 72
6490 OPC_CheckField, 30, 2, 1, // 11026: check Inst[31:30] == 0x1
6491 OPC_CheckField, 12, 3, 0, // 11030: check Inst[14:12] == 0x0
6492 OPC_Decode, 204, 124, 31, // 11034: decode to SHA512SUM1R using decoder 31
6493 // 11034: }
6494 10, 14, // 11038: case 0xa: {
6495 OPC_CheckPredicate, 72, // 11040: check predicate 72
6496 OPC_CheckField, 30, 2, 1, // 11042: check Inst[31:30] == 0x1
6497 OPC_CheckField, 12, 3, 0, // 11046: check Inst[14:12] == 0x0
6498 OPC_Decode, 197, 124, 31, // 11050: decode to SHA512SIG0L using decoder 31
6499 // 11050: }
6500 11, 14, // 11054: case 0xb: {
6501 OPC_CheckPredicate, 72, // 11056: check predicate 72
6502 OPC_CheckField, 30, 2, 1, // 11058: check Inst[31:30] == 0x1
6503 OPC_CheckField, 12, 3, 0, // 11062: check Inst[14:12] == 0x0
6504 OPC_Decode, 200, 124, 31, // 11066: decode to SHA512SIG1L using decoder 31
6505 // 11066: }
6506 14, 14, // 11070: case 0xe: {
6507 OPC_CheckPredicate, 72, // 11072: check predicate 72
6508 OPC_CheckField, 30, 2, 1, // 11074: check Inst[31:30] == 0x1
6509 OPC_CheckField, 12, 3, 0, // 11078: check Inst[14:12] == 0x0
6510 OPC_Decode, 196, 124, 31, // 11082: decode to SHA512SIG0H using decoder 31
6511 // 11082: }
6512 15, 14, // 11086: case 0xf: {
6513 OPC_CheckPredicate, 72, // 11088: check predicate 72
6514 OPC_CheckField, 30, 2, 1, // 11090: check Inst[31:30] == 0x1
6515 OPC_CheckField, 12, 3, 0, // 11094: check Inst[14:12] == 0x0
6516 OPC_Decode, 199, 124, 31, // 11098: decode to SHA512SIG1H using decoder 31
6517 // 11098: }
6518 16, 63, // 11102: case 0x10: {
6519 OPC_SwitchField, 12, 3, // 11104: switch Inst[14:12] {
6520 1, 10, // 11107: case 0x1: {
6521 OPC_CheckPredicate, 44, // 11109: check predicate 44
6522 OPC_CheckField, 30, 2, 1, // 11111: check Inst[31:30] == 0x1
6523 OPC_Decode, 210, 123, 31, // 11115: decode to ROL using decoder 31
6524 // 11115: }
6525 2, 10, // 11119: case 0x2: {
6526 OPC_CheckPredicate, 73, // 11121: check predicate 73
6527 OPC_CheckField, 30, 2, 0, // 11123: check Inst[31:30] == 0x0
6528 OPC_Decode, 184, 124, 31, // 11127: decode to SH1ADD using decoder 31
6529 // 11127: }
6530 4, 10, // 11131: case 0x4: {
6531 OPC_CheckPredicate, 73, // 11133: check predicate 73
6532 OPC_CheckField, 30, 2, 0, // 11135: check Inst[31:30] == 0x0
6533 OPC_Decode, 186, 124, 31, // 11139: decode to SH2ADD using decoder 31
6534 // 11139: }
6535 5, 10, // 11143: case 0x5: {
6536 OPC_CheckPredicate, 44, // 11145: check predicate 44
6537 OPC_CheckField, 30, 2, 1, // 11147: check Inst[31:30] == 0x1
6538 OPC_Decode, 212, 123, 31, // 11151: decode to ROR using decoder 31
6539 // 11151: }
6540 6, 0, // 11155: case 0x6: {
6541 OPC_CheckPredicate, 73, // 11157: check predicate 73
6542 OPC_CheckField, 30, 2, 0, // 11159: check Inst[31:30] == 0x0
6543 OPC_Decode, 188, 124, 31, // 11163: decode to SH3ADD using decoder 31
6544 // 11163: }
6545 // 11163: } // switch Inst[14:12]
6546 // 11163: }
6547 17, 10, // 11167: case 0x11: {
6548 OPC_CheckPredicate, 74, // 11169: check predicate 74
6549 OPC_CheckField, 12, 3, 0, // 11171: check Inst[14:12] == 0x0
6550 OPC_Decode, 211, 107, 60, // 11175: decode to AES32ESI using decoder 60
6551 // 11175: }
6552 19, 10, // 11179: case 0x13: {
6553 OPC_CheckPredicate, 74, // 11181: check predicate 74
6554 OPC_CheckField, 12, 3, 0, // 11183: check Inst[14:12] == 0x0
6555 OPC_Decode, 212, 107, 60, // 11187: decode to AES32ESMI using decoder 60
6556 // 11187: }
6557 20, 50, // 11191: case 0x14: {
6558 OPC_SwitchField, 12, 3, // 11193: switch Inst[14:12] {
6559 1, 19, // 11196: case 0x1: {
6560 OPC_SwitchField, 30, 2, // 11198: switch Inst[31:30] {
6561 0, 6, // 11201: case 0x0: {
6562 OPC_CheckPredicate, 39, // 11203: check predicate 39
6563 OPC_Decode, 238, 110, 31, // 11205: decode to BSET using decoder 31
6564 // 11205: }
6565 1, 0, // 11209: case 0x1: {
6566 OPC_CheckPredicate, 39, // 11211: check predicate 39
6567 OPC_Decode, 231, 110, 31, // 11213: decode to BINV using decoder 31
6568 // 11213: }
6569 // 11213: } // switch Inst[31:30]
6570 // 11213: }
6571 2, 11, // 11217: case 0x2: {
6572 OPC_CheckPredicate, 75, // 11219: check predicate 75
6573 OPC_CheckField, 30, 2, 0, // 11221: check Inst[31:30] == 0x0
6574 OPC_Decode, 160, 132, 1, 31, // 11225: decode to XPERM4 using decoder 31
6575 // 11225: }
6576 4, 0, // 11230: case 0x4: {
6577 OPC_CheckPredicate, 75, // 11232: check predicate 75
6578 OPC_CheckField, 30, 2, 0, // 11234: check Inst[31:30] == 0x0
6579 OPC_Decode, 161, 132, 1, 31, // 11238: decode to XPERM8 using decoder 31
6580 // 11238: }
6581 // 11238: } // switch Inst[14:12]
6582 // 11238: }
6583 21, 10, // 11243: case 0x15: {
6584 OPC_CheckPredicate, 76, // 11245: check predicate 76
6585 OPC_CheckField, 12, 3, 0, // 11247: check Inst[14:12] == 0x0
6586 OPC_Decode, 209, 107, 60, // 11251: decode to AES32DSI using decoder 60
6587 // 11251: }
6588 23, 10, // 11255: case 0x17: {
6589 OPC_CheckPredicate, 76, // 11257: check predicate 76
6590 OPC_CheckField, 12, 3, 0, // 11259: check Inst[14:12] == 0x0
6591 OPC_Decode, 210, 107, 60, // 11263: decode to AES32DSMI using decoder 60
6592 // 11263: }
6593 24, 10, // 11267: case 0x18: {
6594 OPC_CheckPredicate, 77, // 11269: check predicate 77
6595 OPC_CheckField, 12, 3, 0, // 11271: check Inst[14:12] == 0x0
6596 OPC_Decode, 225, 124, 60, // 11275: decode to SM4ED using decoder 60
6597 // 11275: }
6598 25, 14, // 11279: case 0x19: {
6599 OPC_CheckPredicate, 78, // 11281: check predicate 78
6600 OPC_CheckField, 30, 2, 0, // 11283: check Inst[31:30] == 0x0
6601 OPC_CheckField, 12, 3, 0, // 11287: check Inst[14:12] == 0x0
6602 OPC_Decode, 215, 107, 31, // 11291: decode to AES64ES using decoder 31
6603 // 11291: }
6604 26, 10, // 11295: case 0x1a: {
6605 OPC_CheckPredicate, 77, // 11297: check predicate 77
6606 OPC_CheckField, 12, 3, 0, // 11299: check Inst[14:12] == 0x0
6607 OPC_Decode, 226, 124, 60, // 11303: decode to SM4KS using decoder 60
6608 // 11303: }
6609 27, 14, // 11307: case 0x1b: {
6610 OPC_CheckPredicate, 78, // 11309: check predicate 78
6611 OPC_CheckField, 30, 2, 0, // 11311: check Inst[31:30] == 0x0
6612 OPC_CheckField, 12, 3, 0, // 11315: check Inst[14:12] == 0x0
6613 OPC_Decode, 216, 107, 31, // 11319: decode to AES64ESM using decoder 31
6614 // 11319: }
6615 29, 14, // 11323: case 0x1d: {
6616 OPC_CheckPredicate, 40, // 11325: check predicate 40
6617 OPC_CheckField, 30, 2, 0, // 11327: check Inst[31:30] == 0x0
6618 OPC_CheckField, 12, 3, 0, // 11331: check Inst[14:12] == 0x0
6619 OPC_Decode, 213, 107, 31, // 11335: decode to AES64DS using decoder 31
6620 // 11335: }
6621 31, 0, // 11339: case 0x1f: {
6622 OPC_SwitchField, 30, 2, // 11341: switch Inst[31:30] {
6623 0, 10, // 11344: case 0x0: {
6624 OPC_CheckPredicate, 40, // 11346: check predicate 40
6625 OPC_CheckField, 12, 3, 0, // 11348: check Inst[14:12] == 0x0
6626 OPC_Decode, 214, 107, 31, // 11352: decode to AES64DSM using decoder 31
6627 // 11352: }
6628 1, 0, // 11356: case 0x1: {
6629 OPC_CheckPredicate, 41, // 11358: check predicate 41
6630 OPC_CheckField, 12, 3, 0, // 11360: check Inst[14:12] == 0x0
6631 OPC_Decode, 219, 107, 31, // 11364: decode to AES64KS2 using decoder 31
6632 // 11364: }
6633 // 11364: } // switch Inst[31:30]
6634 // 11364: }
6635 // 11364: } // switch Inst[29:25]
6636 // 11364: }
6637 55, 4, // 11368: case 0x37: {
6638 OPC_Decode, 242, 116, 20, // 11370: decode to LUI using decoder 20
6639 // 11370: }
6640 59, 155, 19, // 11374: case 0x3b: {
6641 OPC_SwitchField, 25, 7, // 11377: switch Inst[31:25] {
6642 0, 27, // 11380: case 0x0: {
6643 OPC_SwitchField, 12, 3, // 11382: switch Inst[14:12] {
6644 0, 6, // 11385: case 0x0: {
6645 OPC_CheckPredicate, 22, // 11387: check predicate 22
6646 OPC_Decode, 207, 107, 31, // 11389: decode to ADDW using decoder 31
6647 // 11389: }
6648 1, 6, // 11393: case 0x1: {
6649 OPC_CheckPredicate, 22, // 11395: check predicate 22
6650 OPC_Decode, 217, 124, 31, // 11397: decode to SLLW using decoder 31
6651 // 11397: }
6652 5, 0, // 11401: case 0x5: {
6653 OPC_CheckPredicate, 22, // 11403: check predicate 22
6654 OPC_Decode, 253, 124, 31, // 11405: decode to SRLW using decoder 31
6655 // 11405: }
6656 // 11405: } // switch Inst[14:12]
6657 // 11405: }
6658 1, 43, // 11409: case 0x1: {
6659 OPC_SwitchField, 12, 3, // 11411: switch Inst[14:12] {
6660 0, 6, // 11414: case 0x0: {
6661 OPC_CheckPredicate, 79, // 11416: check predicate 79
6662 OPC_Decode, 136, 118, 31, // 11418: decode to MULW using decoder 31
6663 // 11418: }
6664 4, 6, // 11422: case 0x4: {
6665 OPC_CheckPredicate, 80, // 11424: check predicate 80
6666 OPC_Decode, 148, 114, 31, // 11426: decode to DIVW using decoder 31
6667 // 11426: }
6668 5, 6, // 11430: case 0x5: {
6669 OPC_CheckPredicate, 80, // 11432: check predicate 80
6670 OPC_Decode, 147, 114, 31, // 11434: decode to DIVUW using decoder 31
6671 // 11434: }
6672 6, 6, // 11438: case 0x6: {
6673 OPC_CheckPredicate, 80, // 11440: check predicate 80
6674 OPC_Decode, 204, 123, 31, // 11442: decode to REMW using decoder 31
6675 // 11442: }
6676 7, 0, // 11446: case 0x7: {
6677 OPC_CheckPredicate, 80, // 11448: check predicate 80
6678 OPC_Decode, 203, 123, 31, // 11450: decode to REMUW using decoder 31
6679 // 11450: }
6680 // 11450: } // switch Inst[14:12]
6681 // 11450: }
6682 4, 32, // 11454: case 0x4: {
6683 OPC_SwitchField, 12, 3, // 11456: switch Inst[14:12] {
6684 0, 6, // 11459: case 0x0: {
6685 OPC_CheckPredicate, 50, // 11461: check predicate 50
6686 OPC_Decode, 208, 107, 31, // 11463: decode to ADD_UW using decoder 31
6687 // 11463: }
6688 4, 0, // 11467: case 0x4: {
6689 OPC_Scope, 11, // 11469: try {
6690 OPC_CheckField, 20, 5, 0, // 11471: check Inst[24:20] == 0x0
6691 OPC_CheckPredicate, 49, // 11475: check predicate 49
6692 OPC_Decode, 185, 132, 1, 17, // 11477: decode to ZEXT_H_RV64 using decoder 17
6693 // 11477: } else try {
6694 OPC_CheckPredicate, 81, // 11482: check predicate 81
6695 OPC_Decode, 237, 118, 31, // 11484: decode to PACKW using decoder 31
6696 // 11484: }
6697 // 11484: }
6698 // 11484: } // switch Inst[14:12]
6699 // 11484: }
6700 16, 27, // 11488: case 0x10: {
6701 OPC_SwitchField, 12, 3, // 11490: switch Inst[14:12] {
6702 2, 6, // 11493: case 0x2: {
6703 OPC_CheckPredicate, 50, // 11495: check predicate 50
6704 OPC_Decode, 185, 124, 31, // 11497: decode to SH1ADD_UW using decoder 31
6705 // 11497: }
6706 4, 6, // 11501: case 0x4: {
6707 OPC_CheckPredicate, 50, // 11503: check predicate 50
6708 OPC_Decode, 187, 124, 31, // 11505: decode to SH2ADD_UW using decoder 31
6709 // 11505: }
6710 6, 0, // 11509: case 0x6: {
6711 OPC_CheckPredicate, 50, // 11511: check predicate 50
6712 OPC_Decode, 189, 124, 31, // 11513: decode to SH3ADD_UW using decoder 31
6713 // 11513: }
6714 // 11513: } // switch Inst[14:12]
6715 // 11513: }
6716 32, 19, // 11517: case 0x20: {
6717 OPC_SwitchField, 12, 3, // 11519: switch Inst[14:12] {
6718 0, 6, // 11522: case 0x0: {
6719 OPC_CheckPredicate, 22, // 11524: check predicate 22
6720 OPC_Decode, 148, 125, 31, // 11526: decode to SUBW using decoder 31
6721 // 11526: }
6722 5, 0, // 11530: case 0x5: {
6723 OPC_CheckPredicate, 22, // 11532: check predicate 22
6724 OPC_Decode, 248, 124, 31, // 11534: decode to SRAW using decoder 31
6725 // 11534: }
6726 // 11534: } // switch Inst[14:12]
6727 // 11534: }
6728 48, 19, // 11538: case 0x30: {
6729 OPC_SwitchField, 12, 3, // 11540: switch Inst[14:12] {
6730 1, 6, // 11543: case 0x1: {
6731 OPC_CheckPredicate, 49, // 11545: check predicate 49
6732 OPC_Decode, 211, 123, 31, // 11547: decode to ROLW using decoder 31
6733 // 11547: }
6734 5, 0, // 11551: case 0x5: {
6735 OPC_CheckPredicate, 49, // 11553: check predicate 49
6736 OPC_Decode, 215, 123, 31, // 11555: decode to RORW using decoder 31
6737 // 11555: }
6738 // 11555: } // switch Inst[14:12]
6739 // 11555: }
6740 64, 59, // 11559: case 0x40: {
6741 OPC_SwitchField, 12, 3, // 11561: switch Inst[14:12] {
6742 0, 6, // 11564: case 0x0: {
6743 OPC_CheckPredicate, 43, // 11566: check predicate 43
6744 OPC_Decode, 246, 118, 31, // 11568: decode to PADD_H using decoder 31
6745 // 11568: }
6746 2, 6, // 11572: case 0x2: {
6747 OPC_CheckPredicate, 48, // 11574: check predicate 48
6748 OPC_Decode, 211, 120, 31, // 11576: decode to PNCLIPUP_B using decoder 31
6749 // 11576: }
6750 3, 6, // 11580: case 0x3: {
6751 OPC_CheckPredicate, 43, // 11582: check predicate 43
6752 OPC_Decode, 190, 120, 31, // 11584: decode to PMUL_H_B00 using decoder 31
6753 // 11584: }
6754 4, 6, // 11588: case 0x4: {
6755 OPC_CheckPredicate, 43, // 11590: check predicate 43
6756 OPC_Decode, 235, 120, 31, // 11592: decode to PPAIRE_B using decoder 31
6757 // 11592: }
6758 5, 6, // 11596: case 0x5: {
6759 OPC_CheckPredicate, 43, // 11598: check predicate 43
6760 OPC_Decode, 160, 119, 31, // 11600: decode to PM2ADD_H using decoder 31
6761 // 11600: }
6762 6, 6, // 11604: case 0x6: {
6763 OPC_CheckPredicate, 43, // 11606: check predicate 43
6764 OPC_Decode, 138, 119, 31, // 11608: decode to PAS_HX using decoder 31
6765 // 11608: }
6766 7, 0, // 11612: case 0x7: {
6767 OPC_CheckPredicate, 43, // 11614: check predicate 43
6768 OPC_Decode, 170, 120, 31, // 11616: decode to PMULH_H using decoder 31
6769 // 11616: }
6770 // 11616: } // switch Inst[14:12]
6771 // 11616: }
6772 65, 59, // 11620: case 0x41: {
6773 OPC_SwitchField, 12, 3, // 11622: switch Inst[14:12] {
6774 0, 6, // 11625: case 0x0: {
6775 OPC_CheckPredicate, 48, // 11627: check predicate 48
6776 OPC_Decode, 248, 118, 31, // 11629: decode to PADD_W using decoder 31
6777 // 11629: }
6778 2, 6, // 11633: case 0x2: {
6779 OPC_CheckPredicate, 48, // 11635: check predicate 48
6780 OPC_Decode, 212, 120, 31, // 11637: decode to PNCLIPUP_H using decoder 31
6781 // 11637: }
6782 3, 6, // 11641: case 0x3: {
6783 OPC_CheckPredicate, 48, // 11643: check predicate 48
6784 OPC_Decode, 193, 120, 31, // 11645: decode to PMUL_W_H00 using decoder 31
6785 // 11645: }
6786 4, 6, // 11649: case 0x4: {
6787 OPC_CheckPredicate, 48, // 11651: check predicate 48
6788 OPC_Decode, 238, 120, 31, // 11653: decode to PPAIRE_H using decoder 31
6789 // 11653: }
6790 5, 6, // 11657: case 0x5: {
6791 OPC_CheckPredicate, 48, // 11659: check predicate 48
6792 OPC_Decode, 162, 119, 31, // 11661: decode to PM2ADD_W using decoder 31
6793 // 11661: }
6794 6, 6, // 11665: case 0x6: {
6795 OPC_CheckPredicate, 48, // 11667: check predicate 48
6796 OPC_Decode, 139, 119, 31, // 11669: decode to PAS_WX using decoder 31
6797 // 11669: }
6798 7, 0, // 11673: case 0x7: {
6799 OPC_CheckPredicate, 48, // 11675: check predicate 48
6800 OPC_Decode, 173, 120, 31, // 11677: decode to PMULH_W using decoder 31
6801 // 11677: }
6802 // 11677: } // switch Inst[14:12]
6803 // 11677: }
6804 66, 35, // 11681: case 0x42: {
6805 OPC_SwitchField, 12, 3, // 11683: switch Inst[14:12] {
6806 0, 6, // 11686: case 0x0: {
6807 OPC_CheckPredicate, 43, // 11688: check predicate 43
6808 OPC_Decode, 238, 118, 31, // 11690: decode to PADD_B using decoder 31
6809 // 11690: }
6810 5, 6, // 11694: case 0x5: {
6811 OPC_CheckPredicate, 43, // 11696: check predicate 43
6812 OPC_Decode, 196, 119, 31, // 11698: decode to PM4ADD_B using decoder 31
6813 // 11698: }
6814 6, 6, // 11702: case 0x6: {
6815 OPC_CheckPredicate, 43, // 11704: check predicate 43
6816 OPC_Decode, 158, 121, 31, // 11706: decode to PSA_HX using decoder 31
6817 // 11706: }
6818 7, 0, // 11710: case 0x7: {
6819 OPC_CheckPredicate, 43, // 11712: check predicate 43
6820 OPC_Decode, 160, 120, 31, // 11714: decode to PMULHR_H using decoder 31
6821 // 11714: }
6822 // 11714: } // switch Inst[14:12]
6823 // 11714: }
6824 67, 43, // 11718: case 0x43: {
6825 OPC_SwitchField, 12, 3, // 11720: switch Inst[14:12] {
6826 2, 6, // 11723: case 0x2: {
6827 OPC_CheckPredicate, 48, // 11725: check predicate 48
6828 OPC_Decode, 213, 120, 31, // 11727: decode to PNCLIPUP_W using decoder 31
6829 // 11727: }
6830 3, 6, // 11731: case 0x3: {
6831 OPC_CheckPredicate, 48, // 11733: check predicate 48
6832 OPC_Decode, 140, 118, 31, // 11735: decode to MUL_W00 using decoder 31
6833 // 11735: }
6834 5, 6, // 11739: case 0x5: {
6835 OPC_CheckPredicate, 48, // 11741: check predicate 48
6836 OPC_Decode, 197, 119, 31, // 11743: decode to PM4ADD_H using decoder 31
6837 // 11743: }
6838 6, 6, // 11747: case 0x6: {
6839 OPC_CheckPredicate, 48, // 11749: check predicate 48
6840 OPC_Decode, 159, 121, 31, // 11751: decode to PSA_WX using decoder 31
6841 // 11751: }
6842 7, 0, // 11755: case 0x7: {
6843 OPC_CheckPredicate, 48, // 11757: check predicate 48
6844 OPC_Decode, 161, 120, 31, // 11759: decode to PMULHR_W using decoder 31
6845 // 11759: }
6846 // 11759: } // switch Inst[14:12]
6847 // 11759: }
6848 68, 19, // 11763: case 0x44: {
6849 OPC_SwitchField, 12, 3, // 11765: switch Inst[14:12] {
6850 5, 6, // 11768: case 0x5: {
6851 OPC_CheckPredicate, 43, // 11770: check predicate 43
6852 OPC_Decode, 152, 119, 61, // 11772: decode to PM2ADDA_H using decoder 61
6853 // 11772: }
6854 7, 0, // 11776: case 0x7: {
6855 OPC_CheckPredicate, 43, // 11778: check predicate 43
6856 OPC_Decode, 226, 119, 61, // 11780: decode to PMHACC_H using decoder 61
6857 // 11780: }
6858 // 11780: } // switch Inst[14:12]
6859 // 11780: }
6860 69, 27, // 11784: case 0x45: {
6861 OPC_SwitchField, 12, 3, // 11786: switch Inst[14:12] {
6862 3, 6, // 11789: case 0x3: {
6863 OPC_CheckPredicate, 48, // 11791: check predicate 48
6864 OPC_Decode, 203, 119, 61, // 11793: decode to PMACC_W_H00 using decoder 61
6865 // 11793: }
6866 5, 6, // 11797: case 0x5: {
6867 OPC_CheckPredicate, 48, // 11799: check predicate 48
6868 OPC_Decode, 154, 119, 61, // 11801: decode to PM2ADDA_W using decoder 61
6869 // 11801: }
6870 7, 0, // 11805: case 0x7: {
6871 OPC_CheckPredicate, 48, // 11807: check predicate 48
6872 OPC_Decode, 229, 119, 61, // 11809: decode to PMHACC_W using decoder 61
6873 // 11809: }
6874 // 11809: } // switch Inst[14:12]
6875 // 11809: }
6876 70, 19, // 11813: case 0x46: {
6877 OPC_SwitchField, 12, 3, // 11815: switch Inst[14:12] {
6878 5, 6, // 11818: case 0x5: {
6879 OPC_CheckPredicate, 43, // 11820: check predicate 43
6880 OPC_Decode, 190, 119, 61, // 11822: decode to PM4ADDA_B using decoder 61
6881 // 11822: }
6882 7, 0, // 11826: case 0x7: {
6883 OPC_CheckPredicate, 43, // 11828: check predicate 43
6884 OPC_Decode, 236, 119, 61, // 11830: decode to PMHRACC_H using decoder 61
6885 // 11830: }
6886 // 11830: } // switch Inst[14:12]
6887 // 11830: }
6888 71, 35, // 11834: case 0x47: {
6889 OPC_SwitchField, 12, 3, // 11836: switch Inst[14:12] {
6890 1, 6, // 11839: case 0x1: {
6891 OPC_CheckPredicate, 43, // 11841: check predicate 43
6892 OPC_Decode, 222, 124, 61, // 11843: decode to SLX using decoder 61
6893 // 11843: }
6894 3, 6, // 11847: case 0x3: {
6895 OPC_CheckPredicate, 48, // 11849: check predicate 48
6896 OPC_Decode, 152, 117, 61, // 11851: decode to MACC_W00 using decoder 61
6897 // 11851: }
6898 5, 6, // 11855: case 0x5: {
6899 OPC_CheckPredicate, 48, // 11857: check predicate 48
6900 OPC_Decode, 191, 119, 61, // 11859: decode to PM4ADDA_H using decoder 61
6901 // 11859: }
6902 7, 0, // 11863: case 0x7: {
6903 OPC_CheckPredicate, 48, // 11865: check predicate 48
6904 OPC_Decode, 237, 119, 61, // 11867: decode to PMHRACC_W using decoder 61
6905 // 11867: }
6906 // 11867: } // switch Inst[14:12]
6907 // 11867: }
6908 72, 59, // 11871: case 0x48: {
6909 OPC_SwitchField, 12, 3, // 11873: switch Inst[14:12] {
6910 0, 6, // 11876: case 0x0: {
6911 OPC_CheckPredicate, 43, // 11878: check predicate 43
6912 OPC_Decode, 148, 121, 31, // 11880: decode to PSADD_H using decoder 31
6913 // 11880: }
6914 1, 6, // 11884: case 0x1: {
6915 OPC_CheckPredicate, 43, // 11886: check predicate 43
6916 OPC_Decode, 191, 120, 31, // 11888: decode to PMUL_H_B01 using decoder 31
6917 // 11888: }
6918 3, 6, // 11892: case 0x3: {
6919 OPC_CheckPredicate, 43, // 11894: check predicate 43
6920 OPC_Decode, 192, 120, 31, // 11896: decode to PMUL_H_B11 using decoder 31
6921 // 11896: }
6922 4, 6, // 11900: case 0x4: {
6923 OPC_CheckPredicate, 43, // 11902: check predicate 43
6924 OPC_Decode, 230, 120, 31, // 11904: decode to PPAIREO_B using decoder 31
6925 // 11904: }
6926 5, 6, // 11908: case 0x5: {
6927 OPC_CheckPredicate, 43, // 11910: check predicate 43
6928 OPC_Decode, 161, 119, 31, // 11912: decode to PM2ADD_HX using decoder 31
6929 // 11912: }
6930 6, 6, // 11916: case 0x6: {
6931 OPC_CheckPredicate, 43, // 11918: check predicate 43
6932 OPC_Decode, 151, 121, 31, // 11920: decode to PSAS_HX using decoder 31
6933 // 11920: }
6934 7, 0, // 11924: case 0x7: {
6935 OPC_CheckPredicate, 43, // 11926: check predicate 43
6936 OPC_Decode, 168, 120, 31, // 11928: decode to PMULHU_H using decoder 31
6937 // 11928: }
6938 // 11928: } // switch Inst[14:12]
6939 // 11928: }
6940 73, 59, // 11932: case 0x49: {
6941 OPC_SwitchField, 12, 3, // 11934: switch Inst[14:12] {
6942 0, 6, // 11937: case 0x0: {
6943 OPC_CheckPredicate, 48, // 11939: check predicate 48
6944 OPC_Decode, 149, 121, 31, // 11941: decode to PSADD_W using decoder 31
6945 // 11941: }
6946 1, 6, // 11945: case 0x1: {
6947 OPC_CheckPredicate, 48, // 11947: check predicate 48
6948 OPC_Decode, 194, 120, 31, // 11949: decode to PMUL_W_H01 using decoder 31
6949 // 11949: }
6950 3, 6, // 11953: case 0x3: {
6951 OPC_CheckPredicate, 48, // 11955: check predicate 48
6952 OPC_Decode, 195, 120, 31, // 11957: decode to PMUL_W_H11 using decoder 31
6953 // 11957: }
6954 4, 6, // 11961: case 0x4: {
6955 OPC_CheckPredicate, 43, // 11963: check predicate 43
6956 OPC_Decode, 233, 120, 31, // 11965: decode to PPAIREO_H using decoder 31
6957 // 11965: }
6958 5, 6, // 11969: case 0x5: {
6959 OPC_CheckPredicate, 48, // 11971: check predicate 48
6960 OPC_Decode, 163, 119, 31, // 11973: decode to PM2ADD_WX using decoder 31
6961 // 11973: }
6962 6, 6, // 11977: case 0x6: {
6963 OPC_CheckPredicate, 48, // 11979: check predicate 48
6964 OPC_Decode, 152, 121, 31, // 11981: decode to PSAS_WX using decoder 31
6965 // 11981: }
6966 7, 0, // 11985: case 0x7: {
6967 OPC_CheckPredicate, 48, // 11987: check predicate 48
6968 OPC_Decode, 169, 120, 31, // 11989: decode to PMULHU_W using decoder 31
6969 // 11989: }
6970 // 11989: } // switch Inst[14:12]
6971 // 11989: }
6972 74, 27, // 11993: case 0x4a: {
6973 OPC_SwitchField, 12, 3, // 11995: switch Inst[14:12] {
6974 0, 6, // 11998: case 0x0: {
6975 OPC_CheckPredicate, 43, // 12000: check predicate 43
6976 OPC_Decode, 144, 121, 31, // 12002: decode to PSADD_B using decoder 31
6977 // 12002: }
6978 6, 6, // 12006: case 0x6: {
6979 OPC_CheckPredicate, 43, // 12008: check predicate 43
6980 OPC_Decode, 211, 121, 31, // 12010: decode to PSSA_HX using decoder 31
6981 // 12010: }
6982 7, 0, // 12014: case 0x7: {
6983 OPC_CheckPredicate, 43, // 12016: check predicate 43
6984 OPC_Decode, 158, 120, 31, // 12018: decode to PMULHRU_H using decoder 31
6985 // 12018: }
6986 // 12018: } // switch Inst[14:12]
6987 // 12018: }
6988 75, 43, // 12022: case 0x4b: {
6989 OPC_SwitchField, 12, 3, // 12024: switch Inst[14:12] {
6990 1, 6, // 12027: case 0x1: {
6991 OPC_CheckPredicate, 48, // 12029: check predicate 48
6992 OPC_Decode, 141, 118, 31, // 12031: decode to MUL_W01 using decoder 31
6993 // 12031: }
6994 3, 6, // 12035: case 0x3: {
6995 OPC_CheckPredicate, 48, // 12037: check predicate 48
6996 OPC_Decode, 142, 118, 31, // 12039: decode to MUL_W11 using decoder 31
6997 // 12039: }
6998 4, 6, // 12043: case 0x4: {
6999 OPC_CheckPredicate, 48, // 12045: check predicate 48
7000 OPC_Decode, 234, 120, 31, // 12047: decode to PPAIREO_W using decoder 31
7001 // 12047: }
7002 6, 6, // 12051: case 0x6: {
7003 OPC_CheckPredicate, 48, // 12053: check predicate 48
7004 OPC_Decode, 212, 121, 31, // 12055: decode to PSSA_WX using decoder 31
7005 // 12055: }
7006 7, 0, // 12059: case 0x7: {
7007 OPC_CheckPredicate, 48, // 12061: check predicate 48
7008 OPC_Decode, 159, 120, 31, // 12063: decode to PMULHRU_W using decoder 31
7009 // 12063: }
7010 // 12063: } // switch Inst[14:12]
7011 // 12063: }
7012 76, 35, // 12067: case 0x4c: {
7013 OPC_SwitchField, 12, 3, // 12069: switch Inst[14:12] {
7014 0, 6, // 12072: case 0x0: {
7015 OPC_CheckPredicate, 43, // 12074: check predicate 43
7016 OPC_Decode, 220, 118, 31, // 12076: decode to PAADD_H using decoder 31
7017 // 12076: }
7018 5, 6, // 12080: case 0x5: {
7019 OPC_CheckPredicate, 43, // 12082: check predicate 43
7020 OPC_Decode, 153, 119, 61, // 12084: decode to PM2ADDA_HX using decoder 61
7021 // 12084: }
7022 6, 6, // 12088: case 0x6: {
7023 OPC_CheckPredicate, 43, // 12090: check predicate 43
7024 OPC_Decode, 223, 118, 31, // 12092: decode to PAAS_HX using decoder 31
7025 // 12092: }
7026 7, 0, // 12096: case 0x7: {
7027 OPC_CheckPredicate, 43, // 12098: check predicate 43
7028 OPC_Decode, 224, 119, 61, // 12100: decode to PMHACCU_H using decoder 61
7029 // 12100: }
7030 // 12100: } // switch Inst[14:12]
7031 // 12100: }
7032 77, 51, // 12104: case 0x4d: {
7033 OPC_SwitchField, 12, 3, // 12106: switch Inst[14:12] {
7034 0, 6, // 12109: case 0x0: {
7035 OPC_CheckPredicate, 48, // 12111: check predicate 48
7036 OPC_Decode, 221, 118, 31, // 12113: decode to PAADD_W using decoder 31
7037 // 12113: }
7038 1, 6, // 12117: case 0x1: {
7039 OPC_CheckPredicate, 48, // 12119: check predicate 48
7040 OPC_Decode, 204, 119, 61, // 12121: decode to PMACC_W_H01 using decoder 61
7041 // 12121: }
7042 3, 6, // 12125: case 0x3: {
7043 OPC_CheckPredicate, 48, // 12127: check predicate 48
7044 OPC_Decode, 205, 119, 61, // 12129: decode to PMACC_W_H11 using decoder 61
7045 // 12129: }
7046 5, 6, // 12133: case 0x5: {
7047 OPC_CheckPredicate, 48, // 12135: check predicate 48
7048 OPC_Decode, 155, 119, 61, // 12137: decode to PM2ADDA_WX using decoder 61
7049 // 12137: }
7050 6, 6, // 12141: case 0x6: {
7051 OPC_CheckPredicate, 48, // 12143: check predicate 48
7052 OPC_Decode, 224, 118, 31, // 12145: decode to PAAS_WX using decoder 31
7053 // 12145: }
7054 7, 0, // 12149: case 0x7: {
7055 OPC_CheckPredicate, 48, // 12151: check predicate 48
7056 OPC_Decode, 225, 119, 61, // 12153: decode to PMHACCU_W using decoder 61
7057 // 12153: }
7058 // 12153: } // switch Inst[14:12]
7059 // 12153: }
7060 78, 27, // 12157: case 0x4e: {
7061 OPC_SwitchField, 12, 3, // 12159: switch Inst[14:12] {
7062 0, 6, // 12162: case 0x0: {
7063 OPC_CheckPredicate, 43, // 12164: check predicate 43
7064 OPC_Decode, 216, 118, 31, // 12166: decode to PAADD_B using decoder 31
7065 // 12166: }
7066 6, 6, // 12170: case 0x6: {
7067 OPC_CheckPredicate, 43, // 12172: check predicate 43
7068 OPC_Decode, 251, 118, 31, // 12174: decode to PASA_HX using decoder 31
7069 // 12174: }
7070 7, 0, // 12178: case 0x7: {
7071 OPC_CheckPredicate, 43, // 12180: check predicate 43
7072 OPC_Decode, 234, 119, 61, // 12182: decode to PMHRACCU_H using decoder 61
7073 // 12182: }
7074 // 12182: } // switch Inst[14:12]
7075 // 12182: }
7076 79, 35, // 12186: case 0x4f: {
7077 OPC_SwitchField, 12, 3, // 12188: switch Inst[14:12] {
7078 1, 6, // 12191: case 0x1: {
7079 OPC_CheckPredicate, 48, // 12193: check predicate 48
7080 OPC_Decode, 153, 117, 61, // 12195: decode to MACC_W01 using decoder 61
7081 // 12195: }
7082 3, 6, // 12199: case 0x3: {
7083 OPC_CheckPredicate, 48, // 12201: check predicate 48
7084 OPC_Decode, 154, 117, 61, // 12203: decode to MACC_W11 using decoder 61
7085 // 12203: }
7086 6, 6, // 12207: case 0x6: {
7087 OPC_CheckPredicate, 48, // 12209: check predicate 48
7088 OPC_Decode, 252, 118, 31, // 12211: decode to PASA_WX using decoder 31
7089 // 12211: }
7090 7, 0, // 12215: case 0x7: {
7091 OPC_CheckPredicate, 48, // 12217: check predicate 48
7092 OPC_Decode, 235, 119, 61, // 12219: decode to PMHRACCU_W using decoder 61
7093 // 12219: }
7094 // 12219: } // switch Inst[14:12]
7095 // 12219: }
7096 80, 43, // 12223: case 0x50: {
7097 OPC_SwitchField, 12, 3, // 12225: switch Inst[14:12] {
7098 2, 6, // 12228: case 0x2: {
7099 OPC_CheckPredicate, 43, // 12230: check predicate 43
7100 OPC_Decode, 168, 121, 31, // 12232: decode to PSH1ADD_H using decoder 31
7101 // 12232: }
7102 3, 6, // 12236: case 0x3: {
7103 OPC_CheckPredicate, 43, // 12238: check predicate 43
7104 OPC_Decode, 184, 120, 31, // 12240: decode to PMULU_H_B00 using decoder 31
7105 // 12240: }
7106 4, 6, // 12244: case 0x4: {
7107 OPC_CheckPredicate, 43, // 12246: check predicate 43
7108 OPC_Decode, 239, 120, 31, // 12248: decode to PPAIROE_B using decoder 31
7109 // 12248: }
7110 5, 6, // 12252: case 0x5: {
7111 OPC_CheckPredicate, 43, // 12254: check predicate 43
7112 OPC_Decode, 158, 119, 31, // 12256: decode to PM2ADDU_H using decoder 31
7113 // 12256: }
7114 7, 0, // 12260: case 0x7: {
7115 OPC_CheckPredicate, 43, // 12262: check predicate 43
7116 OPC_Decode, 171, 120, 31, // 12264: decode to PMULH_H_B0 using decoder 31
7117 // 12264: }
7118 // 12264: } // switch Inst[14:12]
7119 // 12264: }
7120 81, 43, // 12268: case 0x51: {
7121 OPC_SwitchField, 12, 3, // 12270: switch Inst[14:12] {
7122 2, 6, // 12273: case 0x2: {
7123 OPC_CheckPredicate, 48, // 12275: check predicate 48
7124 OPC_Decode, 169, 121, 31, // 12277: decode to PSH1ADD_W using decoder 31
7125 // 12277: }
7126 3, 6, // 12281: case 0x3: {
7127 OPC_CheckPredicate, 48, // 12283: check predicate 48
7128 OPC_Decode, 187, 120, 31, // 12285: decode to PMULU_W_H00 using decoder 31
7129 // 12285: }
7130 4, 6, // 12289: case 0x4: {
7131 OPC_CheckPredicate, 43, // 12291: check predicate 43
7132 OPC_Decode, 242, 120, 31, // 12293: decode to PPAIROE_H using decoder 31
7133 // 12293: }
7134 5, 6, // 12297: case 0x5: {
7135 OPC_CheckPredicate, 48, // 12299: check predicate 48
7136 OPC_Decode, 159, 119, 31, // 12301: decode to PM2ADDU_W using decoder 31
7137 // 12301: }
7138 7, 0, // 12305: case 0x7: {
7139 OPC_CheckPredicate, 48, // 12307: check predicate 48
7140 OPC_Decode, 174, 120, 31, // 12309: decode to PMULH_W_H0 using decoder 31
7141 // 12309: }
7142 // 12309: } // switch Inst[14:12]
7143 // 12309: }
7144 82, 19, // 12313: case 0x52: {
7145 OPC_SwitchField, 12, 3, // 12315: switch Inst[14:12] {
7146 5, 6, // 12318: case 0x5: {
7147 OPC_CheckPredicate, 43, // 12320: check predicate 43
7148 OPC_Decode, 194, 119, 31, // 12322: decode to PM4ADDU_B using decoder 31
7149 // 12322: }
7150 7, 0, // 12326: case 0x7: {
7151 OPC_CheckPredicate, 43, // 12328: check predicate 43
7152 OPC_Decode, 163, 120, 31, // 12330: decode to PMULHSU_H_B0 using decoder 31
7153 // 12330: }
7154 // 12330: } // switch Inst[14:12]
7155 // 12330: }
7156 83, 35, // 12334: case 0x53: {
7157 OPC_SwitchField, 12, 3, // 12336: switch Inst[14:12] {
7158 3, 6, // 12339: case 0x3: {
7159 OPC_CheckPredicate, 48, // 12341: check predicate 48
7160 OPC_Decode, 133, 118, 31, // 12343: decode to MULU_W00 using decoder 31
7161 // 12343: }
7162 4, 6, // 12347: case 0x4: {
7163 OPC_CheckPredicate, 48, // 12349: check predicate 48
7164 OPC_Decode, 243, 120, 31, // 12351: decode to PPAIROE_W using decoder 31
7165 // 12351: }
7166 5, 6, // 12355: case 0x5: {
7167 OPC_CheckPredicate, 48, // 12357: check predicate 48
7168 OPC_Decode, 195, 119, 31, // 12359: decode to PM4ADDU_H using decoder 31
7169 // 12359: }
7170 7, 0, // 12363: case 0x7: {
7171 OPC_CheckPredicate, 48, // 12365: check predicate 48
7172 OPC_Decode, 166, 120, 31, // 12367: decode to PMULHSU_W_H0 using decoder 31
7173 // 12367: }
7174 // 12367: } // switch Inst[14:12]
7175 // 12367: }
7176 84, 27, // 12371: case 0x54: {
7177 OPC_SwitchField, 12, 3, // 12373: switch Inst[14:12] {
7178 1, 6, // 12376: case 0x1: {
7179 OPC_CheckPredicate, 43, // 12378: check predicate 43
7180 OPC_Decode, 143, 118, 61, // 12380: decode to MVM using decoder 61
7181 // 12380: }
7182 5, 6, // 12384: case 0x5: {
7183 OPC_CheckPredicate, 43, // 12386: check predicate 43
7184 OPC_Decode, 150, 119, 61, // 12388: decode to PM2ADDAU_H using decoder 61
7185 // 12388: }
7186 7, 0, // 12392: case 0x7: {
7187 OPC_CheckPredicate, 43, // 12394: check predicate 43
7188 OPC_Decode, 227, 119, 61, // 12396: decode to PMHACC_H_B0 using decoder 61
7189 // 12396: }
7190 // 12396: } // switch Inst[14:12]
7191 // 12396: }
7192 85, 35, // 12400: case 0x55: {
7193 OPC_SwitchField, 12, 3, // 12402: switch Inst[14:12] {
7194 1, 6, // 12405: case 0x1: {
7195 OPC_CheckPredicate, 43, // 12407: check predicate 43
7196 OPC_Decode, 144, 118, 61, // 12409: decode to MVMN using decoder 61
7197 // 12409: }
7198 3, 6, // 12413: case 0x3: {
7199 OPC_CheckPredicate, 48, // 12415: check predicate 48
7200 OPC_Decode, 200, 119, 61, // 12417: decode to PMACCU_W_H00 using decoder 61
7201 // 12417: }
7202 5, 6, // 12421: case 0x5: {
7203 OPC_CheckPredicate, 48, // 12423: check predicate 48
7204 OPC_Decode, 151, 119, 61, // 12425: decode to PM2ADDAU_W using decoder 61
7205 // 12425: }
7206 7, 0, // 12429: case 0x7: {
7207 OPC_CheckPredicate, 48, // 12431: check predicate 48
7208 OPC_Decode, 230, 119, 61, // 12433: decode to PMHACC_W_H0 using decoder 61
7209 // 12433: }
7210 // 12433: } // switch Inst[14:12]
7211 // 12433: }
7212 86, 27, // 12437: case 0x56: {
7213 OPC_SwitchField, 12, 3, // 12439: switch Inst[14:12] {
7214 1, 6, // 12442: case 0x1: {
7215 OPC_CheckPredicate, 43, // 12444: check predicate 43
7216 OPC_Decode, 159, 117, 61, // 12446: decode to MERGE using decoder 61
7217 // 12446: }
7218 5, 6, // 12450: case 0x5: {
7219 OPC_CheckPredicate, 43, // 12452: check predicate 43
7220 OPC_Decode, 188, 119, 61, // 12454: decode to PM4ADDAU_B using decoder 61
7221 // 12454: }
7222 7, 0, // 12458: case 0x7: {
7223 OPC_CheckPredicate, 43, // 12460: check predicate 43
7224 OPC_Decode, 219, 119, 61, // 12462: decode to PMHACCSU_H_B0 using decoder 61
7225 // 12462: }
7226 // 12462: } // switch Inst[14:12]
7227 // 12462: }
7228 87, 35, // 12466: case 0x57: {
7229 OPC_SwitchField, 12, 3, // 12468: switch Inst[14:12] {
7230 1, 6, // 12471: case 0x1: {
7231 OPC_CheckPredicate, 43, // 12473: check predicate 43
7232 OPC_Decode, 254, 124, 61, // 12475: decode to SRX using decoder 61
7233 // 12475: }
7234 3, 6, // 12479: case 0x3: {
7235 OPC_CheckPredicate, 48, // 12481: check predicate 48
7236 OPC_Decode, 146, 117, 61, // 12483: decode to MACCU_W00 using decoder 61
7237 // 12483: }
7238 5, 6, // 12487: case 0x5: {
7239 OPC_CheckPredicate, 48, // 12489: check predicate 48
7240 OPC_Decode, 189, 119, 61, // 12491: decode to PM4ADDAU_H using decoder 61
7241 // 12491: }
7242 7, 0, // 12495: case 0x7: {
7243 OPC_CheckPredicate, 48, // 12497: check predicate 48
7244 OPC_Decode, 222, 119, 61, // 12499: decode to PMHACCSU_W_H0 using decoder 61
7245 // 12499: }
7246 // 12499: } // switch Inst[14:12]
7247 // 12499: }
7248 88, 59, // 12503: case 0x58: {
7249 OPC_SwitchField, 12, 3, // 12505: switch Inst[14:12] {
7250 0, 6, // 12508: case 0x0: {
7251 OPC_CheckPredicate, 43, // 12510: check predicate 43
7252 OPC_Decode, 142, 121, 31, // 12512: decode to PSADDU_H using decoder 31
7253 // 12512: }
7254 1, 6, // 12516: case 0x1: {
7255 OPC_CheckPredicate, 43, // 12518: check predicate 43
7256 OPC_Decode, 185, 120, 31, // 12520: decode to PMULU_H_B01 using decoder 31
7257 // 12520: }
7258 2, 6, // 12524: case 0x2: {
7259 OPC_CheckPredicate, 43, // 12526: check predicate 43
7260 OPC_Decode, 215, 121, 31, // 12528: decode to PSSH1SADD_H using decoder 31
7261 // 12528: }
7262 3, 6, // 12532: case 0x3: {
7263 OPC_CheckPredicate, 43, // 12534: check predicate 43
7264 OPC_Decode, 186, 120, 31, // 12536: decode to PMULU_H_B11 using decoder 31
7265 // 12536: }
7266 4, 6, // 12540: case 0x4: {
7267 OPC_CheckPredicate, 43, // 12542: check predicate 43
7268 OPC_Decode, 244, 120, 31, // 12544: decode to PPAIRO_B using decoder 31
7269 // 12544: }
7270 5, 6, // 12548: case 0x5: {
7271 OPC_CheckPredicate, 43, // 12550: check predicate 43
7272 OPC_Decode, 252, 119, 31, // 12552: decode to PMQ2ADD_H using decoder 31
7273 // 12552: }
7274 7, 0, // 12556: case 0x7: {
7275 OPC_CheckPredicate, 43, // 12558: check predicate 43
7276 OPC_Decode, 172, 120, 31, // 12560: decode to PMULH_H_B1 using decoder 31
7277 // 12560: }
7278 // 12560: } // switch Inst[14:12]
7279 // 12560: }
7280 89, 59, // 12564: case 0x59: {
7281 OPC_SwitchField, 12, 3, // 12566: switch Inst[14:12] {
7282 0, 6, // 12569: case 0x0: {
7283 OPC_CheckPredicate, 48, // 12571: check predicate 48
7284 OPC_Decode, 143, 121, 31, // 12573: decode to PSADDU_W using decoder 31
7285 // 12573: }
7286 1, 6, // 12577: case 0x1: {
7287 OPC_CheckPredicate, 48, // 12579: check predicate 48
7288 OPC_Decode, 188, 120, 31, // 12581: decode to PMULU_W_H01 using decoder 31
7289 // 12581: }
7290 2, 6, // 12585: case 0x2: {
7291 OPC_CheckPredicate, 48, // 12587: check predicate 48
7292 OPC_Decode, 216, 121, 31, // 12589: decode to PSSH1SADD_W using decoder 31
7293 // 12589: }
7294 3, 6, // 12593: case 0x3: {
7295 OPC_CheckPredicate, 48, // 12595: check predicate 48
7296 OPC_Decode, 189, 120, 31, // 12597: decode to PMULU_W_H11 using decoder 31
7297 // 12597: }
7298 4, 6, // 12601: case 0x4: {
7299 OPC_CheckPredicate, 43, // 12603: check predicate 43
7300 OPC_Decode, 247, 120, 31, // 12605: decode to PPAIRO_H using decoder 31
7301 // 12605: }
7302 5, 6, // 12609: case 0x5: {
7303 OPC_CheckPredicate, 48, // 12611: check predicate 48
7304 OPC_Decode, 253, 119, 31, // 12613: decode to PMQ2ADD_W using decoder 31
7305 // 12613: }
7306 7, 0, // 12617: case 0x7: {
7307 OPC_CheckPredicate, 48, // 12619: check predicate 48
7308 OPC_Decode, 175, 120, 31, // 12621: decode to PMULH_W_H1 using decoder 31
7309 // 12621: }
7310 // 12621: } // switch Inst[14:12]
7311 // 12621: }
7312 90, 35, // 12625: case 0x5a: {
7313 OPC_SwitchField, 12, 3, // 12627: switch Inst[14:12] {
7314 0, 6, // 12630: case 0x0: {
7315 OPC_CheckPredicate, 43, // 12632: check predicate 43
7316 OPC_Decode, 138, 121, 31, // 12634: decode to PSADDU_B using decoder 31
7317 // 12634: }
7318 1, 6, // 12638: case 0x1: {
7319 OPC_CheckPredicate, 43, // 12640: check predicate 43
7320 OPC_Decode, 226, 118, 31, // 12642: decode to PABDSUMU_B using decoder 31
7321 // 12642: }
7322 5, 6, // 12646: case 0x5: {
7323 OPC_CheckPredicate, 43, // 12648: check predicate 43
7324 OPC_Decode, 131, 120, 31, // 12650: decode to PMQR2ADD_H using decoder 31
7325 // 12650: }
7326 7, 0, // 12654: case 0x7: {
7327 OPC_CheckPredicate, 43, // 12656: check predicate 43
7328 OPC_Decode, 164, 120, 31, // 12658: decode to PMULHSU_H_B1 using decoder 31
7329 // 12658: }
7330 // 12658: } // switch Inst[14:12]
7331 // 12658: }
7332 91, 43, // 12662: case 0x5b: {
7333 OPC_SwitchField, 12, 3, // 12664: switch Inst[14:12] {
7334 1, 6, // 12667: case 0x1: {
7335 OPC_CheckPredicate, 48, // 12669: check predicate 48
7336 OPC_Decode, 134, 118, 31, // 12671: decode to MULU_W01 using decoder 31
7337 // 12671: }
7338 3, 6, // 12675: case 0x3: {
7339 OPC_CheckPredicate, 48, // 12677: check predicate 48
7340 OPC_Decode, 135, 118, 31, // 12679: decode to MULU_W11 using decoder 31
7341 // 12679: }
7342 4, 6, // 12683: case 0x4: {
7343 OPC_CheckPredicate, 48, // 12685: check predicate 48
7344 OPC_Decode, 248, 120, 31, // 12687: decode to PPAIRO_W using decoder 31
7345 // 12687: }
7346 5, 6, // 12691: case 0x5: {
7347 OPC_CheckPredicate, 48, // 12693: check predicate 48
7348 OPC_Decode, 132, 120, 31, // 12695: decode to PMQR2ADD_W using decoder 31
7349 // 12695: }
7350 7, 0, // 12699: case 0x7: {
7351 OPC_CheckPredicate, 48, // 12701: check predicate 48
7352 OPC_Decode, 167, 120, 31, // 12703: decode to PMULHSU_W_H1 using decoder 31
7353 // 12703: }
7354 // 12703: } // switch Inst[14:12]
7355 // 12703: }
7356 92, 27, // 12707: case 0x5c: {
7357 OPC_SwitchField, 12, 3, // 12709: switch Inst[14:12] {
7358 0, 6, // 12712: case 0x0: {
7359 OPC_CheckPredicate, 43, // 12714: check predicate 43
7360 OPC_Decode, 214, 118, 31, // 12716: decode to PAADDU_H using decoder 31
7361 // 12716: }
7362 5, 6, // 12720: case 0x5: {
7363 OPC_CheckPredicate, 43, // 12722: check predicate 43
7364 OPC_Decode, 250, 119, 61, // 12724: decode to PMQ2ADDA_H using decoder 61
7365 // 12724: }
7366 7, 0, // 12728: case 0x7: {
7367 OPC_CheckPredicate, 43, // 12730: check predicate 43
7368 OPC_Decode, 228, 119, 61, // 12732: decode to PMHACC_H_B1 using decoder 61
7369 // 12732: }
7370 // 12732: } // switch Inst[14:12]
7371 // 12732: }
7372 93, 43, // 12736: case 0x5d: {
7373 OPC_SwitchField, 12, 3, // 12738: switch Inst[14:12] {
7374 0, 6, // 12741: case 0x0: {
7375 OPC_CheckPredicate, 48, // 12743: check predicate 48
7376 OPC_Decode, 215, 118, 31, // 12745: decode to PAADDU_W using decoder 31
7377 // 12745: }
7378 1, 6, // 12749: case 0x1: {
7379 OPC_CheckPredicate, 48, // 12751: check predicate 48
7380 OPC_Decode, 201, 119, 61, // 12753: decode to PMACCU_W_H01 using decoder 61
7381 // 12753: }
7382 3, 6, // 12757: case 0x3: {
7383 OPC_CheckPredicate, 48, // 12759: check predicate 48
7384 OPC_Decode, 202, 119, 61, // 12761: decode to PMACCU_W_H11 using decoder 61
7385 // 12761: }
7386 5, 6, // 12765: case 0x5: {
7387 OPC_CheckPredicate, 48, // 12767: check predicate 48
7388 OPC_Decode, 251, 119, 61, // 12769: decode to PMQ2ADDA_W using decoder 61
7389 // 12769: }
7390 7, 0, // 12773: case 0x7: {
7391 OPC_CheckPredicate, 48, // 12775: check predicate 48
7392 OPC_Decode, 231, 119, 61, // 12777: decode to PMHACC_W_H1 using decoder 61
7393 // 12777: }
7394 // 12777: } // switch Inst[14:12]
7395 // 12777: }
7396 94, 35, // 12781: case 0x5e: {
7397 OPC_SwitchField, 12, 3, // 12783: switch Inst[14:12] {
7398 0, 6, // 12786: case 0x0: {
7399 OPC_CheckPredicate, 43, // 12788: check predicate 43
7400 OPC_Decode, 210, 118, 31, // 12790: decode to PAADDU_B using decoder 31
7401 // 12790: }
7402 1, 6, // 12794: case 0x1: {
7403 OPC_CheckPredicate, 43, // 12796: check predicate 43
7404 OPC_Decode, 225, 118, 61, // 12798: decode to PABDSUMAU_B using decoder 61
7405 // 12798: }
7406 5, 6, // 12802: case 0x5: {
7407 OPC_CheckPredicate, 43, // 12804: check predicate 43
7408 OPC_Decode, 129, 120, 61, // 12806: decode to PMQR2ADDA_H using decoder 61
7409 // 12806: }
7410 7, 0, // 12810: case 0x7: {
7411 OPC_CheckPredicate, 43, // 12812: check predicate 43
7412 OPC_Decode, 220, 119, 61, // 12814: decode to PMHACCSU_H_B1 using decoder 61
7413 // 12814: }
7414 // 12814: } // switch Inst[14:12]
7415 // 12814: }
7416 95, 35, // 12818: case 0x5f: {
7417 OPC_SwitchField, 12, 3, // 12820: switch Inst[14:12] {
7418 1, 6, // 12823: case 0x1: {
7419 OPC_CheckPredicate, 48, // 12825: check predicate 48
7420 OPC_Decode, 147, 117, 61, // 12827: decode to MACCU_W01 using decoder 61
7421 // 12827: }
7422 3, 6, // 12831: case 0x3: {
7423 OPC_CheckPredicate, 48, // 12833: check predicate 48
7424 OPC_Decode, 148, 117, 61, // 12835: decode to MACCU_W11 using decoder 61
7425 // 12835: }
7426 5, 6, // 12839: case 0x5: {
7427 OPC_CheckPredicate, 48, // 12841: check predicate 48
7428 OPC_Decode, 130, 120, 61, // 12843: decode to PMQR2ADDA_W using decoder 61
7429 // 12843: }
7430 7, 0, // 12847: case 0x7: {
7431 OPC_CheckPredicate, 48, // 12849: check predicate 48
7432 OPC_Decode, 223, 119, 61, // 12851: decode to PMHACCSU_W_H1 using decoder 61
7433 // 12851: }
7434 // 12851: } // switch Inst[14:12]
7435 // 12851: }
7436 96, 43, // 12855: case 0x60: {
7437 OPC_SwitchField, 12, 3, // 12857: switch Inst[14:12] {
7438 0, 6, // 12860: case 0x0: {
7439 OPC_CheckPredicate, 43, // 12862: check predicate 43
7440 OPC_Decode, 253, 121, 31, // 12864: decode to PSUB_H using decoder 31
7441 // 12864: }
7442 2, 6, // 12868: case 0x2: {
7443 OPC_CheckPredicate, 48, // 12870: check predicate 48
7444 OPC_Decode, 200, 120, 31, // 12872: decode to PNCLIPP_B using decoder 31
7445 // 12872: }
7446 5, 6, // 12876: case 0x5: {
7447 OPC_CheckPredicate, 43, // 12878: check predicate 43
7448 OPC_Decode, 170, 119, 31, // 12880: decode to PM2SUB_H using decoder 31
7449 // 12880: }
7450 6, 6, // 12884: case 0x6: {
7451 OPC_CheckPredicate, 43, // 12886: check predicate 43
7452 OPC_Decode, 142, 120, 31, // 12888: decode to PMSEQ_H using decoder 31
7453 // 12888: }
7454 7, 0, // 12892: case 0x7: {
7455 OPC_CheckPredicate, 43, // 12894: check predicate 43
7456 OPC_Decode, 162, 120, 31, // 12896: decode to PMULHSU_H using decoder 31
7457 // 12896: }
7458 // 12896: } // switch Inst[14:12]
7459 // 12896: }
7460 97, 43, // 12900: case 0x61: {
7461 OPC_SwitchField, 12, 3, // 12902: switch Inst[14:12] {
7462 0, 6, // 12905: case 0x0: {
7463 OPC_CheckPredicate, 48, // 12907: check predicate 48
7464 OPC_Decode, 254, 121, 31, // 12909: decode to PSUB_W using decoder 31
7465 // 12909: }
7466 2, 6, // 12913: case 0x2: {
7467 OPC_CheckPredicate, 48, // 12915: check predicate 48
7468 OPC_Decode, 201, 120, 31, // 12917: decode to PNCLIPP_H using decoder 31
7469 // 12917: }
7470 5, 6, // 12921: case 0x5: {
7471 OPC_CheckPredicate, 48, // 12923: check predicate 48
7472 OPC_Decode, 172, 119, 31, // 12925: decode to PM2SUB_W using decoder 31
7473 // 12925: }
7474 6, 6, // 12929: case 0x6: {
7475 OPC_CheckPredicate, 48, // 12931: check predicate 48
7476 OPC_Decode, 143, 120, 31, // 12933: decode to PMSEQ_W using decoder 31
7477 // 12933: }
7478 7, 0, // 12937: case 0x7: {
7479 OPC_CheckPredicate, 48, // 12939: check predicate 48
7480 OPC_Decode, 165, 120, 31, // 12941: decode to PMULHSU_W using decoder 31
7481 // 12941: }
7482 // 12941: } // switch Inst[14:12]
7483 // 12941: }
7484 98, 35, // 12945: case 0x62: {
7485 OPC_SwitchField, 12, 3, // 12947: switch Inst[14:12] {
7486 0, 6, // 12950: case 0x0: {
7487 OPC_CheckPredicate, 43, // 12952: check predicate 43
7488 OPC_Decode, 249, 121, 31, // 12954: decode to PSUB_B using decoder 31
7489 // 12954: }
7490 5, 6, // 12958: case 0x5: {
7491 OPC_CheckPredicate, 43, // 12960: check predicate 43
7492 OPC_Decode, 164, 119, 31, // 12962: decode to PM2SADD_H using decoder 31
7493 // 12962: }
7494 6, 6, // 12966: case 0x6: {
7495 OPC_CheckPredicate, 43, // 12968: check predicate 43
7496 OPC_Decode, 138, 120, 31, // 12970: decode to PMSEQ_B using decoder 31
7497 // 12970: }
7498 7, 0, // 12974: case 0x7: {
7499 OPC_CheckPredicate, 43, // 12976: check predicate 43
7500 OPC_Decode, 156, 120, 31, // 12978: decode to PMULHRSU_H using decoder 31
7501 // 12978: }
7502 // 12978: } // switch Inst[14:12]
7503 // 12978: }
7504 99, 19, // 12982: case 0x63: {
7505 OPC_SwitchField, 12, 3, // 12984: switch Inst[14:12] {
7506 2, 6, // 12987: case 0x2: {
7507 OPC_CheckPredicate, 48, // 12989: check predicate 48
7508 OPC_Decode, 202, 120, 31, // 12991: decode to PNCLIPP_W using decoder 31
7509 // 12991: }
7510 7, 0, // 12995: case 0x7: {
7511 OPC_CheckPredicate, 48, // 12997: check predicate 48
7512 OPC_Decode, 157, 120, 31, // 12999: decode to PMULHRSU_W using decoder 31
7513 // 12999: }
7514 // 12999: } // switch Inst[14:12]
7515 // 12999: }
7516 100, 27, // 13003: case 0x64: {
7517 OPC_SwitchField, 12, 3, // 13005: switch Inst[14:12] {
7518 0, 6, // 13008: case 0x0: {
7519 OPC_CheckPredicate, 43, // 13010: check predicate 43
7520 OPC_Decode, 234, 118, 31, // 13012: decode to PABD_H using decoder 31
7521 // 13012: }
7522 5, 6, // 13016: case 0x5: {
7523 OPC_CheckPredicate, 43, // 13018: check predicate 43
7524 OPC_Decode, 166, 119, 61, // 13020: decode to PM2SUBA_H using decoder 61
7525 // 13020: }
7526 7, 0, // 13024: case 0x7: {
7527 OPC_CheckPredicate, 43, // 13026: check predicate 43
7528 OPC_Decode, 218, 119, 61, // 13028: decode to PMHACCSU_H using decoder 61
7529 // 13028: }
7530 // 13028: } // switch Inst[14:12]
7531 // 13028: }
7532 101, 19, // 13032: case 0x65: {
7533 OPC_SwitchField, 12, 3, // 13034: switch Inst[14:12] {
7534 5, 6, // 13037: case 0x5: {
7535 OPC_CheckPredicate, 48, // 13039: check predicate 48
7536 OPC_Decode, 168, 119, 61, // 13041: decode to PM2SUBA_W using decoder 61
7537 // 13041: }
7538 7, 0, // 13045: case 0x7: {
7539 OPC_CheckPredicate, 48, // 13047: check predicate 48
7540 OPC_Decode, 221, 119, 61, // 13049: decode to PMHACCSU_W using decoder 61
7541 // 13049: }
7542 // 13049: } // switch Inst[14:12]
7543 // 13049: }
7544 102, 19, // 13053: case 0x66: {
7545 OPC_SwitchField, 12, 3, // 13055: switch Inst[14:12] {
7546 0, 6, // 13058: case 0x0: {
7547 OPC_CheckPredicate, 43, // 13060: check predicate 43
7548 OPC_Decode, 231, 118, 31, // 13062: decode to PABD_B using decoder 31
7549 // 13062: }
7550 7, 0, // 13066: case 0x7: {
7551 OPC_CheckPredicate, 43, // 13068: check predicate 43
7552 OPC_Decode, 232, 119, 61, // 13070: decode to PMHRACCSU_H using decoder 61
7553 // 13070: }
7554 // 13070: } // switch Inst[14:12]
7555 // 13070: }
7556 103, 10, // 13074: case 0x67: {
7557 OPC_CheckPredicate, 48, // 13076: check predicate 48
7558 OPC_CheckField, 12, 3, 7, // 13078: check Inst[14:12] == 0x7
7559 OPC_Decode, 233, 119, 61, // 13082: decode to PMHRACCSU_W using decoder 61
7560 // 13082: }
7561 104, 35, // 13086: case 0x68: {
7562 OPC_SwitchField, 12, 3, // 13088: switch Inst[14:12] {
7563 0, 6, // 13091: case 0x0: {
7564 OPC_CheckPredicate, 43, // 13093: check predicate 43
7565 OPC_Decode, 247, 121, 31, // 13095: decode to PSSUB_H using decoder 31
7566 // 13095: }
7567 5, 6, // 13099: case 0x5: {
7568 OPC_CheckPredicate, 43, // 13101: check predicate 43
7569 OPC_Decode, 171, 119, 31, // 13103: decode to PM2SUB_HX using decoder 31
7570 // 13103: }
7571 6, 6, // 13107: case 0x6: {
7572 OPC_CheckPredicate, 43, // 13109: check predicate 43
7573 OPC_Decode, 154, 120, 31, // 13111: decode to PMSLT_H using decoder 31
7574 // 13111: }
7575 7, 0, // 13115: case 0x7: {
7576 OPC_CheckPredicate, 43, // 13117: check predicate 43
7577 OPC_Decode, 178, 120, 31, // 13119: decode to PMULQ_H using decoder 31
7578 // 13119: }
7579 // 13119: } // switch Inst[14:12]
7580 // 13119: }
7581 105, 35, // 13123: case 0x69: {
7582 OPC_SwitchField, 12, 3, // 13125: switch Inst[14:12] {
7583 0, 6, // 13128: case 0x0: {
7584 OPC_CheckPredicate, 48, // 13130: check predicate 48
7585 OPC_Decode, 248, 121, 31, // 13132: decode to PSSUB_W using decoder 31
7586 // 13132: }
7587 5, 6, // 13136: case 0x5: {
7588 OPC_CheckPredicate, 48, // 13138: check predicate 48
7589 OPC_Decode, 173, 119, 31, // 13140: decode to PM2SUB_WX using decoder 31
7590 // 13140: }
7591 6, 6, // 13144: case 0x6: {
7592 OPC_CheckPredicate, 48, // 13146: check predicate 48
7593 OPC_Decode, 155, 120, 31, // 13148: decode to PMSLT_W using decoder 31
7594 // 13148: }
7595 7, 0, // 13152: case 0x7: {
7596 OPC_CheckPredicate, 48, // 13154: check predicate 48
7597 OPC_Decode, 179, 120, 31, // 13156: decode to PMULQ_W using decoder 31
7598 // 13156: }
7599 // 13156: } // switch Inst[14:12]
7600 // 13156: }
7601 106, 35, // 13160: case 0x6a: {
7602 OPC_SwitchField, 12, 3, // 13162: switch Inst[14:12] {
7603 0, 6, // 13165: case 0x0: {
7604 OPC_CheckPredicate, 43, // 13167: check predicate 43
7605 OPC_Decode, 243, 121, 31, // 13169: decode to PSSUB_B using decoder 31
7606 // 13169: }
7607 5, 6, // 13173: case 0x5: {
7608 OPC_CheckPredicate, 43, // 13175: check predicate 43
7609 OPC_Decode, 165, 119, 31, // 13177: decode to PM2SADD_HX using decoder 31
7610 // 13177: }
7611 6, 6, // 13181: case 0x6: {
7612 OPC_CheckPredicate, 43, // 13183: check predicate 43
7613 OPC_Decode, 150, 120, 31, // 13185: decode to PMSLT_B using decoder 31
7614 // 13185: }
7615 7, 0, // 13189: case 0x7: {
7616 OPC_CheckPredicate, 43, // 13191: check predicate 43
7617 OPC_Decode, 176, 120, 31, // 13193: decode to PMULQR_H using decoder 31
7618 // 13193: }
7619 // 13193: } // switch Inst[14:12]
7620 // 13193: }
7621 107, 10, // 13197: case 0x6b: {
7622 OPC_CheckPredicate, 48, // 13199: check predicate 48
7623 OPC_CheckField, 12, 3, 7, // 13201: check Inst[14:12] == 0x7
7624 OPC_Decode, 177, 120, 31, // 13205: decode to PMULQR_W using decoder 31
7625 // 13205: }
7626 108, 27, // 13209: case 0x6c: {
7627 OPC_SwitchField, 12, 3, // 13211: switch Inst[14:12] {
7628 0, 6, // 13214: case 0x0: {
7629 OPC_CheckPredicate, 43, // 13216: check predicate 43
7630 OPC_Decode, 135, 119, 31, // 13218: decode to PASUB_H using decoder 31
7631 // 13218: }
7632 5, 6, // 13222: case 0x5: {
7633 OPC_CheckPredicate, 43, // 13224: check predicate 43
7634 OPC_Decode, 167, 119, 61, // 13226: decode to PM2SUBA_HX using decoder 61
7635 // 13226: }
7636 6, 0, // 13230: case 0x6: {
7637 OPC_CheckPredicate, 43, // 13232: check predicate 43
7638 OPC_Decode, 148, 120, 31, // 13234: decode to PMSLTU_H using decoder 31
7639 // 13234: }
7640 // 13234: } // switch Inst[14:12]
7641 // 13234: }
7642 109, 27, // 13238: case 0x6d: {
7643 OPC_SwitchField, 12, 3, // 13240: switch Inst[14:12] {
7644 0, 6, // 13243: case 0x0: {
7645 OPC_CheckPredicate, 48, // 13245: check predicate 48
7646 OPC_Decode, 136, 119, 31, // 13247: decode to PASUB_W using decoder 31
7647 // 13247: }
7648 5, 6, // 13251: case 0x5: {
7649 OPC_CheckPredicate, 48, // 13253: check predicate 48
7650 OPC_Decode, 169, 119, 61, // 13255: decode to PM2SUBA_WX using decoder 61
7651 // 13255: }
7652 6, 0, // 13259: case 0x6: {
7653 OPC_CheckPredicate, 48, // 13261: check predicate 48
7654 OPC_Decode, 149, 120, 31, // 13263: decode to PMSLTU_W using decoder 31
7655 // 13263: }
7656 // 13263: } // switch Inst[14:12]
7657 // 13263: }
7658 110, 19, // 13267: case 0x6e: {
7659 OPC_SwitchField, 12, 3, // 13269: switch Inst[14:12] {
7660 0, 6, // 13272: case 0x0: {
7661 OPC_CheckPredicate, 43, // 13274: check predicate 43
7662 OPC_Decode, 131, 119, 31, // 13276: decode to PASUB_B using decoder 31
7663 // 13276: }
7664 6, 0, // 13280: case 0x6: {
7665 OPC_CheckPredicate, 43, // 13282: check predicate 43
7666 OPC_Decode, 144, 120, 31, // 13284: decode to PMSLTU_B using decoder 31
7667 // 13284: }
7668 // 13284: } // switch Inst[14:12]
7669 // 13284: }
7670 112, 35, // 13288: case 0x70: {
7671 OPC_SwitchField, 12, 3, // 13290: switch Inst[14:12] {
7672 2, 6, // 13293: case 0x2: {
7673 OPC_CheckPredicate, 48, // 13295: check predicate 48
7674 OPC_Decode, 138, 126, 31, // 13297: decode to UNZIP8P using decoder 31
7675 // 13297: }
7676 3, 6, // 13301: case 0x3: {
7677 OPC_CheckPredicate, 43, // 13303: check predicate 43
7678 OPC_Decode, 180, 120, 31, // 13305: decode to PMULSU_H_B00 using decoder 31
7679 // 13305: }
7680 5, 6, // 13309: case 0x5: {
7681 OPC_CheckPredicate, 43, // 13311: check predicate 43
7682 OPC_Decode, 156, 119, 31, // 13313: decode to PM2ADDSU_H using decoder 31
7683 // 13313: }
7684 6, 0, // 13317: case 0x6: {
7685 OPC_CheckPredicate, 43, // 13319: check predicate 43
7686 OPC_Decode, 248, 119, 31, // 13321: decode to PMIN_H using decoder 31
7687 // 13321: }
7688 // 13321: } // switch Inst[14:12]
7689 // 13321: }
7690 113, 35, // 13325: case 0x71: {
7691 OPC_SwitchField, 12, 3, // 13327: switch Inst[14:12] {
7692 2, 6, // 13330: case 0x2: {
7693 OPC_CheckPredicate, 48, // 13332: check predicate 48
7694 OPC_Decode, 136, 126, 31, // 13334: decode to UNZIP16P using decoder 31
7695 // 13334: }
7696 3, 6, // 13338: case 0x3: {
7697 OPC_CheckPredicate, 48, // 13340: check predicate 48
7698 OPC_Decode, 182, 120, 31, // 13342: decode to PMULSU_W_H00 using decoder 31
7699 // 13342: }
7700 5, 6, // 13346: case 0x5: {
7701 OPC_CheckPredicate, 48, // 13348: check predicate 48
7702 OPC_Decode, 157, 119, 31, // 13350: decode to PM2ADDSU_W using decoder 31
7703 // 13350: }
7704 6, 0, // 13354: case 0x6: {
7705 OPC_CheckPredicate, 48, // 13356: check predicate 48
7706 OPC_Decode, 249, 119, 31, // 13358: decode to PMIN_W using decoder 31
7707 // 13358: }
7708 // 13358: } // switch Inst[14:12]
7709 // 13358: }
7710 114, 27, // 13362: case 0x72: {
7711 OPC_SwitchField, 12, 3, // 13364: switch Inst[14:12] {
7712 2, 6, // 13367: case 0x2: {
7713 OPC_CheckPredicate, 48, // 13369: check predicate 48
7714 OPC_Decode, 137, 126, 31, // 13371: decode to UNZIP8HP using decoder 31
7715 // 13371: }
7716 5, 6, // 13375: case 0x5: {
7717 OPC_CheckPredicate, 43, // 13377: check predicate 43
7718 OPC_Decode, 192, 119, 31, // 13379: decode to PM4ADDSU_B using decoder 31
7719 // 13379: }
7720 6, 0, // 13383: case 0x6: {
7721 OPC_CheckPredicate, 43, // 13385: check predicate 43
7722 OPC_Decode, 244, 119, 31, // 13387: decode to PMIN_B using decoder 31
7723 // 13387: }
7724 // 13387: } // switch Inst[14:12]
7725 // 13387: }
7726 115, 27, // 13391: case 0x73: {
7727 OPC_SwitchField, 12, 3, // 13393: switch Inst[14:12] {
7728 2, 6, // 13396: case 0x2: {
7729 OPC_CheckPredicate, 48, // 13398: check predicate 48
7730 OPC_Decode, 135, 126, 31, // 13400: decode to UNZIP16HP using decoder 31
7731 // 13400: }
7732 3, 6, // 13404: case 0x3: {
7733 OPC_CheckPredicate, 48, // 13406: check predicate 48
7734 OPC_Decode, 128, 118, 31, // 13408: decode to MULSU_W00 using decoder 31
7735 // 13408: }
7736 5, 0, // 13412: case 0x5: {
7737 OPC_CheckPredicate, 48, // 13414: check predicate 48
7738 OPC_Decode, 193, 119, 31, // 13416: decode to PM4ADDSU_H using decoder 31
7739 // 13416: }
7740 // 13416: } // switch Inst[14:12]
7741 // 13416: }
7742 116, 35, // 13420: case 0x74: {
7743 OPC_SwitchField, 12, 3, // 13422: switch Inst[14:12] {
7744 0, 6, // 13425: case 0x0: {
7745 OPC_CheckPredicate, 43, // 13427: check predicate 43
7746 OPC_Decode, 230, 118, 31, // 13429: decode to PABDU_H using decoder 31
7747 // 13429: }
7748 5, 6, // 13433: case 0x5: {
7749 OPC_CheckPredicate, 43, // 13435: check predicate 43
7750 OPC_Decode, 148, 119, 61, // 13437: decode to PM2ADDASU_H using decoder 61
7751 // 13437: }
7752 6, 6, // 13441: case 0x6: {
7753 OPC_CheckPredicate, 43, // 13443: check predicate 43
7754 OPC_Decode, 242, 119, 31, // 13445: decode to PMINU_H using decoder 31
7755 // 13445: }
7756 7, 0, // 13449: case 0x7: {
7757 OPC_CheckPredicate, 48, // 13451: check predicate 48
7758 OPC_Decode, 254, 119, 61, // 13453: decode to PMQACC_W_H00 using decoder 61
7759 // 13453: }
7760 // 13453: } // switch Inst[14:12]
7761 // 13453: }
7762 117, 35, // 13457: case 0x75: {
7763 OPC_SwitchField, 12, 3, // 13459: switch Inst[14:12] {
7764 3, 6, // 13462: case 0x3: {
7765 OPC_CheckPredicate, 48, // 13464: check predicate 48
7766 OPC_Decode, 198, 119, 61, // 13466: decode to PMACCSU_W_H00 using decoder 61
7767 // 13466: }
7768 5, 6, // 13470: case 0x5: {
7769 OPC_CheckPredicate, 48, // 13472: check predicate 48
7770 OPC_Decode, 149, 119, 61, // 13474: decode to PM2ADDASU_W using decoder 61
7771 // 13474: }
7772 6, 6, // 13478: case 0x6: {
7773 OPC_CheckPredicate, 48, // 13480: check predicate 48
7774 OPC_Decode, 243, 119, 31, // 13482: decode to PMINU_W using decoder 31
7775 // 13482: }
7776 7, 0, // 13486: case 0x7: {
7777 OPC_CheckPredicate, 48, // 13488: check predicate 48
7778 OPC_Decode, 226, 117, 61, // 13490: decode to MQACC_W00 using decoder 61
7779 // 13490: }
7780 // 13490: } // switch Inst[14:12]
7781 // 13490: }
7782 118, 35, // 13494: case 0x76: {
7783 OPC_SwitchField, 12, 3, // 13496: switch Inst[14:12] {
7784 0, 6, // 13499: case 0x0: {
7785 OPC_CheckPredicate, 43, // 13501: check predicate 43
7786 OPC_Decode, 227, 118, 31, // 13503: decode to PABDU_B using decoder 31
7787 // 13503: }
7788 5, 6, // 13507: case 0x5: {
7789 OPC_CheckPredicate, 43, // 13509: check predicate 43
7790 OPC_Decode, 186, 119, 61, // 13511: decode to PM4ADDASU_B using decoder 61
7791 // 13511: }
7792 6, 6, // 13515: case 0x6: {
7793 OPC_CheckPredicate, 43, // 13517: check predicate 43
7794 OPC_Decode, 238, 119, 31, // 13519: decode to PMINU_B using decoder 31
7795 // 13519: }
7796 7, 0, // 13523: case 0x7: {
7797 OPC_CheckPredicate, 48, // 13525: check predicate 48
7798 OPC_Decode, 133, 120, 61, // 13527: decode to PMQRACC_W_H00 using decoder 61
7799 // 13527: }
7800 // 13527: } // switch Inst[14:12]
7801 // 13527: }
7802 119, 27, // 13531: case 0x77: {
7803 OPC_SwitchField, 12, 3, // 13533: switch Inst[14:12] {
7804 3, 6, // 13536: case 0x3: {
7805 OPC_CheckPredicate, 48, // 13538: check predicate 48
7806 OPC_Decode, 141, 117, 61, // 13540: decode to MACCSU_W00 using decoder 61
7807 // 13540: }
7808 5, 6, // 13544: case 0x5: {
7809 OPC_CheckPredicate, 48, // 13546: check predicate 48
7810 OPC_Decode, 187, 119, 61, // 13548: decode to PM4ADDASU_H using decoder 61
7811 // 13548: }
7812 7, 0, // 13552: case 0x7: {
7813 OPC_CheckPredicate, 48, // 13554: check predicate 48
7814 OPC_Decode, 232, 117, 61, // 13556: decode to MQRACC_W00 using decoder 61
7815 // 13556: }
7816 // 13556: } // switch Inst[14:12]
7817 // 13556: }
7818 120, 36, // 13560: case 0x78: {
7819 OPC_SwitchField, 12, 3, // 13562: switch Inst[14:12] {
7820 0, 6, // 13565: case 0x0: {
7821 OPC_CheckPredicate, 43, // 13567: check predicate 43
7822 OPC_Decode, 241, 121, 31, // 13569: decode to PSSUBU_H using decoder 31
7823 // 13569: }
7824 2, 7, // 13573: case 0x2: {
7825 OPC_CheckPredicate, 48, // 13575: check predicate 48
7826 OPC_Decode, 189, 132, 1, 31, // 13577: decode to ZIP8P using decoder 31
7827 // 13577: }
7828 3, 6, // 13582: case 0x3: {
7829 OPC_CheckPredicate, 43, // 13584: check predicate 43
7830 OPC_Decode, 181, 120, 31, // 13586: decode to PMULSU_H_B11 using decoder 31
7831 // 13586: }
7832 6, 0, // 13590: case 0x6: {
7833 OPC_CheckPredicate, 43, // 13592: check predicate 43
7834 OPC_Decode, 216, 119, 31, // 13594: decode to PMAX_H using decoder 31
7835 // 13594: }
7836 // 13594: } // switch Inst[14:12]
7837 // 13594: }
7838 121, 36, // 13598: case 0x79: {
7839 OPC_SwitchField, 12, 3, // 13600: switch Inst[14:12] {
7840 0, 6, // 13603: case 0x0: {
7841 OPC_CheckPredicate, 48, // 13605: check predicate 48
7842 OPC_Decode, 242, 121, 31, // 13607: decode to PSSUBU_W using decoder 31
7843 // 13607: }
7844 2, 7, // 13611: case 0x2: {
7845 OPC_CheckPredicate, 48, // 13613: check predicate 48
7846 OPC_Decode, 187, 132, 1, 31, // 13615: decode to ZIP16P using decoder 31
7847 // 13615: }
7848 3, 6, // 13620: case 0x3: {
7849 OPC_CheckPredicate, 48, // 13622: check predicate 48
7850 OPC_Decode, 183, 120, 31, // 13624: decode to PMULSU_W_H11 using decoder 31
7851 // 13624: }
7852 6, 0, // 13628: case 0x6: {
7853 OPC_CheckPredicate, 48, // 13630: check predicate 48
7854 OPC_Decode, 217, 119, 31, // 13632: decode to PMAX_W using decoder 31
7855 // 13632: }
7856 // 13632: } // switch Inst[14:12]
7857 // 13632: }
7858 122, 28, // 13636: case 0x7a: {
7859 OPC_SwitchField, 12, 3, // 13638: switch Inst[14:12] {
7860 0, 6, // 13641: case 0x0: {
7861 OPC_CheckPredicate, 43, // 13643: check predicate 43
7862 OPC_Decode, 237, 121, 31, // 13645: decode to PSSUBU_B using decoder 31
7863 // 13645: }
7864 2, 7, // 13649: case 0x2: {
7865 OPC_CheckPredicate, 48, // 13651: check predicate 48
7866 OPC_Decode, 188, 132, 1, 31, // 13653: decode to ZIP8HP using decoder 31
7867 // 13653: }
7868 6, 0, // 13658: case 0x6: {
7869 OPC_CheckPredicate, 43, // 13660: check predicate 43
7870 OPC_Decode, 212, 119, 31, // 13662: decode to PMAX_B using decoder 31
7871 // 13662: }
7872 // 13662: } // switch Inst[14:12]
7873 // 13662: }
7874 123, 20, // 13666: case 0x7b: {
7875 OPC_SwitchField, 12, 3, // 13668: switch Inst[14:12] {
7876 2, 7, // 13671: case 0x2: {
7877 OPC_CheckPredicate, 48, // 13673: check predicate 48
7878 OPC_Decode, 186, 132, 1, 31, // 13675: decode to ZIP16HP using decoder 31
7879 // 13675: }
7880 3, 0, // 13680: case 0x3: {
7881 OPC_CheckPredicate, 48, // 13682: check predicate 48
7882 OPC_Decode, 129, 118, 31, // 13684: decode to MULSU_W11 using decoder 31
7883 // 13684: }
7884 // 13684: } // switch Inst[14:12]
7885 // 13684: }
7886 124, 35, // 13688: case 0x7c: {
7887 OPC_SwitchField, 12, 3, // 13690: switch Inst[14:12] {
7888 0, 6, // 13693: case 0x0: {
7889 OPC_CheckPredicate, 43, // 13695: check predicate 43
7890 OPC_Decode, 129, 119, 31, // 13697: decode to PASUBU_H using decoder 31
7891 // 13697: }
7892 5, 6, // 13701: case 0x5: {
7893 OPC_CheckPredicate, 48, // 13703: check predicate 48
7894 OPC_Decode, 255, 119, 61, // 13705: decode to PMQACC_W_H01 using decoder 61
7895 // 13705: }
7896 6, 6, // 13709: case 0x6: {
7897 OPC_CheckPredicate, 43, // 13711: check predicate 43
7898 OPC_Decode, 210, 119, 31, // 13713: decode to PMAXU_H using decoder 31
7899 // 13713: }
7900 7, 0, // 13717: case 0x7: {
7901 OPC_CheckPredicate, 48, // 13719: check predicate 48
7902 OPC_Decode, 128, 120, 61, // 13721: decode to PMQACC_W_H11 using decoder 61
7903 // 13721: }
7904 // 13721: } // switch Inst[14:12]
7905 // 13721: }
7906 125, 43, // 13725: case 0x7d: {
7907 OPC_SwitchField, 12, 3, // 13727: switch Inst[14:12] {
7908 0, 6, // 13730: case 0x0: {
7909 OPC_CheckPredicate, 48, // 13732: check predicate 48
7910 OPC_Decode, 130, 119, 31, // 13734: decode to PASUBU_W using decoder 31
7911 // 13734: }
7912 3, 6, // 13738: case 0x3: {
7913 OPC_CheckPredicate, 48, // 13740: check predicate 48
7914 OPC_Decode, 199, 119, 61, // 13742: decode to PMACCSU_W_H11 using decoder 61
7915 // 13742: }
7916 5, 6, // 13746: case 0x5: {
7917 OPC_CheckPredicate, 48, // 13748: check predicate 48
7918 OPC_Decode, 227, 117, 61, // 13750: decode to MQACC_W01 using decoder 61
7919 // 13750: }
7920 6, 6, // 13754: case 0x6: {
7921 OPC_CheckPredicate, 48, // 13756: check predicate 48
7922 OPC_Decode, 211, 119, 31, // 13758: decode to PMAXU_W using decoder 31
7923 // 13758: }
7924 7, 0, // 13762: case 0x7: {
7925 OPC_CheckPredicate, 48, // 13764: check predicate 48
7926 OPC_Decode, 228, 117, 61, // 13766: decode to MQACC_W11 using decoder 61
7927 // 13766: }
7928 // 13766: } // switch Inst[14:12]
7929 // 13766: }
7930 126, 35, // 13770: case 0x7e: {
7931 OPC_SwitchField, 12, 3, // 13772: switch Inst[14:12] {
7932 0, 6, // 13775: case 0x0: {
7933 OPC_CheckPredicate, 43, // 13777: check predicate 43
7934 OPC_Decode, 253, 118, 31, // 13779: decode to PASUBU_B using decoder 31
7935 // 13779: }
7936 5, 6, // 13783: case 0x5: {
7937 OPC_CheckPredicate, 48, // 13785: check predicate 48
7938 OPC_Decode, 134, 120, 61, // 13787: decode to PMQRACC_W_H01 using decoder 61
7939 // 13787: }
7940 6, 6, // 13791: case 0x6: {
7941 OPC_CheckPredicate, 43, // 13793: check predicate 43
7942 OPC_Decode, 206, 119, 31, // 13795: decode to PMAXU_B using decoder 31
7943 // 13795: }
7944 7, 0, // 13799: case 0x7: {
7945 OPC_CheckPredicate, 48, // 13801: check predicate 48
7946 OPC_Decode, 135, 120, 61, // 13803: decode to PMQRACC_W_H11 using decoder 61
7947 // 13803: }
7948 // 13803: } // switch Inst[14:12]
7949 // 13803: }
7950 127, 0, // 13807: case 0x7f: {
7951 OPC_SwitchField, 12, 3, // 13809: switch Inst[14:12] {
7952 3, 6, // 13812: case 0x3: {
7953 OPC_CheckPredicate, 48, // 13814: check predicate 48
7954 OPC_Decode, 142, 117, 61, // 13816: decode to MACCSU_W11 using decoder 61
7955 // 13816: }
7956 5, 6, // 13820: case 0x5: {
7957 OPC_CheckPredicate, 48, // 13822: check predicate 48
7958 OPC_Decode, 233, 117, 61, // 13824: decode to MQRACC_W01 using decoder 61
7959 // 13824: }
7960 7, 0, // 13828: case 0x7: {
7961 OPC_CheckPredicate, 48, // 13830: check predicate 48
7962 OPC_Decode, 234, 117, 61, // 13832: decode to MQRACC_W11 using decoder 61
7963 // 13832: }
7964 // 13832: } // switch Inst[14:12]
7965 // 13832: }
7966 // 13832: } // switch Inst[31:25]
7967 // 13832: }
7968 67, 35, // 13836: case 0x43: {
7969 OPC_SwitchField, 25, 2, // 13838: switch Inst[26:25] {
7970 0, 6, // 13841: case 0x0: {
7971 OPC_CheckPredicate, 25, // 13843: check predicate 25
7972 OPC_Decode, 182, 115, 62, // 13845: decode to FMADD_S using decoder 62
7973 // 13845: }
7974 1, 6, // 13849: case 0x1: {
7975 OPC_CheckPredicate, 26, // 13851: check predicate 26
7976 OPC_Decode, 176, 115, 63, // 13853: decode to FMADD_D using decoder 63
7977 // 13853: }
7978 2, 6, // 13857: case 0x2: {
7979 OPC_CheckPredicate, 82, // 13859: check predicate 82
7980 OPC_Decode, 179, 115, 64, // 13861: decode to FMADD_H using decoder 64
7981 // 13861: }
7982 3, 0, // 13865: case 0x3: {
7983 OPC_CheckPredicate, 27, // 13867: check predicate 27
7984 OPC_Decode, 181, 115, 65, // 13869: decode to FMADD_Q using decoder 65
7985 // 13869: }
7986 // 13869: } // switch Inst[26:25]
7987 // 13869: }
7988 71, 35, // 13873: case 0x47: {
7989 OPC_SwitchField, 25, 2, // 13875: switch Inst[26:25] {
7990 0, 6, // 13878: case 0x0: {
7991 OPC_CheckPredicate, 25, // 13880: check predicate 25
7992 OPC_Decode, 214, 115, 62, // 13882: decode to FMSUB_S using decoder 62
7993 // 13882: }
7994 1, 6, // 13886: case 0x1: {
7995 OPC_CheckPredicate, 26, // 13888: check predicate 26
7996 OPC_Decode, 208, 115, 63, // 13890: decode to FMSUB_D using decoder 63
7997 // 13890: }
7998 2, 6, // 13894: case 0x2: {
7999 OPC_CheckPredicate, 82, // 13896: check predicate 82
8000 OPC_Decode, 211, 115, 64, // 13898: decode to FMSUB_H using decoder 64
8001 // 13898: }
8002 3, 0, // 13902: case 0x3: {
8003 OPC_CheckPredicate, 27, // 13904: check predicate 27
8004 OPC_Decode, 213, 115, 65, // 13906: decode to FMSUB_Q using decoder 65
8005 // 13906: }
8006 // 13906: } // switch Inst[26:25]
8007 // 13906: }
8008 75, 35, // 13910: case 0x4b: {
8009 OPC_SwitchField, 25, 2, // 13912: switch Inst[26:25] {
8010 0, 6, // 13915: case 0x0: {
8011 OPC_CheckPredicate, 25, // 13917: check predicate 25
8012 OPC_Decode, 249, 115, 62, // 13919: decode to FNMSUB_S using decoder 62
8013 // 13919: }
8014 1, 6, // 13923: case 0x1: {
8015 OPC_CheckPredicate, 26, // 13925: check predicate 26
8016 OPC_Decode, 243, 115, 63, // 13927: decode to FNMSUB_D using decoder 63
8017 // 13927: }
8018 2, 6, // 13931: case 0x2: {
8019 OPC_CheckPredicate, 82, // 13933: check predicate 82
8020 OPC_Decode, 246, 115, 64, // 13935: decode to FNMSUB_H using decoder 64
8021 // 13935: }
8022 3, 0, // 13939: case 0x3: {
8023 OPC_CheckPredicate, 27, // 13941: check predicate 27
8024 OPC_Decode, 248, 115, 65, // 13943: decode to FNMSUB_Q using decoder 65
8025 // 13943: }
8026 // 13943: } // switch Inst[26:25]
8027 // 13943: }
8028 79, 35, // 13947: case 0x4f: {
8029 OPC_SwitchField, 25, 2, // 13949: switch Inst[26:25] {
8030 0, 6, // 13952: case 0x0: {
8031 OPC_CheckPredicate, 25, // 13954: check predicate 25
8032 OPC_Decode, 241, 115, 62, // 13956: decode to FNMADD_S using decoder 62
8033 // 13956: }
8034 1, 6, // 13960: case 0x1: {
8035 OPC_CheckPredicate, 26, // 13962: check predicate 26
8036 OPC_Decode, 235, 115, 63, // 13964: decode to FNMADD_D using decoder 63
8037 // 13964: }
8038 2, 6, // 13968: case 0x2: {
8039 OPC_CheckPredicate, 82, // 13970: check predicate 82
8040 OPC_Decode, 238, 115, 64, // 13972: decode to FNMADD_H using decoder 64
8041 // 13972: }
8042 3, 0, // 13976: case 0x3: {
8043 OPC_CheckPredicate, 27, // 13978: check predicate 27
8044 OPC_Decode, 240, 115, 65, // 13980: decode to FNMADD_Q using decoder 65
8045 // 13980: }
8046 // 13980: } // switch Inst[26:25]
8047 // 13980: }
8048 83, 227, 10, // 13984: case 0x53: {
8049 OPC_SwitchField, 25, 7, // 13987: switch Inst[31:25] {
8050 0, 6, // 13990: case 0x0: {
8051 OPC_CheckPredicate, 25, // 13992: check predicate 25
8052 OPC_Decode, 158, 114, 66, // 13994: decode to FADD_S using decoder 66
8053 // 13994: }
8054 1, 6, // 13998: case 0x1: {
8055 OPC_CheckPredicate, 26, // 14000: check predicate 26
8056 OPC_Decode, 152, 114, 67, // 14002: decode to FADD_D using decoder 67
8057 // 14002: }
8058 2, 6, // 14006: case 0x2: {
8059 OPC_CheckPredicate, 82, // 14008: check predicate 82
8060 OPC_Decode, 155, 114, 68, // 14010: decode to FADD_H using decoder 68
8061 // 14010: }
8062 3, 6, // 14014: case 0x3: {
8063 OPC_CheckPredicate, 27, // 14016: check predicate 27
8064 OPC_Decode, 157, 114, 69, // 14018: decode to FADD_Q using decoder 69
8065 // 14018: }
8066 4, 6, // 14022: case 0x4: {
8067 OPC_CheckPredicate, 25, // 14024: check predicate 25
8068 OPC_Decode, 172, 116, 66, // 14026: decode to FSUB_S using decoder 66
8069 // 14026: }
8070 5, 6, // 14030: case 0x5: {
8071 OPC_CheckPredicate, 26, // 14032: check predicate 26
8072 OPC_Decode, 166, 116, 67, // 14034: decode to FSUB_D using decoder 67
8073 // 14034: }
8074 6, 6, // 14038: case 0x6: {
8075 OPC_CheckPredicate, 82, // 14040: check predicate 82
8076 OPC_Decode, 169, 116, 68, // 14042: decode to FSUB_H using decoder 68
8077 // 14042: }
8078 7, 6, // 14046: case 0x7: {
8079 OPC_CheckPredicate, 27, // 14048: check predicate 27
8080 OPC_Decode, 171, 116, 69, // 14050: decode to FSUB_Q using decoder 69
8081 // 14050: }
8082 8, 6, // 14054: case 0x8: {
8083 OPC_CheckPredicate, 25, // 14056: check predicate 25
8084 OPC_Decode, 222, 115, 66, // 14058: decode to FMUL_S using decoder 66
8085 // 14058: }
8086 9, 6, // 14062: case 0x9: {
8087 OPC_CheckPredicate, 26, // 14064: check predicate 26
8088 OPC_Decode, 216, 115, 67, // 14066: decode to FMUL_D using decoder 67
8089 // 14066: }
8090 10, 6, // 14070: case 0xa: {
8091 OPC_CheckPredicate, 82, // 14072: check predicate 82
8092 OPC_Decode, 219, 115, 68, // 14074: decode to FMUL_H using decoder 68
8093 // 14074: }
8094 11, 6, // 14078: case 0xb: {
8095 OPC_CheckPredicate, 27, // 14080: check predicate 27
8096 OPC_Decode, 221, 115, 69, // 14082: decode to FMUL_Q using decoder 69
8097 // 14082: }
8098 12, 6, // 14086: case 0xc: {
8099 OPC_CheckPredicate, 25, // 14088: check predicate 25
8100 OPC_Decode, 131, 115, 66, // 14090: decode to FDIV_S using decoder 66
8101 // 14090: }
8102 13, 6, // 14094: case 0xd: {
8103 OPC_CheckPredicate, 26, // 14096: check predicate 26
8104 OPC_Decode, 253, 114, 67, // 14098: decode to FDIV_D using decoder 67
8105 // 14098: }
8106 14, 6, // 14102: case 0xe: {
8107 OPC_CheckPredicate, 82, // 14104: check predicate 82
8108 OPC_Decode, 128, 115, 68, // 14106: decode to FDIV_H using decoder 68
8109 // 14106: }
8110 15, 6, // 14110: case 0xf: {
8111 OPC_CheckPredicate, 27, // 14112: check predicate 27
8112 OPC_Decode, 130, 115, 69, // 14114: decode to FDIV_Q using decoder 69
8113 // 14114: }
8114 16, 27, // 14118: case 0x10: {
8115 OPC_SwitchField, 12, 3, // 14120: switch Inst[14:12] {
8116 0, 6, // 14123: case 0x0: {
8117 OPC_CheckPredicate, 25, // 14125: check predicate 25
8118 OPC_Decode, 154, 116, 70, // 14127: decode to FSGNJ_S using decoder 70
8119 // 14127: }
8120 1, 6, // 14131: case 0x1: {
8121 OPC_CheckPredicate, 25, // 14133: check predicate 25
8122 OPC_Decode, 138, 116, 70, // 14135: decode to FSGNJN_S using decoder 70
8123 // 14135: }
8124 2, 0, // 14139: case 0x2: {
8125 OPC_CheckPredicate, 25, // 14141: check predicate 25
8126 OPC_Decode, 146, 116, 70, // 14143: decode to FSGNJX_S using decoder 70
8127 // 14143: }
8128 // 14143: } // switch Inst[14:12]
8129 // 14143: }
8130 17, 27, // 14147: case 0x11: {
8131 OPC_SwitchField, 12, 3, // 14149: switch Inst[14:12] {
8132 0, 6, // 14152: case 0x0: {
8133 OPC_CheckPredicate, 26, // 14154: check predicate 26
8134 OPC_Decode, 148, 116, 71, // 14156: decode to FSGNJ_D using decoder 71
8135 // 14156: }
8136 1, 6, // 14160: case 0x1: {
8137 OPC_CheckPredicate, 26, // 14162: check predicate 26
8138 OPC_Decode, 132, 116, 71, // 14164: decode to FSGNJN_D using decoder 71
8139 // 14164: }
8140 2, 0, // 14168: case 0x2: {
8141 OPC_CheckPredicate, 26, // 14170: check predicate 26
8142 OPC_Decode, 140, 116, 71, // 14172: decode to FSGNJX_D using decoder 71
8143 // 14172: }
8144 // 14172: } // switch Inst[14:12]
8145 // 14172: }
8146 18, 27, // 14176: case 0x12: {
8147 OPC_SwitchField, 12, 3, // 14178: switch Inst[14:12] {
8148 0, 6, // 14181: case 0x0: {
8149 OPC_CheckPredicate, 82, // 14183: check predicate 82
8150 OPC_Decode, 151, 116, 72, // 14185: decode to FSGNJ_H using decoder 72
8151 // 14185: }
8152 1, 6, // 14189: case 0x1: {
8153 OPC_CheckPredicate, 82, // 14191: check predicate 82
8154 OPC_Decode, 135, 116, 72, // 14193: decode to FSGNJN_H using decoder 72
8155 // 14193: }
8156 2, 0, // 14197: case 0x2: {
8157 OPC_CheckPredicate, 82, // 14199: check predicate 82
8158 OPC_Decode, 143, 116, 72, // 14201: decode to FSGNJX_H using decoder 72
8159 // 14201: }
8160 // 14201: } // switch Inst[14:12]
8161 // 14201: }
8162 19, 27, // 14205: case 0x13: {
8163 OPC_SwitchField, 12, 3, // 14207: switch Inst[14:12] {
8164 0, 6, // 14210: case 0x0: {
8165 OPC_CheckPredicate, 27, // 14212: check predicate 27
8166 OPC_Decode, 153, 116, 73, // 14214: decode to FSGNJ_Q using decoder 73
8167 // 14214: }
8168 1, 6, // 14218: case 0x1: {
8169 OPC_CheckPredicate, 27, // 14220: check predicate 27
8170 OPC_Decode, 137, 116, 73, // 14222: decode to FSGNJN_Q using decoder 73
8171 // 14222: }
8172 2, 0, // 14226: case 0x2: {
8173 OPC_CheckPredicate, 27, // 14228: check predicate 27
8174 OPC_Decode, 145, 116, 73, // 14230: decode to FSGNJX_Q using decoder 73
8175 // 14230: }
8176 // 14230: } // switch Inst[14:12]
8177 // 14230: }
8178 20, 35, // 14234: case 0x14: {
8179 OPC_SwitchField, 12, 3, // 14236: switch Inst[14:12] {
8180 0, 6, // 14239: case 0x0: {
8181 OPC_CheckPredicate, 25, // 14241: check predicate 25
8182 OPC_Decode, 206, 115, 70, // 14243: decode to FMIN_S using decoder 70
8183 // 14243: }
8184 1, 6, // 14247: case 0x1: {
8185 OPC_CheckPredicate, 25, // 14249: check predicate 25
8186 OPC_Decode, 194, 115, 70, // 14251: decode to FMAX_S using decoder 70
8187 // 14251: }
8188 2, 6, // 14255: case 0x2: {
8189 OPC_CheckPredicate, 83, // 14257: check predicate 83
8190 OPC_Decode, 199, 115, 70, // 14259: decode to FMINM_S using decoder 70
8191 // 14259: }
8192 3, 0, // 14263: case 0x3: {
8193 OPC_CheckPredicate, 83, // 14265: check predicate 83
8194 OPC_Decode, 187, 115, 70, // 14267: decode to FMAXM_S using decoder 70
8195 // 14267: }
8196 // 14267: } // switch Inst[14:12]
8197 // 14267: }
8198 21, 35, // 14271: case 0x15: {
8199 OPC_SwitchField, 12, 3, // 14273: switch Inst[14:12] {
8200 0, 6, // 14276: case 0x0: {
8201 OPC_CheckPredicate, 26, // 14278: check predicate 26
8202 OPC_Decode, 200, 115, 71, // 14280: decode to FMIN_D using decoder 71
8203 // 14280: }
8204 1, 6, // 14284: case 0x1: {
8205 OPC_CheckPredicate, 26, // 14286: check predicate 26
8206 OPC_Decode, 188, 115, 71, // 14288: decode to FMAX_D using decoder 71
8207 // 14288: }
8208 2, 6, // 14292: case 0x2: {
8209 OPC_CheckPredicate, 84, // 14294: check predicate 84
8210 OPC_Decode, 196, 115, 71, // 14296: decode to FMINM_D using decoder 71
8211 // 14296: }
8212 3, 0, // 14300: case 0x3: {
8213 OPC_CheckPredicate, 84, // 14302: check predicate 84
8214 OPC_Decode, 184, 115, 71, // 14304: decode to FMAXM_D using decoder 71
8215 // 14304: }
8216 // 14304: } // switch Inst[14:12]
8217 // 14304: }
8218 22, 35, // 14308: case 0x16: {
8219 OPC_SwitchField, 12, 3, // 14310: switch Inst[14:12] {
8220 0, 6, // 14313: case 0x0: {
8221 OPC_CheckPredicate, 82, // 14315: check predicate 82
8222 OPC_Decode, 203, 115, 72, // 14317: decode to FMIN_H using decoder 72
8223 // 14317: }
8224 1, 6, // 14321: case 0x1: {
8225 OPC_CheckPredicate, 82, // 14323: check predicate 82
8226 OPC_Decode, 191, 115, 72, // 14325: decode to FMAX_H using decoder 72
8227 // 14325: }
8228 2, 6, // 14329: case 0x2: {
8229 OPC_CheckPredicate, 85, // 14331: check predicate 85
8230 OPC_Decode, 197, 115, 72, // 14333: decode to FMINM_H using decoder 72
8231 // 14333: }
8232 3, 0, // 14337: case 0x3: {
8233 OPC_CheckPredicate, 85, // 14339: check predicate 85
8234 OPC_Decode, 185, 115, 72, // 14341: decode to FMAXM_H using decoder 72
8235 // 14341: }
8236 // 14341: } // switch Inst[14:12]
8237 // 14341: }
8238 23, 35, // 14345: case 0x17: {
8239 OPC_SwitchField, 12, 3, // 14347: switch Inst[14:12] {
8240 0, 6, // 14350: case 0x0: {
8241 OPC_CheckPredicate, 27, // 14352: check predicate 27
8242 OPC_Decode, 205, 115, 73, // 14354: decode to FMIN_Q using decoder 73
8243 // 14354: }
8244 1, 6, // 14358: case 0x1: {
8245 OPC_CheckPredicate, 27, // 14360: check predicate 27
8246 OPC_Decode, 193, 115, 73, // 14362: decode to FMAX_Q using decoder 73
8247 // 14362: }
8248 2, 6, // 14366: case 0x2: {
8249 OPC_CheckPredicate, 86, // 14368: check predicate 86
8250 OPC_Decode, 198, 115, 73, // 14370: decode to FMINM_Q using decoder 73
8251 // 14370: }
8252 3, 0, // 14374: case 0x3: {
8253 OPC_CheckPredicate, 86, // 14376: check predicate 86
8254 OPC_Decode, 186, 115, 73, // 14378: decode to FMAXM_Q using decoder 73
8255 // 14378: }
8256 // 14378: } // switch Inst[14:12]
8257 // 14378: }
8258 32, 51, // 14382: case 0x20: {
8259 OPC_SwitchField, 20, 5, // 14384: switch Inst[24:20] {
8260 1, 6, // 14387: case 0x1: {
8261 OPC_CheckPredicate, 26, // 14389: check predicate 26
8262 OPC_Decode, 223, 114, 74, // 14391: decode to FCVT_S_D using decoder 74
8263 // 14391: }
8264 2, 6, // 14395: case 0x2: {
8265 OPC_CheckPredicate, 87, // 14397: check predicate 87
8266 OPC_Decode, 226, 114, 75, // 14399: decode to FCVT_S_H using decoder 75
8267 // 14399: }
8268 3, 6, // 14403: case 0x3: {
8269 OPC_CheckPredicate, 27, // 14405: check predicate 27
8270 OPC_Decode, 232, 114, 76, // 14407: decode to FCVT_S_Q using decoder 76
8271 // 14407: }
8272 4, 6, // 14411: case 0x4: {
8273 OPC_CheckPredicate, 83, // 14413: check predicate 83
8274 OPC_Decode, 130, 116, 77, // 14415: decode to FROUND_S using decoder 77
8275 // 14415: }
8276 5, 6, // 14419: case 0x5: {
8277 OPC_CheckPredicate, 83, // 14421: check predicate 83
8278 OPC_Decode, 254, 115, 77, // 14423: decode to FROUNDNX_S using decoder 77
8279 // 14423: }
8280 6, 0, // 14427: case 0x6: {
8281 OPC_CheckPredicate, 88, // 14429: check predicate 88
8282 OPC_Decode, 222, 114, 75, // 14431: decode to FCVT_S_BF16 using decoder 75
8283 // 14431: }
8284 // 14431: } // switch Inst[24:20]
8285 // 14431: }
8286 33, 43, // 14435: case 0x21: {
8287 OPC_SwitchField, 20, 5, // 14437: switch Inst[24:20] {
8288 0, 6, // 14440: case 0x0: {
8289 OPC_CheckPredicate, 26, // 14442: check predicate 26
8290 OPC_Decode, 178, 114, 78, // 14444: decode to FCVT_D_S using decoder 78
8291 // 14444: }
8292 2, 6, // 14448: case 0x2: {
8293 OPC_CheckPredicate, 89, // 14450: check predicate 89
8294 OPC_Decode, 170, 114, 79, // 14452: decode to FCVT_D_H using decoder 79
8295 // 14452: }
8296 3, 6, // 14456: case 0x3: {
8297 OPC_CheckPredicate, 27, // 14458: check predicate 27
8298 OPC_Decode, 177, 114, 80, // 14460: decode to FCVT_D_Q using decoder 80
8299 // 14460: }
8300 4, 6, // 14464: case 0x4: {
8301 OPC_CheckPredicate, 84, // 14466: check predicate 84
8302 OPC_Decode, 255, 115, 81, // 14468: decode to FROUND_D using decoder 81
8303 // 14468: }
8304 5, 0, // 14472: case 0x5: {
8305 OPC_CheckPredicate, 84, // 14474: check predicate 84
8306 OPC_Decode, 251, 115, 81, // 14476: decode to FROUNDNX_D using decoder 81
8307 // 14476: }
8308 // 14476: } // switch Inst[24:20]
8309 // 14476: }
8310 34, 51, // 14480: case 0x22: {
8311 OPC_SwitchField, 20, 5, // 14482: switch Inst[24:20] {
8312 0, 6, // 14485: case 0x0: {
8313 OPC_CheckPredicate, 87, // 14487: check predicate 87
8314 OPC_Decode, 195, 114, 82, // 14489: decode to FCVT_H_S using decoder 82
8315 // 14489: }
8316 1, 6, // 14493: case 0x1: {
8317 OPC_CheckPredicate, 89, // 14495: check predicate 89
8318 OPC_Decode, 187, 114, 83, // 14497: decode to FCVT_H_D using decoder 83
8319 // 14497: }
8320 3, 6, // 14501: case 0x3: {
8321 OPC_CheckPredicate, 90, // 14503: check predicate 90
8322 OPC_Decode, 194, 114, 84, // 14505: decode to FCVT_H_Q using decoder 84
8323 // 14505: }
8324 4, 6, // 14509: case 0x4: {
8325 OPC_CheckPredicate, 85, // 14511: check predicate 85
8326 OPC_Decode, 128, 116, 85, // 14513: decode to FROUND_H using decoder 85
8327 // 14513: }
8328 5, 6, // 14517: case 0x5: {
8329 OPC_CheckPredicate, 85, // 14519: check predicate 85
8330 OPC_Decode, 252, 115, 85, // 14521: decode to FROUNDNX_H using decoder 85
8331 // 14521: }
8332 8, 0, // 14525: case 0x8: {
8333 OPC_CheckPredicate, 88, // 14527: check predicate 88
8334 OPC_Decode, 169, 114, 82, // 14529: decode to FCVT_BF16_S using decoder 82
8335 // 14529: }
8336 // 14529: } // switch Inst[24:20]
8337 // 14529: }
8338 35, 43, // 14533: case 0x23: {
8339 OPC_SwitchField, 20, 5, // 14535: switch Inst[24:20] {
8340 0, 6, // 14538: case 0x0: {
8341 OPC_CheckPredicate, 27, // 14540: check predicate 27
8342 OPC_Decode, 219, 114, 86, // 14542: decode to FCVT_Q_S using decoder 86
8343 // 14542: }
8344 1, 6, // 14546: case 0x1: {
8345 OPC_CheckPredicate, 27, // 14548: check predicate 27
8346 OPC_Decode, 215, 114, 87, // 14550: decode to FCVT_Q_D using decoder 87
8347 // 14550: }
8348 2, 6, // 14554: case 0x2: {
8349 OPC_CheckPredicate, 90, // 14556: check predicate 90
8350 OPC_Decode, 216, 114, 88, // 14558: decode to FCVT_Q_H using decoder 88
8351 // 14558: }
8352 4, 6, // 14562: case 0x4: {
8353 OPC_CheckPredicate, 86, // 14564: check predicate 86
8354 OPC_Decode, 129, 116, 89, // 14566: decode to FROUND_Q using decoder 89
8355 // 14566: }
8356 5, 0, // 14570: case 0x5: {
8357 OPC_CheckPredicate, 86, // 14572: check predicate 86
8358 OPC_Decode, 253, 115, 89, // 14574: decode to FROUNDNX_Q using decoder 89
8359 // 14574: }
8360 // 14574: } // switch Inst[24:20]
8361 // 14574: }
8362 44, 10, // 14578: case 0x2c: {
8363 OPC_CheckPredicate, 25, // 14580: check predicate 25
8364 OPC_CheckField, 20, 5, 0, // 14582: check Inst[24:20] == 0x0
8365 OPC_Decode, 164, 116, 77, // 14586: decode to FSQRT_S using decoder 77
8366 // 14586: }
8367 45, 10, // 14590: case 0x2d: {
8368 OPC_CheckPredicate, 26, // 14592: check predicate 26
8369 OPC_CheckField, 20, 5, 0, // 14594: check Inst[24:20] == 0x0
8370 OPC_Decode, 158, 116, 81, // 14598: decode to FSQRT_D using decoder 81
8371 // 14598: }
8372 46, 10, // 14602: case 0x2e: {
8373 OPC_CheckPredicate, 82, // 14604: check predicate 82
8374 OPC_CheckField, 20, 5, 0, // 14606: check Inst[24:20] == 0x0
8375 OPC_Decode, 161, 116, 85, // 14610: decode to FSQRT_H using decoder 85
8376 // 14610: }
8377 47, 10, // 14614: case 0x2f: {
8378 OPC_CheckPredicate, 27, // 14616: check predicate 27
8379 OPC_CheckField, 20, 5, 0, // 14618: check Inst[24:20] == 0x0
8380 OPC_Decode, 163, 116, 89, // 14622: decode to FSQRT_Q using decoder 89
8381 // 14622: }
8382 80, 43, // 14626: case 0x50: {
8383 OPC_SwitchField, 12, 3, // 14628: switch Inst[14:12] {
8384 0, 6, // 14631: case 0x0: {
8385 OPC_CheckPredicate, 25, // 14633: check predicate 25
8386 OPC_Decode, 155, 115, 90, // 14635: decode to FLE_S using decoder 90
8387 // 14635: }
8388 1, 6, // 14639: case 0x1: {
8389 OPC_CheckPredicate, 25, // 14641: check predicate 25
8390 OPC_Decode, 173, 115, 90, // 14643: decode to FLT_S using decoder 90
8391 // 14643: }
8392 2, 6, // 14647: case 0x2: {
8393 OPC_CheckPredicate, 25, // 14649: check predicate 25
8394 OPC_Decode, 142, 115, 90, // 14651: decode to FEQ_S using decoder 90
8395 // 14651: }
8396 4, 6, // 14655: case 0x4: {
8397 OPC_CheckPredicate, 83, // 14657: check predicate 83
8398 OPC_Decode, 148, 115, 90, // 14659: decode to FLEQ_S using decoder 90
8399 // 14659: }
8400 5, 0, // 14663: case 0x5: {
8401 OPC_CheckPredicate, 83, // 14665: check predicate 83
8402 OPC_Decode, 166, 115, 90, // 14667: decode to FLTQ_S using decoder 90
8403 // 14667: }
8404 // 14667: } // switch Inst[14:12]
8405 // 14667: }
8406 81, 43, // 14671: case 0x51: {
8407 OPC_SwitchField, 12, 3, // 14673: switch Inst[14:12] {
8408 0, 6, // 14676: case 0x0: {
8409 OPC_CheckPredicate, 26, // 14678: check predicate 26
8410 OPC_Decode, 149, 115, 91, // 14680: decode to FLE_D using decoder 91
8411 // 14680: }
8412 1, 6, // 14684: case 0x1: {
8413 OPC_CheckPredicate, 26, // 14686: check predicate 26
8414 OPC_Decode, 167, 115, 91, // 14688: decode to FLT_D using decoder 91
8415 // 14688: }
8416 2, 6, // 14692: case 0x2: {
8417 OPC_CheckPredicate, 26, // 14694: check predicate 26
8418 OPC_Decode, 136, 115, 91, // 14696: decode to FEQ_D using decoder 91
8419 // 14696: }
8420 4, 6, // 14700: case 0x4: {
8421 OPC_CheckPredicate, 84, // 14702: check predicate 84
8422 OPC_Decode, 145, 115, 91, // 14704: decode to FLEQ_D using decoder 91
8423 // 14704: }
8424 5, 0, // 14708: case 0x5: {
8425 OPC_CheckPredicate, 84, // 14710: check predicate 84
8426 OPC_Decode, 163, 115, 91, // 14712: decode to FLTQ_D using decoder 91
8427 // 14712: }
8428 // 14712: } // switch Inst[14:12]
8429 // 14712: }
8430 82, 43, // 14716: case 0x52: {
8431 OPC_SwitchField, 12, 3, // 14718: switch Inst[14:12] {
8432 0, 6, // 14721: case 0x0: {
8433 OPC_CheckPredicate, 82, // 14723: check predicate 82
8434 OPC_Decode, 152, 115, 92, // 14725: decode to FLE_H using decoder 92
8435 // 14725: }
8436 1, 6, // 14729: case 0x1: {
8437 OPC_CheckPredicate, 82, // 14731: check predicate 82
8438 OPC_Decode, 170, 115, 92, // 14733: decode to FLT_H using decoder 92
8439 // 14733: }
8440 2, 6, // 14737: case 0x2: {
8441 OPC_CheckPredicate, 82, // 14739: check predicate 82
8442 OPC_Decode, 139, 115, 92, // 14741: decode to FEQ_H using decoder 92
8443 // 14741: }
8444 4, 6, // 14745: case 0x4: {
8445 OPC_CheckPredicate, 85, // 14747: check predicate 85
8446 OPC_Decode, 146, 115, 92, // 14749: decode to FLEQ_H using decoder 92
8447 // 14749: }
8448 5, 0, // 14753: case 0x5: {
8449 OPC_CheckPredicate, 85, // 14755: check predicate 85
8450 OPC_Decode, 164, 115, 92, // 14757: decode to FLTQ_H using decoder 92
8451 // 14757: }
8452 // 14757: } // switch Inst[14:12]
8453 // 14757: }
8454 83, 43, // 14761: case 0x53: {
8455 OPC_SwitchField, 12, 3, // 14763: switch Inst[14:12] {
8456 0, 6, // 14766: case 0x0: {
8457 OPC_CheckPredicate, 27, // 14768: check predicate 27
8458 OPC_Decode, 154, 115, 93, // 14770: decode to FLE_Q using decoder 93
8459 // 14770: }
8460 1, 6, // 14774: case 0x1: {
8461 OPC_CheckPredicate, 27, // 14776: check predicate 27
8462 OPC_Decode, 172, 115, 93, // 14778: decode to FLT_Q using decoder 93
8463 // 14778: }
8464 2, 6, // 14782: case 0x2: {
8465 OPC_CheckPredicate, 27, // 14784: check predicate 27
8466 OPC_Decode, 141, 115, 93, // 14786: decode to FEQ_Q using decoder 93
8467 // 14786: }
8468 4, 6, // 14790: case 0x4: {
8469 OPC_CheckPredicate, 86, // 14792: check predicate 86
8470 OPC_Decode, 147, 115, 93, // 14794: decode to FLEQ_Q using decoder 93
8471 // 14794: }
8472 5, 0, // 14798: case 0x5: {
8473 OPC_CheckPredicate, 86, // 14800: check predicate 86
8474 OPC_Decode, 165, 115, 93, // 14802: decode to FLTQ_Q using decoder 93
8475 // 14802: }
8476 // 14802: } // switch Inst[14:12]
8477 // 14802: }
8478 89, 10, // 14806: case 0x59: {
8479 OPC_CheckPredicate, 91, // 14808: check predicate 91
8480 OPC_CheckField, 12, 3, 0, // 14810: check Inst[14:12] == 0x0
8481 OPC_Decode, 226, 115, 94, // 14814: decode to FMVP_D_X using decoder 94
8482 // 14814: }
8483 91, 10, // 14818: case 0x5b: {
8484 OPC_CheckPredicate, 92, // 14820: check predicate 92
8485 OPC_CheckField, 12, 3, 0, // 14822: check Inst[14:12] == 0x0
8486 OPC_Decode, 227, 115, 95, // 14826: decode to FMVP_Q_X using decoder 95
8487 // 14826: }
8488 96, 35, // 14830: case 0x60: {
8489 OPC_SwitchField, 20, 5, // 14832: switch Inst[24:20] {
8490 0, 6, // 14835: case 0x0: {
8491 OPC_CheckPredicate, 25, // 14837: check predicate 25
8492 OPC_Decode, 251, 114, 96, // 14839: decode to FCVT_W_S using decoder 96
8493 // 14839: }
8494 1, 6, // 14843: case 0x1: {
8495 OPC_CheckPredicate, 25, // 14845: check predicate 25
8496 OPC_Decode, 243, 114, 96, // 14847: decode to FCVT_WU_S using decoder 96
8497 // 14847: }
8498 2, 6, // 14851: case 0x2: {
8499 OPC_CheckPredicate, 93, // 14853: check predicate 93
8500 OPC_Decode, 213, 114, 96, // 14855: decode to FCVT_L_S using decoder 96
8501 // 14855: }
8502 3, 0, // 14859: case 0x3: {
8503 OPC_CheckPredicate, 93, // 14861: check predicate 93
8504 OPC_Decode, 206, 114, 96, // 14863: decode to FCVT_LU_S using decoder 96
8505 // 14863: }
8506 // 14863: } // switch Inst[24:20]
8507 // 14863: }
8508 97, 47, // 14867: case 0x61: {
8509 OPC_SwitchField, 20, 5, // 14869: switch Inst[24:20] {
8510 0, 6, // 14872: case 0x0: {
8511 OPC_CheckPredicate, 26, // 14874: check predicate 26
8512 OPC_Decode, 245, 114, 97, // 14876: decode to FCVT_W_D using decoder 97
8513 // 14876: }
8514 1, 6, // 14880: case 0x1: {
8515 OPC_CheckPredicate, 26, // 14882: check predicate 26
8516 OPC_Decode, 237, 114, 97, // 14884: decode to FCVT_WU_D using decoder 97
8517 // 14884: }
8518 2, 6, // 14888: case 0x2: {
8519 OPC_CheckPredicate, 94, // 14890: check predicate 94
8520 OPC_Decode, 208, 114, 97, // 14892: decode to FCVT_L_D using decoder 97
8521 // 14892: }
8522 3, 6, // 14896: case 0x3: {
8523 OPC_CheckPredicate, 94, // 14898: check predicate 94
8524 OPC_Decode, 201, 114, 97, // 14900: decode to FCVT_LU_D using decoder 97
8525 // 14900: }
8526 8, 0, // 14904: case 0x8: {
8527 OPC_CheckPredicate, 84, // 14906: check predicate 84
8528 OPC_CheckField, 12, 3, 1, // 14908: check Inst[14:12] == 0x1
8529 OPC_Decode, 168, 114, 98, // 14912: decode to FCVTMOD_W_D using decoder 98
8530 // 14912: }
8531 // 14912: } // switch Inst[24:20]
8532 // 14912: }
8533 98, 35, // 14916: case 0x62: {
8534 OPC_SwitchField, 20, 5, // 14918: switch Inst[24:20] {
8535 0, 6, // 14921: case 0x0: {
8536 OPC_CheckPredicate, 82, // 14923: check predicate 82
8537 OPC_Decode, 248, 114, 99, // 14925: decode to FCVT_W_H using decoder 99
8538 // 14925: }
8539 1, 6, // 14929: case 0x1: {
8540 OPC_CheckPredicate, 82, // 14931: check predicate 82
8541 OPC_Decode, 240, 114, 99, // 14933: decode to FCVT_WU_H using decoder 99
8542 // 14933: }
8543 2, 6, // 14937: case 0x2: {
8544 OPC_CheckPredicate, 95, // 14939: check predicate 95
8545 OPC_Decode, 210, 114, 99, // 14941: decode to FCVT_L_H using decoder 99
8546 // 14941: }
8547 3, 0, // 14945: case 0x3: {
8548 OPC_CheckPredicate, 95, // 14947: check predicate 95
8549 OPC_Decode, 203, 114, 99, // 14949: decode to FCVT_LU_H using decoder 99
8550 // 14949: }
8551 // 14949: } // switch Inst[24:20]
8552 // 14949: }
8553 99, 35, // 14953: case 0x63: {
8554 OPC_SwitchField, 20, 5, // 14955: switch Inst[24:20] {
8555 0, 6, // 14958: case 0x0: {
8556 OPC_CheckPredicate, 27, // 14960: check predicate 27
8557 OPC_Decode, 250, 114, 100, // 14962: decode to FCVT_W_Q using decoder 100
8558 // 14962: }
8559 1, 6, // 14966: case 0x1: {
8560 OPC_CheckPredicate, 27, // 14968: check predicate 27
8561 OPC_Decode, 242, 114, 100, // 14970: decode to FCVT_WU_Q using decoder 100
8562 // 14970: }
8563 2, 6, // 14974: case 0x2: {
8564 OPC_CheckPredicate, 96, // 14976: check predicate 96
8565 OPC_Decode, 212, 114, 100, // 14978: decode to FCVT_L_Q using decoder 100
8566 // 14978: }
8567 3, 0, // 14982: case 0x3: {
8568 OPC_CheckPredicate, 96, // 14984: check predicate 96
8569 OPC_Decode, 205, 114, 100, // 14986: decode to FCVT_LU_Q using decoder 100
8570 // 14986: }
8571 // 14986: } // switch Inst[24:20]
8572 // 14986: }
8573 104, 35, // 14990: case 0x68: {
8574 OPC_SwitchField, 20, 5, // 14992: switch Inst[24:20] {
8575 0, 6, // 14995: case 0x0: {
8576 OPC_CheckPredicate, 25, // 14997: check predicate 25
8577 OPC_Decode, 233, 114, 101, // 14999: decode to FCVT_S_W using decoder 101
8578 // 14999: }
8579 1, 6, // 15003: case 0x1: {
8580 OPC_CheckPredicate, 25, // 15005: check predicate 25
8581 OPC_Decode, 234, 114, 101, // 15007: decode to FCVT_S_WU using decoder 101
8582 // 15007: }
8583 2, 6, // 15011: case 0x2: {
8584 OPC_CheckPredicate, 93, // 15013: check predicate 93
8585 OPC_Decode, 228, 114, 101, // 15015: decode to FCVT_S_L using decoder 101
8586 // 15015: }
8587 3, 0, // 15019: case 0x3: {
8588 OPC_CheckPredicate, 93, // 15021: check predicate 93
8589 OPC_Decode, 229, 114, 101, // 15023: decode to FCVT_S_LU using decoder 101
8590 // 15023: }
8591 // 15023: } // switch Inst[24:20]
8592 // 15023: }
8593 105, 35, // 15027: case 0x69: {
8594 OPC_SwitchField, 20, 5, // 15029: switch Inst[24:20] {
8595 0, 6, // 15032: case 0x0: {
8596 OPC_CheckPredicate, 26, // 15034: check predicate 26
8597 OPC_Decode, 181, 114, 102, // 15036: decode to FCVT_D_W using decoder 102
8598 // 15036: }
8599 1, 6, // 15040: case 0x1: {
8600 OPC_CheckPredicate, 26, // 15042: check predicate 26
8601 OPC_Decode, 182, 114, 102, // 15044: decode to FCVT_D_WU using decoder 102
8602 // 15044: }
8603 2, 6, // 15048: case 0x2: {
8604 OPC_CheckPredicate, 94, // 15050: check predicate 94
8605 OPC_Decode, 173, 114, 102, // 15052: decode to FCVT_D_L using decoder 102
8606 // 15052: }
8607 3, 0, // 15056: case 0x3: {
8608 OPC_CheckPredicate, 94, // 15058: check predicate 94
8609 OPC_Decode, 174, 114, 102, // 15060: decode to FCVT_D_LU using decoder 102
8610 // 15060: }
8611 // 15060: } // switch Inst[24:20]
8612 // 15060: }
8613 106, 35, // 15064: case 0x6a: {
8614 OPC_SwitchField, 20, 5, // 15066: switch Inst[24:20] {
8615 0, 6, // 15069: case 0x0: {
8616 OPC_CheckPredicate, 82, // 15071: check predicate 82
8617 OPC_Decode, 197, 114, 103, // 15073: decode to FCVT_H_W using decoder 103
8618 // 15073: }
8619 1, 6, // 15077: case 0x1: {
8620 OPC_CheckPredicate, 82, // 15079: check predicate 82
8621 OPC_Decode, 198, 114, 103, // 15081: decode to FCVT_H_WU using decoder 103
8622 // 15081: }
8623 2, 6, // 15085: case 0x2: {
8624 OPC_CheckPredicate, 95, // 15087: check predicate 95
8625 OPC_Decode, 190, 114, 103, // 15089: decode to FCVT_H_L using decoder 103
8626 // 15089: }
8627 3, 0, // 15093: case 0x3: {
8628 OPC_CheckPredicate, 95, // 15095: check predicate 95
8629 OPC_Decode, 191, 114, 103, // 15097: decode to FCVT_H_LU using decoder 103
8630 // 15097: }
8631 // 15097: } // switch Inst[24:20]
8632 // 15097: }
8633 107, 35, // 15101: case 0x6b: {
8634 OPC_SwitchField, 20, 5, // 15103: switch Inst[24:20] {
8635 0, 6, // 15106: case 0x0: {
8636 OPC_CheckPredicate, 27, // 15108: check predicate 27
8637 OPC_Decode, 220, 114, 104, // 15110: decode to FCVT_Q_W using decoder 104
8638 // 15110: }
8639 1, 6, // 15114: case 0x1: {
8640 OPC_CheckPredicate, 27, // 15116: check predicate 27
8641 OPC_Decode, 221, 114, 104, // 15118: decode to FCVT_Q_WU using decoder 104
8642 // 15118: }
8643 2, 6, // 15122: case 0x2: {
8644 OPC_CheckPredicate, 96, // 15124: check predicate 96
8645 OPC_Decode, 217, 114, 104, // 15126: decode to FCVT_Q_L using decoder 104
8646 // 15126: }
8647 3, 0, // 15130: case 0x3: {
8648 OPC_CheckPredicate, 96, // 15132: check predicate 96
8649 OPC_Decode, 218, 114, 104, // 15134: decode to FCVT_Q_LU using decoder 104
8650 // 15134: }
8651 // 15134: } // switch Inst[24:20]
8652 // 15134: }
8653 112, 27, // 15138: case 0x70: {
8654 OPC_SwitchField, 12, 3, // 15140: switch Inst[14:12] {
8655 0, 10, // 15143: case 0x0: {
8656 OPC_CheckPredicate, 25, // 15145: check predicate 25
8657 OPC_CheckField, 20, 5, 0, // 15147: check Inst[24:20] == 0x0
8658 OPC_Decode, 233, 115, 105, // 15151: decode to FMV_X_W using decoder 105
8659 // 15151: }
8660 1, 0, // 15155: case 0x1: {
8661 OPC_CheckPredicate, 25, // 15157: check predicate 25
8662 OPC_CheckField, 20, 5, 0, // 15159: check Inst[24:20] == 0x0
8663 OPC_Decode, 166, 114, 105, // 15163: decode to FCLASS_S using decoder 105
8664 // 15163: }
8665 // 15163: } // switch Inst[14:12]
8666 // 15163: }
8667 113, 36, // 15167: case 0x71: {
8668 OPC_SwitchField, 12, 3, // 15169: switch Inst[14:12] {
8669 0, 19, // 15172: case 0x0: {
8670 OPC_SwitchField, 20, 5, // 15174: switch Inst[24:20] {
8671 0, 6, // 15177: case 0x0: {
8672 OPC_CheckPredicate, 94, // 15179: check predicate 94
8673 OPC_Decode, 231, 115, 106, // 15181: decode to FMV_X_D using decoder 106
8674 // 15181: }
8675 1, 0, // 15185: case 0x1: {
8676 OPC_CheckPredicate, 91, // 15187: check predicate 91
8677 OPC_Decode, 224, 115, 106, // 15189: decode to FMVH_X_D using decoder 106
8678 // 15189: }
8679 // 15189: } // switch Inst[24:20]
8680 // 15189: }
8681 1, 0, // 15193: case 0x1: {
8682 OPC_CheckPredicate, 26, // 15195: check predicate 26
8683 OPC_CheckField, 20, 5, 0, // 15197: check Inst[24:20] == 0x0
8684 OPC_Decode, 160, 114, 106, // 15201: decode to FCLASS_D using decoder 106
8685 // 15201: }
8686 // 15201: } // switch Inst[14:12]
8687 // 15201: }
8688 114, 27, // 15205: case 0x72: {
8689 OPC_SwitchField, 12, 3, // 15207: switch Inst[14:12] {
8690 0, 10, // 15210: case 0x0: {
8691 OPC_CheckPredicate, 24, // 15212: check predicate 24
8692 OPC_CheckField, 20, 5, 0, // 15214: check Inst[24:20] == 0x0
8693 OPC_Decode, 232, 115, 107, // 15218: decode to FMV_X_H using decoder 107
8694 // 15218: }
8695 1, 0, // 15222: case 0x1: {
8696 OPC_CheckPredicate, 82, // 15224: check predicate 82
8697 OPC_CheckField, 20, 5, 0, // 15226: check Inst[24:20] == 0x0
8698 OPC_Decode, 163, 114, 107, // 15230: decode to FCLASS_H using decoder 107
8699 // 15230: }
8700 // 15230: } // switch Inst[14:12]
8701 // 15230: }
8702 115, 27, // 15234: case 0x73: {
8703 OPC_SwitchField, 12, 3, // 15236: switch Inst[14:12] {
8704 0, 10, // 15239: case 0x0: {
8705 OPC_CheckPredicate, 92, // 15241: check predicate 92
8706 OPC_CheckField, 20, 5, 1, // 15243: check Inst[24:20] == 0x1
8707 OPC_Decode, 225, 115, 108, // 15247: decode to FMVH_X_Q using decoder 108
8708 // 15247: }
8709 1, 0, // 15251: case 0x1: {
8710 OPC_CheckPredicate, 27, // 15253: check predicate 27
8711 OPC_CheckField, 20, 5, 0, // 15255: check Inst[24:20] == 0x0
8712 OPC_Decode, 165, 114, 108, // 15259: decode to FCLASS_Q using decoder 108
8713 // 15259: }
8714 // 15259: } // switch Inst[14:12]
8715 // 15259: }
8716 120, 27, // 15263: case 0x78: {
8717 OPC_SwitchField, 20, 5, // 15265: switch Inst[24:20] {
8718 0, 10, // 15268: case 0x0: {
8719 OPC_CheckPredicate, 25, // 15270: check predicate 25
8720 OPC_CheckField, 12, 3, 0, // 15272: check Inst[14:12] == 0x0
8721 OPC_Decode, 230, 115, 109, // 15276: decode to FMV_W_X using decoder 109
8722 // 15276: }
8723 1, 0, // 15280: case 0x1: {
8724 OPC_CheckPredicate, 83, // 15282: check predicate 83
8725 OPC_CheckField, 12, 3, 0, // 15284: check Inst[14:12] == 0x0
8726 OPC_Decode, 161, 115, 110, // 15288: decode to FLI_S using decoder 110
8727 // 15288: }
8728 // 15288: } // switch Inst[24:20]
8729 // 15288: }
8730 121, 27, // 15292: case 0x79: {
8731 OPC_SwitchField, 20, 5, // 15294: switch Inst[24:20] {
8732 0, 10, // 15297: case 0x0: {
8733 OPC_CheckPredicate, 94, // 15299: check predicate 94
8734 OPC_CheckField, 12, 3, 0, // 15301: check Inst[14:12] == 0x0
8735 OPC_Decode, 228, 115, 111, // 15305: decode to FMV_D_X using decoder 111
8736 // 15305: }
8737 1, 0, // 15309: case 0x1: {
8738 OPC_CheckPredicate, 84, // 15311: check predicate 84
8739 OPC_CheckField, 12, 3, 0, // 15313: check Inst[14:12] == 0x0
8740 OPC_Decode, 158, 115, 112, // 15317: decode to FLI_D using decoder 112
8741 // 15317: }
8742 // 15317: } // switch Inst[24:20]
8743 // 15317: }
8744 122, 27, // 15321: case 0x7a: {
8745 OPC_SwitchField, 20, 5, // 15323: switch Inst[24:20] {
8746 0, 10, // 15326: case 0x0: {
8747 OPC_CheckPredicate, 24, // 15328: check predicate 24
8748 OPC_CheckField, 12, 3, 0, // 15330: check Inst[14:12] == 0x0
8749 OPC_Decode, 229, 115, 113, // 15334: decode to FMV_H_X using decoder 113
8750 // 15334: }
8751 1, 0, // 15338: case 0x1: {
8752 OPC_CheckPredicate, 97, // 15340: check predicate 97
8753 OPC_CheckField, 12, 3, 0, // 15342: check Inst[14:12] == 0x0
8754 OPC_Decode, 159, 115, 114, // 15346: decode to FLI_H using decoder 114
8755 // 15346: }
8756 // 15346: } // switch Inst[24:20]
8757 // 15346: }
8758 123, 0, // 15350: case 0x7b: {
8759 OPC_CheckPredicate, 86, // 15352: check predicate 86
8760 OPC_CheckField, 20, 5, 1, // 15354: check Inst[24:20] == 0x1
8761 OPC_CheckField, 12, 3, 0, // 15358: check Inst[14:12] == 0x0
8762 OPC_Decode, 160, 115, 115, // 15362: decode to FLI_Q using decoder 115
8763 // 15362: }
8764 // 15362: } // switch Inst[31:25]
8765 // 15362: }
8766 87, 185, 29, // 15366: case 0x57: {
8767 OPC_SwitchField, 12, 3, // 15369: switch Inst[14:12] {
8768 0, 152, 4, // 15372: case 0x0: {
8769 OPC_SwitchField, 26, 6, // 15375: switch Inst[31:26] {
8770 0, 6, // 15378: case 0x0: {
8771 OPC_CheckPredicate, 23, // 15380: check predicate 23
8772 OPC_Decode, 155, 126, 116, // 15382: decode to VADD_VV using decoder 116
8773 // 15382: }
8774 1, 6, // 15386: case 0x1: {
8775 OPC_CheckPredicate, 98, // 15388: check predicate 98
8776 OPC_Decode, 168, 126, 116, // 15390: decode to VANDN_VV using decoder 116
8777 // 15390: }
8778 2, 7, // 15394: case 0x2: {
8779 OPC_CheckPredicate, 23, // 15396: check predicate 23
8780 OPC_Decode, 179, 131, 1, 116, // 15398: decode to VSUB_VV using decoder 116
8781 // 15398: }
8782 4, 7, // 15403: case 0x4: {
8783 OPC_CheckPredicate, 23, // 15405: check predicate 23
8784 OPC_Decode, 171, 129, 1, 116, // 15407: decode to VMINU_VV using decoder 116
8785 // 15407: }
8786 5, 7, // 15412: case 0x5: {
8787 OPC_CheckPredicate, 23, // 15414: check predicate 23
8788 OPC_Decode, 173, 129, 1, 116, // 15416: decode to VMIN_VV using decoder 116
8789 // 15416: }
8790 6, 7, // 15421: case 0x6: {
8791 OPC_CheckPredicate, 23, // 15423: check predicate 23
8792 OPC_Decode, 154, 129, 1, 116, // 15425: decode to VMAXU_VV using decoder 116
8793 // 15425: }
8794 7, 7, // 15430: case 0x7: {
8795 OPC_CheckPredicate, 23, // 15432: check predicate 23
8796 OPC_Decode, 156, 129, 1, 116, // 15434: decode to VMAX_VV using decoder 116
8797 // 15434: }
8798 9, 6, // 15439: case 0x9: {
8799 OPC_CheckPredicate, 23, // 15441: check predicate 23
8800 OPC_Decode, 171, 126, 116, // 15443: decode to VAND_VV using decoder 116
8801 // 15443: }
8802 10, 7, // 15447: case 0xa: {
8803 OPC_CheckPredicate, 23, // 15449: check predicate 23
8804 OPC_Decode, 251, 129, 1, 116, // 15451: decode to VOR_VV using decoder 116
8805 // 15451: }
8806 11, 7, // 15456: case 0xb: {
8807 OPC_CheckPredicate, 23, // 15458: check predicate 23
8808 OPC_Decode, 128, 132, 1, 116, // 15460: decode to VXOR_VV using decoder 116
8809 // 15460: }
8810 12, 7, // 15465: case 0xc: {
8811 OPC_CheckPredicate, 23, // 15467: check predicate 23
8812 OPC_Decode, 148, 130, 1, 116, // 15469: decode to VRGATHER_VV using decoder 116
8813 // 15469: }
8814 14, 7, // 15474: case 0xe: {
8815 OPC_CheckPredicate, 23, // 15476: check predicate 23
8816 OPC_Decode, 146, 130, 1, 116, // 15478: decode to VRGATHEREI16_VV using decoder 116
8817 // 15478: }
8818 15, 7, // 15483: case 0xf: {
8819 OPC_CheckPredicate, 99, // 15485: check predicate 99
8820 OPC_Decode, 254, 129, 1, 116, // 15487: decode to VPAIRE_VV using decoder 116
8821 // 15487: }
8822 16, 10, // 15492: case 0x10: {
8823 OPC_CheckPredicate, 23, // 15494: check predicate 23
8824 OPC_CheckField, 25, 1, 0, // 15496: check Inst[25] == 0x0
8825 OPC_Decode, 152, 126, 117, // 15500: decode to VADC_VVM using decoder 117
8826 // 15500: }
8827 17, 21, // 15504: case 0x11: {
8828 OPC_SwitchField, 25, 1, // 15506: switch Inst[25] {
8829 0, 7, // 15509: case 0x0: {
8830 OPC_CheckPredicate, 23, // 15511: check predicate 23
8831 OPC_Decode, 251, 128, 1, 117, // 15513: decode to VMADC_VVM using decoder 117
8832 // 15513: }
8833 1, 0, // 15518: case 0x1: {
8834 OPC_CheckPredicate, 23, // 15520: check predicate 23
8835 OPC_Decode, 250, 128, 1, 118, // 15522: decode to VMADC_VV using decoder 118
8836 // 15522: }
8837 // 15522: } // switch Inst[25]
8838 // 15522: }
8839 18, 11, // 15527: case 0x12: {
8840 OPC_CheckPredicate, 23, // 15529: check predicate 23
8841 OPC_CheckField, 25, 1, 0, // 15531: check Inst[25] == 0x0
8842 OPC_Decode, 167, 130, 1, 117, // 15535: decode to VSBC_VVM using decoder 117
8843 // 15535: }
8844 19, 21, // 15540: case 0x13: {
8845 OPC_SwitchField, 25, 1, // 15542: switch Inst[25] {
8846 0, 7, // 15545: case 0x0: {
8847 OPC_CheckPredicate, 23, // 15547: check predicate 23
8848 OPC_Decode, 181, 129, 1, 117, // 15549: decode to VMSBC_VVM using decoder 117
8849 // 15549: }
8850 1, 0, // 15554: case 0x1: {
8851 OPC_CheckPredicate, 23, // 15556: check predicate 23
8852 OPC_Decode, 180, 129, 1, 118, // 15558: decode to VMSBC_VV using decoder 118
8853 // 15558: }
8854 // 15558: } // switch Inst[25]
8855 // 15558: }
8856 20, 7, // 15563: case 0x14: {
8857 OPC_CheckPredicate, 98, // 15565: check predicate 98
8858 OPC_Decode, 153, 130, 1, 116, // 15567: decode to VROR_VV using decoder 116
8859 // 15567: }
8860 21, 7, // 15572: case 0x15: {
8861 OPC_CheckPredicate, 98, // 15574: check predicate 98
8862 OPC_Decode, 150, 130, 1, 116, // 15576: decode to VROL_VV using decoder 116
8863 // 15576: }
8864 23, 25, // 15581: case 0x17: {
8865 OPC_SwitchField, 25, 1, // 15583: switch Inst[25] {
8866 0, 7, // 15586: case 0x0: {
8867 OPC_CheckPredicate, 23, // 15588: check predicate 23
8868 OPC_Decode, 159, 129, 1, 117, // 15590: decode to VMERGE_VVM using decoder 117
8869 // 15590: }
8870 1, 0, // 15595: case 0x1: {
8871 OPC_CheckPredicate, 23, // 15597: check predicate 23
8872 OPC_CheckField, 20, 5, 0, // 15599: check Inst[24:20] == 0x0
8873 OPC_Decode, 225, 129, 1, 119, // 15603: decode to VMV_V_V using decoder 119
8874 // 15603: }
8875 // 15603: } // switch Inst[25]
8876 // 15603: }
8877 24, 7, // 15608: case 0x18: {
8878 OPC_CheckPredicate, 23, // 15610: check predicate 23
8879 OPC_Decode, 186, 129, 1, 116, // 15612: decode to VMSEQ_VV using decoder 116
8880 // 15612: }
8881 25, 7, // 15617: case 0x19: {
8882 OPC_CheckPredicate, 23, // 15619: check predicate 23
8883 OPC_Decode, 204, 129, 1, 116, // 15621: decode to VMSNE_VV using decoder 116
8884 // 15621: }
8885 26, 7, // 15626: case 0x1a: {
8886 OPC_CheckPredicate, 23, // 15628: check predicate 23
8887 OPC_Decode, 199, 129, 1, 116, // 15630: decode to VMSLTU_VV using decoder 116
8888 // 15630: }
8889 27, 7, // 15635: case 0x1b: {
8890 OPC_CheckPredicate, 23, // 15637: check predicate 23
8891 OPC_Decode, 201, 129, 1, 116, // 15639: decode to VMSLT_VV using decoder 116
8892 // 15639: }
8893 28, 7, // 15644: case 0x1c: {
8894 OPC_CheckPredicate, 23, // 15646: check predicate 23
8895 OPC_Decode, 194, 129, 1, 116, // 15648: decode to VMSLEU_VV using decoder 116
8896 // 15648: }
8897 29, 7, // 15653: case 0x1d: {
8898 OPC_CheckPredicate, 23, // 15655: check predicate 23
8899 OPC_Decode, 197, 129, 1, 116, // 15657: decode to VMSLE_VV using decoder 116
8900 // 15657: }
8901 32, 7, // 15662: case 0x20: {
8902 OPC_CheckPredicate, 23, // 15664: check predicate 23
8903 OPC_Decode, 162, 130, 1, 116, // 15666: decode to VSADDU_VV using decoder 116
8904 // 15666: }
8905 33, 7, // 15671: case 0x21: {
8906 OPC_CheckPredicate, 23, // 15673: check predicate 23
8907 OPC_Decode, 165, 130, 1, 116, // 15675: decode to VSADD_VV using decoder 116
8908 // 15675: }
8909 34, 7, // 15680: case 0x22: {
8910 OPC_CheckPredicate, 23, // 15682: check predicate 23
8911 OPC_Decode, 175, 131, 1, 116, // 15684: decode to VSSUBU_VV using decoder 116
8912 // 15684: }
8913 35, 7, // 15689: case 0x23: {
8914 OPC_CheckPredicate, 23, // 15691: check predicate 23
8915 OPC_Decode, 177, 131, 1, 116, // 15693: decode to VSSUB_VV using decoder 116
8916 // 15693: }
8917 37, 7, // 15698: case 0x25: {
8918 OPC_CheckPredicate, 23, // 15700: check predicate 23
8919 OPC_Decode, 189, 130, 1, 116, // 15702: decode to VSLL_VV using decoder 116
8920 // 15702: }
8921 39, 7, // 15707: case 0x27: {
8922 OPC_CheckPredicate, 23, // 15709: check predicate 23
8923 OPC_Decode, 196, 130, 1, 116, // 15711: decode to VSMUL_VV using decoder 116
8924 // 15711: }
8925 40, 7, // 15716: case 0x28: {
8926 OPC_CheckPredicate, 23, // 15718: check predicate 23
8927 OPC_Decode, 235, 130, 1, 116, // 15720: decode to VSRL_VV using decoder 116
8928 // 15720: }
8929 41, 7, // 15725: case 0x29: {
8930 OPC_CheckPredicate, 23, // 15727: check predicate 23
8931 OPC_Decode, 232, 130, 1, 116, // 15729: decode to VSRA_VV using decoder 116
8932 // 15729: }
8933 42, 7, // 15734: case 0x2a: {
8934 OPC_CheckPredicate, 23, // 15736: check predicate 23
8935 OPC_Decode, 145, 131, 1, 116, // 15738: decode to VSSRL_VV using decoder 116
8936 // 15738: }
8937 43, 7, // 15743: case 0x2b: {
8938 OPC_CheckPredicate, 23, // 15745: check predicate 23
8939 OPC_Decode, 142, 131, 1, 116, // 15747: decode to VSSRA_VV using decoder 116
8940 // 15747: }
8941 44, 7, // 15752: case 0x2c: {
8942 OPC_CheckPredicate, 23, // 15754: check predicate 23
8943 OPC_Decode, 248, 129, 1, 116, // 15756: decode to VNSRL_WV using decoder 116
8944 // 15756: }
8945 45, 7, // 15761: case 0x2d: {
8946 OPC_CheckPredicate, 23, // 15763: check predicate 23
8947 OPC_Decode, 245, 129, 1, 116, // 15765: decode to VNSRA_WV using decoder 116
8948 // 15765: }
8949 46, 7, // 15770: case 0x2e: {
8950 OPC_CheckPredicate, 23, // 15772: check predicate 23
8951 OPC_Decode, 231, 129, 1, 116, // 15774: decode to VNCLIPU_WV using decoder 116
8952 // 15774: }
8953 47, 7, // 15779: case 0x2f: {
8954 OPC_CheckPredicate, 23, // 15781: check predicate 23
8955 OPC_Decode, 234, 129, 1, 116, // 15783: decode to VNCLIP_WV using decoder 116
8956 // 15783: }
8957 48, 7, // 15788: case 0x30: {
8958 OPC_CheckPredicate, 23, // 15790: check predicate 23
8959 OPC_Decode, 242, 131, 1, 116, // 15792: decode to VWREDSUMU_VS using decoder 116
8960 // 15792: }
8961 49, 7, // 15797: case 0x31: {
8962 OPC_CheckPredicate, 23, // 15799: check predicate 23
8963 OPC_Decode, 243, 131, 1, 116, // 15801: decode to VWREDSUM_VS using decoder 116
8964 // 15801: }
8965 53, 7, // 15806: case 0x35: {
8966 OPC_CheckPredicate, 100, // 15808: check predicate 100
8967 OPC_Decode, 245, 131, 1, 116, // 15810: decode to VWSLL_VV using decoder 116
8968 // 15810: }
8969 56, 11, // 15815: case 0x38: {
8970 OPC_CheckPredicate, 101, // 15817: check predicate 101
8971 OPC_CheckField, 25, 1, 1, // 15819: check Inst[25] == 0x1
8972 OPC_Decode, 175, 129, 1, 120, // 15823: decode to VMMACC_VV using decoder 120
8973 // 15823: }
8974 57, 20, // 15828: case 0x39: {
8975 OPC_SwitchField, 25, 1, // 15830: switch Inst[25] {
8976 0, 6, // 15833: case 0x0: {
8977 OPC_CheckPredicate, 102, // 15835: check predicate 102
8978 OPC_Decode, 166, 127, 121, // 15837: decode to VFWIMMACC_VV using decoder 121
8979 // 15837: }
8980 1, 0, // 15841: case 0x1: {
8981 OPC_CheckPredicate, 101, // 15843: check predicate 101
8982 OPC_Decode, 235, 131, 1, 120, // 15845: decode to VWMMACC_VV using decoder 120
8983 // 15845: }
8984 // 15845: } // switch Inst[25]
8985 // 15845: }
8986 58, 20, // 15850: case 0x3a: {
8987 OPC_SwitchField, 25, 1, // 15852: switch Inst[25] {
8988 0, 6, // 15855: case 0x0: {
8989 OPC_CheckPredicate, 102, // 15857: check predicate 102
8990 OPC_Decode, 254, 126, 121, // 15859: decode to VFQIMMACC_VV using decoder 121
8991 // 15859: }
8992 1, 0, // 15863: case 0x1: {
8993 OPC_CheckPredicate, 101, // 15865: check predicate 101
8994 OPC_Decode, 128, 130, 1, 120, // 15867: decode to VQMMACC_VV using decoder 120
8995 // 15867: }
8996 // 15867: } // switch Inst[25]
8997 // 15867: }
8998 59, 19, // 15872: case 0x3b: {
8999 OPC_SwitchField, 25, 1, // 15874: switch Inst[25] {
9000 0, 6, // 15877: case 0x0: {
9001 OPC_CheckPredicate, 102, // 15879: check predicate 102
9002 OPC_Decode, 199, 126, 121, // 15881: decode to VF8WIMMACC_VV using decoder 121
9003 // 15881: }
9004 1, 0, // 15885: case 0x1: {
9005 OPC_CheckPredicate, 101, // 15887: check predicate 101
9006 OPC_Decode, 142, 126, 120, // 15889: decode to V8WMMACC_VV using decoder 120
9007 // 15889: }
9008 // 15889: } // switch Inst[25]
9009 // 15889: }
9010 61, 7, // 15893: case 0x3d: {
9011 OPC_CheckPredicate, 103, // 15895: check predicate 103
9012 OPC_Decode, 218, 131, 1, 122, // 15897: decode to VWABDA_VV using decoder 122
9013 // 15897: }
9014 62, 0, // 15902: case 0x3e: {
9015 OPC_CheckPredicate, 103, // 15904: check predicate 103
9016 OPC_Decode, 216, 131, 1, 122, // 15906: decode to VWABDAU_VV using decoder 122
9017 // 15906: }
9018 // 15906: } // switch Inst[31:26]
9019 // 15906: }
9020 1, 133, 5, // 15911: case 0x1: {
9021 OPC_SwitchField, 26, 6, // 15914: switch Inst[31:26] {
9022 0, 6, // 15917: case 0x0: {
9023 OPC_CheckPredicate, 104, // 15919: check predicate 104
9024 OPC_Decode, 203, 126, 116, // 15921: decode to VFADD_VV using decoder 116
9025 // 15921: }
9026 1, 6, // 15925: case 0x1: {
9027 OPC_CheckPredicate, 104, // 15927: check predicate 104
9028 OPC_Decode, 138, 127, 116, // 15929: decode to VFREDUSUM_VS using decoder 116
9029 // 15929: }
9030 2, 6, // 15933: case 0x2: {
9031 OPC_CheckPredicate, 104, // 15935: check predicate 104
9032 OPC_Decode, 151, 127, 116, // 15937: decode to VFSUB_VV using decoder 116
9033 // 15937: }
9034 3, 6, // 15941: case 0x3: {
9035 OPC_CheckPredicate, 104, // 15943: check predicate 104
9036 OPC_Decode, 137, 127, 116, // 15945: decode to VFREDOSUM_VS using decoder 116
9037 // 15945: }
9038 4, 6, // 15949: case 0x4: {
9039 OPC_CheckPredicate, 104, // 15951: check predicate 104
9040 OPC_Decode, 223, 126, 116, // 15953: decode to VFMIN_VV using decoder 116
9041 // 15953: }
9042 5, 6, // 15957: case 0x5: {
9043 OPC_CheckPredicate, 104, // 15959: check predicate 104
9044 OPC_Decode, 136, 127, 116, // 15961: decode to VFREDMIN_VS using decoder 116
9045 // 15961: }
9046 6, 6, // 15965: case 0x6: {
9047 OPC_CheckPredicate, 104, // 15967: check predicate 104
9048 OPC_Decode, 220, 126, 116, // 15969: decode to VFMAX_VV using decoder 116
9049 // 15969: }
9050 7, 6, // 15973: case 0x7: {
9051 OPC_CheckPredicate, 104, // 15975: check predicate 104
9052 OPC_Decode, 135, 127, 116, // 15977: decode to VFREDMAX_VS using decoder 116
9053 // 15977: }
9054 8, 6, // 15981: case 0x8: {
9055 OPC_CheckPredicate, 104, // 15983: check predicate 104
9056 OPC_Decode, 146, 127, 116, // 15985: decode to VFSGNJ_VV using decoder 116
9057 // 15985: }
9058 9, 6, // 15989: case 0x9: {
9059 OPC_CheckPredicate, 104, // 15991: check predicate 104
9060 OPC_Decode, 142, 127, 116, // 15993: decode to VFSGNJN_VV using decoder 116
9061 // 15993: }
9062 10, 6, // 15997: case 0xa: {
9063 OPC_CheckPredicate, 104, // 15999: check predicate 104
9064 OPC_Decode, 144, 127, 116, // 16001: decode to VFSGNJX_VV using decoder 116
9065 // 16001: }
9066 16, 14, // 16005: case 0x10: {
9067 OPC_CheckPredicate, 104, // 16007: check predicate 104
9068 OPC_CheckField, 25, 1, 1, // 16009: check Inst[25] == 0x1
9069 OPC_CheckField, 15, 5, 0, // 16013: check Inst[19:15] == 0x0
9070 OPC_Decode, 231, 126, 123, // 16017: decode to VFMV_F_S using decoder 123
9071 // 16017: }
9072 18, 211, 1, // 16021: case 0x12: {
9073 OPC_SwitchField, 15, 5, // 16024: switch Inst[19:15] {
9074 0, 6, // 16027: case 0x0: {
9075 OPC_CheckPredicate, 104, // 16029: check predicate 104
9076 OPC_Decode, 210, 126, 124, // 16031: decode to VFCVT_XU_F_V using decoder 124
9077 // 16031: }
9078 1, 6, // 16035: case 0x1: {
9079 OPC_CheckPredicate, 104, // 16037: check predicate 104
9080 OPC_Decode, 211, 126, 124, // 16039: decode to VFCVT_X_F_V using decoder 124
9081 // 16039: }
9082 2, 6, // 16043: case 0x2: {
9083 OPC_CheckPredicate, 104, // 16045: check predicate 104
9084 OPC_Decode, 206, 126, 124, // 16047: decode to VFCVT_F_XU_V using decoder 124
9085 // 16047: }
9086 3, 6, // 16051: case 0x3: {
9087 OPC_CheckPredicate, 104, // 16053: check predicate 104
9088 OPC_Decode, 207, 126, 124, // 16055: decode to VFCVT_F_X_V using decoder 124
9089 // 16055: }
9090 6, 6, // 16059: case 0x6: {
9091 OPC_CheckPredicate, 104, // 16061: check predicate 104
9092 OPC_Decode, 208, 126, 124, // 16063: decode to VFCVT_RTZ_XU_F_V using decoder 124
9093 // 16063: }
9094 7, 6, // 16067: case 0x7: {
9095 OPC_CheckPredicate, 104, // 16069: check predicate 104
9096 OPC_Decode, 209, 126, 124, // 16071: decode to VFCVT_RTZ_X_F_V using decoder 124
9097 // 16071: }
9098 8, 6, // 16075: case 0x8: {
9099 OPC_CheckPredicate, 104, // 16077: check predicate 104
9100 OPC_Decode, 163, 127, 124, // 16079: decode to VFWCVT_XU_F_V using decoder 124
9101 // 16079: }
9102 9, 6, // 16083: case 0x9: {
9103 OPC_CheckPredicate, 104, // 16085: check predicate 104
9104 OPC_Decode, 164, 127, 124, // 16087: decode to VFWCVT_X_F_V using decoder 124
9105 // 16087: }
9106 10, 6, // 16091: case 0xa: {
9107 OPC_CheckPredicate, 104, // 16093: check predicate 104
9108 OPC_Decode, 159, 127, 124, // 16095: decode to VFWCVT_F_XU_V using decoder 124
9109 // 16095: }
9110 11, 6, // 16099: case 0xb: {
9111 OPC_CheckPredicate, 104, // 16101: check predicate 104
9112 OPC_Decode, 160, 127, 124, // 16103: decode to VFWCVT_F_X_V using decoder 124
9113 // 16103: }
9114 12, 6, // 16107: case 0xc: {
9115 OPC_CheckPredicate, 104, // 16109: check predicate 104
9116 OPC_Decode, 158, 127, 124, // 16111: decode to VFWCVT_F_F_V using decoder 124
9117 // 16111: }
9118 13, 6, // 16115: case 0xd: {
9119 OPC_CheckPredicate, 105, // 16117: check predicate 105
9120 OPC_Decode, 157, 127, 124, // 16119: decode to VFWCVTBF16_F_F_V using decoder 124
9121 // 16119: }
9122 14, 6, // 16123: case 0xe: {
9123 OPC_CheckPredicate, 104, // 16125: check predicate 104
9124 OPC_Decode, 161, 127, 124, // 16127: decode to VFWCVT_RTZ_XU_F_V using decoder 124
9125 // 16127: }
9126 15, 6, // 16131: case 0xf: {
9127 OPC_CheckPredicate, 104, // 16133: check predicate 104
9128 OPC_Decode, 162, 127, 124, // 16135: decode to VFWCVT_RTZ_X_F_V using decoder 124
9129 // 16135: }
9130 16, 6, // 16139: case 0x10: {
9131 OPC_CheckPredicate, 104, // 16141: check predicate 104
9132 OPC_Decode, 244, 126, 124, // 16143: decode to VFNCVT_XU_F_W using decoder 124
9133 // 16143: }
9134 17, 6, // 16147: case 0x11: {
9135 OPC_CheckPredicate, 104, // 16149: check predicate 104
9136 OPC_Decode, 245, 126, 124, // 16151: decode to VFNCVT_X_F_W using decoder 124
9137 // 16151: }
9138 18, 6, // 16155: case 0x12: {
9139 OPC_CheckPredicate, 104, // 16157: check predicate 104
9140 OPC_Decode, 238, 126, 124, // 16159: decode to VFNCVT_F_XU_W using decoder 124
9141 // 16159: }
9142 19, 6, // 16163: case 0x13: {
9143 OPC_CheckPredicate, 104, // 16165: check predicate 104
9144 OPC_Decode, 239, 126, 124, // 16167: decode to VFNCVT_F_X_W using decoder 124
9145 // 16167: }
9146 20, 6, // 16171: case 0x14: {
9147 OPC_CheckPredicate, 104, // 16173: check predicate 104
9148 OPC_Decode, 237, 126, 124, // 16175: decode to VFNCVT_F_F_W using decoder 124
9149 // 16175: }
9150 21, 6, // 16179: case 0x15: {
9151 OPC_CheckPredicate, 104, // 16181: check predicate 104
9152 OPC_Decode, 240, 126, 124, // 16183: decode to VFNCVT_ROD_F_F_W using decoder 124
9153 // 16183: }
9154 22, 6, // 16187: case 0x16: {
9155 OPC_CheckPredicate, 104, // 16189: check predicate 104
9156 OPC_Decode, 241, 126, 124, // 16191: decode to VFNCVT_RTZ_XU_F_W using decoder 124
9157 // 16191: }
9158 23, 6, // 16195: case 0x17: {
9159 OPC_CheckPredicate, 104, // 16197: check predicate 104
9160 OPC_Decode, 242, 126, 124, // 16199: decode to VFNCVT_RTZ_X_F_W using decoder 124
9161 // 16199: }
9162 25, 6, // 16203: case 0x19: {
9163 OPC_CheckPredicate, 106, // 16205: check predicate 106
9164 OPC_Decode, 236, 126, 124, // 16207: decode to VFNCVT_F_F_Q using decoder 124
9165 // 16207: }
9166 27, 6, // 16211: case 0x1b: {
9167 OPC_CheckPredicate, 106, // 16213: check predicate 106
9168 OPC_Decode, 243, 126, 124, // 16215: decode to VFNCVT_SAT_F_F_Q using decoder 124
9169 // 16215: }
9170 29, 6, // 16219: case 0x1d: {
9171 OPC_CheckPredicate, 105, // 16221: check predicate 105
9172 OPC_Decode, 234, 126, 124, // 16223: decode to VFNCVTBF16_F_F_W using decoder 124
9173 // 16223: }
9174 31, 0, // 16227: case 0x1f: {
9175 OPC_CheckPredicate, 106, // 16229: check predicate 106
9176 OPC_Decode, 235, 126, 124, // 16231: decode to VFNCVTBF16_SAT_F_F_W using decoder 124
9177 // 16231: }
9178 // 16231: } // switch Inst[19:15]
9179 // 16231: }
9180 19, 35, // 16235: case 0x13: {
9181 OPC_SwitchField, 15, 5, // 16237: switch Inst[19:15] {
9182 0, 6, // 16240: case 0x0: {
9183 OPC_CheckPredicate, 104, // 16242: check predicate 104
9184 OPC_Decode, 149, 127, 124, // 16244: decode to VFSQRT_V using decoder 124
9185 // 16244: }
9186 4, 6, // 16248: case 0x4: {
9187 OPC_CheckPredicate, 104, // 16250: check predicate 104
9188 OPC_Decode, 139, 127, 124, // 16252: decode to VFRSQRT7_V using decoder 124
9189 // 16252: }
9190 5, 6, // 16256: case 0x5: {
9191 OPC_CheckPredicate, 104, // 16258: check predicate 104
9192 OPC_Decode, 134, 127, 124, // 16260: decode to VFREC7_V using decoder 124
9193 // 16260: }
9194 16, 0, // 16264: case 0x10: {
9195 OPC_CheckPredicate, 104, // 16266: check predicate 104
9196 OPC_Decode, 205, 126, 124, // 16268: decode to VFCLASS_V using decoder 124
9197 // 16268: }
9198 // 16268: } // switch Inst[19:15]
9199 // 16268: }
9200 20, 10, // 16272: case 0x14: {
9201 OPC_CheckPredicate, 102, // 16274: check predicate 102
9202 OPC_CheckField, 25, 1, 1, // 16276: check Inst[25] == 0x1
9203 OPC_Decode, 224, 126, 120, // 16280: decode to VFMMACC_VV using decoder 120
9204 // 16280: }
9205 21, 19, // 16284: case 0x15: {
9206 OPC_SwitchField, 25, 1, // 16286: switch Inst[25] {
9207 0, 6, // 16289: case 0x0: {
9208 OPC_CheckPredicate, 102, // 16291: check predicate 102
9209 OPC_Decode, 176, 127, 121, // 16293: decode to VFWMMACC_VV_SCALE using decoder 121
9210 // 16293: }
9211 1, 0, // 16297: case 0x1: {
9212 OPC_CheckPredicate, 102, // 16299: check predicate 102
9213 OPC_Decode, 175, 127, 120, // 16301: decode to VFWMMACC_VV using decoder 120
9214 // 16301: }
9215 // 16301: } // switch Inst[25]
9216 // 16301: }
9217 22, 19, // 16305: case 0x16: {
9218 OPC_SwitchField, 25, 1, // 16307: switch Inst[25] {
9219 0, 6, // 16310: case 0x0: {
9220 OPC_CheckPredicate, 102, // 16312: check predicate 102
9221 OPC_Decode, 128, 127, 121, // 16314: decode to VFQMMACC_VV_SCALE using decoder 121
9222 // 16314: }
9223 1, 0, // 16318: case 0x1: {
9224 OPC_CheckPredicate, 102, // 16320: check predicate 102
9225 OPC_Decode, 255, 126, 120, // 16322: decode to VFQMMACC_VV using decoder 120
9226 // 16322: }
9227 // 16322: } // switch Inst[25]
9228 // 16322: }
9229 23, 19, // 16326: case 0x17: {
9230 OPC_SwitchField, 25, 1, // 16328: switch Inst[25] {
9231 0, 6, // 16331: case 0x0: {
9232 OPC_CheckPredicate, 102, // 16333: check predicate 102
9233 OPC_Decode, 201, 126, 121, // 16335: decode to VF8WMMACC_VV_SCALE using decoder 121
9234 // 16335: }
9235 1, 0, // 16339: case 0x1: {
9236 OPC_CheckPredicate, 102, // 16341: check predicate 102
9237 OPC_Decode, 200, 126, 120, // 16343: decode to VF8WMMACC_VV using decoder 120
9238 // 16343: }
9239 // 16343: } // switch Inst[25]
9240 // 16343: }
9241 24, 7, // 16347: case 0x18: {
9242 OPC_CheckPredicate, 104, // 16349: check predicate 104
9243 OPC_Decode, 162, 129, 1, 116, // 16351: decode to VMFEQ_VV using decoder 116
9244 // 16351: }
9245 25, 7, // 16356: case 0x19: {
9246 OPC_CheckPredicate, 104, // 16358: check predicate 104
9247 OPC_Decode, 166, 129, 1, 116, // 16360: decode to VMFLE_VV using decoder 116
9248 // 16360: }
9249 27, 7, // 16365: case 0x1b: {
9250 OPC_CheckPredicate, 104, // 16367: check predicate 104
9251 OPC_Decode, 168, 129, 1, 116, // 16369: decode to VMFLT_VV using decoder 116
9252 // 16369: }
9253 28, 7, // 16374: case 0x1c: {
9254 OPC_CheckPredicate, 104, // 16376: check predicate 104
9255 OPC_Decode, 170, 129, 1, 116, // 16378: decode to VMFNE_VV using decoder 116
9256 // 16378: }
9257 32, 6, // 16383: case 0x20: {
9258 OPC_CheckPredicate, 104, // 16385: check predicate 104
9259 OPC_Decode, 213, 126, 116, // 16387: decode to VFDIV_VV using decoder 116
9260 // 16387: }
9261 36, 6, // 16391: case 0x24: {
9262 OPC_CheckPredicate, 104, // 16393: check predicate 104
9263 OPC_Decode, 230, 126, 116, // 16395: decode to VFMUL_VV using decoder 116
9264 // 16395: }
9265 40, 6, // 16399: case 0x28: {
9266 OPC_CheckPredicate, 104, // 16401: check predicate 104
9267 OPC_Decode, 218, 126, 125, // 16403: decode to VFMADD_VV using decoder 125
9268 // 16403: }
9269 41, 6, // 16407: case 0x29: {
9270 OPC_CheckPredicate, 104, // 16409: check predicate 104
9271 OPC_Decode, 249, 126, 125, // 16411: decode to VFNMADD_VV using decoder 125
9272 // 16411: }
9273 42, 6, // 16415: case 0x2a: {
9274 OPC_CheckPredicate, 104, // 16417: check predicate 104
9275 OPC_Decode, 228, 126, 125, // 16419: decode to VFMSUB_VV using decoder 125
9276 // 16419: }
9277 43, 6, // 16423: case 0x2b: {
9278 OPC_CheckPredicate, 104, // 16425: check predicate 104
9279 OPC_Decode, 253, 126, 125, // 16427: decode to VFNMSUB_VV using decoder 125
9280 // 16427: }
9281 44, 6, // 16431: case 0x2c: {
9282 OPC_CheckPredicate, 104, // 16433: check predicate 104
9283 OPC_Decode, 216, 126, 125, // 16435: decode to VFMACC_VV using decoder 125
9284 // 16435: }
9285 45, 6, // 16439: case 0x2d: {
9286 OPC_CheckPredicate, 104, // 16441: check predicate 104
9287 OPC_Decode, 247, 126, 125, // 16443: decode to VFNMACC_VV using decoder 125
9288 // 16443: }
9289 46, 6, // 16447: case 0x2e: {
9290 OPC_CheckPredicate, 104, // 16449: check predicate 104
9291 OPC_Decode, 226, 126, 125, // 16451: decode to VFMSAC_VV using decoder 125
9292 // 16451: }
9293 47, 6, // 16455: case 0x2f: {
9294 OPC_CheckPredicate, 104, // 16457: check predicate 104
9295 OPC_Decode, 251, 126, 125, // 16459: decode to VFNMSAC_VV using decoder 125
9296 // 16459: }
9297 48, 6, // 16463: case 0x30: {
9298 OPC_CheckPredicate, 104, // 16465: check predicate 104
9299 OPC_Decode, 153, 127, 116, // 16467: decode to VFWADD_VV using decoder 116
9300 // 16467: }
9301 49, 6, // 16471: case 0x31: {
9302 OPC_CheckPredicate, 104, // 16473: check predicate 104
9303 OPC_Decode, 186, 127, 116, // 16475: decode to VFWREDUSUM_VS using decoder 116
9304 // 16475: }
9305 50, 6, // 16479: case 0x32: {
9306 OPC_CheckPredicate, 104, // 16481: check predicate 104
9307 OPC_Decode, 188, 127, 116, // 16483: decode to VFWSUB_VV using decoder 116
9308 // 16483: }
9309 51, 6, // 16487: case 0x33: {
9310 OPC_CheckPredicate, 104, // 16489: check predicate 104
9311 OPC_Decode, 185, 127, 116, // 16491: decode to VFWREDOSUM_VS using decoder 116
9312 // 16491: }
9313 52, 6, // 16495: case 0x34: {
9314 OPC_CheckPredicate, 104, // 16497: check predicate 104
9315 OPC_Decode, 155, 127, 116, // 16499: decode to VFWADD_WV using decoder 116
9316 // 16499: }
9317 54, 6, // 16503: case 0x36: {
9318 OPC_CheckPredicate, 104, // 16505: check predicate 104
9319 OPC_Decode, 190, 127, 116, // 16507: decode to VFWSUB_WV using decoder 116
9320 // 16507: }
9321 56, 6, // 16511: case 0x38: {
9322 OPC_CheckPredicate, 104, // 16513: check predicate 104
9323 OPC_Decode, 180, 127, 116, // 16515: decode to VFWMUL_VV using decoder 116
9324 // 16515: }
9325 59, 6, // 16519: case 0x3b: {
9326 OPC_CheckPredicate, 107, // 16521: check predicate 107
9327 OPC_Decode, 168, 127, 125, // 16523: decode to VFWMACCBF16_VV using decoder 125
9328 // 16523: }
9329 60, 6, // 16527: case 0x3c: {
9330 OPC_CheckPredicate, 104, // 16529: check predicate 104
9331 OPC_Decode, 170, 127, 125, // 16531: decode to VFWMACC_VV using decoder 125
9332 // 16531: }
9333 61, 6, // 16535: case 0x3d: {
9334 OPC_CheckPredicate, 104, // 16537: check predicate 104
9335 OPC_Decode, 182, 127, 125, // 16539: decode to VFWNMACC_VV using decoder 125
9336 // 16539: }
9337 62, 6, // 16543: case 0x3e: {
9338 OPC_CheckPredicate, 104, // 16545: check predicate 104
9339 OPC_Decode, 178, 127, 125, // 16547: decode to VFWMSAC_VV using decoder 125
9340 // 16547: }
9341 63, 0, // 16551: case 0x3f: {
9342 OPC_CheckPredicate, 104, // 16553: check predicate 104
9343 OPC_Decode, 184, 127, 125, // 16555: decode to VFWNMSAC_VV using decoder 125
9344 // 16555: }
9345 // 16555: } // switch Inst[31:26]
9346 // 16555: }
9347 2, 230, 5, // 16559: case 0x2: {
9348 OPC_SwitchField, 26, 6, // 16562: switch Inst[31:26] {
9349 0, 7, // 16565: case 0x0: {
9350 OPC_CheckPredicate, 23, // 16567: check predicate 23
9351 OPC_Decode, 139, 130, 1, 116, // 16569: decode to VREDSUM_VS using decoder 116
9352 // 16569: }
9353 1, 7, // 16574: case 0x1: {
9354 OPC_CheckPredicate, 23, // 16576: check predicate 23
9355 OPC_Decode, 133, 130, 1, 116, // 16578: decode to VREDAND_VS using decoder 116
9356 // 16578: }
9357 2, 7, // 16583: case 0x2: {
9358 OPC_CheckPredicate, 23, // 16585: check predicate 23
9359 OPC_Decode, 138, 130, 1, 116, // 16587: decode to VREDOR_VS using decoder 116
9360 // 16587: }
9361 3, 7, // 16592: case 0x3: {
9362 OPC_CheckPredicate, 23, // 16594: check predicate 23
9363 OPC_Decode, 140, 130, 1, 116, // 16596: decode to VREDXOR_VS using decoder 116
9364 // 16596: }
9365 4, 7, // 16601: case 0x4: {
9366 OPC_CheckPredicate, 23, // 16603: check predicate 23
9367 OPC_Decode, 136, 130, 1, 116, // 16605: decode to VREDMINU_VS using decoder 116
9368 // 16605: }
9369 5, 7, // 16610: case 0x5: {
9370 OPC_CheckPredicate, 23, // 16612: check predicate 23
9371 OPC_Decode, 137, 130, 1, 116, // 16614: decode to VREDMIN_VS using decoder 116
9372 // 16614: }
9373 6, 7, // 16619: case 0x6: {
9374 OPC_CheckPredicate, 23, // 16621: check predicate 23
9375 OPC_Decode, 134, 130, 1, 116, // 16623: decode to VREDMAXU_VS using decoder 116
9376 // 16623: }
9377 7, 7, // 16628: case 0x7: {
9378 OPC_CheckPredicate, 23, // 16630: check predicate 23
9379 OPC_Decode, 135, 130, 1, 116, // 16632: decode to VREDMAX_VS using decoder 116
9380 // 16632: }
9381 8, 6, // 16637: case 0x8: {
9382 OPC_CheckPredicate, 23, // 16639: check predicate 23
9383 OPC_Decode, 143, 126, 116, // 16641: decode to VAADDU_VV using decoder 116
9384 // 16641: }
9385 9, 6, // 16645: case 0x9: {
9386 OPC_CheckPredicate, 23, // 16647: check predicate 23
9387 OPC_Decode, 145, 126, 116, // 16649: decode to VAADD_VV using decoder 116
9388 // 16649: }
9389 10, 6, // 16653: case 0xa: {
9390 OPC_CheckPredicate, 23, // 16655: check predicate 23
9391 OPC_Decode, 173, 126, 116, // 16657: decode to VASUBU_VV using decoder 116
9392 // 16657: }
9393 11, 6, // 16661: case 0xb: {
9394 OPC_CheckPredicate, 23, // 16663: check predicate 23
9395 OPC_Decode, 175, 126, 116, // 16665: decode to VASUB_VV using decoder 116
9396 // 16665: }
9397 12, 6, // 16669: case 0xc: {
9398 OPC_CheckPredicate, 108, // 16671: check predicate 108
9399 OPC_Decode, 181, 126, 116, // 16673: decode to VCLMUL_VV using decoder 116
9400 // 16673: }
9401 13, 6, // 16677: case 0xd: {
9402 OPC_CheckPredicate, 108, // 16679: check predicate 108
9403 OPC_Decode, 179, 126, 116, // 16681: decode to VCLMULH_VV using decoder 116
9404 // 16681: }
9405 15, 7, // 16685: case 0xf: {
9406 OPC_CheckPredicate, 99, // 16687: check predicate 99
9407 OPC_Decode, 255, 129, 1, 116, // 16689: decode to VPAIRO_VV using decoder 116
9408 // 16689: }
9409 16, 32, // 16694: case 0x10: {
9410 OPC_SwitchField, 15, 5, // 16696: switch Inst[19:15] {
9411 0, 11, // 16699: case 0x0: {
9412 OPC_CheckPredicate, 23, // 16701: check predicate 23
9413 OPC_CheckField, 25, 1, 1, // 16703: check Inst[25] == 0x1
9414 OPC_Decode, 227, 129, 1, 126, // 16707: decode to VMV_X_S using decoder 126
9415 // 16707: }
9416 16, 6, // 16712: case 0x10: {
9417 OPC_CheckPredicate, 23, // 16714: check predicate 23
9418 OPC_Decode, 185, 126, 127, // 16716: decode to VCPOP_M using decoder 127
9419 // 16716: }
9420 17, 0, // 16720: case 0x11: {
9421 OPC_CheckPredicate, 23, // 16722: check predicate 23
9422 OPC_Decode, 214, 126, 127, // 16724: decode to VFIRST_M using decoder 127
9423 // 16724: }
9424 // 16724: } // switch Inst[19:15]
9425 // 16724: }
9426 18, 124, // 16728: case 0x12: {
9427 OPC_SwitchField, 15, 5, // 16730: switch Inst[19:15] {
9428 2, 7, // 16733: case 0x2: {
9429 OPC_CheckPredicate, 23, // 16735: check predicate 23
9430 OPC_Decode, 132, 132, 1, 124, // 16737: decode to VZEXT_VF8 using decoder 124
9431 // 16737: }
9432 3, 7, // 16742: case 0x3: {
9433 OPC_CheckPredicate, 23, // 16744: check predicate 23
9434 OPC_Decode, 178, 130, 1, 124, // 16746: decode to VSEXT_VF8 using decoder 124
9435 // 16746: }
9436 4, 7, // 16751: case 0x4: {
9437 OPC_CheckPredicate, 23, // 16753: check predicate 23
9438 OPC_Decode, 131, 132, 1, 124, // 16755: decode to VZEXT_VF4 using decoder 124
9439 // 16755: }
9440 5, 7, // 16760: case 0x5: {
9441 OPC_CheckPredicate, 23, // 16762: check predicate 23
9442 OPC_Decode, 177, 130, 1, 124, // 16764: decode to VSEXT_VF4 using decoder 124
9443 // 16764: }
9444 6, 7, // 16769: case 0x6: {
9445 OPC_CheckPredicate, 23, // 16771: check predicate 23
9446 OPC_Decode, 130, 132, 1, 124, // 16773: decode to VZEXT_VF2 using decoder 124
9447 // 16773: }
9448 7, 7, // 16778: case 0x7: {
9449 OPC_CheckPredicate, 23, // 16780: check predicate 23
9450 OPC_Decode, 176, 130, 1, 124, // 16782: decode to VSEXT_VF2 using decoder 124
9451 // 16782: }
9452 8, 6, // 16787: case 0x8: {
9453 OPC_CheckPredicate, 98, // 16789: check predicate 98
9454 OPC_Decode, 177, 126, 124, // 16791: decode to VBREV8_V using decoder 124
9455 // 16791: }
9456 9, 7, // 16795: case 0x9: {
9457 OPC_CheckPredicate, 98, // 16797: check predicate 98
9458 OPC_Decode, 145, 130, 1, 124, // 16799: decode to VREV8_V using decoder 124
9459 // 16799: }
9460 10, 6, // 16804: case 0xa: {
9461 OPC_CheckPredicate, 100, // 16806: check predicate 100
9462 OPC_Decode, 178, 126, 124, // 16808: decode to VBREV_V using decoder 124
9463 // 16808: }
9464 11, 7, // 16812: case 0xb: {
9465 OPC_CheckPredicate, 99, // 16814: check predicate 99
9466 OPC_Decode, 213, 131, 1, 124, // 16816: decode to VUNZIPE_V using decoder 124
9467 // 16816: }
9468 12, 6, // 16821: case 0xc: {
9469 OPC_CheckPredicate, 100, // 16823: check predicate 100
9470 OPC_Decode, 183, 126, 124, // 16825: decode to VCLZ_V using decoder 124
9471 // 16825: }
9472 13, 6, // 16829: case 0xd: {
9473 OPC_CheckPredicate, 100, // 16831: check predicate 100
9474 OPC_Decode, 187, 126, 124, // 16833: decode to VCTZ_V using decoder 124
9475 // 16833: }
9476 14, 6, // 16837: case 0xe: {
9477 OPC_CheckPredicate, 100, // 16839: check predicate 100
9478 OPC_Decode, 186, 126, 124, // 16841: decode to VCPOP_V using decoder 124
9479 // 16841: }
9480 15, 0, // 16845: case 0xf: {
9481 OPC_CheckPredicate, 99, // 16847: check predicate 99
9482 OPC_Decode, 214, 131, 1, 124, // 16849: decode to VUNZIPO_V using decoder 124
9483 // 16849: }
9484 // 16849: } // switch Inst[19:15]
9485 // 16849: }
9486 20, 51, // 16854: case 0x14: {
9487 OPC_SwitchField, 15, 5, // 16856: switch Inst[19:15] {
9488 1, 7, // 16859: case 0x1: {
9489 OPC_CheckPredicate, 23, // 16861: check predicate 23
9490 OPC_Decode, 184, 129, 1, 124, // 16863: decode to VMSBF_M using decoder 124
9491 // 16863: }
9492 2, 7, // 16868: case 0x2: {
9493 OPC_CheckPredicate, 23, // 16870: check predicate 23
9494 OPC_Decode, 206, 129, 1, 124, // 16872: decode to VMSOF_M using decoder 124
9495 // 16872: }
9496 3, 7, // 16877: case 0x3: {
9497 OPC_CheckPredicate, 23, // 16879: check predicate 23
9498 OPC_Decode, 192, 129, 1, 124, // 16881: decode to VMSIF_M using decoder 124
9499 // 16881: }
9500 16, 6, // 16886: case 0x10: {
9501 OPC_CheckPredicate, 23, // 16888: check predicate 23
9502 OPC_Decode, 196, 127, 124, // 16890: decode to VIOTA_M using decoder 124
9503 // 16890: }
9504 17, 0, // 16894: case 0x11: {
9505 OPC_CheckPredicate, 23, // 16896: check predicate 23
9506 OPC_CheckField, 20, 5, 0, // 16898: check Inst[24:20] == 0x0
9507 OPC_Decode, 195, 127, 128, 1, // 16902: decode to VID_V using decoder 128
9508 // 16902: }
9509 // 16902: } // switch Inst[19:15]
9510 // 16902: }
9511 21, 6, // 16907: case 0x15: {
9512 OPC_CheckPredicate, 103, // 16909: check predicate 103
9513 OPC_Decode, 149, 126, 116, // 16911: decode to VABD_VV using decoder 116
9514 // 16911: }
9515 22, 6, // 16915: case 0x16: {
9516 OPC_CheckPredicate, 103, // 16917: check predicate 103
9517 OPC_Decode, 147, 126, 116, // 16919: decode to VABDU_VV using decoder 116
9518 // 16919: }
9519 23, 10, // 16923: case 0x17: {
9520 OPC_CheckPredicate, 23, // 16925: check predicate 23
9521 OPC_CheckField, 25, 1, 1, // 16927: check Inst[25] == 0x1
9522 OPC_Decode, 184, 126, 118, // 16931: decode to VCOMPRESS_VM using decoder 118
9523 // 16931: }
9524 24, 11, // 16935: case 0x18: {
9525 OPC_CheckPredicate, 23, // 16937: check predicate 23
9526 OPC_CheckField, 25, 1, 1, // 16939: check Inst[25] == 0x1
9527 OPC_Decode, 152, 129, 1, 118, // 16943: decode to VMANDN_MM using decoder 118
9528 // 16943: }
9529 25, 11, // 16948: case 0x19: {
9530 OPC_CheckPredicate, 23, // 16950: check predicate 23
9531 OPC_CheckField, 25, 1, 1, // 16952: check Inst[25] == 0x1
9532 OPC_Decode, 153, 129, 1, 118, // 16956: decode to VMAND_MM using decoder 118
9533 // 16956: }
9534 26, 11, // 16961: case 0x1a: {
9535 OPC_CheckPredicate, 23, // 16963: check predicate 23
9536 OPC_CheckField, 25, 1, 1, // 16965: check Inst[25] == 0x1
9537 OPC_Decode, 179, 129, 1, 118, // 16969: decode to VMOR_MM using decoder 118
9538 // 16969: }
9539 27, 11, // 16974: case 0x1b: {
9540 OPC_CheckPredicate, 23, // 16976: check predicate 23
9541 OPC_CheckField, 25, 1, 1, // 16978: check Inst[25] == 0x1
9542 OPC_Decode, 229, 129, 1, 118, // 16982: decode to VMXOR_MM using decoder 118
9543 // 16982: }
9544 28, 11, // 16987: case 0x1c: {
9545 OPC_CheckPredicate, 23, // 16989: check predicate 23
9546 OPC_CheckField, 25, 1, 1, // 16991: check Inst[25] == 0x1
9547 OPC_Decode, 178, 129, 1, 118, // 16995: decode to VMORN_MM using decoder 118
9548 // 16995: }
9549 29, 11, // 17000: case 0x1d: {
9550 OPC_CheckPredicate, 23, // 17002: check predicate 23
9551 OPC_CheckField, 25, 1, 1, // 17004: check Inst[25] == 0x1
9552 OPC_Decode, 176, 129, 1, 118, // 17008: decode to VMNAND_MM using decoder 118
9553 // 17008: }
9554 30, 11, // 17013: case 0x1e: {
9555 OPC_CheckPredicate, 23, // 17015: check predicate 23
9556 OPC_CheckField, 25, 1, 1, // 17017: check Inst[25] == 0x1
9557 OPC_Decode, 177, 129, 1, 118, // 17021: decode to VMNOR_MM using decoder 118
9558 // 17021: }
9559 31, 11, // 17026: case 0x1f: {
9560 OPC_CheckPredicate, 23, // 17028: check predicate 23
9561 OPC_CheckField, 25, 1, 1, // 17030: check Inst[25] == 0x1
9562 OPC_Decode, 228, 129, 1, 118, // 17034: decode to VMXNOR_MM using decoder 118
9563 // 17034: }
9564 32, 6, // 17039: case 0x20: {
9565 OPC_CheckPredicate, 23, // 17041: check predicate 23
9566 OPC_Decode, 188, 126, 116, // 17043: decode to VDIVU_VV using decoder 116
9567 // 17043: }
9568 33, 6, // 17047: case 0x21: {
9569 OPC_CheckPredicate, 23, // 17049: check predicate 23
9570 OPC_Decode, 190, 126, 116, // 17051: decode to VDIV_VV using decoder 116
9571 // 17051: }
9572 34, 7, // 17055: case 0x22: {
9573 OPC_CheckPredicate, 23, // 17057: check predicate 23
9574 OPC_Decode, 141, 130, 1, 116, // 17059: decode to VREMU_VV using decoder 116
9575 // 17059: }
9576 35, 7, // 17064: case 0x23: {
9577 OPC_CheckPredicate, 23, // 17066: check predicate 23
9578 OPC_Decode, 143, 130, 1, 116, // 17068: decode to VREM_VV using decoder 116
9579 // 17068: }
9580 36, 7, // 17073: case 0x24: {
9581 OPC_CheckPredicate, 23, // 17075: check predicate 23
9582 OPC_Decode, 213, 129, 1, 116, // 17077: decode to VMULHU_VV using decoder 116
9583 // 17077: }
9584 37, 7, // 17082: case 0x25: {
9585 OPC_CheckPredicate, 23, // 17084: check predicate 23
9586 OPC_Decode, 217, 129, 1, 116, // 17086: decode to VMUL_VV using decoder 116
9587 // 17086: }
9588 38, 7, // 17091: case 0x26: {
9589 OPC_CheckPredicate, 23, // 17093: check predicate 23
9590 OPC_Decode, 211, 129, 1, 116, // 17095: decode to VMULHSU_VV using decoder 116
9591 // 17095: }
9592 39, 7, // 17100: case 0x27: {
9593 OPC_CheckPredicate, 23, // 17102: check predicate 23
9594 OPC_Decode, 215, 129, 1, 116, // 17104: decode to VMULH_VV using decoder 116
9595 // 17104: }
9596 40, 6, // 17109: case 0x28: {
9597 OPC_CheckPredicate, 109, // 17111: check predicate 109
9598 OPC_Decode, 195, 126, 122, // 17113: decode to VDOT4AU_VV using decoder 122
9599 // 17113: }
9600 41, 7, // 17117: case 0x29: {
9601 OPC_CheckPredicate, 23, // 17119: check predicate 23
9602 OPC_Decode, 254, 128, 1, 125, // 17121: decode to VMADD_VV using decoder 125
9603 // 17121: }
9604 42, 6, // 17126: case 0x2a: {
9605 OPC_CheckPredicate, 109, // 17128: check predicate 109
9606 OPC_Decode, 192, 126, 122, // 17130: decode to VDOT4ASU_VV using decoder 122
9607 // 17130: }
9608 43, 7, // 17134: case 0x2b: {
9609 OPC_CheckPredicate, 23, // 17136: check predicate 23
9610 OPC_Decode, 238, 129, 1, 125, // 17138: decode to VNMSUB_VV using decoder 125
9611 // 17138: }
9612 44, 6, // 17143: case 0x2c: {
9613 OPC_CheckPredicate, 109, // 17145: check predicate 109
9614 OPC_Decode, 197, 126, 122, // 17147: decode to VDOT4A_VV using decoder 122
9615 // 17147: }
9616 45, 7, // 17151: case 0x2d: {
9617 OPC_CheckPredicate, 23, // 17153: check predicate 23
9618 OPC_Decode, 246, 128, 1, 125, // 17155: decode to VMACC_VV using decoder 125
9619 // 17155: }
9620 47, 7, // 17160: case 0x2f: {
9621 OPC_CheckPredicate, 23, // 17162: check predicate 23
9622 OPC_Decode, 236, 129, 1, 125, // 17164: decode to VNMSAC_VV using decoder 125
9623 // 17164: }
9624 48, 7, // 17169: case 0x30: {
9625 OPC_CheckPredicate, 23, // 17171: check predicate 23
9626 OPC_Decode, 220, 131, 1, 116, // 17173: decode to VWADDU_VV using decoder 116
9627 // 17173: }
9628 49, 7, // 17178: case 0x31: {
9629 OPC_CheckPredicate, 23, // 17180: check predicate 23
9630 OPC_Decode, 224, 131, 1, 116, // 17182: decode to VWADD_VV using decoder 116
9631 // 17182: }
9632 50, 7, // 17187: case 0x32: {
9633 OPC_CheckPredicate, 23, // 17189: check predicate 23
9634 OPC_Decode, 247, 131, 1, 116, // 17191: decode to VWSUBU_VV using decoder 116
9635 // 17191: }
9636 51, 7, // 17196: case 0x33: {
9637 OPC_CheckPredicate, 23, // 17198: check predicate 23
9638 OPC_Decode, 251, 131, 1, 116, // 17200: decode to VWSUB_VV using decoder 116
9639 // 17200: }
9640 52, 7, // 17205: case 0x34: {
9641 OPC_CheckPredicate, 23, // 17207: check predicate 23
9642 OPC_Decode, 222, 131, 1, 116, // 17209: decode to VWADDU_WV using decoder 116
9643 // 17209: }
9644 53, 7, // 17214: case 0x35: {
9645 OPC_CheckPredicate, 23, // 17216: check predicate 23
9646 OPC_Decode, 226, 131, 1, 116, // 17218: decode to VWADD_WV using decoder 116
9647 // 17218: }
9648 54, 7, // 17223: case 0x36: {
9649 OPC_CheckPredicate, 23, // 17225: check predicate 23
9650 OPC_Decode, 249, 131, 1, 116, // 17227: decode to VWSUBU_WV using decoder 116
9651 // 17227: }
9652 55, 7, // 17232: case 0x37: {
9653 OPC_CheckPredicate, 23, // 17234: check predicate 23
9654 OPC_Decode, 253, 131, 1, 116, // 17236: decode to VWSUB_WV using decoder 116
9655 // 17236: }
9656 56, 7, // 17241: case 0x38: {
9657 OPC_CheckPredicate, 23, // 17243: check predicate 23
9658 OPC_Decode, 238, 131, 1, 116, // 17245: decode to VWMULU_VV using decoder 116
9659 // 17245: }
9660 58, 7, // 17250: case 0x3a: {
9661 OPC_CheckPredicate, 23, // 17252: check predicate 23
9662 OPC_Decode, 236, 131, 1, 116, // 17254: decode to VWMULSU_VV using decoder 116
9663 // 17254: }
9664 59, 7, // 17259: case 0x3b: {
9665 OPC_CheckPredicate, 23, // 17261: check predicate 23
9666 OPC_Decode, 240, 131, 1, 116, // 17263: decode to VWMUL_VV using decoder 116
9667 // 17263: }
9668 60, 7, // 17268: case 0x3c: {
9669 OPC_CheckPredicate, 23, // 17270: check predicate 23
9670 OPC_Decode, 231, 131, 1, 125, // 17272: decode to VWMACCU_VV using decoder 125
9671 // 17272: }
9672 61, 7, // 17277: case 0x3d: {
9673 OPC_CheckPredicate, 23, // 17279: check predicate 23
9674 OPC_Decode, 233, 131, 1, 125, // 17281: decode to VWMACC_VV using decoder 125
9675 // 17281: }
9676 62, 7, // 17286: case 0x3e: {
9677 OPC_CheckPredicate, 99, // 17288: check predicate 99
9678 OPC_Decode, 133, 132, 1, 116, // 17290: decode to VZIP_VV using decoder 116
9679 // 17290: }
9680 63, 0, // 17295: case 0x3f: {
9681 OPC_CheckPredicate, 23, // 17297: check predicate 23
9682 OPC_Decode, 228, 131, 1, 125, // 17299: decode to VWMACCSU_VV using decoder 125
9683 // 17299: }
9684 // 17299: } // switch Inst[31:26]
9685 // 17299: }
9686 3, 213, 3, // 17304: case 0x3: {
9687 OPC_SwitchField, 27, 5, // 17307: switch Inst[31:27] {
9688 0, 11, // 17310: case 0x0: {
9689 OPC_CheckPredicate, 23, // 17312: check predicate 23
9690 OPC_CheckField, 26, 1, 0, // 17314: check Inst[26] == 0x0
9691 OPC_Decode, 154, 126, 129, 1, // 17318: decode to VADD_VI using decoder 129
9692 // 17318: }
9693 1, 12, // 17323: case 0x1: {
9694 OPC_CheckPredicate, 23, // 17325: check predicate 23
9695 OPC_CheckField, 26, 1, 1, // 17327: check Inst[26] == 0x1
9696 OPC_Decode, 155, 130, 1, 129, 1, // 17331: decode to VRSUB_VI using decoder 129
9697 // 17331: }
9698 4, 11, // 17337: case 0x4: {
9699 OPC_CheckPredicate, 23, // 17339: check predicate 23
9700 OPC_CheckField, 26, 1, 1, // 17341: check Inst[26] == 0x1
9701 OPC_Decode, 170, 126, 129, 1, // 17345: decode to VAND_VI using decoder 129
9702 // 17345: }
9703 5, 23, // 17350: case 0x5: {
9704 OPC_SwitchField, 26, 1, // 17352: switch Inst[26] {
9705 0, 8, // 17355: case 0x0: {
9706 OPC_CheckPredicate, 23, // 17357: check predicate 23
9707 OPC_Decode, 250, 129, 1, 129, 1, // 17359: decode to VOR_VI using decoder 129
9708 // 17359: }
9709 1, 0, // 17365: case 0x1: {
9710 OPC_CheckPredicate, 23, // 17367: check predicate 23
9711 OPC_Decode, 255, 131, 1, 129, 1, // 17369: decode to VXOR_VI using decoder 129
9712 // 17369: }
9713 // 17369: } // switch Inst[26]
9714 // 17369: }
9715 6, 12, // 17375: case 0x6: {
9716 OPC_CheckPredicate, 23, // 17377: check predicate 23
9717 OPC_CheckField, 26, 1, 0, // 17379: check Inst[26] == 0x0
9718 OPC_Decode, 147, 130, 1, 130, 1, // 17383: decode to VRGATHER_VI using decoder 130
9719 // 17383: }
9720 7, 23, // 17389: case 0x7: {
9721 OPC_SwitchField, 26, 1, // 17391: switch Inst[26] {
9722 0, 8, // 17394: case 0x0: {
9723 OPC_CheckPredicate, 23, // 17396: check predicate 23
9724 OPC_Decode, 186, 130, 1, 130, 1, // 17398: decode to VSLIDEUP_VI using decoder 130
9725 // 17398: }
9726 1, 0, // 17404: case 0x1: {
9727 OPC_CheckPredicate, 23, // 17406: check predicate 23
9728 OPC_Decode, 184, 130, 1, 130, 1, // 17408: decode to VSLIDEDOWN_VI using decoder 130
9729 // 17408: }
9730 // 17408: } // switch Inst[26]
9731 // 17408: }
9732 8, 32, // 17414: case 0x8: {
9733 OPC_SwitchField, 25, 2, // 17416: switch Inst[26:25] {
9734 0, 7, // 17419: case 0x0: {
9735 OPC_CheckPredicate, 23, // 17421: check predicate 23
9736 OPC_Decode, 151, 126, 131, 1, // 17423: decode to VADC_VIM using decoder 131
9737 // 17423: }
9738 2, 8, // 17428: case 0x2: {
9739 OPC_CheckPredicate, 23, // 17430: check predicate 23
9740 OPC_Decode, 249, 128, 1, 131, 1, // 17432: decode to VMADC_VIM using decoder 131
9741 // 17432: }
9742 3, 0, // 17438: case 0x3: {
9743 OPC_CheckPredicate, 23, // 17440: check predicate 23
9744 OPC_Decode, 248, 128, 1, 132, 1, // 17442: decode to VMADC_VI using decoder 132
9745 // 17442: }
9746 // 17442: } // switch Inst[26:25]
9747 // 17442: }
9748 10, 8, // 17448: case 0xa: {
9749 OPC_CheckPredicate, 98, // 17450: check predicate 98
9750 OPC_Decode, 152, 130, 1, 133, 1, // 17452: decode to VROR_VI using decoder 133
9751 // 17452: }
9752 11, 27, // 17458: case 0xb: {
9753 OPC_SwitchField, 25, 2, // 17460: switch Inst[26:25] {
9754 2, 8, // 17463: case 0x2: {
9755 OPC_CheckPredicate, 23, // 17465: check predicate 23
9756 OPC_Decode, 158, 129, 1, 131, 1, // 17467: decode to VMERGE_VIM using decoder 131
9757 // 17467: }
9758 3, 0, // 17473: case 0x3: {
9759 OPC_CheckPredicate, 23, // 17475: check predicate 23
9760 OPC_CheckField, 20, 5, 0, // 17477: check Inst[24:20] == 0x0
9761 OPC_Decode, 224, 129, 1, 134, 1, // 17481: decode to VMV_V_I using decoder 134
9762 // 17481: }
9763 // 17481: } // switch Inst[26:25]
9764 // 17481: }
9765 12, 23, // 17487: case 0xc: {
9766 OPC_SwitchField, 26, 1, // 17489: switch Inst[26] {
9767 0, 8, // 17492: case 0x0: {
9768 OPC_CheckPredicate, 23, // 17494: check predicate 23
9769 OPC_Decode, 185, 129, 1, 129, 1, // 17496: decode to VMSEQ_VI using decoder 129
9770 // 17496: }
9771 1, 0, // 17502: case 0x1: {
9772 OPC_CheckPredicate, 23, // 17504: check predicate 23
9773 OPC_Decode, 203, 129, 1, 129, 1, // 17506: decode to VMSNE_VI using decoder 129
9774 // 17506: }
9775 // 17506: } // switch Inst[26]
9776 // 17506: }
9777 14, 23, // 17512: case 0xe: {
9778 OPC_SwitchField, 26, 1, // 17514: switch Inst[26] {
9779 0, 8, // 17517: case 0x0: {
9780 OPC_CheckPredicate, 23, // 17519: check predicate 23
9781 OPC_Decode, 193, 129, 1, 129, 1, // 17521: decode to VMSLEU_VI using decoder 129
9782 // 17521: }
9783 1, 0, // 17527: case 0x1: {
9784 OPC_CheckPredicate, 23, // 17529: check predicate 23
9785 OPC_Decode, 196, 129, 1, 129, 1, // 17531: decode to VMSLE_VI using decoder 129
9786 // 17531: }
9787 // 17531: } // switch Inst[26]
9788 // 17531: }
9789 15, 23, // 17537: case 0xf: {
9790 OPC_SwitchField, 26, 1, // 17539: switch Inst[26] {
9791 0, 8, // 17542: case 0x0: {
9792 OPC_CheckPredicate, 23, // 17544: check predicate 23
9793 OPC_Decode, 188, 129, 1, 129, 1, // 17546: decode to VMSGTU_VI using decoder 129
9794 // 17546: }
9795 1, 0, // 17552: case 0x1: {
9796 OPC_CheckPredicate, 23, // 17554: check predicate 23
9797 OPC_Decode, 190, 129, 1, 129, 1, // 17556: decode to VMSGT_VI using decoder 129
9798 // 17556: }
9799 // 17556: } // switch Inst[26]
9800 // 17556: }
9801 16, 23, // 17562: case 0x10: {
9802 OPC_SwitchField, 26, 1, // 17564: switch Inst[26] {
9803 0, 8, // 17567: case 0x0: {
9804 OPC_CheckPredicate, 23, // 17569: check predicate 23
9805 OPC_Decode, 161, 130, 1, 129, 1, // 17571: decode to VSADDU_VI using decoder 129
9806 // 17571: }
9807 1, 0, // 17577: case 0x1: {
9808 OPC_CheckPredicate, 23, // 17579: check predicate 23
9809 OPC_Decode, 164, 130, 1, 129, 1, // 17581: decode to VSADD_VI using decoder 129
9810 // 17581: }
9811 // 17581: } // switch Inst[26]
9812 // 17581: }
9813 18, 12, // 17587: case 0x12: {
9814 OPC_CheckPredicate, 23, // 17589: check predicate 23
9815 OPC_CheckField, 26, 1, 1, // 17591: check Inst[26] == 0x1
9816 OPC_Decode, 188, 130, 1, 130, 1, // 17595: decode to VSLL_VI using decoder 130
9817 // 17595: }
9818 19, 59, // 17601: case 0x13: {
9819 OPC_SwitchField, 15, 5, // 17603: switch Inst[19:15] {
9820 0, 12, // 17606: case 0x0: {
9821 OPC_CheckPredicate, 23, // 17608: check predicate 23
9822 OPC_CheckField, 25, 2, 3, // 17610: check Inst[26:25] == 0x3
9823 OPC_Decode, 219, 129, 1, 135, 1, // 17614: decode to VMV1R_V using decoder 135
9824 // 17614: }
9825 1, 12, // 17620: case 0x1: {
9826 OPC_CheckPredicate, 23, // 17622: check predicate 23
9827 OPC_CheckField, 25, 2, 3, // 17624: check Inst[26:25] == 0x3
9828 OPC_Decode, 220, 129, 1, 136, 1, // 17628: decode to VMV2R_V using decoder 136
9829 // 17628: }
9830 3, 12, // 17634: case 0x3: {
9831 OPC_CheckPredicate, 23, // 17636: check predicate 23
9832 OPC_CheckField, 25, 2, 3, // 17638: check Inst[26:25] == 0x3
9833 OPC_Decode, 221, 129, 1, 137, 1, // 17642: decode to VMV4R_V using decoder 137
9834 // 17642: }
9835 7, 0, // 17648: case 0x7: {
9836 OPC_CheckPredicate, 23, // 17650: check predicate 23
9837 OPC_CheckField, 25, 2, 3, // 17652: check Inst[26:25] == 0x3
9838 OPC_Decode, 222, 129, 1, 138, 1, // 17656: decode to VMV8R_V using decoder 138
9839 // 17656: }
9840 // 17656: } // switch Inst[19:15]
9841 // 17656: }
9842 20, 23, // 17662: case 0x14: {
9843 OPC_SwitchField, 26, 1, // 17664: switch Inst[26] {
9844 0, 8, // 17667: case 0x0: {
9845 OPC_CheckPredicate, 23, // 17669: check predicate 23
9846 OPC_Decode, 234, 130, 1, 130, 1, // 17671: decode to VSRL_VI using decoder 130
9847 // 17671: }
9848 1, 0, // 17677: case 0x1: {
9849 OPC_CheckPredicate, 23, // 17679: check predicate 23
9850 OPC_Decode, 231, 130, 1, 130, 1, // 17681: decode to VSRA_VI using decoder 130
9851 // 17681: }
9852 // 17681: } // switch Inst[26]
9853 // 17681: }
9854 21, 23, // 17687: case 0x15: {
9855 OPC_SwitchField, 26, 1, // 17689: switch Inst[26] {
9856 0, 8, // 17692: case 0x0: {
9857 OPC_CheckPredicate, 23, // 17694: check predicate 23
9858 OPC_Decode, 144, 131, 1, 130, 1, // 17696: decode to VSSRL_VI using decoder 130
9859 // 17696: }
9860 1, 0, // 17702: case 0x1: {
9861 OPC_CheckPredicate, 23, // 17704: check predicate 23
9862 OPC_Decode, 141, 131, 1, 130, 1, // 17706: decode to VSSRA_VI using decoder 130
9863 // 17706: }
9864 // 17706: } // switch Inst[26]
9865 // 17706: }
9866 22, 23, // 17712: case 0x16: {
9867 OPC_SwitchField, 26, 1, // 17714: switch Inst[26] {
9868 0, 8, // 17717: case 0x0: {
9869 OPC_CheckPredicate, 23, // 17719: check predicate 23
9870 OPC_Decode, 247, 129, 1, 130, 1, // 17721: decode to VNSRL_WI using decoder 130
9871 // 17721: }
9872 1, 0, // 17727: case 0x1: {
9873 OPC_CheckPredicate, 23, // 17729: check predicate 23
9874 OPC_Decode, 244, 129, 1, 130, 1, // 17731: decode to VNSRA_WI using decoder 130
9875 // 17731: }
9876 // 17731: } // switch Inst[26]
9877 // 17731: }
9878 23, 23, // 17737: case 0x17: {
9879 OPC_SwitchField, 26, 1, // 17739: switch Inst[26] {
9880 0, 8, // 17742: case 0x0: {
9881 OPC_CheckPredicate, 23, // 17744: check predicate 23
9882 OPC_Decode, 230, 129, 1, 130, 1, // 17746: decode to VNCLIPU_WI using decoder 130
9883 // 17746: }
9884 1, 0, // 17752: case 0x1: {
9885 OPC_CheckPredicate, 23, // 17754: check predicate 23
9886 OPC_Decode, 233, 129, 1, 130, 1, // 17756: decode to VNCLIP_WI using decoder 130
9887 // 17756: }
9888 // 17756: } // switch Inst[26]
9889 // 17756: }
9890 26, 0, // 17762: case 0x1a: {
9891 OPC_CheckPredicate, 100, // 17764: check predicate 100
9892 OPC_CheckField, 26, 1, 1, // 17766: check Inst[26] == 0x1
9893 OPC_Decode, 244, 131, 1, 130, 1, // 17770: decode to VWSLL_VI using decoder 130
9894 // 17770: }
9895 // 17770: } // switch Inst[31:27]
9896 // 17770: }
9897 4, 131, 4, // 17776: case 0x4: {
9898 OPC_SwitchField, 26, 6, // 17779: switch Inst[31:26] {
9899 0, 7, // 17782: case 0x0: {
9900 OPC_CheckPredicate, 23, // 17784: check predicate 23
9901 OPC_Decode, 156, 126, 139, 1, // 17786: decode to VADD_VX using decoder 139
9902 // 17786: }
9903 1, 7, // 17791: case 0x1: {
9904 OPC_CheckPredicate, 98, // 17793: check predicate 98
9905 OPC_Decode, 169, 126, 139, 1, // 17795: decode to VANDN_VX using decoder 139
9906 // 17795: }
9907 2, 8, // 17800: case 0x2: {
9908 OPC_CheckPredicate, 23, // 17802: check predicate 23
9909 OPC_Decode, 180, 131, 1, 139, 1, // 17804: decode to VSUB_VX using decoder 139
9910 // 17804: }
9911 3, 8, // 17810: case 0x3: {
9912 OPC_CheckPredicate, 23, // 17812: check predicate 23
9913 OPC_Decode, 156, 130, 1, 139, 1, // 17814: decode to VRSUB_VX using decoder 139
9914 // 17814: }
9915 4, 8, // 17820: case 0x4: {
9916 OPC_CheckPredicate, 23, // 17822: check predicate 23
9917 OPC_Decode, 172, 129, 1, 139, 1, // 17824: decode to VMINU_VX using decoder 139
9918 // 17824: }
9919 5, 8, // 17830: case 0x5: {
9920 OPC_CheckPredicate, 23, // 17832: check predicate 23
9921 OPC_Decode, 174, 129, 1, 139, 1, // 17834: decode to VMIN_VX using decoder 139
9922 // 17834: }
9923 6, 8, // 17840: case 0x6: {
9924 OPC_CheckPredicate, 23, // 17842: check predicate 23
9925 OPC_Decode, 155, 129, 1, 139, 1, // 17844: decode to VMAXU_VX using decoder 139
9926 // 17844: }
9927 7, 8, // 17850: case 0x7: {
9928 OPC_CheckPredicate, 23, // 17852: check predicate 23
9929 OPC_Decode, 157, 129, 1, 139, 1, // 17854: decode to VMAX_VX using decoder 139
9930 // 17854: }
9931 9, 7, // 17860: case 0x9: {
9932 OPC_CheckPredicate, 23, // 17862: check predicate 23
9933 OPC_Decode, 172, 126, 139, 1, // 17864: decode to VAND_VX using decoder 139
9934 // 17864: }
9935 10, 8, // 17869: case 0xa: {
9936 OPC_CheckPredicate, 23, // 17871: check predicate 23
9937 OPC_Decode, 252, 129, 1, 139, 1, // 17873: decode to VOR_VX using decoder 139
9938 // 17873: }
9939 11, 8, // 17879: case 0xb: {
9940 OPC_CheckPredicate, 23, // 17881: check predicate 23
9941 OPC_Decode, 129, 132, 1, 139, 1, // 17883: decode to VXOR_VX using decoder 139
9942 // 17883: }
9943 12, 8, // 17889: case 0xc: {
9944 OPC_CheckPredicate, 23, // 17891: check predicate 23
9945 OPC_Decode, 149, 130, 1, 139, 1, // 17893: decode to VRGATHER_VX using decoder 139
9946 // 17893: }
9947 14, 8, // 17899: case 0xe: {
9948 OPC_CheckPredicate, 23, // 17901: check predicate 23
9949 OPC_Decode, 187, 130, 1, 139, 1, // 17903: decode to VSLIDEUP_VX using decoder 139
9950 // 17903: }
9951 15, 8, // 17909: case 0xf: {
9952 OPC_CheckPredicate, 23, // 17911: check predicate 23
9953 OPC_Decode, 185, 130, 1, 139, 1, // 17913: decode to VSLIDEDOWN_VX using decoder 139
9954 // 17913: }
9955 16, 11, // 17919: case 0x10: {
9956 OPC_CheckPredicate, 23, // 17921: check predicate 23
9957 OPC_CheckField, 25, 1, 0, // 17923: check Inst[25] == 0x0
9958 OPC_Decode, 153, 126, 140, 1, // 17927: decode to VADC_VXM using decoder 140
9959 // 17927: }
9960 17, 23, // 17932: case 0x11: {
9961 OPC_SwitchField, 25, 1, // 17934: switch Inst[25] {
9962 0, 8, // 17937: case 0x0: {
9963 OPC_CheckPredicate, 23, // 17939: check predicate 23
9964 OPC_Decode, 253, 128, 1, 140, 1, // 17941: decode to VMADC_VXM using decoder 140
9965 // 17941: }
9966 1, 0, // 17947: case 0x1: {
9967 OPC_CheckPredicate, 23, // 17949: check predicate 23
9968 OPC_Decode, 252, 128, 1, 141, 1, // 17951: decode to VMADC_VX using decoder 141
9969 // 17951: }
9970 // 17951: } // switch Inst[25]
9971 // 17951: }
9972 18, 12, // 17957: case 0x12: {
9973 OPC_CheckPredicate, 23, // 17959: check predicate 23
9974 OPC_CheckField, 25, 1, 0, // 17961: check Inst[25] == 0x0
9975 OPC_Decode, 168, 130, 1, 140, 1, // 17965: decode to VSBC_VXM using decoder 140
9976 // 17965: }
9977 19, 23, // 17971: case 0x13: {
9978 OPC_SwitchField, 25, 1, // 17973: switch Inst[25] {
9979 0, 8, // 17976: case 0x0: {
9980 OPC_CheckPredicate, 23, // 17978: check predicate 23
9981 OPC_Decode, 183, 129, 1, 140, 1, // 17980: decode to VMSBC_VXM using decoder 140
9982 // 17980: }
9983 1, 0, // 17986: case 0x1: {
9984 OPC_CheckPredicate, 23, // 17988: check predicate 23
9985 OPC_Decode, 182, 129, 1, 141, 1, // 17990: decode to VMSBC_VX using decoder 141
9986 // 17990: }
9987 // 17990: } // switch Inst[25]
9988 // 17990: }
9989 20, 8, // 17996: case 0x14: {
9990 OPC_CheckPredicate, 98, // 17998: check predicate 98
9991 OPC_Decode, 154, 130, 1, 139, 1, // 18000: decode to VROR_VX using decoder 139
9992 // 18000: }
9993 21, 8, // 18006: case 0x15: {
9994 OPC_CheckPredicate, 98, // 18008: check predicate 98
9995 OPC_Decode, 151, 130, 1, 139, 1, // 18010: decode to VROL_VX using decoder 139
9996 // 18010: }
9997 23, 26, // 18016: case 0x17: {
9998 OPC_SwitchField, 25, 1, // 18018: switch Inst[25] {
9999 0, 8, // 18021: case 0x0: {
10000 OPC_CheckPredicate, 23, // 18023: check predicate 23
10001 OPC_Decode, 160, 129, 1, 140, 1, // 18025: decode to VMERGE_VXM using decoder 140
10002 // 18025: }
10003 1, 0, // 18031: case 0x1: {
10004 OPC_CheckPredicate, 23, // 18033: check predicate 23
10005 OPC_CheckField, 20, 5, 0, // 18035: check Inst[24:20] == 0x0
10006 OPC_Decode, 226, 129, 1, 2, // 18039: decode to VMV_V_X using decoder 2
10007 // 18039: }
10008 // 18039: } // switch Inst[25]
10009 // 18039: }
10010 24, 8, // 18044: case 0x18: {
10011 OPC_CheckPredicate, 23, // 18046: check predicate 23
10012 OPC_Decode, 187, 129, 1, 139, 1, // 18048: decode to VMSEQ_VX using decoder 139
10013 // 18048: }
10014 25, 8, // 18054: case 0x19: {
10015 OPC_CheckPredicate, 23, // 18056: check predicate 23
10016 OPC_Decode, 205, 129, 1, 139, 1, // 18058: decode to VMSNE_VX using decoder 139
10017 // 18058: }
10018 26, 8, // 18064: case 0x1a: {
10019 OPC_CheckPredicate, 23, // 18066: check predicate 23
10020 OPC_Decode, 200, 129, 1, 139, 1, // 18068: decode to VMSLTU_VX using decoder 139
10021 // 18068: }
10022 27, 8, // 18074: case 0x1b: {
10023 OPC_CheckPredicate, 23, // 18076: check predicate 23
10024 OPC_Decode, 202, 129, 1, 139, 1, // 18078: decode to VMSLT_VX using decoder 139
10025 // 18078: }
10026 28, 8, // 18084: case 0x1c: {
10027 OPC_CheckPredicate, 23, // 18086: check predicate 23
10028 OPC_Decode, 195, 129, 1, 139, 1, // 18088: decode to VMSLEU_VX using decoder 139
10029 // 18088: }
10030 29, 8, // 18094: case 0x1d: {
10031 OPC_CheckPredicate, 23, // 18096: check predicate 23
10032 OPC_Decode, 198, 129, 1, 139, 1, // 18098: decode to VMSLE_VX using decoder 139
10033 // 18098: }
10034 30, 8, // 18104: case 0x1e: {
10035 OPC_CheckPredicate, 23, // 18106: check predicate 23
10036 OPC_Decode, 189, 129, 1, 139, 1, // 18108: decode to VMSGTU_VX using decoder 139
10037 // 18108: }
10038 31, 8, // 18114: case 0x1f: {
10039 OPC_CheckPredicate, 23, // 18116: check predicate 23
10040 OPC_Decode, 191, 129, 1, 139, 1, // 18118: decode to VMSGT_VX using decoder 139
10041 // 18118: }
10042 32, 8, // 18124: case 0x20: {
10043 OPC_CheckPredicate, 23, // 18126: check predicate 23
10044 OPC_Decode, 163, 130, 1, 139, 1, // 18128: decode to VSADDU_VX using decoder 139
10045 // 18128: }
10046 33, 8, // 18134: case 0x21: {
10047 OPC_CheckPredicate, 23, // 18136: check predicate 23
10048 OPC_Decode, 166, 130, 1, 139, 1, // 18138: decode to VSADD_VX using decoder 139
10049 // 18138: }
10050 34, 8, // 18144: case 0x22: {
10051 OPC_CheckPredicate, 23, // 18146: check predicate 23
10052 OPC_Decode, 176, 131, 1, 139, 1, // 18148: decode to VSSUBU_VX using decoder 139
10053 // 18148: }
10054 35, 8, // 18154: case 0x23: {
10055 OPC_CheckPredicate, 23, // 18156: check predicate 23
10056 OPC_Decode, 178, 131, 1, 139, 1, // 18158: decode to VSSUB_VX using decoder 139
10057 // 18158: }
10058 37, 8, // 18164: case 0x25: {
10059 OPC_CheckPredicate, 23, // 18166: check predicate 23
10060 OPC_Decode, 190, 130, 1, 139, 1, // 18168: decode to VSLL_VX using decoder 139
10061 // 18168: }
10062 39, 8, // 18174: case 0x27: {
10063 OPC_CheckPredicate, 23, // 18176: check predicate 23
10064 OPC_Decode, 197, 130, 1, 139, 1, // 18178: decode to VSMUL_VX using decoder 139
10065 // 18178: }
10066 40, 8, // 18184: case 0x28: {
10067 OPC_CheckPredicate, 23, // 18186: check predicate 23
10068 OPC_Decode, 236, 130, 1, 139, 1, // 18188: decode to VSRL_VX using decoder 139
10069 // 18188: }
10070 41, 8, // 18194: case 0x29: {
10071 OPC_CheckPredicate, 23, // 18196: check predicate 23
10072 OPC_Decode, 233, 130, 1, 139, 1, // 18198: decode to VSRA_VX using decoder 139
10073 // 18198: }
10074 42, 8, // 18204: case 0x2a: {
10075 OPC_CheckPredicate, 23, // 18206: check predicate 23
10076 OPC_Decode, 146, 131, 1, 139, 1, // 18208: decode to VSSRL_VX using decoder 139
10077 // 18208: }
10078 43, 8, // 18214: case 0x2b: {
10079 OPC_CheckPredicate, 23, // 18216: check predicate 23
10080 OPC_Decode, 143, 131, 1, 139, 1, // 18218: decode to VSSRA_VX using decoder 139
10081 // 18218: }
10082 44, 8, // 18224: case 0x2c: {
10083 OPC_CheckPredicate, 23, // 18226: check predicate 23
10084 OPC_Decode, 249, 129, 1, 139, 1, // 18228: decode to VNSRL_WX using decoder 139
10085 // 18228: }
10086 45, 8, // 18234: case 0x2d: {
10087 OPC_CheckPredicate, 23, // 18236: check predicate 23
10088 OPC_Decode, 246, 129, 1, 139, 1, // 18238: decode to VNSRA_WX using decoder 139
10089 // 18238: }
10090 46, 8, // 18244: case 0x2e: {
10091 OPC_CheckPredicate, 23, // 18246: check predicate 23
10092 OPC_Decode, 232, 129, 1, 139, 1, // 18248: decode to VNCLIPU_WX using decoder 139
10093 // 18248: }
10094 47, 8, // 18254: case 0x2f: {
10095 OPC_CheckPredicate, 23, // 18256: check predicate 23
10096 OPC_Decode, 235, 129, 1, 139, 1, // 18258: decode to VNCLIP_WX using decoder 139
10097 // 18258: }
10098 53, 8, // 18264: case 0x35: {
10099 OPC_CheckPredicate, 100, // 18266: check predicate 100
10100 OPC_Decode, 246, 131, 1, 139, 1, // 18268: decode to VWSLL_VX using decoder 139
10101 // 18268: }
10102 61, 8, // 18274: case 0x3d: {
10103 OPC_CheckPredicate, 103, // 18276: check predicate 103
10104 OPC_Decode, 219, 131, 1, 142, 1, // 18278: decode to VWABDA_VX using decoder 142
10105 // 18278: }
10106 62, 0, // 18284: case 0x3e: {
10107 OPC_CheckPredicate, 103, // 18286: check predicate 103
10108 OPC_Decode, 217, 131, 1, 142, 1, // 18288: decode to VWABDAU_VX using decoder 142
10109 // 18288: }
10110 // 18288: } // switch Inst[31:26]
10111 // 18288: }
10112 5, 254, 2, // 18294: case 0x5: {
10113 OPC_SwitchField, 26, 6, // 18297: switch Inst[31:26] {
10114 0, 7, // 18300: case 0x0: {
10115 OPC_CheckPredicate, 104, // 18302: check predicate 104
10116 OPC_Decode, 202, 126, 143, 1, // 18304: decode to VFADD_VF using decoder 143
10117 // 18304: }
10118 2, 7, // 18309: case 0x2: {
10119 OPC_CheckPredicate, 104, // 18311: check predicate 104
10120 OPC_Decode, 150, 127, 143, 1, // 18313: decode to VFSUB_VF using decoder 143
10121 // 18313: }
10122 4, 7, // 18318: case 0x4: {
10123 OPC_CheckPredicate, 104, // 18320: check predicate 104
10124 OPC_Decode, 222, 126, 143, 1, // 18322: decode to VFMIN_VF using decoder 143
10125 // 18322: }
10126 6, 7, // 18327: case 0x6: {
10127 OPC_CheckPredicate, 104, // 18329: check predicate 104
10128 OPC_Decode, 219, 126, 143, 1, // 18331: decode to VFMAX_VF using decoder 143
10129 // 18331: }
10130 8, 7, // 18336: case 0x8: {
10131 OPC_CheckPredicate, 104, // 18338: check predicate 104
10132 OPC_Decode, 145, 127, 143, 1, // 18340: decode to VFSGNJ_VF using decoder 143
10133 // 18340: }
10134 9, 7, // 18345: case 0x9: {
10135 OPC_CheckPredicate, 104, // 18347: check predicate 104
10136 OPC_Decode, 141, 127, 143, 1, // 18349: decode to VFSGNJN_VF using decoder 143
10137 // 18349: }
10138 10, 7, // 18354: case 0xa: {
10139 OPC_CheckPredicate, 104, // 18356: check predicate 104
10140 OPC_Decode, 143, 127, 143, 1, // 18358: decode to VFSGNJX_VF using decoder 143
10141 // 18358: }
10142 14, 7, // 18363: case 0xe: {
10143 OPC_CheckPredicate, 104, // 18365: check predicate 104
10144 OPC_Decode, 148, 127, 143, 1, // 18367: decode to VFSLIDE1UP_VF using decoder 143
10145 // 18367: }
10146 15, 7, // 18372: case 0xf: {
10147 OPC_CheckPredicate, 104, // 18374: check predicate 104
10148 OPC_Decode, 147, 127, 143, 1, // 18376: decode to VFSLIDE1DOWN_VF using decoder 143
10149 // 18376: }
10150 16, 11, // 18381: case 0x10: {
10151 OPC_CheckPredicate, 104, // 18383: check predicate 104
10152 OPC_CheckField, 20, 6, 32, // 18385: check Inst[25:20] == 0x20
10153 OPC_Decode, 232, 126, 144, 1, // 18389: decode to VFMV_S_F using decoder 144
10154 // 18389: }
10155 23, 25, // 18394: case 0x17: {
10156 OPC_SwitchField, 25, 1, // 18396: switch Inst[25] {
10157 0, 7, // 18399: case 0x0: {
10158 OPC_CheckPredicate, 104, // 18401: check predicate 104
10159 OPC_Decode, 221, 126, 145, 1, // 18403: decode to VFMERGE_VFM using decoder 145
10160 // 18403: }
10161 1, 0, // 18408: case 0x1: {
10162 OPC_CheckPredicate, 104, // 18410: check predicate 104
10163 OPC_CheckField, 20, 5, 0, // 18412: check Inst[24:20] == 0x0
10164 OPC_Decode, 233, 126, 146, 1, // 18416: decode to VFMV_V_F using decoder 146
10165 // 18416: }
10166 // 18416: } // switch Inst[25]
10167 // 18416: }
10168 24, 8, // 18421: case 0x18: {
10169 OPC_CheckPredicate, 104, // 18423: check predicate 104
10170 OPC_Decode, 161, 129, 1, 143, 1, // 18425: decode to VMFEQ_VF using decoder 143
10171 // 18425: }
10172 25, 8, // 18431: case 0x19: {
10173 OPC_CheckPredicate, 104, // 18433: check predicate 104
10174 OPC_Decode, 165, 129, 1, 143, 1, // 18435: decode to VMFLE_VF using decoder 143
10175 // 18435: }
10176 27, 8, // 18441: case 0x1b: {
10177 OPC_CheckPredicate, 104, // 18443: check predicate 104
10178 OPC_Decode, 167, 129, 1, 143, 1, // 18445: decode to VMFLT_VF using decoder 143
10179 // 18445: }
10180 28, 8, // 18451: case 0x1c: {
10181 OPC_CheckPredicate, 104, // 18453: check predicate 104
10182 OPC_Decode, 169, 129, 1, 143, 1, // 18455: decode to VMFNE_VF using decoder 143
10183 // 18455: }
10184 29, 8, // 18461: case 0x1d: {
10185 OPC_CheckPredicate, 104, // 18463: check predicate 104
10186 OPC_Decode, 164, 129, 1, 143, 1, // 18465: decode to VMFGT_VF using decoder 143
10187 // 18465: }
10188 31, 8, // 18471: case 0x1f: {
10189 OPC_CheckPredicate, 104, // 18473: check predicate 104
10190 OPC_Decode, 163, 129, 1, 143, 1, // 18475: decode to VMFGE_VF using decoder 143
10191 // 18475: }
10192 32, 7, // 18481: case 0x20: {
10193 OPC_CheckPredicate, 104, // 18483: check predicate 104
10194 OPC_Decode, 212, 126, 143, 1, // 18485: decode to VFDIV_VF using decoder 143
10195 // 18485: }
10196 33, 7, // 18490: case 0x21: {
10197 OPC_CheckPredicate, 104, // 18492: check predicate 104
10198 OPC_Decode, 133, 127, 143, 1, // 18494: decode to VFRDIV_VF using decoder 143
10199 // 18494: }
10200 36, 7, // 18499: case 0x24: {
10201 OPC_CheckPredicate, 104, // 18501: check predicate 104
10202 OPC_Decode, 229, 126, 143, 1, // 18503: decode to VFMUL_VF using decoder 143
10203 // 18503: }
10204 39, 7, // 18508: case 0x27: {
10205 OPC_CheckPredicate, 104, // 18510: check predicate 104
10206 OPC_Decode, 140, 127, 143, 1, // 18512: decode to VFRSUB_VF using decoder 143
10207 // 18512: }
10208 40, 7, // 18517: case 0x28: {
10209 OPC_CheckPredicate, 104, // 18519: check predicate 104
10210 OPC_Decode, 217, 126, 147, 1, // 18521: decode to VFMADD_VF using decoder 147
10211 // 18521: }
10212 41, 7, // 18526: case 0x29: {
10213 OPC_CheckPredicate, 104, // 18528: check predicate 104
10214 OPC_Decode, 248, 126, 147, 1, // 18530: decode to VFNMADD_VF using decoder 147
10215 // 18530: }
10216 42, 7, // 18535: case 0x2a: {
10217 OPC_CheckPredicate, 104, // 18537: check predicate 104
10218 OPC_Decode, 227, 126, 147, 1, // 18539: decode to VFMSUB_VF using decoder 147
10219 // 18539: }
10220 43, 7, // 18544: case 0x2b: {
10221 OPC_CheckPredicate, 104, // 18546: check predicate 104
10222 OPC_Decode, 252, 126, 147, 1, // 18548: decode to VFNMSUB_VF using decoder 147
10223 // 18548: }
10224 44, 7, // 18553: case 0x2c: {
10225 OPC_CheckPredicate, 104, // 18555: check predicate 104
10226 OPC_Decode, 215, 126, 147, 1, // 18557: decode to VFMACC_VF using decoder 147
10227 // 18557: }
10228 45, 7, // 18562: case 0x2d: {
10229 OPC_CheckPredicate, 104, // 18564: check predicate 104
10230 OPC_Decode, 246, 126, 147, 1, // 18566: decode to VFNMACC_VF using decoder 147
10231 // 18566: }
10232 46, 7, // 18571: case 0x2e: {
10233 OPC_CheckPredicate, 104, // 18573: check predicate 104
10234 OPC_Decode, 225, 126, 147, 1, // 18575: decode to VFMSAC_VF using decoder 147
10235 // 18575: }
10236 47, 7, // 18580: case 0x2f: {
10237 OPC_CheckPredicate, 104, // 18582: check predicate 104
10238 OPC_Decode, 250, 126, 147, 1, // 18584: decode to VFNMSAC_VF using decoder 147
10239 // 18584: }
10240 48, 7, // 18589: case 0x30: {
10241 OPC_CheckPredicate, 104, // 18591: check predicate 104
10242 OPC_Decode, 152, 127, 143, 1, // 18593: decode to VFWADD_VF using decoder 143
10243 // 18593: }
10244 50, 7, // 18598: case 0x32: {
10245 OPC_CheckPredicate, 104, // 18600: check predicate 104
10246 OPC_Decode, 187, 127, 143, 1, // 18602: decode to VFWSUB_VF using decoder 143
10247 // 18602: }
10248 52, 7, // 18607: case 0x34: {
10249 OPC_CheckPredicate, 104, // 18609: check predicate 104
10250 OPC_Decode, 154, 127, 143, 1, // 18611: decode to VFWADD_WF using decoder 143
10251 // 18611: }
10252 54, 7, // 18616: case 0x36: {
10253 OPC_CheckPredicate, 104, // 18618: check predicate 104
10254 OPC_Decode, 189, 127, 143, 1, // 18620: decode to VFWSUB_WF using decoder 143
10255 // 18620: }
10256 56, 7, // 18625: case 0x38: {
10257 OPC_CheckPredicate, 104, // 18627: check predicate 104
10258 OPC_Decode, 179, 127, 143, 1, // 18629: decode to VFWMUL_VF using decoder 143
10259 // 18629: }
10260 59, 7, // 18634: case 0x3b: {
10261 OPC_CheckPredicate, 107, // 18636: check predicate 107
10262 OPC_Decode, 167, 127, 147, 1, // 18638: decode to VFWMACCBF16_VF using decoder 147
10263 // 18638: }
10264 60, 7, // 18643: case 0x3c: {
10265 OPC_CheckPredicate, 104, // 18645: check predicate 104
10266 OPC_Decode, 169, 127, 147, 1, // 18647: decode to VFWMACC_VF using decoder 147
10267 // 18647: }
10268 61, 7, // 18652: case 0x3d: {
10269 OPC_CheckPredicate, 104, // 18654: check predicate 104
10270 OPC_Decode, 181, 127, 147, 1, // 18656: decode to VFWNMACC_VF using decoder 147
10271 // 18656: }
10272 62, 7, // 18661: case 0x3e: {
10273 OPC_CheckPredicate, 104, // 18663: check predicate 104
10274 OPC_Decode, 177, 127, 147, 1, // 18665: decode to VFWMSAC_VF using decoder 147
10275 // 18665: }
10276 63, 0, // 18670: case 0x3f: {
10277 OPC_CheckPredicate, 104, // 18672: check predicate 104
10278 OPC_Decode, 183, 127, 147, 1, // 18674: decode to VFWNMSAC_VF using decoder 147
10279 // 18674: }
10280 // 18674: } // switch Inst[31:26]
10281 // 18674: }
10282 6, 157, 3, // 18679: case 0x6: {
10283 OPC_SwitchField, 26, 6, // 18682: switch Inst[31:26] {
10284 8, 7, // 18685: case 0x8: {
10285 OPC_CheckPredicate, 23, // 18687: check predicate 23
10286 OPC_Decode, 144, 126, 139, 1, // 18689: decode to VAADDU_VX using decoder 139
10287 // 18689: }
10288 9, 7, // 18694: case 0x9: {
10289 OPC_CheckPredicate, 23, // 18696: check predicate 23
10290 OPC_Decode, 146, 126, 139, 1, // 18698: decode to VAADD_VX using decoder 139
10291 // 18698: }
10292 10, 7, // 18703: case 0xa: {
10293 OPC_CheckPredicate, 23, // 18705: check predicate 23
10294 OPC_Decode, 174, 126, 139, 1, // 18707: decode to VASUBU_VX using decoder 139
10295 // 18707: }
10296 11, 7, // 18712: case 0xb: {
10297 OPC_CheckPredicate, 23, // 18714: check predicate 23
10298 OPC_Decode, 176, 126, 139, 1, // 18716: decode to VASUB_VX using decoder 139
10299 // 18716: }
10300 12, 7, // 18721: case 0xc: {
10301 OPC_CheckPredicate, 108, // 18723: check predicate 108
10302 OPC_Decode, 182, 126, 139, 1, // 18725: decode to VCLMUL_VX using decoder 139
10303 // 18725: }
10304 13, 7, // 18730: case 0xd: {
10305 OPC_CheckPredicate, 108, // 18732: check predicate 108
10306 OPC_Decode, 180, 126, 139, 1, // 18734: decode to VCLMULH_VX using decoder 139
10307 // 18734: }
10308 14, 8, // 18739: case 0xe: {
10309 OPC_CheckPredicate, 23, // 18741: check predicate 23
10310 OPC_Decode, 183, 130, 1, 139, 1, // 18743: decode to VSLIDE1UP_VX using decoder 139
10311 // 18743: }
10312 15, 8, // 18749: case 0xf: {
10313 OPC_CheckPredicate, 23, // 18751: check predicate 23
10314 OPC_Decode, 182, 130, 1, 139, 1, // 18753: decode to VSLIDE1DOWN_VX using decoder 139
10315 // 18753: }
10316 16, 12, // 18759: case 0x10: {
10317 OPC_CheckPredicate, 23, // 18761: check predicate 23
10318 OPC_CheckField, 20, 6, 32, // 18763: check Inst[25:20] == 0x20
10319 OPC_Decode, 223, 129, 1, 148, 1, // 18767: decode to VMV_S_X using decoder 148
10320 // 18767: }
10321 21, 7, // 18773: case 0x15: {
10322 OPC_CheckPredicate, 103, // 18775: check predicate 103
10323 OPC_Decode, 150, 126, 139, 1, // 18777: decode to VABD_VX using decoder 139
10324 // 18777: }
10325 22, 7, // 18782: case 0x16: {
10326 OPC_CheckPredicate, 103, // 18784: check predicate 103
10327 OPC_Decode, 148, 126, 139, 1, // 18786: decode to VABDU_VX using decoder 139
10328 // 18786: }
10329 32, 7, // 18791: case 0x20: {
10330 OPC_CheckPredicate, 23, // 18793: check predicate 23
10331 OPC_Decode, 189, 126, 139, 1, // 18795: decode to VDIVU_VX using decoder 139
10332 // 18795: }
10333 33, 7, // 18800: case 0x21: {
10334 OPC_CheckPredicate, 23, // 18802: check predicate 23
10335 OPC_Decode, 191, 126, 139, 1, // 18804: decode to VDIV_VX using decoder 139
10336 // 18804: }
10337 34, 8, // 18809: case 0x22: {
10338 OPC_CheckPredicate, 23, // 18811: check predicate 23
10339 OPC_Decode, 142, 130, 1, 139, 1, // 18813: decode to VREMU_VX using decoder 139
10340 // 18813: }
10341 35, 8, // 18819: case 0x23: {
10342 OPC_CheckPredicate, 23, // 18821: check predicate 23
10343 OPC_Decode, 144, 130, 1, 139, 1, // 18823: decode to VREM_VX using decoder 139
10344 // 18823: }
10345 36, 8, // 18829: case 0x24: {
10346 OPC_CheckPredicate, 23, // 18831: check predicate 23
10347 OPC_Decode, 214, 129, 1, 139, 1, // 18833: decode to VMULHU_VX using decoder 139
10348 // 18833: }
10349 37, 8, // 18839: case 0x25: {
10350 OPC_CheckPredicate, 23, // 18841: check predicate 23
10351 OPC_Decode, 218, 129, 1, 139, 1, // 18843: decode to VMUL_VX using decoder 139
10352 // 18843: }
10353 38, 8, // 18849: case 0x26: {
10354 OPC_CheckPredicate, 23, // 18851: check predicate 23
10355 OPC_Decode, 212, 129, 1, 139, 1, // 18853: decode to VMULHSU_VX using decoder 139
10356 // 18853: }
10357 39, 8, // 18859: case 0x27: {
10358 OPC_CheckPredicate, 23, // 18861: check predicate 23
10359 OPC_Decode, 216, 129, 1, 139, 1, // 18863: decode to VMULH_VX using decoder 139
10360 // 18863: }
10361 40, 7, // 18869: case 0x28: {
10362 OPC_CheckPredicate, 109, // 18871: check predicate 109
10363 OPC_Decode, 196, 126, 142, 1, // 18873: decode to VDOT4AU_VX using decoder 142
10364 // 18873: }
10365 41, 8, // 18878: case 0x29: {
10366 OPC_CheckPredicate, 23, // 18880: check predicate 23
10367 OPC_Decode, 255, 128, 1, 149, 1, // 18882: decode to VMADD_VX using decoder 149
10368 // 18882: }
10369 42, 7, // 18888: case 0x2a: {
10370 OPC_CheckPredicate, 109, // 18890: check predicate 109
10371 OPC_Decode, 193, 126, 142, 1, // 18892: decode to VDOT4ASU_VX using decoder 142
10372 // 18892: }
10373 43, 8, // 18897: case 0x2b: {
10374 OPC_CheckPredicate, 23, // 18899: check predicate 23
10375 OPC_Decode, 239, 129, 1, 149, 1, // 18901: decode to VNMSUB_VX using decoder 149
10376 // 18901: }
10377 44, 7, // 18907: case 0x2c: {
10378 OPC_CheckPredicate, 109, // 18909: check predicate 109
10379 OPC_Decode, 198, 126, 142, 1, // 18911: decode to VDOT4A_VX using decoder 142
10380 // 18911: }
10381 45, 8, // 18916: case 0x2d: {
10382 OPC_CheckPredicate, 23, // 18918: check predicate 23
10383 OPC_Decode, 247, 128, 1, 149, 1, // 18920: decode to VMACC_VX using decoder 149
10384 // 18920: }
10385 46, 7, // 18926: case 0x2e: {
10386 OPC_CheckPredicate, 109, // 18928: check predicate 109
10387 OPC_Decode, 194, 126, 142, 1, // 18930: decode to VDOT4AUS_VX using decoder 142
10388 // 18930: }
10389 47, 8, // 18935: case 0x2f: {
10390 OPC_CheckPredicate, 23, // 18937: check predicate 23
10391 OPC_Decode, 237, 129, 1, 149, 1, // 18939: decode to VNMSAC_VX using decoder 149
10392 // 18939: }
10393 48, 8, // 18945: case 0x30: {
10394 OPC_CheckPredicate, 23, // 18947: check predicate 23
10395 OPC_Decode, 221, 131, 1, 139, 1, // 18949: decode to VWADDU_VX using decoder 139
10396 // 18949: }
10397 49, 8, // 18955: case 0x31: {
10398 OPC_CheckPredicate, 23, // 18957: check predicate 23
10399 OPC_Decode, 225, 131, 1, 139, 1, // 18959: decode to VWADD_VX using decoder 139
10400 // 18959: }
10401 50, 8, // 18965: case 0x32: {
10402 OPC_CheckPredicate, 23, // 18967: check predicate 23
10403 OPC_Decode, 248, 131, 1, 139, 1, // 18969: decode to VWSUBU_VX using decoder 139
10404 // 18969: }
10405 51, 8, // 18975: case 0x33: {
10406 OPC_CheckPredicate, 23, // 18977: check predicate 23
10407 OPC_Decode, 252, 131, 1, 139, 1, // 18979: decode to VWSUB_VX using decoder 139
10408 // 18979: }
10409 52, 8, // 18985: case 0x34: {
10410 OPC_CheckPredicate, 23, // 18987: check predicate 23
10411 OPC_Decode, 223, 131, 1, 139, 1, // 18989: decode to VWADDU_WX using decoder 139
10412 // 18989: }
10413 53, 8, // 18995: case 0x35: {
10414 OPC_CheckPredicate, 23, // 18997: check predicate 23
10415 OPC_Decode, 227, 131, 1, 139, 1, // 18999: decode to VWADD_WX using decoder 139
10416 // 18999: }
10417 54, 8, // 19005: case 0x36: {
10418 OPC_CheckPredicate, 23, // 19007: check predicate 23
10419 OPC_Decode, 250, 131, 1, 139, 1, // 19009: decode to VWSUBU_WX using decoder 139
10420 // 19009: }
10421 55, 8, // 19015: case 0x37: {
10422 OPC_CheckPredicate, 23, // 19017: check predicate 23
10423 OPC_Decode, 254, 131, 1, 139, 1, // 19019: decode to VWSUB_WX using decoder 139
10424 // 19019: }
10425 56, 8, // 19025: case 0x38: {
10426 OPC_CheckPredicate, 23, // 19027: check predicate 23
10427 OPC_Decode, 239, 131, 1, 139, 1, // 19029: decode to VWMULU_VX using decoder 139
10428 // 19029: }
10429 58, 8, // 19035: case 0x3a: {
10430 OPC_CheckPredicate, 23, // 19037: check predicate 23
10431 OPC_Decode, 237, 131, 1, 139, 1, // 19039: decode to VWMULSU_VX using decoder 139
10432 // 19039: }
10433 59, 8, // 19045: case 0x3b: {
10434 OPC_CheckPredicate, 23, // 19047: check predicate 23
10435 OPC_Decode, 241, 131, 1, 139, 1, // 19049: decode to VWMUL_VX using decoder 139
10436 // 19049: }
10437 60, 8, // 19055: case 0x3c: {
10438 OPC_CheckPredicate, 23, // 19057: check predicate 23
10439 OPC_Decode, 232, 131, 1, 149, 1, // 19059: decode to VWMACCU_VX using decoder 149
10440 // 19059: }
10441 61, 8, // 19065: case 0x3d: {
10442 OPC_CheckPredicate, 23, // 19067: check predicate 23
10443 OPC_Decode, 234, 131, 1, 149, 1, // 19069: decode to VWMACC_VX using decoder 149
10444 // 19069: }
10445 62, 8, // 19075: case 0x3e: {
10446 OPC_CheckPredicate, 23, // 19077: check predicate 23
10447 OPC_Decode, 230, 131, 1, 149, 1, // 19079: decode to VWMACCUS_VX using decoder 149
10448 // 19079: }
10449 63, 0, // 19085: case 0x3f: {
10450 OPC_CheckPredicate, 23, // 19087: check predicate 23
10451 OPC_Decode, 229, 131, 1, 149, 1, // 19089: decode to VWMACCSU_VX using decoder 149
10452 // 19089: }
10453 // 19089: } // switch Inst[31:26]
10454 // 19089: }
10455 7, 0, // 19095: case 0x7: {
10456 OPC_SwitchField, 31, 1, // 19097: switch Inst[31] {
10457 0, 8, // 19100: case 0x0: {
10458 OPC_CheckPredicate, 23, // 19102: check predicate 23
10459 OPC_Decode, 175, 130, 1, 150, 1, // 19104: decode to VSETVLI using decoder 150
10460 // 19104: }
10461 1, 0, // 19110: case 0x1: {
10462 OPC_SwitchField, 30, 1, // 19112: switch Inst[30] {
10463 0, 11, // 19115: case 0x0: {
10464 OPC_CheckPredicate, 23, // 19117: check predicate 23
10465 OPC_CheckField, 25, 5, 0, // 19119: check Inst[29:25] == 0x0
10466 OPC_Decode, 174, 130, 1, 31, // 19123: decode to VSETVL using decoder 31
10467 // 19123: }
10468 1, 0, // 19128: case 0x1: {
10469 OPC_CheckPredicate, 23, // 19130: check predicate 23
10470 OPC_Decode, 173, 130, 1, 151, 1, // 19132: decode to VSETIVLI using decoder 151
10471 // 19132: }
10472 // 19132: } // switch Inst[30]
10473 // 19132: }
10474 // 19132: } // switch Inst[31]
10475 // 19132: }
10476 // 19132: } // switch Inst[14:12]
10477 // 19132: }
10478 99, 63, // 19138: case 0x63: {
10479 OPC_SwitchField, 12, 3, // 19140: switch Inst[14:12] {
10480 0, 5, // 19143: case 0x0: {
10481 OPC_Decode, 225, 110, 152, 1, // 19145: decode to BEQ using decoder 152
10482 // 19145: }
10483 1, 5, // 19150: case 0x1: {
10484 OPC_Decode, 235, 110, 152, 1, // 19152: decode to BNE using decoder 152
10485 // 19152: }
10486 2, 7, // 19157: case 0x2: {
10487 OPC_CheckPredicate, 110, // 19159: check predicate 110
10488 OPC_Decode, 226, 110, 153, 1, // 19161: decode to BEQI using decoder 153
10489 // 19161: }
10490 3, 7, // 19166: case 0x3: {
10491 OPC_CheckPredicate, 110, // 19168: check predicate 110
10492 OPC_Decode, 236, 110, 153, 1, // 19170: decode to BNEI using decoder 153
10493 // 19170: }
10494 4, 5, // 19175: case 0x4: {
10495 OPC_Decode, 233, 110, 152, 1, // 19177: decode to BLT using decoder 152
10496 // 19177: }
10497 5, 5, // 19182: case 0x5: {
10498 OPC_Decode, 229, 110, 152, 1, // 19184: decode to BGE using decoder 152
10499 // 19184: }
10500 6, 5, // 19189: case 0x6: {
10501 OPC_Decode, 234, 110, 152, 1, // 19191: decode to BLTU using decoder 152
10502 // 19191: }
10503 7, 0, // 19196: case 0x7: {
10504 OPC_Decode, 230, 110, 152, 1, // 19198: decode to BGEU using decoder 152
10505 // 19198: }
10506 // 19198: } // switch Inst[14:12]
10507 // 19198: }
10508 103, 8, // 19203: case 0x67: {
10509 OPC_CheckField, 12, 3, 0, // 19205: check Inst[14:12] == 0x0
10510 OPC_Decode, 220, 116, 0, // 19209: decode to JALR using decoder 0
10511 // 19209: }
10512 111, 5, // 19213: case 0x6f: {
10513 OPC_Decode, 219, 116, 154, 1, // 19215: decode to JAL using decoder 154
10514 // 19215: }
10515 115, 173, 7, // 19220: case 0x73: {
10516 OPC_SwitchField, 12, 3, // 19223: switch Inst[14:12] {
10517 0, 201, 2, // 19226: case 0x0: {
10518 OPC_SwitchField, 25, 7, // 19229: switch Inst[31:25] {
10519 0, 51, // 19232: case 0x0: {
10520 OPC_SwitchField, 15, 10, // 19234: switch Inst[24:15] {
10521 0, 8, // 19237: case 0x0: {
10522 OPC_CheckField, 7, 5, 0, // 19239: check Inst[11:7] == 0x0
10523 OPC_Decode, 151, 114, 14, // 19243: decode to ECALL using decoder 14
10524 // 19243: }
10525 32, 8, // 19247: case 0x20: {
10526 OPC_CheckField, 7, 5, 0, // 19249: check Inst[11:7] == 0x0
10527 OPC_Decode, 150, 114, 14, // 19253: decode to EBREAK using decoder 14
10528 // 19253: }
10529 160, 3, 11, // 19257: case 0x1a0: {
10530 OPC_CheckPredicate, 111, // 19260: check predicate 111
10531 OPC_CheckField, 7, 5, 0, // 19262: check Inst[11:7] == 0x0
10532 OPC_Decode, 145, 132, 1, 14, // 19266: decode to WRS_NTO using decoder 14
10533 // 19266: }
10534 160, 7, 0, // 19271: case 0x3a0: {
10535 OPC_CheckPredicate, 111, // 19274: check predicate 111
10536 OPC_CheckField, 7, 5, 0, // 19276: check Inst[11:7] == 0x0
10537 OPC_Decode, 146, 132, 1, 14, // 19280: decode to WRS_STO using decoder 14
10538 // 19280: }
10539 // 19280: } // switch Inst[24:15]
10540 // 19280: }
10541 8, 82, // 19285: case 0x8: {
10542 OPC_SwitchField, 20, 5, // 19287: switch Inst[24:20] {
10543 2, 12, // 19290: case 0x2: {
10544 OPC_CheckField, 15, 5, 0, // 19292: check Inst[19:15] == 0x0
10545 OPC_CheckField, 7, 5, 0, // 19296: check Inst[11:7] == 0x0
10546 OPC_Decode, 249, 124, 14, // 19300: decode to SRET using decoder 14
10547 // 19300: }
10548 4, 14, // 19304: case 0x4: {
10549 OPC_CheckPredicate, 112, // 19306: check predicate 112
10550 OPC_CheckField, 15, 5, 0, // 19308: check Inst[19:15] == 0x0
10551 OPC_CheckField, 7, 5, 0, // 19312: check Inst[11:7] == 0x0
10552 OPC_Decode, 225, 123, 14, // 19316: decode to SCTRCLR using decoder 14
10553 // 19316: }
10554 5, 13, // 19320: case 0x5: {
10555 OPC_CheckField, 15, 5, 0, // 19322: check Inst[19:15] == 0x0
10556 OPC_CheckField, 7, 5, 0, // 19326: check Inst[11:7] == 0x0
10557 OPC_Decode, 138, 132, 1, 14, // 19330: decode to WFI using decoder 14
10558 // 19330: }
10559 8, 14, // 19335: case 0x8: {
10560 OPC_CheckPredicate, 113, // 19337: check predicate 113
10561 OPC_CheckField, 15, 5, 0, // 19339: check Inst[19:15] == 0x0
10562 OPC_CheckField, 7, 5, 0, // 19343: check Inst[11:7] == 0x0
10563 OPC_Decode, 212, 124, 14, // 19347: decode to SIPOPRET using decoder 14
10564 // 19347: }
10565 9, 7, // 19351: case 0x9: {
10566 OPC_CheckPredicate, 114, // 19353: check predicate 114
10567 OPC_Decode, 224, 123, 155, 1, // 19355: decode to SCSPSPUSH using decoder 155
10568 // 19355: }
10569 12, 0, // 19360: case 0xc: {
10570 OPC_CheckPredicate, 114, // 19362: check predicate 114
10571 OPC_Decode, 223, 123, 155, 1, // 19364: decode to SCSPSPOP using decoder 155
10572 // 19364: }
10573 // 19364: } // switch Inst[24:20]
10574 // 19364: }
10575 9, 9, // 19369: case 0x9: {
10576 OPC_CheckField, 7, 5, 0, // 19371: check Inst[11:7] == 0x0
10577 OPC_Decode, 241, 123, 156, 1, // 19375: decode to SFENCE_VMA using decoder 156
10578 // 19375: }
10579 11, 11, // 19380: case 0xb: {
10580 OPC_CheckPredicate, 115, // 19382: check predicate 115
10581 OPC_CheckField, 7, 5, 0, // 19384: check Inst[11:7] == 0x0
10582 OPC_Decode, 211, 124, 156, 1, // 19388: decode to SINVAL_VMA using decoder 156
10583 // 19388: }
10584 12, 27, // 19393: case 0xc: {
10585 OPC_SwitchField, 15, 10, // 19395: switch Inst[24:15] {
10586 0, 10, // 19398: case 0x0: {
10587 OPC_CheckPredicate, 115, // 19400: check predicate 115
10588 OPC_CheckField, 7, 5, 0, // 19402: check Inst[11:7] == 0x0
10589 OPC_Decode, 242, 123, 14, // 19406: decode to SFENCE_W_INVAL using decoder 14
10590 // 19406: }
10591 32, 0, // 19410: case 0x20: {
10592 OPC_CheckPredicate, 115, // 19412: check predicate 115
10593 OPC_CheckField, 7, 5, 0, // 19414: check Inst[11:7] == 0x0
10594 OPC_Decode, 240, 123, 14, // 19418: decode to SFENCE_INVAL_IR using decoder 14
10595 // 19418: }
10596 // 19418: } // switch Inst[24:15]
10597 // 19418: }
10598 17, 11, // 19422: case 0x11: {
10599 OPC_CheckPredicate, 116, // 19424: check predicate 116
10600 OPC_CheckField, 7, 5, 0, // 19426: check Inst[11:7] == 0x0
10601 OPC_Decode, 176, 116, 156, 1, // 19430: decode to HFENCE_VVMA using decoder 156
10602 // 19430: }
10603 19, 11, // 19435: case 0x13: {
10604 OPC_CheckPredicate, 117, // 19437: check predicate 117
10605 OPC_CheckField, 7, 5, 0, // 19439: check Inst[11:7] == 0x0
10606 OPC_Decode, 178, 116, 156, 1, // 19443: decode to HINVAL_VVMA using decoder 156
10607 // 19443: }
10608 24, 51, // 19448: case 0x18: {
10609 OPC_SwitchField, 20, 5, // 19450: switch Inst[24:20] {
10610 2, 12, // 19453: case 0x2: {
10611 OPC_CheckField, 15, 5, 0, // 19455: check Inst[19:15] == 0x0
10612 OPC_CheckField, 7, 5, 0, // 19459: check Inst[11:7] == 0x0
10613 OPC_Decode, 237, 117, 14, // 19463: decode to MRET using decoder 14
10614 // 19463: }
10615 8, 14, // 19467: case 0x8: {
10616 OPC_CheckPredicate, 118, // 19469: check predicate 118
10617 OPC_CheckField, 15, 5, 0, // 19471: check Inst[19:15] == 0x0
10618 OPC_CheckField, 7, 5, 0, // 19475: check Inst[11:7] == 0x0
10619 OPC_Decode, 172, 117, 14, // 19479: decode to MIPOPRET using decoder 14
10620 // 19479: }
10621 9, 7, // 19483: case 0x9: {
10622 OPC_CheckPredicate, 119, // 19485: check predicate 119
10623 OPC_Decode, 158, 117, 155, 1, // 19487: decode to MCSPSPUSH using decoder 155
10624 // 19487: }
10625 12, 0, // 19492: case 0xc: {
10626 OPC_CheckPredicate, 119, // 19494: check predicate 119
10627 OPC_Decode, 157, 117, 155, 1, // 19496: decode to MCSPSPOP using decoder 155
10628 // 19496: }
10629 // 19496: } // switch Inst[24:20]
10630 // 19496: }
10631 49, 11, // 19501: case 0x31: {
10632 OPC_CheckPredicate, 116, // 19503: check predicate 116
10633 OPC_CheckField, 7, 5, 0, // 19505: check Inst[11:7] == 0x0
10634 OPC_Decode, 175, 116, 156, 1, // 19509: decode to HFENCE_GVMA using decoder 156
10635 // 19509: }
10636 51, 11, // 19514: case 0x33: {
10637 OPC_CheckPredicate, 117, // 19516: check predicate 117
10638 OPC_CheckField, 7, 5, 0, // 19518: check Inst[11:7] == 0x0
10639 OPC_Decode, 177, 116, 156, 1, // 19522: decode to HINVAL_GVMA using decoder 156
10640 // 19522: }
10641 56, 14, // 19527: case 0x38: {
10642 OPC_CheckPredicate, 120, // 19529: check predicate 120
10643 OPC_CheckField, 15, 10, 64, // 19531: check Inst[24:15] == 0x40
10644 OPC_CheckField, 7, 5, 0, // 19535: check Inst[11:7] == 0x0
10645 OPC_Decode, 182, 117, 14, // 19539: decode to MNRET using decoder 14
10646 // 19539: }
10647 61, 0, // 19543: case 0x3d: {
10648 OPC_CheckField, 15, 10, 192, 4, // 19545: check Inst[24:15] == 0x240
10649 OPC_CheckField, 7, 5, 0, // 19550: check Inst[11:7] == 0x0
10650 OPC_Decode, 149, 114, 14, // 19554: decode to DRET using decoder 14
10651 // 19554: }
10652 // 19554: } // switch Inst[31:25]
10653 // 19554: }
10654 1, 21, // 19558: case 0x1: {
10655 OPC_Scope, 14, // 19560: try {
10656 OPC_CheckField, 7, 5, 0, // 19562: check Inst[11:7] == 0x0
10657 OPC_CheckField, 15, 17, 128, 128, 6, // 19566: check Inst[31:15] == 0x18000
10658 OPC_Decode, 134, 126, 14, // 19572: decode to UNIMP using decoder 14
10659 // 19572: } else try {
10660 OPC_Decode, 137, 111, 157, 1, // 19576: decode to CSRRW using decoder 157
10661 // 19576: }
10662 // 19576: }
10663 2, 5, // 19581: case 0x2: {
10664 OPC_Decode, 135, 111, 157, 1, // 19583: decode to CSRRS using decoder 157
10665 // 19583: }
10666 3, 5, // 19588: case 0x3: {
10667 OPC_Decode, 133, 111, 157, 1, // 19590: decode to CSRRC using decoder 157
10668 // 19590: }
10669 4, 161, 4, // 19595: case 0x4: {
10670 OPC_SwitchField, 25, 7, // 19598: switch Inst[31:25] {
10671 48, 19, // 19601: case 0x30: {
10672 OPC_SwitchField, 20, 5, // 19603: switch Inst[24:20] {
10673 0, 6, // 19606: case 0x0: {
10674 OPC_CheckPredicate, 116, // 19608: check predicate 116
10675 OPC_Decode, 181, 116, 17, // 19610: decode to HLV_B using decoder 17
10676 // 19610: }
10677 1, 0, // 19614: case 0x1: {
10678 OPC_CheckPredicate, 116, // 19616: check predicate 116
10679 OPC_Decode, 182, 116, 17, // 19618: decode to HLV_BU using decoder 17
10680 // 19618: }
10681 // 19618: } // switch Inst[24:20]
10682 // 19618: }
10683 49, 10, // 19622: case 0x31: {
10684 OPC_CheckPredicate, 116, // 19624: check predicate 116
10685 OPC_CheckField, 7, 5, 0, // 19626: check Inst[11:7] == 0x0
10686 OPC_Decode, 188, 116, 59, // 19630: decode to HSV_B using decoder 59
10687 // 19630: }
10688 50, 27, // 19634: case 0x32: {
10689 OPC_SwitchField, 20, 5, // 19636: switch Inst[24:20] {
10690 0, 6, // 19639: case 0x0: {
10691 OPC_CheckPredicate, 116, // 19641: check predicate 116
10692 OPC_Decode, 184, 116, 17, // 19643: decode to HLV_H using decoder 17
10693 // 19643: }
10694 1, 6, // 19647: case 0x1: {
10695 OPC_CheckPredicate, 116, // 19649: check predicate 116
10696 OPC_Decode, 185, 116, 17, // 19651: decode to HLV_HU using decoder 17
10697 // 19651: }
10698 3, 0, // 19655: case 0x3: {
10699 OPC_CheckPredicate, 116, // 19657: check predicate 116
10700 OPC_Decode, 179, 116, 17, // 19659: decode to HLVX_HU using decoder 17
10701 // 19659: }
10702 // 19659: } // switch Inst[24:20]
10703 // 19659: }
10704 51, 10, // 19663: case 0x33: {
10705 OPC_CheckPredicate, 116, // 19665: check predicate 116
10706 OPC_CheckField, 7, 5, 0, // 19667: check Inst[11:7] == 0x0
10707 OPC_Decode, 190, 116, 59, // 19671: decode to HSV_H using decoder 59
10708 // 19671: }
10709 52, 27, // 19675: case 0x34: {
10710 OPC_SwitchField, 20, 5, // 19677: switch Inst[24:20] {
10711 0, 6, // 19680: case 0x0: {
10712 OPC_CheckPredicate, 116, // 19682: check predicate 116
10713 OPC_Decode, 186, 116, 17, // 19684: decode to HLV_W using decoder 17
10714 // 19684: }
10715 1, 6, // 19688: case 0x1: {
10716 OPC_CheckPredicate, 121, // 19690: check predicate 121
10717 OPC_Decode, 187, 116, 17, // 19692: decode to HLV_WU using decoder 17
10718 // 19692: }
10719 3, 0, // 19696: case 0x3: {
10720 OPC_CheckPredicate, 116, // 19698: check predicate 116
10721 OPC_Decode, 180, 116, 17, // 19700: decode to HLVX_WU using decoder 17
10722 // 19700: }
10723 // 19700: } // switch Inst[24:20]
10724 // 19700: }
10725 53, 10, // 19704: case 0x35: {
10726 OPC_CheckPredicate, 116, // 19706: check predicate 116
10727 OPC_CheckField, 7, 5, 0, // 19708: check Inst[11:7] == 0x0
10728 OPC_Decode, 191, 116, 59, // 19712: decode to HSV_W using decoder 59
10729 // 19712: }
10730 54, 10, // 19716: case 0x36: {
10731 OPC_CheckPredicate, 121, // 19718: check predicate 121
10732 OPC_CheckField, 20, 5, 0, // 19720: check Inst[24:20] == 0x0
10733 OPC_Decode, 183, 116, 17, // 19724: decode to HLV_D using decoder 17
10734 // 19724: }
10735 55, 10, // 19728: case 0x37: {
10736 OPC_CheckPredicate, 121, // 19730: check predicate 121
10737 OPC_CheckField, 7, 5, 0, // 19732: check Inst[11:7] == 0x0
10738 OPC_Decode, 189, 116, 59, // 19736: decode to HSV_D using decoder 59
10739 // 19736: }
10740 64, 35, // 19740: case 0x40: {
10741 OPC_SwitchField, 20, 5, // 19742: switch Inst[24:20] {
10742 28, 6, // 19745: case 0x1c: {
10743 OPC_CheckPredicate, 122, // 19747: check predicate 122
10744 OPC_Decode, 191, 117, 17, // 19749: decode to MOP_R_0 using decoder 17
10745 // 19749: }
10746 29, 6, // 19753: case 0x1d: {
10747 OPC_CheckPredicate, 122, // 19755: check predicate 122
10748 OPC_Decode, 192, 117, 17, // 19757: decode to MOP_R_1 using decoder 17
10749 // 19757: }
10750 30, 6, // 19761: case 0x1e: {
10751 OPC_CheckPredicate, 122, // 19763: check predicate 122
10752 OPC_Decode, 203, 117, 17, // 19765: decode to MOP_R_2 using decoder 17
10753 // 19765: }
10754 31, 0, // 19769: case 0x1f: {
10755 OPC_CheckPredicate, 122, // 19771: check predicate 122
10756 OPC_Decode, 214, 117, 17, // 19773: decode to MOP_R_3 using decoder 17
10757 // 19773: }
10758 // 19773: } // switch Inst[24:20]
10759 // 19773: }
10760 65, 6, // 19777: case 0x41: {
10761 OPC_CheckPredicate, 122, // 19779: check predicate 122
10762 OPC_Decode, 183, 117, 31, // 19781: decode to MOP_RR_0 using decoder 31
10763 // 19781: }
10764 66, 35, // 19785: case 0x42: {
10765 OPC_SwitchField, 20, 5, // 19787: switch Inst[24:20] {
10766 28, 6, // 19790: case 0x1c: {
10767 OPC_CheckPredicate, 122, // 19792: check predicate 122
10768 OPC_Decode, 217, 117, 17, // 19794: decode to MOP_R_4 using decoder 17
10769 // 19794: }
10770 29, 6, // 19798: case 0x1d: {
10771 OPC_CheckPredicate, 122, // 19800: check predicate 122
10772 OPC_Decode, 218, 117, 17, // 19802: decode to MOP_R_5 using decoder 17
10773 // 19802: }
10774 30, 6, // 19806: case 0x1e: {
10775 OPC_CheckPredicate, 122, // 19808: check predicate 122
10776 OPC_Decode, 219, 117, 17, // 19810: decode to MOP_R_6 using decoder 17
10777 // 19810: }
10778 31, 0, // 19814: case 0x1f: {
10779 OPC_CheckPredicate, 122, // 19816: check predicate 122
10780 OPC_Decode, 220, 117, 17, // 19818: decode to MOP_R_7 using decoder 17
10781 // 19818: }
10782 // 19818: } // switch Inst[24:20]
10783 // 19818: }
10784 67, 6, // 19822: case 0x43: {
10785 OPC_CheckPredicate, 122, // 19824: check predicate 122
10786 OPC_Decode, 184, 117, 31, // 19826: decode to MOP_RR_1 using decoder 31
10787 // 19826: }
10788 68, 35, // 19830: case 0x44: {
10789 OPC_SwitchField, 20, 5, // 19832: switch Inst[24:20] {
10790 28, 6, // 19835: case 0x1c: {
10791 OPC_CheckPredicate, 122, // 19837: check predicate 122
10792 OPC_Decode, 221, 117, 17, // 19839: decode to MOP_R_8 using decoder 17
10793 // 19839: }
10794 29, 6, // 19843: case 0x1d: {
10795 OPC_CheckPredicate, 122, // 19845: check predicate 122
10796 OPC_Decode, 222, 117, 17, // 19847: decode to MOP_R_9 using decoder 17
10797 // 19847: }
10798 30, 6, // 19851: case 0x1e: {
10799 OPC_CheckPredicate, 122, // 19853: check predicate 122
10800 OPC_Decode, 193, 117, 17, // 19855: decode to MOP_R_10 using decoder 17
10801 // 19855: }
10802 31, 0, // 19859: case 0x1f: {
10803 OPC_CheckPredicate, 122, // 19861: check predicate 122
10804 OPC_Decode, 194, 117, 17, // 19863: decode to MOP_R_11 using decoder 17
10805 // 19863: }
10806 // 19863: } // switch Inst[24:20]
10807 // 19863: }
10808 69, 6, // 19867: case 0x45: {
10809 OPC_CheckPredicate, 122, // 19869: check predicate 122
10810 OPC_Decode, 185, 117, 31, // 19871: decode to MOP_RR_2 using decoder 31
10811 // 19871: }
10812 70, 35, // 19875: case 0x46: {
10813 OPC_SwitchField, 20, 5, // 19877: switch Inst[24:20] {
10814 28, 6, // 19880: case 0x1c: {
10815 OPC_CheckPredicate, 122, // 19882: check predicate 122
10816 OPC_Decode, 195, 117, 17, // 19884: decode to MOP_R_12 using decoder 17
10817 // 19884: }
10818 29, 6, // 19888: case 0x1d: {
10819 OPC_CheckPredicate, 122, // 19890: check predicate 122
10820 OPC_Decode, 196, 117, 17, // 19892: decode to MOP_R_13 using decoder 17
10821 // 19892: }
10822 30, 6, // 19896: case 0x1e: {
10823 OPC_CheckPredicate, 122, // 19898: check predicate 122
10824 OPC_Decode, 197, 117, 17, // 19900: decode to MOP_R_14 using decoder 17
10825 // 19900: }
10826 31, 0, // 19904: case 0x1f: {
10827 OPC_CheckPredicate, 122, // 19906: check predicate 122
10828 OPC_Decode, 198, 117, 17, // 19908: decode to MOP_R_15 using decoder 17
10829 // 19908: }
10830 // 19908: } // switch Inst[24:20]
10831 // 19908: }
10832 71, 6, // 19912: case 0x47: {
10833 OPC_CheckPredicate, 122, // 19914: check predicate 122
10834 OPC_Decode, 186, 117, 31, // 19916: decode to MOP_RR_3 using decoder 31
10835 // 19916: }
10836 96, 35, // 19920: case 0x60: {
10837 OPC_SwitchField, 20, 5, // 19922: switch Inst[24:20] {
10838 28, 6, // 19925: case 0x1c: {
10839 OPC_CheckPredicate, 122, // 19927: check predicate 122
10840 OPC_Decode, 199, 117, 17, // 19929: decode to MOP_R_16 using decoder 17
10841 // 19929: }
10842 29, 6, // 19933: case 0x1d: {
10843 OPC_CheckPredicate, 122, // 19935: check predicate 122
10844 OPC_Decode, 200, 117, 17, // 19937: decode to MOP_R_17 using decoder 17
10845 // 19937: }
10846 30, 6, // 19941: case 0x1e: {
10847 OPC_CheckPredicate, 122, // 19943: check predicate 122
10848 OPC_Decode, 201, 117, 17, // 19945: decode to MOP_R_18 using decoder 17
10849 // 19945: }
10850 31, 0, // 19949: case 0x1f: {
10851 OPC_CheckPredicate, 122, // 19951: check predicate 122
10852 OPC_Decode, 202, 117, 17, // 19953: decode to MOP_R_19 using decoder 17
10853 // 19953: }
10854 // 19953: } // switch Inst[24:20]
10855 // 19953: }
10856 97, 6, // 19957: case 0x61: {
10857 OPC_CheckPredicate, 122, // 19959: check predicate 122
10858 OPC_Decode, 187, 117, 31, // 19961: decode to MOP_RR_4 using decoder 31
10859 // 19961: }
10860 98, 35, // 19965: case 0x62: {
10861 OPC_SwitchField, 20, 5, // 19967: switch Inst[24:20] {
10862 28, 6, // 19970: case 0x1c: {
10863 OPC_CheckPredicate, 122, // 19972: check predicate 122
10864 OPC_Decode, 204, 117, 17, // 19974: decode to MOP_R_20 using decoder 17
10865 // 19974: }
10866 29, 6, // 19978: case 0x1d: {
10867 OPC_CheckPredicate, 122, // 19980: check predicate 122
10868 OPC_Decode, 205, 117, 17, // 19982: decode to MOP_R_21 using decoder 17
10869 // 19982: }
10870 30, 6, // 19986: case 0x1e: {
10871 OPC_CheckPredicate, 122, // 19988: check predicate 122
10872 OPC_Decode, 206, 117, 17, // 19990: decode to MOP_R_22 using decoder 17
10873 // 19990: }
10874 31, 0, // 19994: case 0x1f: {
10875 OPC_CheckPredicate, 122, // 19996: check predicate 122
10876 OPC_Decode, 207, 117, 17, // 19998: decode to MOP_R_23 using decoder 17
10877 // 19998: }
10878 // 19998: } // switch Inst[24:20]
10879 // 19998: }
10880 99, 6, // 20002: case 0x63: {
10881 OPC_CheckPredicate, 122, // 20004: check predicate 122
10882 OPC_Decode, 188, 117, 31, // 20006: decode to MOP_RR_5 using decoder 31
10883 // 20006: }
10884 100, 35, // 20010: case 0x64: {
10885 OPC_SwitchField, 20, 5, // 20012: switch Inst[24:20] {
10886 28, 6, // 20015: case 0x1c: {
10887 OPC_CheckPredicate, 122, // 20017: check predicate 122
10888 OPC_Decode, 208, 117, 17, // 20019: decode to MOP_R_24 using decoder 17
10889 // 20019: }
10890 29, 6, // 20023: case 0x1d: {
10891 OPC_CheckPredicate, 122, // 20025: check predicate 122
10892 OPC_Decode, 209, 117, 17, // 20027: decode to MOP_R_25 using decoder 17
10893 // 20027: }
10894 30, 6, // 20031: case 0x1e: {
10895 OPC_CheckPredicate, 122, // 20033: check predicate 122
10896 OPC_Decode, 210, 117, 17, // 20035: decode to MOP_R_26 using decoder 17
10897 // 20035: }
10898 31, 0, // 20039: case 0x1f: {
10899 OPC_CheckPredicate, 122, // 20041: check predicate 122
10900 OPC_Decode, 211, 117, 17, // 20043: decode to MOP_R_27 using decoder 17
10901 // 20043: }
10902 // 20043: } // switch Inst[24:20]
10903 // 20043: }
10904 101, 6, // 20047: case 0x65: {
10905 OPC_CheckPredicate, 122, // 20049: check predicate 122
10906 OPC_Decode, 189, 117, 31, // 20051: decode to MOP_RR_6 using decoder 31
10907 // 20051: }
10908 102, 61, // 20055: case 0x66: {
10909 OPC_SwitchField, 20, 5, // 20057: switch Inst[24:20] {
10910 28, 32, // 20060: case 0x1c: {
10911 OPC_Scope, 11, // 20062: try {
10912 OPC_CheckField, 7, 5, 0, // 20064: check Inst[11:7] == 0x0
10913 OPC_CheckPredicate, 122, // 20068: check predicate 122
10914 OPC_Decode, 141, 125, 158, 1, // 20070: decode to SSPOPCHK using decoder 158
10915 OPC_Scope, 11, // 20075: } else try {
10916 OPC_CheckField, 15, 5, 0, // 20077: check Inst[19:15] == 0x0
10917 OPC_CheckPredicate, 122, // 20081: check predicate 122
10918 OPC_Decode, 143, 125, 159, 1, // 20083: decode to SSRDP using decoder 159
10919 // 20083: } else try {
10920 OPC_CheckPredicate, 122, // 20088: check predicate 122
10921 OPC_Decode, 212, 117, 17, // 20090: decode to MOP_R_28 using decoder 17
10922 // 20090: }
10923 // 20090: }
10924 29, 6, // 20094: case 0x1d: {
10925 OPC_CheckPredicate, 122, // 20096: check predicate 122
10926 OPC_Decode, 213, 117, 17, // 20098: decode to MOP_R_29 using decoder 17
10927 // 20098: }
10928 30, 6, // 20102: case 0x1e: {
10929 OPC_CheckPredicate, 122, // 20104: check predicate 122
10930 OPC_Decode, 215, 117, 17, // 20106: decode to MOP_R_30 using decoder 17
10931 // 20106: }
10932 31, 0, // 20110: case 0x1f: {
10933 OPC_CheckPredicate, 122, // 20112: check predicate 122
10934 OPC_Decode, 216, 117, 17, // 20114: decode to MOP_R_31 using decoder 17
10935 // 20114: }
10936 // 20114: } // switch Inst[24:20]
10937 // 20114: }
10938 103, 0, // 20118: case 0x67: {
10939 OPC_Scope, 15, // 20120: try {
10940 OPC_CheckField, 7, 5, 0, // 20122: check Inst[11:7] == 0x0
10941 OPC_CheckPredicate, 122, // 20126: check predicate 122
10942 OPC_CheckField, 15, 5, 0, // 20128: check Inst[19:15] == 0x0
10943 OPC_Decode, 142, 125, 160, 1, // 20132: decode to SSPUSH using decoder 160
10944 // 20132: } else try {
10945 OPC_CheckPredicate, 122, // 20137: check predicate 122
10946 OPC_Decode, 190, 117, 31, // 20139: decode to MOP_RR_7 using decoder 31
10947 // 20139: }
10948 // 20139: }
10949 // 20139: } // switch Inst[31:25]
10950 // 20139: }
10951 5, 5, // 20143: case 0x5: {
10952 OPC_Decode, 138, 111, 161, 1, // 20145: decode to CSRRWI using decoder 161
10953 // 20145: }
10954 6, 5, // 20150: case 0x6: {
10955 OPC_Decode, 136, 111, 161, 1, // 20152: decode to CSRRSI using decoder 161
10956 // 20152: }
10957 7, 0, // 20157: case 0x7: {
10958 OPC_Decode, 134, 111, 161, 1, // 20159: decode to CSRRCI using decoder 161
10959 // 20159: }
10960 // 20159: } // switch Inst[14:12]
10961 // 20159: }
10962 119, 238, 3, // 20164: case 0x77: {
10963 OPC_SwitchField, 26, 6, // 20167: switch Inst[31:26] {
10964 32, 15, // 20170: case 0x20: {
10965 OPC_CheckPredicate, 123, // 20172: check predicate 123
10966 OPC_CheckField, 25, 1, 1, // 20174: check Inst[25] == 0x1
10967 OPC_CheckField, 12, 3, 2, // 20178: check Inst[14:12] == 0x2
10968 OPC_Decode, 192, 130, 1, 118, // 20182: decode to VSM3ME_VV using decoder 118
10969 // 20182: }
10970 33, 16, // 20187: case 0x21: {
10971 OPC_CheckPredicate, 124, // 20189: check predicate 124
10972 OPC_CheckField, 25, 1, 1, // 20191: check Inst[25] == 0x1
10973 OPC_CheckField, 12, 3, 2, // 20195: check Inst[14:12] == 0x2
10974 OPC_Decode, 193, 130, 1, 162, 1, // 20199: decode to VSM4K_VI using decoder 162
10975 // 20199: }
10976 34, 15, // 20205: case 0x22: {
10977 OPC_CheckPredicate, 125, // 20207: check predicate 125
10978 OPC_CheckField, 25, 1, 1, // 20209: check Inst[25] == 0x1
10979 OPC_CheckField, 12, 3, 2, // 20213: check Inst[14:12] == 0x2
10980 OPC_Decode, 165, 126, 162, 1, // 20217: decode to VAESKF1_VI using decoder 162
10981 // 20217: }
10982 35, 15, // 20222: case 0x23: {
10983 OPC_CheckPredicate, 126, // 20224: check predicate 126
10984 OPC_CheckField, 25, 1, 1, // 20226: check Inst[25] == 0x1
10985 OPC_CheckField, 12, 3, 2, // 20230: check Inst[14:12] == 0x2
10986 OPC_Decode, 191, 127, 163, 1, // 20234: decode to VGHSH_VS using decoder 163
10987 // 20234: }
10988 36, 10, // 20239: case 0x24: {
10989 OPC_CheckPredicate, 127, // 20241: check predicate 127
10990 OPC_CheckField, 12, 3, 1, // 20243: check Inst[14:12] == 0x1
10991 OPC_Decode, 165, 127, 122, // 20247: decode to VFWDOTA_VV using decoder 122
10992 // 20247: }
10993 38, 22, // 20251: case 0x26: {
10994 OPC_SwitchField, 12, 3, // 20253: switch Inst[14:12] {
10995 0, 8, // 20256: case 0x0: {
10996 OPC_CheckPredicate, 128, 1, // 20258: check predicate 128
10997 OPC_Decode, 132, 130, 1, 122, // 20261: decode to VQWDOTAU_VV using decoder 122
10998 // 20261: }
10999 1, 0, // 20266: case 0x1: {
11000 OPC_CheckPredicate, 129, 1, // 20268: check predicate 129
11001 OPC_Decode, 132, 127, 122, // 20271: decode to VFQWDOTA_VV using decoder 122
11002 // 20271: }
11003 // 20271: } // switch Inst[14:12]
11004 // 20271: }
11005 39, 22, // 20275: case 0x27: {
11006 OPC_SwitchField, 12, 3, // 20277: switch Inst[14:12] {
11007 0, 8, // 20280: case 0x0: {
11008 OPC_CheckPredicate, 128, 1, // 20282: check predicate 128
11009 OPC_Decode, 131, 130, 1, 122, // 20285: decode to VQWDOTAS_VV using decoder 122
11010 // 20285: }
11011 1, 0, // 20290: case 0x1: {
11012 OPC_CheckPredicate, 129, 1, // 20292: check predicate 129
11013 OPC_Decode, 131, 127, 122, // 20295: decode to VFQWDOTA_ALT_VV using decoder 122
11014 // 20295: }
11015 // 20295: } // switch Inst[14:12]
11016 // 20295: }
11017 40, 85, // 20299: case 0x28: {
11018 OPC_SwitchField, 12, 8, // 20301: switch Inst[19:12] {
11019 2, 11, // 20304: case 0x2: {
11020 OPC_CheckPredicate, 125, // 20306: check predicate 125
11021 OPC_CheckField, 25, 1, 1, // 20308: check Inst[25] == 0x1
11022 OPC_Decode, 160, 126, 164, 1, // 20312: decode to VAESDM_VV using decoder 164
11023 // 20312: }
11024 10, 11, // 20317: case 0xa: {
11025 OPC_CheckPredicate, 125, // 20319: check predicate 125
11026 OPC_CheckField, 25, 1, 1, // 20321: check Inst[25] == 0x1
11027 OPC_Decode, 158, 126, 164, 1, // 20325: decode to VAESDF_VV using decoder 164
11028 // 20325: }
11029 18, 11, // 20330: case 0x12: {
11030 OPC_CheckPredicate, 125, // 20332: check predicate 125
11031 OPC_CheckField, 25, 1, 1, // 20334: check Inst[25] == 0x1
11032 OPC_Decode, 164, 126, 164, 1, // 20338: decode to VAESEM_VV using decoder 164
11033 // 20338: }
11034 26, 11, // 20343: case 0x1a: {
11035 OPC_CheckPredicate, 125, // 20345: check predicate 125
11036 OPC_CheckField, 25, 1, 1, // 20347: check Inst[25] == 0x1
11037 OPC_Decode, 162, 126, 164, 1, // 20351: decode to VAESEF_VV using decoder 164
11038 // 20351: }
11039 130, 1, 12, // 20356: case 0x82: {
11040 OPC_CheckPredicate, 124, // 20359: check predicate 124
11041 OPC_CheckField, 25, 1, 1, // 20361: check Inst[25] == 0x1
11042 OPC_Decode, 195, 130, 1, 164, 1, // 20365: decode to VSM4R_VV using decoder 164
11043 // 20365: }
11044 138, 1, 0, // 20371: case 0x8a: {
11045 OPC_CheckPredicate, 130, 1, // 20374: check predicate 130
11046 OPC_CheckField, 25, 1, 1, // 20377: check Inst[25] == 0x1
11047 OPC_Decode, 194, 127, 164, 1, // 20381: decode to VGMUL_VV using decoder 164
11048 // 20381: }
11049 // 20381: } // switch Inst[19:12]
11050 // 20381: }
11051 41, 97, // 20386: case 0x29: {
11052 OPC_SwitchField, 12, 8, // 20388: switch Inst[19:12] {
11053 2, 11, // 20391: case 0x2: {
11054 OPC_CheckPredicate, 125, // 20393: check predicate 125
11055 OPC_CheckField, 25, 1, 1, // 20395: check Inst[25] == 0x1
11056 OPC_Decode, 159, 126, 164, 1, // 20399: decode to VAESDM_VS using decoder 164
11057 // 20399: }
11058 10, 11, // 20404: case 0xa: {
11059 OPC_CheckPredicate, 125, // 20406: check predicate 125
11060 OPC_CheckField, 25, 1, 1, // 20408: check Inst[25] == 0x1
11061 OPC_Decode, 157, 126, 164, 1, // 20412: decode to VAESDF_VS using decoder 164
11062 // 20412: }
11063 18, 11, // 20417: case 0x12: {
11064 OPC_CheckPredicate, 125, // 20419: check predicate 125
11065 OPC_CheckField, 25, 1, 1, // 20421: check Inst[25] == 0x1
11066 OPC_Decode, 163, 126, 164, 1, // 20425: decode to VAESEM_VS using decoder 164
11067 // 20425: }
11068 26, 11, // 20430: case 0x1a: {
11069 OPC_CheckPredicate, 125, // 20432: check predicate 125
11070 OPC_CheckField, 25, 1, 1, // 20434: check Inst[25] == 0x1
11071 OPC_Decode, 161, 126, 164, 1, // 20438: decode to VAESEF_VS using decoder 164
11072 // 20438: }
11073 58, 11, // 20443: case 0x3a: {
11074 OPC_CheckPredicate, 125, // 20445: check predicate 125
11075 OPC_CheckField, 25, 1, 1, // 20447: check Inst[25] == 0x1
11076 OPC_Decode, 167, 126, 164, 1, // 20451: decode to VAESZ_VS using decoder 164
11077 // 20451: }
11078 130, 1, 12, // 20456: case 0x82: {
11079 OPC_CheckPredicate, 124, // 20459: check predicate 124
11080 OPC_CheckField, 25, 1, 1, // 20461: check Inst[25] == 0x1
11081 OPC_Decode, 194, 130, 1, 164, 1, // 20465: decode to VSM4R_VS using decoder 164
11082 // 20465: }
11083 138, 1, 0, // 20471: case 0x8a: {
11084 OPC_CheckPredicate, 126, // 20474: check predicate 126
11085 OPC_CheckField, 25, 1, 1, // 20476: check Inst[25] == 0x1
11086 OPC_Decode, 193, 127, 164, 1, // 20480: decode to VGMUL_VS using decoder 164
11087 // 20480: }
11088 // 20480: } // switch Inst[19:12]
11089 // 20480: }
11090 42, 15, // 20485: case 0x2a: {
11091 OPC_CheckPredicate, 125, // 20487: check predicate 125
11092 OPC_CheckField, 25, 1, 1, // 20489: check Inst[25] == 0x1
11093 OPC_CheckField, 12, 3, 2, // 20493: check Inst[14:12] == 0x2
11094 OPC_Decode, 166, 126, 165, 1, // 20497: decode to VAESKF2_VI using decoder 165
11095 // 20497: }
11096 43, 27, // 20502: case 0x2b: {
11097 OPC_SwitchField, 12, 3, // 20504: switch Inst[14:12] {
11098 1, 8, // 20507: case 0x1: {
11099 OPC_CheckPredicate, 131, 1, // 20509: check predicate 131
11100 OPC_Decode, 204, 126, 166, 1, // 20512: decode to VFBDOTA_VV using decoder 166
11101 // 20512: }
11102 2, 0, // 20517: case 0x2: {
11103 OPC_CheckPredicate, 123, // 20519: check predicate 123
11104 OPC_CheckField, 25, 1, 1, // 20521: check Inst[25] == 0x1
11105 OPC_Decode, 191, 130, 1, 165, 1, // 20525: decode to VSM3C_VI using decoder 165
11106 // 20525: }
11107 // 20525: } // switch Inst[14:12]
11108 // 20525: }
11109 44, 27, // 20531: case 0x2c: {
11110 OPC_SwitchField, 12, 3, // 20533: switch Inst[14:12] {
11111 1, 8, // 20536: case 0x1: {
11112 OPC_CheckPredicate, 132, 1, // 20538: check predicate 132
11113 OPC_Decode, 156, 127, 166, 1, // 20541: decode to VFWBDOTA_VV using decoder 166
11114 // 20541: }
11115 2, 0, // 20546: case 0x2: {
11116 OPC_CheckPredicate, 130, 1, // 20548: check predicate 130
11117 OPC_CheckField, 25, 1, 1, // 20551: check Inst[25] == 0x1
11118 OPC_Decode, 192, 127, 163, 1, // 20555: decode to VGHSH_VV using decoder 163
11119 // 20555: }
11120 // 20555: } // switch Inst[14:12]
11121 // 20555: }
11122 45, 17, // 20560: case 0x2d: {
11123 OPC_CheckPredicate, 133, 1, // 20562: check predicate 133
11124 OPC_CheckField, 25, 1, 1, // 20565: check Inst[25] == 0x1
11125 OPC_CheckField, 12, 3, 2, // 20569: check Inst[14:12] == 0x2
11126 OPC_Decode, 181, 130, 1, 163, 1, // 20573: decode to VSHA2MS_VV using decoder 163
11127 // 20573: }
11128 46, 39, // 20579: case 0x2e: {
11129 OPC_SwitchField, 12, 3, // 20581: switch Inst[14:12] {
11130 0, 9, // 20584: case 0x0: {
11131 OPC_CheckPredicate, 134, 1, // 20586: check predicate 134
11132 OPC_Decode, 130, 130, 1, 166, 1, // 20589: decode to VQWBDOTAU_VV using decoder 166
11133 // 20589: }
11134 1, 8, // 20595: case 0x1: {
11135 OPC_CheckPredicate, 135, 1, // 20597: check predicate 135
11136 OPC_Decode, 130, 127, 166, 1, // 20600: decode to VFQWBDOTA_VV using decoder 166
11137 // 20600: }
11138 2, 0, // 20605: case 0x2: {
11139 OPC_CheckPredicate, 133, 1, // 20607: check predicate 133
11140 OPC_CheckField, 25, 1, 1, // 20610: check Inst[25] == 0x1
11141 OPC_Decode, 179, 130, 1, 163, 1, // 20614: decode to VSHA2CH_VV using decoder 163
11142 // 20614: }
11143 // 20614: } // switch Inst[14:12]
11144 // 20614: }
11145 47, 0, // 20620: case 0x2f: {
11146 OPC_SwitchField, 12, 3, // 20622: switch Inst[14:12] {
11147 0, 9, // 20625: case 0x0: {
11148 OPC_CheckPredicate, 134, 1, // 20627: check predicate 134
11149 OPC_Decode, 129, 130, 1, 166, 1, // 20630: decode to VQWBDOTAS_VV using decoder 166
11150 // 20630: }
11151 1, 8, // 20636: case 0x1: {
11152 OPC_CheckPredicate, 135, 1, // 20638: check predicate 135
11153 OPC_Decode, 129, 127, 166, 1, // 20641: decode to VFQWBDOTA_ALT_VV using decoder 166
11154 // 20641: }
11155 2, 0, // 20646: case 0x2: {
11156 OPC_CheckPredicate, 133, 1, // 20648: check predicate 133
11157 OPC_CheckField, 25, 1, 1, // 20651: check Inst[25] == 0x1
11158 OPC_Decode, 180, 130, 1, 163, 1, // 20655: decode to VSHA2CL_VV using decoder 163
11159 // 20655: }
11160 // 20655: } // switch Inst[14:12]
11161 // 20655: }
11162 // 20655: } // switch Inst[31:26]
11163 // 20655: }
11164 123, 0, // 20661: case 0x7b: {
11165 OPC_SwitchField, 12, 3, // 20663: switch Inst[14:12] {
11166 0, 239, 1, // 20666: case 0x0: {
11167 OPC_SwitchField, 25, 7, // 20669: switch Inst[31:25] {
11168 1, 9, // 20672: case 0x1: {
11169 OPC_CheckPredicate, 136, 1, // 20674: check predicate 136
11170 OPC_Decode, 173, 132, 1, 167, 1, // 20677: decode to YHIW using decoder 167
11171 // 20677: }
11172 3, 24, // 20683: case 0x3: {
11173 OPC_Scope, 13, // 20685: try {
11174 OPC_CheckField, 20, 5, 0, // 20687: check Inst[24:20] == 0x0
11175 OPC_CheckPredicate, 136, 1, // 20691: check predicate 136
11176 OPC_Decode, 175, 132, 1, 168, 1, // 20694: decode to YMV using decoder 168
11177 // 20694: } else try {
11178 OPC_CheckPredicate, 136, 1, // 20700: check predicate 136
11179 OPC_Decode, 162, 132, 1, 169, 1, // 20703: decode to YADD using decoder 169
11180 // 20703: }
11181 // 20703: }
11182 6, 9, // 20709: case 0x6: {
11183 OPC_CheckPredicate, 136, 1, // 20711: check predicate 136
11184 OPC_Decode, 171, 132, 1, 170, 1, // 20714: decode to YEQ using decoder 170
11185 // 20714: }
11186 7, 9, // 20720: case 0x7: {
11187 OPC_CheckPredicate, 136, 1, // 20722: check predicate 136
11188 OPC_Decode, 183, 132, 1, 171, 1, // 20725: decode to YUNSEALS using decoder 171
11189 // 20725: }
11190 11, 9, // 20731: case 0xb: {
11191 OPC_CheckPredicate, 136, 1, // 20733: check predicate 136
11192 OPC_Decode, 164, 132, 1, 172, 1, // 20736: decode to YADDRW using decoder 172
11193 // 20736: }
11194 14, 9, // 20742: case 0xe: {
11195 OPC_CheckPredicate, 136, 1, // 20744: check predicate 136
11196 OPC_Decode, 179, 132, 1, 170, 1, // 20747: decode to YSS using decoder 170
11197 // 20747: }
11198 15, 9, // 20753: case 0xf: {
11199 OPC_CheckPredicate, 136, 1, // 20755: check predicate 136
11200 OPC_Decode, 167, 132, 1, 171, 1, // 20758: decode to YBLD using decoder 171
11201 // 20758: }
11202 19, 9, // 20764: case 0x13: {
11203 OPC_CheckPredicate, 136, 1, // 20766: check predicate 136
11204 OPC_Decode, 176, 132, 1, 172, 1, // 20769: decode to YPERMC using decoder 172
11205 // 20769: }
11206 23, 13, // 20775: case 0x17: {
11207 OPC_CheckPredicate, 136, 1, // 20777: check predicate 136
11208 OPC_CheckField, 15, 5, 0, // 20780: check Inst[19:15] == 0x0
11209 OPC_Decode, 178, 132, 1, 173, 1, // 20784: decode to YSEALE using decoder 173
11210 // 20784: }
11211 27, 9, // 20790: case 0x1b: {
11212 OPC_CheckPredicate, 136, 1, // 20792: check predicate 136
11213 OPC_Decode, 169, 132, 1, 172, 1, // 20795: decode to YBNDSW using decoder 172
11214 // 20795: }
11215 35, 9, // 20801: case 0x23: {
11216 OPC_CheckPredicate, 136, 1, // 20803: check predicate 136
11217 OPC_Decode, 168, 132, 1, 172, 1, // 20806: decode to YBNDSRW using decoder 172
11218 // 20806: }
11219 120, 12, // 20812: case 0x78: {
11220 OPC_CheckPredicate, 136, 1, // 20814: check predicate 136
11221 OPC_CheckField, 20, 5, 0, // 20817: check Inst[24:20] == 0x0
11222 OPC_Decode, 165, 132, 1, 17, // 20821: decode to YAMASK using decoder 17
11223 // 20821: }
11224 122, 0, // 20826: case 0x7a: {
11225 OPC_SwitchField, 20, 5, // 20828: switch Inst[24:20] {
11226 0, 9, // 20831: case 0x0: {
11227 OPC_CheckPredicate, 136, 1, // 20833: check predicate 136
11228 OPC_Decode, 166, 132, 1, 174, 1, // 20836: decode to YBASER using decoder 174
11229 // 20836: }
11230 1, 9, // 20842: case 0x1: {
11231 OPC_CheckPredicate, 136, 1, // 20844: check predicate 136
11232 OPC_Decode, 177, 132, 1, 174, 1, // 20847: decode to YPERMR using decoder 174
11233 // 20847: }
11234 2, 9, // 20853: case 0x2: {
11235 OPC_CheckPredicate, 136, 1, // 20855: check predicate 136
11236 OPC_Decode, 181, 132, 1, 174, 1, // 20858: decode to YTOPR using decoder 174
11237 // 20858: }
11238 3, 9, // 20864: case 0x3: {
11239 OPC_CheckPredicate, 136, 1, // 20866: check predicate 136
11240 OPC_Decode, 174, 132, 1, 174, 1, // 20869: decode to YLENR using decoder 174
11241 // 20869: }
11242 4, 9, // 20875: case 0x4: {
11243 OPC_CheckPredicate, 136, 1, // 20877: check predicate 136
11244 OPC_Decode, 180, 132, 1, 174, 1, // 20880: decode to YTAGR using decoder 174
11245 // 20880: }
11246 5, 9, // 20886: case 0x5: {
11247 OPC_CheckPredicate, 136, 1, // 20888: check predicate 136
11248 OPC_Decode, 182, 132, 1, 174, 1, // 20891: decode to YTYPER using decoder 174
11249 // 20891: }
11250 7, 0, // 20897: case 0x7: {
11251 OPC_CheckPredicate, 136, 1, // 20899: check predicate 136
11252 OPC_Decode, 172, 132, 1, 174, 1, // 20902: decode to YHIR using decoder 174
11253 // 20902: }
11254 // 20902: } // switch Inst[24:20]
11255 // 20902: }
11256 // 20902: } // switch Inst[31:25]
11257 // 20902: }
11258 4, 9, // 20908: case 0x4: {
11259 OPC_CheckPredicate, 136, 1, // 20910: check predicate 136
11260 OPC_Decode, 163, 132, 1, 175, 1, // 20913: decode to YADDI using decoder 175
11261 // 20913: }
11262 5, 0, // 20919: case 0x5: {
11263 OPC_CheckPredicate, 136, 1, // 20921: check predicate 136
11264 OPC_CheckField, 29, 3, 7, // 20924: check Inst[31:29] == 0x7
11265 OPC_Decode, 170, 132, 1, 176, 1, // 20928: decode to YBNDSWI using decoder 176
11266 // 20928: }
11267 // 20928: } // switch Inst[14:12]
11268 // 20928: }
11269 // 20928: } // switch Inst[6:0]
11270};
11271static const uint8_t DecoderTableRV32Only32[795] = {
11272 32, // 0: BitWidth 32
11273 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
11274 0, 99, // 4: case 0x0: {
11275 OPC_SwitchField, 25, 7, // 6: switch Inst[31:25] {
11276 73, 10, // 9: case 0x49: {
11277 OPC_CheckPredicate, 47, // 11: check predicate 47
11278 OPC_CheckField, 0, 7, 59, // 13: check Inst[6:0] == 0x3b
11279 OPC_Decode, 216, 123, 31, // 17: decode to SADD using decoder 31
11280 // 17: }
11281 77, 10, // 21: case 0x4d: {
11282 OPC_CheckPredicate, 47, // 23: check predicate 47
11283 OPC_CheckField, 0, 7, 59, // 25: check Inst[6:0] == 0x3b
11284 OPC_Decode, 199, 107, 31, // 29: decode to AADD using decoder 31
11285 // 29: }
11286 89, 10, // 33: case 0x59: {
11287 OPC_CheckPredicate, 47, // 35: check predicate 47
11288 OPC_CheckField, 0, 7, 59, // 37: check Inst[6:0] == 0x3b
11289 OPC_Decode, 217, 123, 31, // 41: decode to SADDU using decoder 31
11290 // 41: }
11291 93, 10, // 45: case 0x5d: {
11292 OPC_CheckPredicate, 47, // 47: check predicate 47
11293 OPC_CheckField, 0, 7, 59, // 49: check Inst[6:0] == 0x3b
11294 OPC_Decode, 200, 107, 31, // 53: decode to AADDU using decoder 31
11295 // 53: }
11296 105, 10, // 57: case 0x69: {
11297 OPC_CheckPredicate, 47, // 59: check predicate 47
11298 OPC_CheckField, 0, 7, 59, // 61: check Inst[6:0] == 0x3b
11299 OPC_Decode, 144, 125, 31, // 65: decode to SSUB using decoder 31
11300 // 65: }
11301 109, 10, // 69: case 0x6d: {
11302 OPC_CheckPredicate, 47, // 71: check predicate 47
11303 OPC_CheckField, 0, 7, 59, // 73: check Inst[6:0] == 0x3b
11304 OPC_Decode, 220, 110, 31, // 77: decode to ASUB using decoder 31
11305 // 77: }
11306 121, 10, // 81: case 0x79: {
11307 OPC_CheckPredicate, 47, // 83: check predicate 47
11308 OPC_CheckField, 0, 7, 59, // 85: check Inst[6:0] == 0x3b
11309 OPC_Decode, 145, 125, 31, // 89: decode to SSUBU using decoder 31
11310 // 89: }
11311 125, 0, // 93: case 0x7d: {
11312 OPC_CheckPredicate, 47, // 95: check predicate 47
11313 OPC_CheckField, 0, 7, 59, // 97: check Inst[6:0] == 0x3b
11314 OPC_Decode, 221, 110, 31, // 101: decode to ASUBU using decoder 31
11315 // 101: }
11316 // 101: } // switch Inst[31:25]
11317 // 101: }
11318 1, 51, // 105: case 0x1: {
11319 OPC_SwitchField, 25, 7, // 107: switch Inst[31:25] {
11320 73, 10, // 110: case 0x49: {
11321 OPC_CheckPredicate, 47, // 112: check predicate 47
11322 OPC_CheckField, 0, 7, 59, // 114: check Inst[6:0] == 0x3b
11323 OPC_Decode, 138, 118, 31, // 118: decode to MUL_H01 using decoder 31
11324 // 118: }
11325 77, 10, // 122: case 0x4d: {
11326 OPC_CheckPredicate, 47, // 124: check predicate 47
11327 OPC_CheckField, 0, 7, 59, // 126: check Inst[6:0] == 0x3b
11328 OPC_Decode, 150, 117, 61, // 130: decode to MACC_H01 using decoder 61
11329 // 130: }
11330 89, 10, // 134: case 0x59: {
11331 OPC_CheckPredicate, 47, // 136: check predicate 47
11332 OPC_CheckField, 0, 7, 59, // 138: check Inst[6:0] == 0x3b
11333 OPC_Decode, 131, 118, 31, // 142: decode to MULU_H01 using decoder 31
11334 // 142: }
11335 93, 0, // 146: case 0x5d: {
11336 OPC_CheckPredicate, 47, // 148: check predicate 47
11337 OPC_CheckField, 0, 7, 59, // 150: check Inst[6:0] == 0x3b
11338 OPC_Decode, 144, 117, 61, // 154: decode to MACCU_H01 using decoder 61
11339 // 154: }
11340 // 154: } // switch Inst[31:25]
11341 // 154: }
11342 2, 75, // 158: case 0x2: {
11343 OPC_SwitchField, 25, 7, // 160: switch Inst[31:25] {
11344 85, 10, // 163: case 0x55: {
11345 OPC_CheckPredicate, 47, // 165: check predicate 47
11346 OPC_CheckField, 0, 7, 27, // 167: check Inst[6:0] == 0x1b
11347 OPC_Decode, 138, 125, 31, // 171: decode to SSHL using decoder 31
11348 // 171: }
11349 89, 10, // 175: case 0x59: {
11350 OPC_CheckPredicate, 47, // 177: check predicate 47
11351 OPC_CheckField, 0, 7, 59, // 179: check Inst[6:0] == 0x3b
11352 OPC_Decode, 135, 125, 31, // 183: decode to SSH1SADD using decoder 31
11353 // 183: }
11354 93, 10, // 187: case 0x5d: {
11355 OPC_CheckPredicate, 47, // 189: check predicate 47
11356 OPC_CheckField, 0, 7, 27, // 191: check Inst[6:0] == 0x1b
11357 OPC_Decode, 139, 125, 31, // 195: decode to SSHLR using decoder 31
11358 // 195: }
11359 105, 10, // 199: case 0x69: {
11360 OPC_CheckPredicate, 47, // 201: check predicate 47
11361 OPC_CheckField, 0, 7, 27, // 203: check Inst[6:0] == 0x1b
11362 OPC_Decode, 140, 125, 21, // 207: decode to SSLAI using decoder 21
11363 // 207: }
11364 117, 10, // 211: case 0x75: {
11365 OPC_CheckPredicate, 47, // 213: check predicate 47
11366 OPC_CheckField, 0, 7, 27, // 215: check Inst[6:0] == 0x1b
11367 OPC_Decode, 136, 125, 31, // 219: decode to SSHA using decoder 31
11368 // 219: }
11369 125, 0, // 223: case 0x7d: {
11370 OPC_CheckPredicate, 47, // 225: check predicate 47
11371 OPC_CheckField, 0, 7, 27, // 227: check Inst[6:0] == 0x1b
11372 OPC_Decode, 137, 125, 31, // 231: decode to SSHAR using decoder 31
11373 // 231: }
11374 // 231: } // switch Inst[31:25]
11375 // 231: }
11376 3, 165, 1, // 235: case 0x3: {
11377 OPC_SwitchField, 0, 7, // 238: switch Inst[6:0] {
11378 3, 8, // 241: case 0x3: {
11379 OPC_CheckPredicate, 137, 1, // 243: check predicate 137
11380 OPC_Decode, 228, 116, 177, 1, // 246: decode to LD_RV32 using decoder 177
11381 // 246: }
11382 35, 8, // 251: case 0x23: {
11383 OPC_CheckPredicate, 137, 1, // 253: check predicate 137
11384 OPC_Decode, 237, 123, 178, 1, // 256: decode to SD_RV32 using decoder 178
11385 // 256: }
11386 47, 39, // 261: case 0x2f: {
11387 OPC_SwitchField, 25, 7, // 263: switch Inst[31:25] {
11388 20, 7, // 266: case 0x14: {
11389 OPC_CheckPredicate, 138, 1, // 268: check predicate 138
11390 OPC_Decode, 213, 109, 58, // 271: decode to AMOCAS_D_RV32 using decoder 58
11391 // 271: }
11392 21, 7, // 275: case 0x15: {
11393 OPC_CheckPredicate, 138, 1, // 277: check predicate 138
11394 OPC_Decode, 216, 109, 58, // 280: decode to AMOCAS_D_RV32_RL using decoder 58
11395 // 280: }
11396 22, 7, // 284: case 0x16: {
11397 OPC_CheckPredicate, 138, 1, // 286: check predicate 138
11398 OPC_Decode, 214, 109, 58, // 289: decode to AMOCAS_D_RV32_AQ using decoder 58
11399 // 289: }
11400 23, 0, // 293: case 0x17: {
11401 OPC_CheckPredicate, 138, 1, // 295: check predicate 138
11402 OPC_Decode, 215, 109, 58, // 298: decode to AMOCAS_D_RV32_AQRL using decoder 58
11403 // 298: }
11404 // 298: } // switch Inst[31:25]
11405 // 298: }
11406 59, 0, // 302: case 0x3b: {
11407 OPC_SwitchField, 25, 7, // 304: switch Inst[31:25] {
11408 65, 6, // 307: case 0x41: {
11409 OPC_CheckPredicate, 47, // 309: check predicate 47
11410 OPC_Decode, 137, 118, 31, // 311: decode to MUL_H00 using decoder 31
11411 // 311: }
11412 69, 6, // 315: case 0x45: {
11413 OPC_CheckPredicate, 47, // 317: check predicate 47
11414 OPC_Decode, 149, 117, 61, // 319: decode to MACC_H00 using decoder 61
11415 // 319: }
11416 73, 6, // 323: case 0x49: {
11417 OPC_CheckPredicate, 47, // 325: check predicate 47
11418 OPC_Decode, 139, 118, 31, // 327: decode to MUL_H11 using decoder 31
11419 // 327: }
11420 77, 6, // 331: case 0x4d: {
11421 OPC_CheckPredicate, 47, // 333: check predicate 47
11422 OPC_Decode, 151, 117, 61, // 335: decode to MACC_H11 using decoder 61
11423 // 335: }
11424 81, 6, // 339: case 0x51: {
11425 OPC_CheckPredicate, 47, // 341: check predicate 47
11426 OPC_Decode, 130, 118, 31, // 343: decode to MULU_H00 using decoder 31
11427 // 343: }
11428 85, 6, // 347: case 0x55: {
11429 OPC_CheckPredicate, 47, // 349: check predicate 47
11430 OPC_Decode, 143, 117, 61, // 351: decode to MACCU_H00 using decoder 61
11431 // 351: }
11432 89, 6, // 355: case 0x59: {
11433 OPC_CheckPredicate, 47, // 357: check predicate 47
11434 OPC_Decode, 132, 118, 31, // 359: decode to MULU_H11 using decoder 31
11435 // 359: }
11436 93, 6, // 363: case 0x5d: {
11437 OPC_CheckPredicate, 47, // 365: check predicate 47
11438 OPC_Decode, 145, 117, 61, // 367: decode to MACCU_H11 using decoder 61
11439 // 367: }
11440 113, 6, // 371: case 0x71: {
11441 OPC_CheckPredicate, 47, // 373: check predicate 47
11442 OPC_Decode, 254, 117, 31, // 375: decode to MULSU_H00 using decoder 31
11443 // 375: }
11444 117, 6, // 379: case 0x75: {
11445 OPC_CheckPredicate, 47, // 381: check predicate 47
11446 OPC_Decode, 139, 117, 61, // 383: decode to MACCSU_H00 using decoder 61
11447 // 383: }
11448 121, 6, // 387: case 0x79: {
11449 OPC_CheckPredicate, 47, // 389: check predicate 47
11450 OPC_Decode, 255, 117, 31, // 391: decode to MULSU_H11 using decoder 31
11451 // 391: }
11452 125, 0, // 395: case 0x7d: {
11453 OPC_CheckPredicate, 47, // 397: check predicate 47
11454 OPC_Decode, 140, 117, 61, // 399: decode to MACCSU_H11 using decoder 61
11455 // 399: }
11456 // 399: } // switch Inst[31:25]
11457 // 399: }
11458 // 399: } // switch Inst[6:0]
11459 // 399: }
11460 4, 39, // 403: case 0x4: {
11461 OPC_SwitchField, 25, 7, // 405: switch Inst[31:25] {
11462 81, 10, // 408: case 0x51: {
11463 OPC_CheckPredicate, 47, // 410: check predicate 47
11464 OPC_CheckField, 0, 7, 27, // 412: check Inst[6:0] == 0x1b
11465 OPC_Decode, 140, 126, 21, // 416: decode to USATI_RV32 using decoder 21
11466 // 416: }
11467 105, 10, // 420: case 0x69: {
11468 OPC_CheckPredicate, 47, // 422: check predicate 47
11469 OPC_CheckField, 0, 7, 27, // 424: check Inst[6:0] == 0x1b
11470 OPC_Decode, 246, 124, 21, // 428: decode to SRARI_RV32 using decoder 21
11471 // 428: }
11472 113, 0, // 432: case 0x71: {
11473 OPC_CheckPredicate, 47, // 434: check predicate 47
11474 OPC_CheckField, 0, 7, 27, // 436: check Inst[6:0] == 0x1b
11475 OPC_Decode, 218, 123, 41, // 440: decode to SATI_RV32 using decoder 41
11476 // 440: }
11477 // 440: } // switch Inst[31:25]
11478 // 440: }
11479 5, 27, // 444: case 0x5: {
11480 OPC_SwitchField, 25, 7, // 446: switch Inst[31:25] {
11481 124, 10, // 449: case 0x7c: {
11482 OPC_CheckPredicate, 47, // 451: check predicate 47
11483 OPC_CheckField, 0, 7, 59, // 453: check Inst[6:0] == 0x3b
11484 OPC_Decode, 224, 117, 61, // 457: decode to MQACC_H01 using decoder 61
11485 // 457: }
11486 126, 0, // 461: case 0x7e: {
11487 OPC_CheckPredicate, 47, // 463: check predicate 47
11488 OPC_CheckField, 0, 7, 59, // 465: check Inst[6:0] == 0x3b
11489 OPC_Decode, 230, 117, 61, // 469: decode to MQRACC_H01 using decoder 61
11490 // 469: }
11491 // 469: } // switch Inst[31:25]
11492 // 469: }
11493 6, 39, // 473: case 0x6: {
11494 OPC_SwitchField, 25, 7, // 475: switch Inst[31:25] {
11495 97, 10, // 478: case 0x61: {
11496 OPC_CheckPredicate, 47, // 480: check predicate 47
11497 OPC_CheckField, 0, 7, 59, // 482: check Inst[6:0] == 0x3b
11498 OPC_Decode, 238, 117, 31, // 486: decode to MSEQ using decoder 31
11499 // 486: }
11500 105, 10, // 490: case 0x69: {
11501 OPC_CheckPredicate, 47, // 492: check predicate 47
11502 OPC_CheckField, 0, 7, 59, // 494: check Inst[6:0] == 0x3b
11503 OPC_Decode, 239, 117, 31, // 498: decode to MSLT using decoder 31
11504 // 498: }
11505 109, 0, // 502: case 0x6d: {
11506 OPC_CheckPredicate, 47, // 504: check predicate 47
11507 OPC_CheckField, 0, 7, 59, // 506: check Inst[6:0] == 0x3b
11508 OPC_Decode, 240, 117, 31, // 510: decode to MSLTU using decoder 31
11509 // 510: }
11510 // 510: } // switch Inst[31:25]
11511 // 510: }
11512 7, 0, // 514: case 0x7: {
11513 OPC_SwitchField, 25, 7, // 516: switch Inst[31:25] {
11514 67, 10, // 519: case 0x43: {
11515 OPC_CheckPredicate, 47, // 521: check predicate 47
11516 OPC_CheckField, 0, 7, 59, // 523: check Inst[6:0] == 0x3b
11517 OPC_Decode, 243, 117, 31, // 527: decode to MULHR using decoder 31
11518 // 527: }
11519 69, 10, // 531: case 0x45: {
11520 OPC_CheckPredicate, 47, // 533: check predicate 47
11521 OPC_CheckField, 0, 7, 59, // 535: check Inst[6:0] == 0x3b
11522 OPC_Decode, 160, 117, 61, // 539: decode to MHACC using decoder 61
11523 // 539: }
11524 71, 10, // 543: case 0x47: {
11525 OPC_CheckPredicate, 47, // 545: check predicate 47
11526 OPC_CheckField, 0, 7, 59, // 547: check Inst[6:0] == 0x3b
11527 OPC_Decode, 167, 117, 61, // 551: decode to MHRACC using decoder 61
11528 // 551: }
11529 75, 10, // 555: case 0x4b: {
11530 OPC_CheckPredicate, 47, // 557: check predicate 47
11531 OPC_CheckField, 0, 7, 59, // 559: check Inst[6:0] == 0x3b
11532 OPC_Decode, 245, 117, 31, // 563: decode to MULHRU using decoder 31
11533 // 563: }
11534 77, 10, // 567: case 0x4d: {
11535 OPC_CheckPredicate, 47, // 569: check predicate 47
11536 OPC_CheckField, 0, 7, 59, // 571: check Inst[6:0] == 0x3b
11537 OPC_Decode, 164, 117, 61, // 575: decode to MHACCU using decoder 61
11538 // 575: }
11539 79, 10, // 579: case 0x4f: {
11540 OPC_CheckPredicate, 47, // 581: check predicate 47
11541 OPC_CheckField, 0, 7, 59, // 583: check Inst[6:0] == 0x3b
11542 OPC_Decode, 169, 117, 61, // 587: decode to MHRACCU using decoder 61
11543 // 587: }
11544 81, 10, // 591: case 0x51: {
11545 OPC_CheckPredicate, 47, // 593: check predicate 47
11546 OPC_CheckField, 0, 7, 59, // 595: check Inst[6:0] == 0x3b
11547 OPC_Decode, 250, 117, 31, // 599: decode to MULH_H0 using decoder 31
11548 // 599: }
11549 83, 10, // 603: case 0x53: {
11550 OPC_CheckPredicate, 47, // 605: check predicate 47
11551 OPC_CheckField, 0, 7, 59, // 607: check Inst[6:0] == 0x3b
11552 OPC_Decode, 247, 117, 31, // 611: decode to MULHSU_H0 using decoder 31
11553 // 611: }
11554 85, 10, // 615: case 0x55: {
11555 OPC_CheckPredicate, 47, // 617: check predicate 47
11556 OPC_CheckField, 0, 7, 59, // 619: check Inst[6:0] == 0x3b
11557 OPC_Decode, 165, 117, 61, // 623: decode to MHACC_H0 using decoder 61
11558 // 623: }
11559 87, 10, // 627: case 0x57: {
11560 OPC_CheckPredicate, 47, // 629: check predicate 47
11561 OPC_CheckField, 0, 7, 59, // 631: check Inst[6:0] == 0x3b
11562 OPC_Decode, 162, 117, 61, // 635: decode to MHACCSU_H0 using decoder 61
11563 // 635: }
11564 89, 10, // 639: case 0x59: {
11565 OPC_CheckPredicate, 47, // 641: check predicate 47
11566 OPC_CheckField, 0, 7, 59, // 643: check Inst[6:0] == 0x3b
11567 OPC_Decode, 251, 117, 31, // 647: decode to MULH_H1 using decoder 31
11568 // 647: }
11569 91, 10, // 651: case 0x5b: {
11570 OPC_CheckPredicate, 47, // 653: check predicate 47
11571 OPC_CheckField, 0, 7, 59, // 655: check Inst[6:0] == 0x3b
11572 OPC_Decode, 248, 117, 31, // 659: decode to MULHSU_H1 using decoder 31
11573 // 659: }
11574 93, 10, // 663: case 0x5d: {
11575 OPC_CheckPredicate, 47, // 665: check predicate 47
11576 OPC_CheckField, 0, 7, 59, // 667: check Inst[6:0] == 0x3b
11577 OPC_Decode, 166, 117, 61, // 671: decode to MHACC_H1 using decoder 61
11578 // 671: }
11579 95, 10, // 675: case 0x5f: {
11580 OPC_CheckPredicate, 47, // 677: check predicate 47
11581 OPC_CheckField, 0, 7, 59, // 679: check Inst[6:0] == 0x3b
11582 OPC_Decode, 163, 117, 61, // 683: decode to MHACCSU_H1 using decoder 61
11583 // 683: }
11584 99, 10, // 687: case 0x63: {
11585 OPC_CheckPredicate, 47, // 689: check predicate 47
11586 OPC_CheckField, 0, 7, 59, // 691: check Inst[6:0] == 0x3b
11587 OPC_Decode, 244, 117, 31, // 695: decode to MULHRSU using decoder 31
11588 // 695: }
11589 101, 10, // 699: case 0x65: {
11590 OPC_CheckPredicate, 47, // 701: check predicate 47
11591 OPC_CheckField, 0, 7, 59, // 703: check Inst[6:0] == 0x3b
11592 OPC_Decode, 161, 117, 61, // 707: decode to MHACCSU using decoder 61
11593 // 707: }
11594 103, 10, // 711: case 0x67: {
11595 OPC_CheckPredicate, 47, // 713: check predicate 47
11596 OPC_CheckField, 0, 7, 59, // 715: check Inst[6:0] == 0x3b
11597 OPC_Decode, 168, 117, 61, // 719: decode to MHRACCSU using decoder 61
11598 // 719: }
11599 105, 10, // 723: case 0x69: {
11600 OPC_CheckPredicate, 47, // 725: check predicate 47
11601 OPC_CheckField, 0, 7, 59, // 727: check Inst[6:0] == 0x3b
11602 OPC_Decode, 252, 117, 31, // 731: decode to MULQ using decoder 31
11603 // 731: }
11604 107, 10, // 735: case 0x6b: {
11605 OPC_CheckPredicate, 47, // 737: check predicate 47
11606 OPC_CheckField, 0, 7, 59, // 739: check Inst[6:0] == 0x3b
11607 OPC_Decode, 253, 117, 31, // 743: decode to MULQR using decoder 31
11608 // 743: }
11609 116, 10, // 747: case 0x74: {
11610 OPC_CheckPredicate, 47, // 749: check predicate 47
11611 OPC_CheckField, 0, 7, 59, // 751: check Inst[6:0] == 0x3b
11612 OPC_Decode, 223, 117, 61, // 755: decode to MQACC_H00 using decoder 61
11613 // 755: }
11614 118, 10, // 759: case 0x76: {
11615 OPC_CheckPredicate, 47, // 761: check predicate 47
11616 OPC_CheckField, 0, 7, 59, // 763: check Inst[6:0] == 0x3b
11617 OPC_Decode, 229, 117, 61, // 767: decode to MQRACC_H00 using decoder 61
11618 // 767: }
11619 124, 10, // 771: case 0x7c: {
11620 OPC_CheckPredicate, 47, // 773: check predicate 47
11621 OPC_CheckField, 0, 7, 59, // 775: check Inst[6:0] == 0x3b
11622 OPC_Decode, 225, 117, 61, // 779: decode to MQACC_H11 using decoder 61
11623 // 779: }
11624 126, 0, // 783: case 0x7e: {
11625 OPC_CheckPredicate, 47, // 785: check predicate 47
11626 OPC_CheckField, 0, 7, 59, // 787: check Inst[6:0] == 0x3b
11627 OPC_Decode, 231, 117, 61, // 791: decode to MQRACC_H11 using decoder 61
11628 // 791: }
11629 // 791: } // switch Inst[31:25]
11630 // 791: }
11631 // 791: } // switch Inst[14:12]
11632};
11633static const uint8_t DecoderTableXAIF32[2612] = {
11634 32, // 0: BitWidth 32
11635 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
11636 7, 12, // 4: case 0x7: {
11637 OPC_CheckPredicate, 139, 1, // 6: check predicate 139
11638 OPC_CheckField, 12, 3, 5, // 9: check Inst[14:12] == 0x5
11639 OPC_Decode, 221, 108, 179, 1, // 13: decode to AIF_FLQ2 using decoder 179
11640 // 13: }
11641 11, 195, 4, // 18: case 0xb: {
11642 OPC_SwitchField, 12, 3, // 21: switch Inst[14:12] {
11643 0, 8, // 24: case 0x0: {
11644 OPC_CheckPredicate, 139, 1, // 26: check predicate 139
11645 OPC_Decode, 167, 108, 179, 1, // 29: decode to AIF_FBC_PS using decoder 179
11646 // 29: }
11647 1, 123, // 34: case 0x1: {
11648 OPC_SwitchField, 25, 7, // 36: switch Inst[31:25] {
11649 4, 8, // 39: case 0x4: {
11650 OPC_CheckPredicate, 139, 1, // 41: check predicate 139
11651 OPC_Decode, 205, 108, 180, 1, // 44: decode to AIF_FG32B_PS using decoder 180
11652 // 44: }
11653 8, 8, // 49: case 0x8: {
11654 OPC_CheckPredicate, 139, 1, // 51: check predicate 139
11655 OPC_Decode, 206, 108, 180, 1, // 54: decode to AIF_FG32H_PS using decoder 180
11656 // 54: }
11657 16, 8, // 59: case 0x10: {
11658 OPC_CheckPredicate, 139, 1, // 61: check predicate 139
11659 OPC_Decode, 207, 108, 180, 1, // 64: decode to AIF_FG32W_PS using decoder 180
11660 // 64: }
11661 36, 8, // 69: case 0x24: {
11662 OPC_CheckPredicate, 139, 1, // 71: check predicate 139
11663 OPC_Decode, 210, 108, 181, 1, // 74: decode to AIF_FGB_PS using decoder 181
11664 // 74: }
11665 40, 8, // 79: case 0x28: {
11666 OPC_CheckPredicate, 139, 1, // 81: check predicate 139
11667 OPC_Decode, 213, 108, 181, 1, // 84: decode to AIF_FGH_PS using decoder 181
11668 // 84: }
11669 48, 8, // 89: case 0x30: {
11670 OPC_CheckPredicate, 139, 1, // 91: check predicate 139
11671 OPC_Decode, 216, 108, 181, 1, // 94: decode to AIF_FGW_PS using decoder 181
11672 // 94: }
11673 68, 8, // 99: case 0x44: {
11674 OPC_CheckPredicate, 139, 1, // 101: check predicate 139
11675 OPC_Decode, 130, 109, 180, 1, // 104: decode to AIF_FSC32B_PS using decoder 180
11676 // 104: }
11677 72, 8, // 109: case 0x48: {
11678 OPC_CheckPredicate, 139, 1, // 111: check predicate 139
11679 OPC_Decode, 131, 109, 180, 1, // 114: decode to AIF_FSC32H_PS using decoder 180
11680 // 114: }
11681 80, 8, // 119: case 0x50: {
11682 OPC_CheckPredicate, 139, 1, // 121: check predicate 139
11683 OPC_Decode, 132, 109, 180, 1, // 124: decode to AIF_FSC32W_PS using decoder 180
11684 // 124: }
11685 100, 8, // 129: case 0x64: {
11686 OPC_CheckPredicate, 139, 1, // 131: check predicate 139
11687 OPC_Decode, 135, 109, 181, 1, // 134: decode to AIF_FSCB_PS using decoder 181
11688 // 134: }
11689 104, 8, // 139: case 0x68: {
11690 OPC_CheckPredicate, 139, 1, // 141: check predicate 139
11691 OPC_Decode, 138, 109, 181, 1, // 144: decode to AIF_FSCH_PS using decoder 181
11692 // 144: }
11693 112, 0, // 149: case 0x70: {
11694 OPC_CheckPredicate, 139, 1, // 151: check predicate 139
11695 OPC_Decode, 141, 109, 181, 1, // 154: decode to AIF_FSCW_PS using decoder 181
11696 // 154: }
11697 // 154: } // switch Inst[31:25]
11698 // 154: }
11699 2, 8, // 159: case 0x2: {
11700 OPC_CheckPredicate, 139, 1, // 161: check predicate 139
11701 OPC_Decode, 229, 108, 179, 1, // 164: decode to AIF_FLW_PS using decoder 179
11702 // 164: }
11703 3, 12, // 169: case 0x3: {
11704 OPC_CheckPredicate, 139, 1, // 171: check predicate 139
11705 OPC_CheckField, 20, 12, 0, // 174: check Inst[31:20] == 0x0
11706 OPC_Decode, 166, 108, 182, 1, // 178: decode to AIF_FBCX_PS using decoder 182
11707 // 178: }
11708 4, 223, 1, // 183: case 0x4: {
11709 OPC_SwitchField, 25, 7, // 186: switch Inst[31:25] {
11710 3, 8, // 189: case 0x3: {
11711 OPC_CheckPredicate, 139, 1, // 191: check predicate 139
11712 OPC_Decode, 141, 108, 181, 1, // 194: decode to AIF_FAMOADDL_PI using decoder 181
11713 // 194: }
11714 7, 8, // 199: case 0x7: {
11715 OPC_CheckPredicate, 139, 1, // 201: check predicate 139
11716 OPC_Decode, 159, 108, 181, 1, // 204: decode to AIF_FAMOSWAPL_PI using decoder 181
11717 // 204: }
11718 11, 8, // 209: case 0xb: {
11719 OPC_CheckPredicate, 139, 1, // 211: check predicate 139
11720 OPC_Decode, 143, 108, 181, 1, // 214: decode to AIF_FAMOANDL_PI using decoder 181
11721 // 214: }
11722 15, 8, // 219: case 0xf: {
11723 OPC_CheckPredicate, 139, 1, // 221: check predicate 139
11724 OPC_Decode, 157, 108, 181, 1, // 224: decode to AIF_FAMOORL_PI using decoder 181
11725 // 224: }
11726 19, 8, // 229: case 0x13: {
11727 OPC_CheckPredicate, 139, 1, // 231: check predicate 139
11728 OPC_Decode, 161, 108, 181, 1, // 234: decode to AIF_FAMOXORL_PI using decoder 181
11729 // 234: }
11730 20, 8, // 239: case 0x14: {
11731 OPC_CheckPredicate, 139, 1, // 241: check predicate 139
11732 OPC_Decode, 147, 108, 181, 1, // 244: decode to AIF_FAMOMAXL_PS using decoder 181
11733 // 244: }
11734 23, 8, // 249: case 0x17: {
11735 OPC_CheckPredicate, 139, 1, // 251: check predicate 139
11736 OPC_Decode, 152, 108, 181, 1, // 254: decode to AIF_FAMOMINL_PI using decoder 181
11737 // 254: }
11738 24, 8, // 259: case 0x18: {
11739 OPC_CheckPredicate, 139, 1, // 261: check predicate 139
11740 OPC_Decode, 153, 108, 181, 1, // 264: decode to AIF_FAMOMINL_PS using decoder 181
11741 // 264: }
11742 27, 8, // 269: case 0x1b: {
11743 OPC_CheckPredicate, 139, 1, // 271: check predicate 139
11744 OPC_Decode, 146, 108, 181, 1, // 274: decode to AIF_FAMOMAXL_PI using decoder 181
11745 // 274: }
11746 31, 8, // 279: case 0x1f: {
11747 OPC_CheckPredicate, 139, 1, // 281: check predicate 139
11748 OPC_Decode, 155, 108, 181, 1, // 284: decode to AIF_FAMOMINUL_PI using decoder 181
11749 // 284: }
11750 35, 8, // 289: case 0x23: {
11751 OPC_CheckPredicate, 139, 1, // 291: check predicate 139
11752 OPC_Decode, 149, 108, 181, 1, // 294: decode to AIF_FAMOMAXUL_PI using decoder 181
11753 // 294: }
11754 67, 8, // 299: case 0x43: {
11755 OPC_CheckPredicate, 139, 1, // 301: check predicate 139
11756 OPC_Decode, 140, 108, 181, 1, // 304: decode to AIF_FAMOADDG_PI using decoder 181
11757 // 304: }
11758 71, 8, // 309: case 0x47: {
11759 OPC_CheckPredicate, 139, 1, // 311: check predicate 139
11760 OPC_Decode, 158, 108, 181, 1, // 314: decode to AIF_FAMOSWAPG_PI using decoder 181
11761 // 314: }
11762 75, 8, // 319: case 0x4b: {
11763 OPC_CheckPredicate, 139, 1, // 321: check predicate 139
11764 OPC_Decode, 142, 108, 181, 1, // 324: decode to AIF_FAMOANDG_PI using decoder 181
11765 // 324: }
11766 79, 8, // 329: case 0x4f: {
11767 OPC_CheckPredicate, 139, 1, // 331: check predicate 139
11768 OPC_Decode, 156, 108, 181, 1, // 334: decode to AIF_FAMOORG_PI using decoder 181
11769 // 334: }
11770 83, 8, // 339: case 0x53: {
11771 OPC_CheckPredicate, 139, 1, // 341: check predicate 139
11772 OPC_Decode, 160, 108, 181, 1, // 344: decode to AIF_FAMOXORG_PI using decoder 181
11773 // 344: }
11774 84, 8, // 349: case 0x54: {
11775 OPC_CheckPredicate, 139, 1, // 351: check predicate 139
11776 OPC_Decode, 145, 108, 181, 1, // 354: decode to AIF_FAMOMAXG_PS using decoder 181
11777 // 354: }
11778 87, 8, // 359: case 0x57: {
11779 OPC_CheckPredicate, 139, 1, // 361: check predicate 139
11780 OPC_Decode, 150, 108, 181, 1, // 364: decode to AIF_FAMOMING_PI using decoder 181
11781 // 364: }
11782 88, 8, // 369: case 0x58: {
11783 OPC_CheckPredicate, 139, 1, // 371: check predicate 139
11784 OPC_Decode, 151, 108, 181, 1, // 374: decode to AIF_FAMOMING_PS using decoder 181
11785 // 374: }
11786 91, 8, // 379: case 0x5b: {
11787 OPC_CheckPredicate, 139, 1, // 381: check predicate 139
11788 OPC_Decode, 144, 108, 181, 1, // 384: decode to AIF_FAMOMAXG_PI using decoder 181
11789 // 384: }
11790 95, 8, // 389: case 0x5f: {
11791 OPC_CheckPredicate, 139, 1, // 391: check predicate 139
11792 OPC_Decode, 154, 108, 181, 1, // 394: decode to AIF_FAMOMINUG_PI using decoder 181
11793 // 394: }
11794 99, 0, // 399: case 0x63: {
11795 OPC_CheckPredicate, 139, 1, // 401: check predicate 139
11796 OPC_Decode, 148, 108, 181, 1, // 404: decode to AIF_FAMOMAXUG_PI using decoder 181
11797 // 404: }
11798 // 404: } // switch Inst[31:25]
11799 // 404: }
11800 6, 8, // 409: case 0x6: {
11801 OPC_CheckPredicate, 139, 1, // 411: check predicate 139
11802 OPC_Decode, 160, 109, 183, 1, // 414: decode to AIF_FSW_PS using decoder 183
11803 // 414: }
11804 7, 0, // 419: case 0x7: {
11805 OPC_SwitchField, 25, 7, // 421: switch Inst[31:25] {
11806 8, 12, // 424: case 0x8: {
11807 OPC_CheckPredicate, 139, 1, // 426: check predicate 139
11808 OPC_CheckField, 20, 5, 0, // 429: check Inst[24:20] == 0x0
11809 OPC_Decode, 228, 108, 182, 1, // 433: decode to AIF_FLWL_PS using decoder 182
11810 // 433: }
11811 9, 12, // 438: case 0x9: {
11812 OPC_CheckPredicate, 139, 1, // 440: check predicate 139
11813 OPC_CheckField, 20, 5, 0, // 443: check Inst[24:20] == 0x0
11814 OPC_Decode, 227, 108, 182, 1, // 447: decode to AIF_FLWG_PS using decoder 182
11815 // 447: }
11816 40, 12, // 452: case 0x28: {
11817 OPC_CheckPredicate, 139, 1, // 454: check predicate 139
11818 OPC_CheckField, 20, 5, 0, // 457: check Inst[24:20] == 0x0
11819 OPC_Decode, 159, 109, 182, 1, // 461: decode to AIF_FSWL_PS using decoder 182
11820 // 461: }
11821 41, 12, // 466: case 0x29: {
11822 OPC_CheckPredicate, 139, 1, // 468: check predicate 139
11823 OPC_CheckField, 20, 5, 0, // 471: check Inst[24:20] == 0x0
11824 OPC_Decode, 157, 109, 182, 1, // 475: decode to AIF_FSWG_PS using decoder 182
11825 // 475: }
11826 64, 8, // 480: case 0x40: {
11827 OPC_CheckPredicate, 139, 1, // 482: check predicate 139
11828 OPC_Decode, 209, 108, 181, 1, // 485: decode to AIF_FGBL_PS using decoder 181
11829 // 485: }
11830 65, 8, // 490: case 0x41: {
11831 OPC_CheckPredicate, 139, 1, // 492: check predicate 139
11832 OPC_Decode, 208, 108, 181, 1, // 495: decode to AIF_FGBG_PS using decoder 181
11833 // 495: }
11834 68, 8, // 500: case 0x44: {
11835 OPC_CheckPredicate, 139, 1, // 502: check predicate 139
11836 OPC_Decode, 212, 108, 181, 1, // 505: decode to AIF_FGHL_PS using decoder 181
11837 // 505: }
11838 69, 8, // 510: case 0x45: {
11839 OPC_CheckPredicate, 139, 1, // 512: check predicate 139
11840 OPC_Decode, 211, 108, 181, 1, // 515: decode to AIF_FGHG_PS using decoder 181
11841 // 515: }
11842 72, 8, // 520: case 0x48: {
11843 OPC_CheckPredicate, 139, 1, // 522: check predicate 139
11844 OPC_Decode, 215, 108, 181, 1, // 525: decode to AIF_FGWL_PS using decoder 181
11845 // 525: }
11846 73, 8, // 530: case 0x49: {
11847 OPC_CheckPredicate, 139, 1, // 532: check predicate 139
11848 OPC_Decode, 214, 108, 181, 1, // 535: decode to AIF_FGWG_PS using decoder 181
11849 // 535: }
11850 96, 8, // 540: case 0x60: {
11851 OPC_CheckPredicate, 139, 1, // 542: check predicate 139
11852 OPC_Decode, 134, 109, 181, 1, // 545: decode to AIF_FSCBL_PS using decoder 181
11853 // 545: }
11854 97, 8, // 550: case 0x61: {
11855 OPC_CheckPredicate, 139, 1, // 552: check predicate 139
11856 OPC_Decode, 133, 109, 181, 1, // 555: decode to AIF_FSCBG_PS using decoder 181
11857 // 555: }
11858 100, 8, // 560: case 0x64: {
11859 OPC_CheckPredicate, 139, 1, // 562: check predicate 139
11860 OPC_Decode, 137, 109, 181, 1, // 565: decode to AIF_FSCHL_PS using decoder 181
11861 // 565: }
11862 101, 8, // 570: case 0x65: {
11863 OPC_CheckPredicate, 139, 1, // 572: check predicate 139
11864 OPC_Decode, 136, 109, 181, 1, // 575: decode to AIF_FSCHG_PS using decoder 181
11865 // 575: }
11866 104, 8, // 580: case 0x68: {
11867 OPC_CheckPredicate, 139, 1, // 582: check predicate 139
11868 OPC_Decode, 140, 109, 181, 1, // 585: decode to AIF_FSCWL_PS using decoder 181
11869 // 585: }
11870 105, 0, // 590: case 0x69: {
11871 OPC_CheckPredicate, 139, 1, // 592: check predicate 139
11872 OPC_Decode, 139, 109, 181, 1, // 595: decode to AIF_FSCWG_PS using decoder 181
11873 // 595: }
11874 // 595: } // switch Inst[31:25]
11875 // 595: }
11876 // 595: } // switch Inst[14:12]
11877 // 595: }
11878 31, 8, // 600: case 0x1f: {
11879 OPC_CheckPredicate, 139, 1, // 602: check predicate 139
11880 OPC_Decode, 165, 108, 184, 1, // 605: decode to AIF_FBCI_PS using decoder 184
11881 // 605: }
11882 39, 12, // 610: case 0x27: {
11883 OPC_CheckPredicate, 139, 1, // 612: check predicate 139
11884 OPC_CheckField, 12, 3, 5, // 615: check Inst[14:12] == 0x5
11885 OPC_Decode, 149, 109, 183, 1, // 619: decode to AIF_FSQ2 using decoder 183
11886 // 619: }
11887 59, 149, 4, // 624: case 0x3b: {
11888 OPC_SwitchField, 25, 7, // 627: switch Inst[31:25] {
11889 0, 21, // 630: case 0x0: {
11890 OPC_SwitchField, 12, 3, // 632: switch Inst[14:12] {
11891 2, 7, // 635: case 0x2: {
11892 OPC_CheckPredicate, 139, 1, // 637: check predicate 139
11893 OPC_Decode, 223, 107, 56, // 640: decode to AIF_AMOADDL_W using decoder 56
11894 // 640: }
11895 3, 0, // 644: case 0x3: {
11896 OPC_CheckPredicate, 139, 1, // 646: check predicate 139
11897 OPC_Decode, 222, 107, 56, // 649: decode to AIF_AMOADDL_D using decoder 56
11898 // 649: }
11899 // 649: } // switch Inst[14:12]
11900 // 649: }
11901 1, 21, // 653: case 0x1: {
11902 OPC_SwitchField, 12, 3, // 655: switch Inst[14:12] {
11903 2, 7, // 658: case 0x2: {
11904 OPC_CheckPredicate, 139, 1, // 660: check predicate 139
11905 OPC_Decode, 221, 107, 56, // 663: decode to AIF_AMOADDG_W using decoder 56
11906 // 663: }
11907 3, 0, // 667: case 0x3: {
11908 OPC_CheckPredicate, 139, 1, // 669: check predicate 139
11909 OPC_Decode, 220, 107, 56, // 672: decode to AIF_AMOADDG_D using decoder 56
11910 // 672: }
11911 // 672: } // switch Inst[14:12]
11912 // 672: }
11913 4, 21, // 676: case 0x4: {
11914 OPC_SwitchField, 12, 3, // 678: switch Inst[14:12] {
11915 2, 7, // 681: case 0x2: {
11916 OPC_CheckPredicate, 139, 1, // 683: check predicate 139
11917 OPC_Decode, 255, 107, 56, // 686: decode to AIF_AMOSWAPL_W using decoder 56
11918 // 686: }
11919 3, 0, // 690: case 0x3: {
11920 OPC_CheckPredicate, 139, 1, // 692: check predicate 139
11921 OPC_Decode, 254, 107, 56, // 695: decode to AIF_AMOSWAPL_D using decoder 56
11922 // 695: }
11923 // 695: } // switch Inst[14:12]
11924 // 695: }
11925 5, 21, // 699: case 0x5: {
11926 OPC_SwitchField, 12, 3, // 701: switch Inst[14:12] {
11927 2, 7, // 704: case 0x2: {
11928 OPC_CheckPredicate, 139, 1, // 706: check predicate 139
11929 OPC_Decode, 253, 107, 56, // 709: decode to AIF_AMOSWAPG_W using decoder 56
11930 // 709: }
11931 3, 0, // 713: case 0x3: {
11932 OPC_CheckPredicate, 139, 1, // 715: check predicate 139
11933 OPC_Decode, 252, 107, 56, // 718: decode to AIF_AMOSWAPG_D using decoder 56
11934 // 718: }
11935 // 718: } // switch Inst[14:12]
11936 // 718: }
11937 8, 11, // 722: case 0x8: {
11938 OPC_CheckPredicate, 139, 1, // 724: check predicate 139
11939 OPC_CheckField, 7, 8, 96, // 727: check Inst[14:7] == 0x60
11940 OPC_Decode, 174, 109, 59, // 731: decode to AIF_SBL using decoder 59
11941 // 731: }
11942 9, 11, // 735: case 0x9: {
11943 OPC_CheckPredicate, 139, 1, // 737: check predicate 139
11944 OPC_CheckField, 7, 8, 96, // 740: check Inst[14:7] == 0x60
11945 OPC_Decode, 173, 109, 59, // 744: decode to AIF_SBG using decoder 59
11946 // 744: }
11947 12, 11, // 748: case 0xc: {
11948 OPC_CheckPredicate, 139, 1, // 750: check predicate 139
11949 OPC_CheckField, 7, 8, 96, // 753: check Inst[14:7] == 0x60
11950 OPC_Decode, 176, 109, 59, // 757: decode to AIF_SHL using decoder 59
11951 // 757: }
11952 13, 11, // 761: case 0xd: {
11953 OPC_CheckPredicate, 139, 1, // 763: check predicate 139
11954 OPC_CheckField, 7, 8, 96, // 766: check Inst[14:7] == 0x60
11955 OPC_Decode, 175, 109, 59, // 770: decode to AIF_SHG using decoder 59
11956 // 770: }
11957 16, 21, // 774: case 0x10: {
11958 OPC_SwitchField, 12, 3, // 776: switch Inst[14:12] {
11959 2, 7, // 779: case 0x2: {
11960 OPC_CheckPredicate, 139, 1, // 781: check predicate 139
11961 OPC_Decode, 131, 108, 56, // 784: decode to AIF_AMOXORL_W using decoder 56
11962 // 784: }
11963 3, 0, // 788: case 0x3: {
11964 OPC_CheckPredicate, 139, 1, // 790: check predicate 139
11965 OPC_Decode, 130, 108, 56, // 793: decode to AIF_AMOXORL_D using decoder 56
11966 // 793: }
11967 // 793: } // switch Inst[14:12]
11968 // 793: }
11969 17, 21, // 797: case 0x11: {
11970 OPC_SwitchField, 12, 3, // 799: switch Inst[14:12] {
11971 2, 7, // 802: case 0x2: {
11972 OPC_CheckPredicate, 139, 1, // 804: check predicate 139
11973 OPC_Decode, 129, 108, 56, // 807: decode to AIF_AMOXORG_W using decoder 56
11974 // 807: }
11975 3, 0, // 811: case 0x3: {
11976 OPC_CheckPredicate, 139, 1, // 813: check predicate 139
11977 OPC_Decode, 128, 108, 56, // 816: decode to AIF_AMOXORG_D using decoder 56
11978 // 816: }
11979 // 816: } // switch Inst[14:12]
11980 // 816: }
11981 32, 21, // 820: case 0x20: {
11982 OPC_SwitchField, 12, 3, // 822: switch Inst[14:12] {
11983 2, 7, // 825: case 0x2: {
11984 OPC_CheckPredicate, 139, 1, // 827: check predicate 139
11985 OPC_Decode, 251, 107, 56, // 830: decode to AIF_AMOORL_W using decoder 56
11986 // 830: }
11987 3, 0, // 834: case 0x3: {
11988 OPC_CheckPredicate, 139, 1, // 836: check predicate 139
11989 OPC_Decode, 250, 107, 56, // 839: decode to AIF_AMOORL_D using decoder 56
11990 // 839: }
11991 // 839: } // switch Inst[14:12]
11992 // 839: }
11993 33, 21, // 843: case 0x21: {
11994 OPC_SwitchField, 12, 3, // 845: switch Inst[14:12] {
11995 2, 7, // 848: case 0x2: {
11996 OPC_CheckPredicate, 139, 1, // 850: check predicate 139
11997 OPC_Decode, 249, 107, 56, // 853: decode to AIF_AMOORG_W using decoder 56
11998 // 853: }
11999 3, 0, // 857: case 0x3: {
12000 OPC_CheckPredicate, 139, 1, // 859: check predicate 139
12001 OPC_Decode, 248, 107, 56, // 862: decode to AIF_AMOORG_D using decoder 56
12002 // 862: }
12003 // 862: } // switch Inst[14:12]
12004 // 862: }
12005 48, 21, // 866: case 0x30: {
12006 OPC_SwitchField, 12, 3, // 868: switch Inst[14:12] {
12007 2, 7, // 871: case 0x2: {
12008 OPC_CheckPredicate, 139, 1, // 873: check predicate 139
12009 OPC_Decode, 227, 107, 56, // 876: decode to AIF_AMOANDL_W using decoder 56
12010 // 876: }
12011 3, 0, // 880: case 0x3: {
12012 OPC_CheckPredicate, 139, 1, // 882: check predicate 139
12013 OPC_Decode, 226, 107, 56, // 885: decode to AIF_AMOANDL_D using decoder 56
12014 // 885: }
12015 // 885: } // switch Inst[14:12]
12016 // 885: }
12017 49, 21, // 889: case 0x31: {
12018 OPC_SwitchField, 12, 3, // 891: switch Inst[14:12] {
12019 2, 7, // 894: case 0x2: {
12020 OPC_CheckPredicate, 139, 1, // 896: check predicate 139
12021 OPC_Decode, 225, 107, 56, // 899: decode to AIF_AMOANDG_W using decoder 56
12022 // 899: }
12023 3, 0, // 903: case 0x3: {
12024 OPC_CheckPredicate, 139, 1, // 905: check predicate 139
12025 OPC_Decode, 224, 107, 56, // 908: decode to AIF_AMOANDG_D using decoder 56
12026 // 908: }
12027 // 908: } // switch Inst[14:12]
12028 // 908: }
12029 64, 39, // 912: case 0x40: {
12030 OPC_SwitchField, 12, 3, // 914: switch Inst[14:12] {
12031 2, 7, // 917: case 0x2: {
12032 OPC_CheckPredicate, 139, 1, // 919: check predicate 139
12033 OPC_Decode, 243, 107, 56, // 922: decode to AIF_AMOMINL_W using decoder 56
12034 // 922: }
12035 3, 7, // 926: case 0x3: {
12036 OPC_CheckPredicate, 139, 1, // 928: check predicate 139
12037 OPC_Decode, 242, 107, 56, // 931: decode to AIF_AMOMINL_D using decoder 56
12038 // 931: }
12039 6, 7, // 935: case 0x6: {
12040 OPC_CheckPredicate, 139, 1, // 937: check predicate 139
12041 OPC_Decode, 172, 109, 31, // 940: decode to AIF_PACKB using decoder 31
12042 // 940: }
12043 7, 0, // 944: case 0x7: {
12044 OPC_CheckPredicate, 139, 1, // 946: check predicate 139
12045 OPC_Decode, 132, 108, 31, // 949: decode to AIF_BITMIXB using decoder 31
12046 // 949: }
12047 // 949: } // switch Inst[14:12]
12048 // 949: }
12049 65, 21, // 953: case 0x41: {
12050 OPC_SwitchField, 12, 3, // 955: switch Inst[14:12] {
12051 2, 7, // 958: case 0x2: {
12052 OPC_CheckPredicate, 139, 1, // 960: check predicate 139
12053 OPC_Decode, 241, 107, 56, // 963: decode to AIF_AMOMING_W using decoder 56
12054 // 963: }
12055 3, 0, // 967: case 0x3: {
12056 OPC_CheckPredicate, 139, 1, // 969: check predicate 139
12057 OPC_Decode, 240, 107, 56, // 972: decode to AIF_AMOMING_D using decoder 56
12058 // 972: }
12059 // 972: } // switch Inst[14:12]
12060 // 972: }
12061 80, 21, // 976: case 0x50: {
12062 OPC_SwitchField, 12, 3, // 978: switch Inst[14:12] {
12063 2, 7, // 981: case 0x2: {
12064 OPC_CheckPredicate, 139, 1, // 983: check predicate 139
12065 OPC_Decode, 235, 107, 56, // 986: decode to AIF_AMOMAXL_W using decoder 56
12066 // 986: }
12067 3, 0, // 990: case 0x3: {
12068 OPC_CheckPredicate, 139, 1, // 992: check predicate 139
12069 OPC_Decode, 234, 107, 56, // 995: decode to AIF_AMOMAXL_D using decoder 56
12070 // 995: }
12071 // 995: } // switch Inst[14:12]
12072 // 995: }
12073 81, 21, // 999: case 0x51: {
12074 OPC_SwitchField, 12, 3, // 1001: switch Inst[14:12] {
12075 2, 7, // 1004: case 0x2: {
12076 OPC_CheckPredicate, 139, 1, // 1006: check predicate 139
12077 OPC_Decode, 233, 107, 56, // 1009: decode to AIF_AMOMAXG_W using decoder 56
12078 // 1009: }
12079 3, 0, // 1013: case 0x3: {
12080 OPC_CheckPredicate, 139, 1, // 1015: check predicate 139
12081 OPC_Decode, 232, 107, 56, // 1018: decode to AIF_AMOMAXG_D using decoder 56
12082 // 1018: }
12083 // 1018: } // switch Inst[14:12]
12084 // 1018: }
12085 96, 21, // 1022: case 0x60: {
12086 OPC_SwitchField, 12, 3, // 1024: switch Inst[14:12] {
12087 2, 7, // 1027: case 0x2: {
12088 OPC_CheckPredicate, 139, 1, // 1029: check predicate 139
12089 OPC_Decode, 247, 107, 56, // 1032: decode to AIF_AMOMINUL_W using decoder 56
12090 // 1032: }
12091 3, 0, // 1036: case 0x3: {
12092 OPC_CheckPredicate, 139, 1, // 1038: check predicate 139
12093 OPC_Decode, 246, 107, 56, // 1041: decode to AIF_AMOMINUL_D using decoder 56
12094 // 1041: }
12095 // 1041: } // switch Inst[14:12]
12096 // 1041: }
12097 97, 21, // 1045: case 0x61: {
12098 OPC_SwitchField, 12, 3, // 1047: switch Inst[14:12] {
12099 2, 7, // 1050: case 0x2: {
12100 OPC_CheckPredicate, 139, 1, // 1052: check predicate 139
12101 OPC_Decode, 245, 107, 56, // 1055: decode to AIF_AMOMINUG_W using decoder 56
12102 // 1055: }
12103 3, 0, // 1059: case 0x3: {
12104 OPC_CheckPredicate, 139, 1, // 1061: check predicate 139
12105 OPC_Decode, 244, 107, 56, // 1064: decode to AIF_AMOMINUG_D using decoder 56
12106 // 1064: }
12107 // 1064: } // switch Inst[14:12]
12108 // 1064: }
12109 112, 21, // 1068: case 0x70: {
12110 OPC_SwitchField, 12, 3, // 1070: switch Inst[14:12] {
12111 2, 7, // 1073: case 0x2: {
12112 OPC_CheckPredicate, 139, 1, // 1075: check predicate 139
12113 OPC_Decode, 239, 107, 56, // 1078: decode to AIF_AMOMAXUL_W using decoder 56
12114 // 1078: }
12115 3, 0, // 1082: case 0x3: {
12116 OPC_CheckPredicate, 139, 1, // 1084: check predicate 139
12117 OPC_Decode, 238, 107, 56, // 1087: decode to AIF_AMOMAXUL_D using decoder 56
12118 // 1087: }
12119 // 1087: } // switch Inst[14:12]
12120 // 1087: }
12121 113, 21, // 1091: case 0x71: {
12122 OPC_SwitchField, 12, 3, // 1093: switch Inst[14:12] {
12123 2, 7, // 1096: case 0x2: {
12124 OPC_CheckPredicate, 139, 1, // 1098: check predicate 139
12125 OPC_Decode, 237, 107, 56, // 1101: decode to AIF_AMOMAXUG_W using decoder 56
12126 // 1101: }
12127 3, 0, // 1105: case 0x3: {
12128 OPC_CheckPredicate, 139, 1, // 1107: check predicate 139
12129 OPC_Decode, 236, 107, 56, // 1110: decode to AIF_AMOMAXUG_D using decoder 56
12130 // 1110: }
12131 // 1110: } // switch Inst[14:12]
12132 // 1110: }
12133 120, 21, // 1114: case 0x78: {
12134 OPC_SwitchField, 12, 3, // 1116: switch Inst[14:12] {
12135 2, 7, // 1119: case 0x2: {
12136 OPC_CheckPredicate, 139, 1, // 1121: check predicate 139
12137 OPC_Decode, 231, 107, 56, // 1124: decode to AIF_AMOCMPSWAPL_W using decoder 56
12138 // 1124: }
12139 3, 0, // 1128: case 0x3: {
12140 OPC_CheckPredicate, 139, 1, // 1130: check predicate 139
12141 OPC_Decode, 230, 107, 56, // 1133: decode to AIF_AMOCMPSWAPL_D using decoder 56
12142 // 1133: }
12143 // 1133: } // switch Inst[14:12]
12144 // 1133: }
12145 121, 0, // 1137: case 0x79: {
12146 OPC_SwitchField, 12, 3, // 1139: switch Inst[14:12] {
12147 2, 7, // 1142: case 0x2: {
12148 OPC_CheckPredicate, 139, 1, // 1144: check predicate 139
12149 OPC_Decode, 229, 107, 56, // 1147: decode to AIF_AMOCMPSWAPG_W using decoder 56
12150 // 1147: }
12151 3, 0, // 1151: case 0x3: {
12152 OPC_CheckPredicate, 139, 1, // 1153: check predicate 139
12153 OPC_Decode, 228, 107, 56, // 1156: decode to AIF_AMOCMPSWAPG_D using decoder 56
12154 // 1156: }
12155 // 1156: } // switch Inst[14:12]
12156 // 1156: }
12157 // 1156: } // switch Inst[31:25]
12158 // 1156: }
12159 63, 45, // 1160: case 0x3f: {
12160 OPC_SwitchField, 12, 3, // 1162: switch Inst[14:12] {
12161 0, 12, // 1165: case 0x0: {
12162 OPC_CheckPredicate, 139, 1, // 1167: check predicate 139
12163 OPC_CheckField, 25, 2, 2, // 1170: check Inst[26:25] == 0x2
12164 OPC_Decode, 137, 108, 185, 1, // 1174: decode to AIF_FADDI_PI using decoder 185
12165 // 1174: }
12166 1, 12, // 1179: case 0x1: {
12167 OPC_CheckPredicate, 139, 1, // 1181: check predicate 139
12168 OPC_CheckField, 25, 2, 2, // 1184: check Inst[26:25] == 0x2
12169 OPC_Decode, 162, 108, 185, 1, // 1188: decode to AIF_FANDI_PI using decoder 185
12170 // 1188: }
12171 2, 0, // 1193: case 0x2: {
12172 OPC_CheckPredicate, 139, 1, // 1195: check predicate 139
12173 OPC_CheckField, 25, 2, 2, // 1198: check Inst[26:25] == 0x2
12174 OPC_Decode, 170, 108, 186, 1, // 1202: decode to AIF_FCMOV_PS using decoder 186
12175 // 1202: }
12176 // 1202: } // switch Inst[14:12]
12177 // 1202: }
12178 91, 43, // 1207: case 0x5b: {
12179 OPC_SwitchField, 25, 2, // 1209: switch Inst[26:25] {
12180 0, 8, // 1212: case 0x0: {
12181 OPC_CheckPredicate, 139, 1, // 1214: check predicate 139
12182 OPC_Decode, 230, 108, 187, 1, // 1217: decode to AIF_FMADD_PS using decoder 187
12183 // 1217: }
12184 1, 8, // 1222: case 0x1: {
12185 OPC_CheckPredicate, 139, 1, // 1224: check predicate 139
12186 OPC_Decode, 237, 108, 187, 1, // 1227: decode to AIF_FMSUB_PS using decoder 187
12187 // 1227: }
12188 2, 8, // 1232: case 0x2: {
12189 OPC_CheckPredicate, 139, 1, // 1234: check predicate 139
12190 OPC_Decode, 245, 108, 187, 1, // 1237: decode to AIF_FNMSUB_PS using decoder 187
12191 // 1237: }
12192 3, 0, // 1242: case 0x3: {
12193 OPC_CheckPredicate, 139, 1, // 1244: check predicate 139
12194 OPC_Decode, 244, 108, 187, 1, // 1247: decode to AIF_FNMADD_PS using decoder 187
12195 // 1247: }
12196 // 1247: } // switch Inst[26:25]
12197 // 1247: }
12198 95, 8, // 1252: case 0x5f: {
12199 OPC_CheckPredicate, 139, 1, // 1254: check predicate 139
12200 OPC_Decode, 164, 108, 184, 1, // 1257: decode to AIF_FBCI_PI using decoder 184
12201 // 1257: }
12202 119, 16, // 1262: case 0x77: {
12203 OPC_CheckPredicate, 139, 1, // 1264: check predicate 139
12204 OPC_CheckField, 25, 7, 0, // 1267: check Inst[31:25] == 0x0
12205 OPC_CheckField, 12, 3, 0, // 1271: check Inst[14:12] == 0x0
12206 OPC_Decode, 169, 108, 188, 1, // 1275: decode to AIF_FCMOVM_PS using decoder 188
12207 // 1275: }
12208 123, 0, // 1280: case 0x7b: {
12209 OPC_SwitchField, 25, 7, // 1282: switch Inst[31:25] {
12210 0, 8, // 1285: case 0x0: {
12211 OPC_CheckPredicate, 139, 1, // 1287: check predicate 139
12212 OPC_Decode, 139, 108, 189, 1, // 1290: decode to AIF_FADD_PS using decoder 189
12213 // 1290: }
12214 3, 102, // 1295: case 0x3: {
12215 OPC_SwitchField, 12, 3, // 1297: switch Inst[14:12] {
12216 0, 8, // 1300: case 0x0: {
12217 OPC_CheckPredicate, 139, 1, // 1302: check predicate 139
12218 OPC_Decode, 138, 108, 188, 1, // 1305: decode to AIF_FADD_PI using decoder 188
12219 // 1305: }
12220 1, 8, // 1310: case 0x1: {
12221 OPC_CheckPredicate, 139, 1, // 1312: check predicate 139
12222 OPC_Decode, 148, 109, 188, 1, // 1315: decode to AIF_FSLL_PI using decoder 188
12223 // 1315: }
12224 2, 12, // 1320: case 0x2: {
12225 OPC_CheckPredicate, 139, 1, // 1322: check predicate 139
12226 OPC_CheckField, 20, 5, 0, // 1325: check Inst[24:20] == 0x0
12227 OPC_Decode, 246, 108, 190, 1, // 1329: decode to AIF_FNOT_PI using decoder 190
12228 // 1329: }
12229 3, 23, // 1334: case 0x3: {
12230 OPC_SwitchField, 20, 5, // 1336: switch Inst[24:20] {
12231 0, 8, // 1339: case 0x0: {
12232 OPC_CheckPredicate, 139, 1, // 1341: check predicate 139
12233 OPC_Decode, 128, 109, 190, 1, // 1344: decode to AIF_FSAT8_PI using decoder 190
12234 // 1344: }
12235 1, 0, // 1349: case 0x1: {
12236 OPC_CheckPredicate, 139, 1, // 1351: check predicate 139
12237 OPC_Decode, 129, 109, 190, 1, // 1354: decode to AIF_FSATU8_PI using decoder 190
12238 // 1354: }
12239 // 1354: } // switch Inst[24:20]
12240 // 1354: }
12241 4, 8, // 1359: case 0x4: {
12242 OPC_CheckPredicate, 139, 1, // 1361: check predicate 139
12243 OPC_Decode, 161, 109, 188, 1, // 1364: decode to AIF_FXOR_PI using decoder 188
12244 // 1364: }
12245 5, 8, // 1369: case 0x5: {
12246 OPC_CheckPredicate, 139, 1, // 1371: check predicate 139
12247 OPC_Decode, 154, 109, 188, 1, // 1374: decode to AIF_FSRL_PI using decoder 188
12248 // 1374: }
12249 6, 8, // 1379: case 0x6: {
12250 OPC_CheckPredicate, 139, 1, // 1381: check predicate 139
12251 OPC_Decode, 247, 108, 188, 1, // 1384: decode to AIF_FOR_PI using decoder 188
12252 // 1384: }
12253 7, 0, // 1389: case 0x7: {
12254 OPC_CheckPredicate, 139, 1, // 1391: check predicate 139
12255 OPC_Decode, 163, 108, 188, 1, // 1394: decode to AIF_FAND_PI using decoder 188
12256 // 1394: }
12257 // 1394: } // switch Inst[14:12]
12258 // 1394: }
12259 4, 8, // 1399: case 0x4: {
12260 OPC_CheckPredicate, 139, 1, // 1401: check predicate 139
12261 OPC_Decode, 156, 109, 189, 1, // 1404: decode to AIF_FSUB_PS using decoder 189
12262 // 1404: }
12263 7, 23, // 1409: case 0x7: {
12264 OPC_SwitchField, 12, 3, // 1411: switch Inst[14:12] {
12265 0, 8, // 1414: case 0x0: {
12266 OPC_CheckPredicate, 139, 1, // 1416: check predicate 139
12267 OPC_Decode, 155, 109, 188, 1, // 1419: decode to AIF_FSUB_PI using decoder 188
12268 // 1419: }
12269 5, 0, // 1424: case 0x5: {
12270 OPC_CheckPredicate, 139, 1, // 1426: check predicate 139
12271 OPC_Decode, 152, 109, 188, 1, // 1429: decode to AIF_FSRA_PI using decoder 188
12272 // 1429: }
12273 // 1429: } // switch Inst[14:12]
12274 // 1429: }
12275 8, 8, // 1434: case 0x8: {
12276 OPC_CheckPredicate, 139, 1, // 1436: check predicate 139
12277 OPC_Decode, 241, 108, 189, 1, // 1439: decode to AIF_FMUL_PS using decoder 189
12278 // 1439: }
12279 11, 33, // 1444: case 0xb: {
12280 OPC_SwitchField, 12, 3, // 1446: switch Inst[14:12] {
12281 0, 8, // 1449: case 0x0: {
12282 OPC_CheckPredicate, 139, 1, // 1451: check predicate 139
12283 OPC_Decode, 240, 108, 188, 1, // 1454: decode to AIF_FMUL_PI using decoder 188
12284 // 1454: }
12285 1, 8, // 1459: case 0x1: {
12286 OPC_CheckPredicate, 139, 1, // 1461: check predicate 139
12287 OPC_Decode, 239, 108, 188, 1, // 1464: decode to AIF_FMULH_PI using decoder 188
12288 // 1464: }
12289 2, 0, // 1469: case 0x2: {
12290 OPC_CheckPredicate, 139, 1, // 1471: check predicate 139
12291 OPC_Decode, 238, 108, 188, 1, // 1474: decode to AIF_FMULHU_PI using decoder 188
12292 // 1474: }
12293 // 1474: } // switch Inst[14:12]
12294 // 1474: }
12295 12, 8, // 1479: case 0xc: {
12296 OPC_CheckPredicate, 139, 1, // 1481: check predicate 139
12297 OPC_Decode, 199, 108, 189, 1, // 1484: decode to AIF_FDIV_PS using decoder 189
12298 // 1484: }
12299 15, 43, // 1489: case 0xf: {
12300 OPC_SwitchField, 12, 3, // 1491: switch Inst[14:12] {
12301 0, 8, // 1494: case 0x0: {
12302 OPC_CheckPredicate, 139, 1, // 1496: check predicate 139
12303 OPC_Decode, 198, 108, 188, 1, // 1499: decode to AIF_FDIV_PI using decoder 188
12304 // 1499: }
12305 1, 8, // 1504: case 0x1: {
12306 OPC_CheckPredicate, 139, 1, // 1506: check predicate 139
12307 OPC_Decode, 197, 108, 188, 1, // 1509: decode to AIF_FDIVU_PI using decoder 188
12308 // 1509: }
12309 2, 8, // 1514: case 0x2: {
12310 OPC_CheckPredicate, 139, 1, // 1516: check predicate 139
12311 OPC_Decode, 253, 108, 188, 1, // 1519: decode to AIF_FREM_PI using decoder 188
12312 // 1519: }
12313 3, 0, // 1524: case 0x3: {
12314 OPC_CheckPredicate, 139, 1, // 1526: check predicate 139
12315 OPC_Decode, 252, 108, 188, 1, // 1529: decode to AIF_FREMU_PI using decoder 188
12316 // 1529: }
12317 // 1529: } // switch Inst[14:12]
12318 // 1529: }
12319 16, 33, // 1534: case 0x10: {
12320 OPC_SwitchField, 12, 3, // 1536: switch Inst[14:12] {
12321 0, 8, // 1539: case 0x0: {
12322 OPC_CheckPredicate, 139, 1, // 1541: check predicate 139
12323 OPC_Decode, 145, 109, 188, 1, // 1544: decode to AIF_FSGNJ_PS using decoder 188
12324 // 1544: }
12325 1, 8, // 1549: case 0x1: {
12326 OPC_CheckPredicate, 139, 1, // 1551: check predicate 139
12327 OPC_Decode, 143, 109, 188, 1, // 1554: decode to AIF_FSGNJN_PS using decoder 188
12328 // 1554: }
12329 2, 0, // 1559: case 0x2: {
12330 OPC_CheckPredicate, 139, 1, // 1561: check predicate 139
12331 OPC_Decode, 144, 109, 188, 1, // 1564: decode to AIF_FSGNJX_PS using decoder 188
12332 // 1564: }
12333 // 1564: } // switch Inst[14:12]
12334 // 1564: }
12335 19, 31, // 1569: case 0x13: {
12336 OPC_SwitchField, 12, 3, // 1571: switch Inst[14:12] {
12337 0, 12, // 1574: case 0x0: {
12338 OPC_CheckPredicate, 139, 1, // 1576: check predicate 139
12339 OPC_CheckField, 20, 5, 0, // 1579: check Inst[24:20] == 0x0
12340 OPC_Decode, 248, 108, 190, 1, // 1583: decode to AIF_FPACKREPB_PI using decoder 190
12341 // 1583: }
12342 1, 0, // 1588: case 0x1: {
12343 OPC_CheckPredicate, 139, 1, // 1590: check predicate 139
12344 OPC_CheckField, 20, 5, 0, // 1593: check Inst[24:20] == 0x0
12345 OPC_Decode, 249, 108, 190, 1, // 1597: decode to AIF_FPACKREPH_PI using decoder 190
12346 // 1597: }
12347 // 1597: } // switch Inst[14:12]
12348 // 1597: }
12349 20, 23, // 1602: case 0x14: {
12350 OPC_SwitchField, 12, 3, // 1604: switch Inst[14:12] {
12351 0, 8, // 1607: case 0x0: {
12352 OPC_CheckPredicate, 139, 1, // 1609: check predicate 139
12353 OPC_Decode, 236, 108, 188, 1, // 1612: decode to AIF_FMIN_PS using decoder 188
12354 // 1612: }
12355 1, 0, // 1617: case 0x1: {
12356 OPC_CheckPredicate, 139, 1, // 1619: check predicate 139
12357 OPC_Decode, 233, 108, 188, 1, // 1622: decode to AIF_FMAX_PS using decoder 188
12358 // 1622: }
12359 // 1622: } // switch Inst[14:12]
12360 // 1622: }
12361 23, 43, // 1627: case 0x17: {
12362 OPC_SwitchField, 12, 3, // 1629: switch Inst[14:12] {
12363 0, 8, // 1632: case 0x0: {
12364 OPC_CheckPredicate, 139, 1, // 1634: check predicate 139
12365 OPC_Decode, 235, 108, 188, 1, // 1637: decode to AIF_FMIN_PI using decoder 188
12366 // 1637: }
12367 1, 8, // 1642: case 0x1: {
12368 OPC_CheckPredicate, 139, 1, // 1644: check predicate 139
12369 OPC_Decode, 232, 108, 188, 1, // 1647: decode to AIF_FMAX_PI using decoder 188
12370 // 1647: }
12371 2, 8, // 1652: case 0x2: {
12372 OPC_CheckPredicate, 139, 1, // 1654: check predicate 139
12373 OPC_Decode, 234, 108, 188, 1, // 1657: decode to AIF_FMINU_PI using decoder 188
12374 // 1657: }
12375 3, 0, // 1662: case 0x3: {
12376 OPC_CheckPredicate, 139, 1, // 1664: check predicate 139
12377 OPC_Decode, 231, 108, 188, 1, // 1667: decode to AIF_FMAXU_PI using decoder 188
12378 // 1667: }
12379 // 1667: } // switch Inst[14:12]
12380 // 1667: }
12381 24, 12, // 1672: case 0x18: {
12382 OPC_CheckPredicate, 139, 1, // 1674: check predicate 139
12383 OPC_CheckField, 12, 3, 0, // 1677: check Inst[14:12] == 0x0
12384 OPC_Decode, 250, 108, 188, 1, // 1681: decode to AIF_FRCP_FIX_RAST using decoder 188
12385 // 1681: }
12386 31, 12, // 1686: case 0x1f: {
12387 OPC_CheckPredicate, 139, 1, // 1688: check predicate 139
12388 OPC_CheckField, 12, 3, 0, // 1691: check Inst[14:12] == 0x0
12389 OPC_Decode, 222, 108, 191, 1, // 1695: decode to AIF_FLTM_PI using decoder 191
12390 // 1695: }
12391 39, 33, // 1700: case 0x27: {
12392 OPC_SwitchField, 12, 3, // 1702: switch Inst[14:12] {
12393 1, 8, // 1705: case 0x1: {
12394 OPC_CheckPredicate, 139, 1, // 1707: check predicate 139
12395 OPC_Decode, 147, 109, 192, 1, // 1710: decode to AIF_FSLLI_PI using decoder 192
12396 // 1710: }
12397 5, 8, // 1715: case 0x5: {
12398 OPC_CheckPredicate, 139, 1, // 1717: check predicate 139
12399 OPC_Decode, 153, 109, 192, 1, // 1720: decode to AIF_FSRLI_PI using decoder 192
12400 // 1720: }
12401 7, 0, // 1725: case 0x7: {
12402 OPC_CheckPredicate, 139, 1, // 1727: check predicate 139
12403 OPC_Decode, 151, 109, 192, 1, // 1730: decode to AIF_FSRAI_PI using decoder 192
12404 // 1730: }
12405 // 1730: } // switch Inst[14:12]
12406 // 1730: }
12407 41, 16, // 1735: case 0x29: {
12408 OPC_CheckPredicate, 139, 1, // 1737: check predicate 139
12409 OPC_CheckField, 18, 7, 0, // 1740: check Inst[24:18] == 0x0
12410 OPC_CheckField, 12, 3, 0, // 1744: check Inst[14:12] == 0x0
12411 OPC_Decode, 165, 109, 193, 1, // 1748: decode to AIF_MASKPOPC using decoder 193
12412 // 1748: }
12413 42, 16, // 1753: case 0x2a: {
12414 OPC_CheckPredicate, 139, 1, // 1755: check predicate 139
12415 OPC_CheckField, 18, 7, 0, // 1758: check Inst[24:18] == 0x0
12416 OPC_CheckField, 12, 3, 0, // 1762: check Inst[14:12] == 0x0
12417 OPC_Decode, 166, 109, 193, 1, // 1766: decode to AIF_MASKPOPCZ using decoder 193
12418 // 1766: }
12419 43, 12, // 1771: case 0x2b: {
12420 OPC_CheckPredicate, 139, 1, // 1773: check predicate 139
12421 OPC_CheckField, 10, 2, 0, // 1776: check Inst[11:10] == 0x0
12422 OPC_Decode, 171, 109, 194, 1, // 1780: decode to AIF_MOV_M_X using decoder 194
12423 // 1780: }
12424 44, 111, // 1785: case 0x2c: {
12425 OPC_SwitchField, 20, 5, // 1787: switch Inst[24:20] {
12426 0, 12, // 1790: case 0x0: {
12427 OPC_CheckPredicate, 139, 1, // 1792: check predicate 139
12428 OPC_CheckField, 12, 3, 0, // 1795: check Inst[14:12] == 0x0
12429 OPC_Decode, 150, 109, 190, 1, // 1799: decode to AIF_FSQRT_PS using decoder 190
12430 // 1799: }
12431 1, 8, // 1804: case 0x1: {
12432 OPC_CheckPredicate, 139, 1, // 1806: check predicate 139
12433 OPC_Decode, 254, 108, 195, 1, // 1809: decode to AIF_FROUND_PS using decoder 195
12434 // 1809: }
12435 2, 12, // 1814: case 0x2: {
12436 OPC_CheckPredicate, 139, 1, // 1816: check predicate 139
12437 OPC_CheckField, 12, 3, 0, // 1819: check Inst[14:12] == 0x0
12438 OPC_Decode, 204, 108, 190, 1, // 1823: decode to AIF_FFRC_PS using decoder 190
12439 // 1823: }
12440 3, 12, // 1828: case 0x3: {
12441 OPC_CheckPredicate, 139, 1, // 1830: check predicate 139
12442 OPC_CheckField, 12, 3, 0, // 1833: check Inst[14:12] == 0x0
12443 OPC_Decode, 220, 108, 190, 1, // 1837: decode to AIF_FLOG_PS using decoder 190
12444 // 1837: }
12445 4, 12, // 1842: case 0x4: {
12446 OPC_CheckPredicate, 139, 1, // 1844: check predicate 139
12447 OPC_CheckField, 12, 3, 0, // 1847: check Inst[14:12] == 0x0
12448 OPC_Decode, 203, 108, 190, 1, // 1851: decode to AIF_FEXP_PS using decoder 190
12449 // 1851: }
12450 6, 12, // 1856: case 0x6: {
12451 OPC_CheckPredicate, 139, 1, // 1858: check predicate 139
12452 OPC_CheckField, 12, 3, 0, // 1861: check Inst[14:12] == 0x0
12453 OPC_Decode, 146, 109, 190, 1, // 1865: decode to AIF_FSIN_PS using decoder 190
12454 // 1865: }
12455 7, 12, // 1870: case 0x7: {
12456 OPC_CheckPredicate, 139, 1, // 1872: check predicate 139
12457 OPC_CheckField, 12, 3, 0, // 1875: check Inst[14:12] == 0x0
12458 OPC_Decode, 251, 108, 190, 1, // 1879: decode to AIF_FRCP_PS using decoder 190
12459 // 1879: }
12460 8, 0, // 1884: case 0x8: {
12461 OPC_CheckPredicate, 139, 1, // 1886: check predicate 139
12462 OPC_CheckField, 12, 3, 0, // 1889: check Inst[14:12] == 0x0
12463 OPC_Decode, 255, 108, 190, 1, // 1893: decode to AIF_FRSQ_PS using decoder 190
12464 // 1893: }
12465 // 1893: } // switch Inst[24:20]
12466 // 1893: }
12467 47, 12, // 1898: case 0x2f: {
12468 OPC_CheckPredicate, 139, 1, // 1900: check predicate 139
12469 OPC_CheckField, 12, 3, 0, // 1903: check Inst[14:12] == 0x0
12470 OPC_Decode, 167, 109, 196, 1, // 1907: decode to AIF_MASKPOPC_ET_RAST using decoder 196
12471 // 1907: }
12472 51, 71, // 1912: case 0x33: {
12473 OPC_SwitchField, 10, 5, // 1914: switch Inst[14:10] {
12474 8, 12, // 1917: case 0x8: {
12475 OPC_CheckPredicate, 139, 1, // 1919: check predicate 139
12476 OPC_CheckField, 18, 7, 0, // 1922: check Inst[24:18] == 0x0
12477 OPC_Decode, 163, 109, 197, 1, // 1926: decode to AIF_MASKNOT using decoder 197
12478 // 1926: }
12479 16, 16, // 1931: case 0x10: {
12480 OPC_CheckPredicate, 139, 1, // 1933: check predicate 139
12481 OPC_CheckField, 23, 2, 0, // 1936: check Inst[24:23] == 0x0
12482 OPC_CheckField, 18, 2, 0, // 1940: check Inst[19:18] == 0x0
12483 OPC_Decode, 168, 109, 198, 1, // 1944: decode to AIF_MASKXOR using decoder 198
12484 // 1944: }
12485 24, 16, // 1949: case 0x18: {
12486 OPC_CheckPredicate, 139, 1, // 1951: check predicate 139
12487 OPC_CheckField, 23, 2, 0, // 1954: check Inst[24:23] == 0x0
12488 OPC_CheckField, 18, 2, 0, // 1958: check Inst[19:18] == 0x0
12489 OPC_Decode, 164, 109, 198, 1, // 1962: decode to AIF_MASKOR using decoder 198
12490 // 1962: }
12491 28, 0, // 1967: case 0x1c: {
12492 OPC_CheckPredicate, 139, 1, // 1969: check predicate 139
12493 OPC_CheckField, 23, 2, 0, // 1972: check Inst[24:23] == 0x0
12494 OPC_CheckField, 18, 2, 0, // 1976: check Inst[19:18] == 0x0
12495 OPC_Decode, 162, 109, 198, 1, // 1980: decode to AIF_MASKAND using decoder 198
12496 // 1980: }
12497 // 1980: } // switch Inst[14:10]
12498 // 1980: }
12499 68, 43, // 1985: case 0x44: {
12500 OPC_SwitchField, 12, 3, // 1987: switch Inst[14:12] {
12501 0, 8, // 1990: case 0x0: {
12502 OPC_CheckPredicate, 139, 1, // 1992: check predicate 139
12503 OPC_Decode, 134, 108, 188, 1, // 1995: decode to AIF_CUBEFACE_PS using decoder 188
12504 // 1995: }
12505 1, 8, // 2000: case 0x1: {
12506 OPC_CheckPredicate, 139, 1, // 2002: check predicate 139
12507 OPC_Decode, 133, 108, 188, 1, // 2005: decode to AIF_CUBEFACEIDX_PS using decoder 188
12508 // 2005: }
12509 2, 8, // 2010: case 0x2: {
12510 OPC_CheckPredicate, 139, 1, // 2012: check predicate 139
12511 OPC_Decode, 135, 108, 188, 1, // 2015: decode to AIF_CUBESGNSC_PS using decoder 188
12512 // 2015: }
12513 3, 0, // 2020: case 0x3: {
12514 OPC_CheckPredicate, 139, 1, // 2022: check predicate 139
12515 OPC_Decode, 136, 108, 188, 1, // 2025: decode to AIF_CUBESGNTC_PS using decoder 188
12516 // 2025: }
12517 // 2025: } // switch Inst[14:12]
12518 // 2025: }
12519 80, 63, // 2030: case 0x50: {
12520 OPC_SwitchField, 12, 3, // 2032: switch Inst[14:12] {
12521 0, 8, // 2035: case 0x0: {
12522 OPC_CheckPredicate, 139, 1, // 2037: check predicate 139
12523 OPC_Decode, 219, 108, 188, 1, // 2040: decode to AIF_FLE_PS using decoder 188
12524 // 2040: }
12525 1, 8, // 2045: case 0x1: {
12526 OPC_CheckPredicate, 139, 1, // 2047: check predicate 139
12527 OPC_Decode, 226, 108, 188, 1, // 2050: decode to AIF_FLT_PS using decoder 188
12528 // 2050: }
12529 2, 8, // 2055: case 0x2: {
12530 OPC_CheckPredicate, 139, 1, // 2057: check predicate 139
12531 OPC_Decode, 202, 108, 188, 1, // 2060: decode to AIF_FEQ_PS using decoder 188
12532 // 2060: }
12533 4, 8, // 2065: case 0x4: {
12534 OPC_CheckPredicate, 139, 1, // 2067: check predicate 139
12535 OPC_Decode, 217, 108, 191, 1, // 2070: decode to AIF_FLEM_PS using decoder 191
12536 // 2070: }
12537 5, 8, // 2075: case 0x5: {
12538 OPC_CheckPredicate, 139, 1, // 2077: check predicate 139
12539 OPC_Decode, 223, 108, 191, 1, // 2080: decode to AIF_FLTM_PS using decoder 191
12540 // 2080: }
12541 6, 0, // 2085: case 0x6: {
12542 OPC_CheckPredicate, 139, 1, // 2087: check predicate 139
12543 OPC_Decode, 200, 108, 191, 1, // 2090: decode to AIF_FEQM_PS using decoder 191
12544 // 2090: }
12545 // 2090: } // switch Inst[14:12]
12546 // 2090: }
12547 83, 57, // 2095: case 0x53: {
12548 OPC_SwitchField, 12, 3, // 2097: switch Inst[14:12] {
12549 0, 8, // 2100: case 0x0: {
12550 OPC_CheckPredicate, 139, 1, // 2102: check predicate 139
12551 OPC_Decode, 218, 108, 188, 1, // 2105: decode to AIF_FLE_PI using decoder 188
12552 // 2105: }
12553 1, 8, // 2110: case 0x1: {
12554 OPC_CheckPredicate, 139, 1, // 2112: check predicate 139
12555 OPC_Decode, 225, 108, 188, 1, // 2115: decode to AIF_FLT_PI using decoder 188
12556 // 2115: }
12557 2, 8, // 2120: case 0x2: {
12558 OPC_CheckPredicate, 139, 1, // 2122: check predicate 139
12559 OPC_Decode, 201, 108, 188, 1, // 2125: decode to AIF_FEQ_PI using decoder 188
12560 // 2125: }
12561 3, 8, // 2130: case 0x3: {
12562 OPC_CheckPredicate, 139, 1, // 2132: check predicate 139
12563 OPC_Decode, 224, 108, 188, 1, // 2135: decode to AIF_FLTU_PI using decoder 188
12564 // 2135: }
12565 4, 0, // 2140: case 0x4: {
12566 OPC_CheckPredicate, 139, 1, // 2142: check predicate 139
12567 OPC_CheckField, 20, 5, 0, // 2145: check Inst[24:20] == 0x0
12568 OPC_Decode, 142, 109, 199, 1, // 2149: decode to AIF_FSETM_PI using decoder 199
12569 // 2149: }
12570 // 2149: } // switch Inst[14:12]
12571 // 2149: }
12572 96, 37, // 2154: case 0x60: {
12573 OPC_SwitchField, 20, 5, // 2156: switch Inst[24:20] {
12574 0, 8, // 2159: case 0x0: {
12575 OPC_CheckPredicate, 139, 1, // 2161: check predicate 139
12576 OPC_Decode, 188, 108, 195, 1, // 2164: decode to AIF_FCVT_PW_PS using decoder 195
12577 // 2164: }
12578 1, 8, // 2169: case 0x1: {
12579 OPC_CheckPredicate, 139, 1, // 2171: check predicate 139
12580 OPC_Decode, 187, 108, 195, 1, // 2174: decode to AIF_FCVT_PWU_PS using decoder 195
12581 // 2174: }
12582 2, 0, // 2179: case 0x2: {
12583 OPC_CheckPredicate, 139, 1, // 2181: check predicate 139
12584 OPC_CheckField, 12, 3, 0, // 2184: check Inst[14:12] == 0x0
12585 OPC_Decode, 189, 108, 190, 1, // 2188: decode to AIF_FCVT_RAST_PS using decoder 190
12586 // 2188: }
12587 // 2188: } // switch Inst[24:20]
12588 // 2188: }
12589 104, 177, 1, // 2193: case 0x68: {
12590 OPC_SwitchField, 20, 5, // 2196: switch Inst[24:20] {
12591 0, 8, // 2199: case 0x0: {
12592 OPC_CheckPredicate, 139, 1, // 2201: check predicate 139
12593 OPC_Decode, 177, 108, 195, 1, // 2204: decode to AIF_FCVT_PS_PW using decoder 195
12594 // 2204: }
12595 1, 8, // 2209: case 0x1: {
12596 OPC_CheckPredicate, 139, 1, // 2211: check predicate 139
12597 OPC_Decode, 178, 108, 195, 1, // 2214: decode to AIF_FCVT_PS_PWU using decoder 195
12598 // 2214: }
12599 2, 12, // 2219: case 0x2: {
12600 OPC_CheckPredicate, 139, 1, // 2221: check predicate 139
12601 OPC_CheckField, 12, 3, 0, // 2224: check Inst[14:12] == 0x0
12602 OPC_Decode, 179, 108, 190, 1, // 2228: decode to AIF_FCVT_PS_RAST using decoder 190
12603 // 2228: }
12604 8, 12, // 2233: case 0x8: {
12605 OPC_CheckPredicate, 139, 1, // 2235: check predicate 139
12606 OPC_CheckField, 12, 3, 0, // 2238: check Inst[14:12] == 0x0
12607 OPC_Decode, 174, 108, 190, 1, // 2242: decode to AIF_FCVT_PS_F10 using decoder 190
12608 // 2242: }
12609 9, 12, // 2247: case 0x9: {
12610 OPC_CheckPredicate, 139, 1, // 2249: check predicate 139
12611 OPC_CheckField, 12, 3, 0, // 2252: check Inst[14:12] == 0x0
12612 OPC_Decode, 175, 108, 190, 1, // 2256: decode to AIF_FCVT_PS_F11 using decoder 190
12613 // 2256: }
12614 10, 12, // 2261: case 0xa: {
12615 OPC_CheckPredicate, 139, 1, // 2263: check predicate 139
12616 OPC_CheckField, 12, 3, 0, // 2266: check Inst[14:12] == 0x0
12617 OPC_Decode, 176, 108, 190, 1, // 2270: decode to AIF_FCVT_PS_F16 using decoder 190
12618 // 2270: }
12619 16, 12, // 2275: case 0x10: {
12620 OPC_CheckPredicate, 139, 1, // 2277: check predicate 139
12621 OPC_CheckField, 12, 3, 0, // 2280: check Inst[14:12] == 0x0
12622 OPC_Decode, 185, 108, 190, 1, // 2284: decode to AIF_FCVT_PS_UN24 using decoder 190
12623 // 2284: }
12624 17, 12, // 2289: case 0x11: {
12625 OPC_CheckPredicate, 139, 1, // 2291: check predicate 139
12626 OPC_CheckField, 12, 3, 0, // 2294: check Inst[14:12] == 0x0
12627 OPC_Decode, 183, 108, 190, 1, // 2298: decode to AIF_FCVT_PS_UN16 using decoder 190
12628 // 2298: }
12629 18, 12, // 2303: case 0x12: {
12630 OPC_CheckPredicate, 139, 1, // 2305: check predicate 139
12631 OPC_CheckField, 12, 3, 0, // 2308: check Inst[14:12] == 0x0
12632 OPC_Decode, 182, 108, 190, 1, // 2312: decode to AIF_FCVT_PS_UN10 using decoder 190
12633 // 2312: }
12634 19, 12, // 2317: case 0x13: {
12635 OPC_CheckPredicate, 139, 1, // 2319: check predicate 139
12636 OPC_CheckField, 12, 3, 0, // 2322: check Inst[14:12] == 0x0
12637 OPC_Decode, 186, 108, 190, 1, // 2326: decode to AIF_FCVT_PS_UN8 using decoder 190
12638 // 2326: }
12639 23, 12, // 2331: case 0x17: {
12640 OPC_CheckPredicate, 139, 1, // 2333: check predicate 139
12641 OPC_CheckField, 12, 3, 0, // 2336: check Inst[14:12] == 0x0
12642 OPC_Decode, 184, 108, 190, 1, // 2340: decode to AIF_FCVT_PS_UN2 using decoder 190
12643 // 2340: }
12644 25, 12, // 2345: case 0x19: {
12645 OPC_CheckPredicate, 139, 1, // 2347: check predicate 139
12646 OPC_CheckField, 12, 3, 0, // 2350: check Inst[14:12] == 0x0
12647 OPC_Decode, 180, 108, 190, 1, // 2354: decode to AIF_FCVT_PS_SN16 using decoder 190
12648 // 2354: }
12649 27, 0, // 2359: case 0x1b: {
12650 OPC_CheckPredicate, 139, 1, // 2361: check predicate 139
12651 OPC_CheckField, 12, 3, 0, // 2364: check Inst[14:12] == 0x0
12652 OPC_Decode, 181, 108, 190, 1, // 2368: decode to AIF_FCVT_PS_SN8 using decoder 190
12653 // 2368: }
12654 // 2368: } // switch Inst[24:20]
12655 // 2368: }
12656 107, 34, // 2373: case 0x6b: {
12657 OPC_SwitchField, 12, 3, // 2375: switch Inst[14:12] {
12658 0, 12, // 2378: case 0x0: {
12659 OPC_CheckPredicate, 139, 1, // 2380: check predicate 139
12660 OPC_CheckField, 15, 10, 0, // 2383: check Inst[24:15] == 0x0
12661 OPC_Decode, 170, 109, 200, 1, // 2387: decode to AIF_MOVA_X_M using decoder 200
12662 // 2387: }
12663 1, 0, // 2392: case 0x1: {
12664 OPC_CheckPredicate, 139, 1, // 2394: check predicate 139
12665 OPC_CheckField, 20, 5, 0, // 2397: check Inst[24:20] == 0x0
12666 OPC_CheckField, 7, 5, 0, // 2401: check Inst[11:7] == 0x0
12667 OPC_Decode, 169, 109, 15, // 2405: decode to AIF_MOVA_M_X using decoder 15
12668 // 2405: }
12669 // 2405: } // switch Inst[14:12]
12670 // 2405: }
12671 108, 143, 1, // 2409: case 0x6c: {
12672 OPC_SwitchField, 20, 5, // 2412: switch Inst[24:20] {
12673 8, 12, // 2415: case 0x8: {
12674 OPC_CheckPredicate, 139, 1, // 2417: check predicate 139
12675 OPC_CheckField, 12, 3, 0, // 2420: check Inst[14:12] == 0x0
12676 OPC_Decode, 172, 108, 190, 1, // 2424: decode to AIF_FCVT_F11_PS using decoder 190
12677 // 2424: }
12678 9, 12, // 2429: case 0x9: {
12679 OPC_CheckPredicate, 139, 1, // 2431: check predicate 139
12680 OPC_CheckField, 12, 3, 0, // 2434: check Inst[14:12] == 0x0
12681 OPC_Decode, 173, 108, 190, 1, // 2438: decode to AIF_FCVT_F16_PS using decoder 190
12682 // 2438: }
12683 11, 12, // 2443: case 0xb: {
12684 OPC_CheckPredicate, 139, 1, // 2445: check predicate 139
12685 OPC_CheckField, 12, 3, 0, // 2448: check Inst[14:12] == 0x0
12686 OPC_Decode, 171, 108, 190, 1, // 2452: decode to AIF_FCVT_F10_PS using decoder 190
12687 // 2452: }
12688 16, 12, // 2457: case 0x10: {
12689 OPC_CheckPredicate, 139, 1, // 2459: check predicate 139
12690 OPC_CheckField, 12, 3, 0, // 2462: check Inst[14:12] == 0x0
12691 OPC_Decode, 194, 108, 190, 1, // 2466: decode to AIF_FCVT_UN24_PS using decoder 190
12692 // 2466: }
12693 17, 12, // 2471: case 0x11: {
12694 OPC_CheckPredicate, 139, 1, // 2473: check predicate 139
12695 OPC_CheckField, 12, 3, 0, // 2476: check Inst[14:12] == 0x0
12696 OPC_Decode, 193, 108, 190, 1, // 2480: decode to AIF_FCVT_UN16_PS using decoder 190
12697 // 2480: }
12698 18, 12, // 2485: case 0x12: {
12699 OPC_CheckPredicate, 139, 1, // 2487: check predicate 139
12700 OPC_CheckField, 12, 3, 0, // 2490: check Inst[14:12] == 0x0
12701 OPC_Decode, 192, 108, 190, 1, // 2494: decode to AIF_FCVT_UN10_PS using decoder 190
12702 // 2494: }
12703 19, 12, // 2499: case 0x13: {
12704 OPC_CheckPredicate, 139, 1, // 2501: check predicate 139
12705 OPC_CheckField, 12, 3, 0, // 2504: check Inst[14:12] == 0x0
12706 OPC_Decode, 196, 108, 190, 1, // 2508: decode to AIF_FCVT_UN8_PS using decoder 190
12707 // 2508: }
12708 23, 12, // 2513: case 0x17: {
12709 OPC_CheckPredicate, 139, 1, // 2515: check predicate 139
12710 OPC_CheckField, 12, 3, 0, // 2518: check Inst[14:12] == 0x0
12711 OPC_Decode, 195, 108, 190, 1, // 2522: decode to AIF_FCVT_UN2_PS using decoder 190
12712 // 2522: }
12713 25, 12, // 2527: case 0x19: {
12714 OPC_CheckPredicate, 139, 1, // 2529: check predicate 139
12715 OPC_CheckField, 12, 3, 0, // 2532: check Inst[14:12] == 0x0
12716 OPC_Decode, 190, 108, 190, 1, // 2536: decode to AIF_FCVT_SN16_PS using decoder 190
12717 // 2536: }
12718 27, 0, // 2541: case 0x1b: {
12719 OPC_CheckPredicate, 139, 1, // 2543: check predicate 139
12720 OPC_CheckField, 12, 3, 0, // 2546: check Inst[14:12] == 0x0
12721 OPC_Decode, 191, 108, 190, 1, // 2550: decode to AIF_FCVT_SN8_PS using decoder 190
12722 // 2550: }
12723 // 2550: } // switch Inst[24:20]
12724 // 2550: }
12725 112, 45, // 2555: case 0x70: {
12726 OPC_SwitchField, 12, 3, // 2557: switch Inst[14:12] {
12727 0, 12, // 2560: case 0x0: {
12728 OPC_CheckPredicate, 139, 1, // 2562: check predicate 139
12729 OPC_CheckField, 23, 2, 0, // 2565: check Inst[24:23] == 0x0
12730 OPC_Decode, 243, 108, 201, 1, // 2569: decode to AIF_FMVZ_X_PS using decoder 201
12731 // 2569: }
12732 1, 12, // 2574: case 0x1: {
12733 OPC_CheckPredicate, 139, 1, // 2576: check predicate 139
12734 OPC_CheckField, 20, 5, 0, // 2579: check Inst[24:20] == 0x0
12735 OPC_Decode, 168, 108, 190, 1, // 2583: decode to AIF_FCLASS_PS using decoder 190
12736 // 2583: }
12737 2, 0, // 2588: case 0x2: {
12738 OPC_CheckPredicate, 139, 1, // 2590: check predicate 139
12739 OPC_CheckField, 23, 2, 0, // 2593: check Inst[24:23] == 0x0
12740 OPC_Decode, 242, 108, 201, 1, // 2597: decode to AIF_FMVS_X_PS using decoder 201
12741 // 2597: }
12742 // 2597: } // switch Inst[14:12]
12743 // 2597: }
12744 115, 0, // 2602: case 0x73: {
12745 OPC_CheckPredicate, 139, 1, // 2604: check predicate 139
12746 OPC_Decode, 158, 109, 202, 1, // 2607: decode to AIF_FSWIZZ_PS using decoder 202
12747 // 2607: }
12748 // 2607: } // switch Inst[31:25]
12749 // 2607: }
12750 // 2607: } // switch Inst[6:0]
12751};
12752static const uint8_t DecoderTableXAndes32[612] = {
12753 32, // 0: BitWidth 32
12754 OPC_SwitchField, 12, 2, // 1: switch Inst[13:12] {
12755 0, 150, 3, // 4: case 0x0: {
12756 OPC_SwitchField, 0, 7, // 7: switch Inst[6:0] {
12757 11, 8, // 10: case 0xb: {
12758 OPC_CheckPredicate, 140, 1, // 12: check predicate 140
12759 OPC_Decode, 168, 118, 203, 1, // 15: decode to NDS_LBGP using decoder 203
12760 // 15: }
12761 43, 23, // 20: case 0x2b: {
12762 OPC_SwitchField, 14, 1, // 22: switch Inst[14] {
12763 0, 8, // 25: case 0x0: {
12764 OPC_CheckPredicate, 140, 1, // 27: check predicate 140
12765 OPC_Decode, 184, 118, 204, 1, // 30: decode to NDS_SHGP using decoder 204
12766 // 30: }
12767 1, 0, // 35: case 0x1: {
12768 OPC_CheckPredicate, 140, 1, // 37: check predicate 140
12769 OPC_Decode, 185, 118, 205, 1, // 40: decode to NDS_SWGP using decoder 205
12770 // 40: }
12771 // 40: } // switch Inst[14]
12772 // 40: }
12773 91, 0, // 45: case 0x5b: {
12774 OPC_SwitchField, 26, 6, // 47: switch Inst[31:26] {
12775 0, 95, // 50: case 0x0: {
12776 OPC_SwitchField, 14, 6, // 52: switch Inst[19:14] {
12777 1, 12, // 55: case 0x1: {
12778 OPC_CheckPredicate, 141, 1, // 57: check predicate 141
12779 OPC_CheckField, 25, 1, 0, // 60: check Inst[25] == 0x0
12780 OPC_Decode, 196, 118, 135, 1, // 64: decode to NDS_VFWCVT_S_BF16 using decoder 135
12781 // 64: }
12782 3, 12, // 69: case 0x3: {
12783 OPC_CheckPredicate, 141, 1, // 71: check predicate 141
12784 OPC_CheckField, 25, 1, 0, // 74: check Inst[25] == 0x0
12785 OPC_Decode, 189, 118, 135, 1, // 78: decode to NDS_VFNCVT_BF16_S using decoder 135
12786 // 78: }
12787 5, 12, // 83: case 0x5: {
12788 OPC_CheckPredicate, 142, 1, // 85: check predicate 142
12789 OPC_CheckField, 25, 1, 0, // 88: check Inst[25] == 0x0
12790 OPC_Decode, 161, 118, 206, 1, // 92: decode to NDS_FCVT_S_BF16 using decoder 206
12791 // 92: }
12792 7, 12, // 97: case 0x7: {
12793 OPC_CheckPredicate, 142, 1, // 99: check predicate 142
12794 OPC_CheckField, 25, 1, 0, // 102: check Inst[25] == 0x0
12795 OPC_Decode, 160, 118, 207, 1, // 106: decode to NDS_FCVT_BF16_S using decoder 207
12796 // 106: }
12797 9, 7, // 111: case 0x9: {
12798 OPC_CheckPredicate, 143, 1, // 113: check predicate 143
12799 OPC_Decode, 194, 118, 124, // 116: decode to NDS_VFWCVT_F_N using decoder 124
12800 // 116: }
12801 11, 7, // 120: case 0xb: {
12802 OPC_CheckPredicate, 143, 1, // 122: check predicate 143
12803 OPC_Decode, 195, 118, 124, // 125: decode to NDS_VFWCVT_F_NU using decoder 124
12804 // 125: }
12805 13, 7, // 129: case 0xd: {
12806 OPC_CheckPredicate, 143, 1, // 131: check predicate 143
12807 OPC_Decode, 192, 118, 124, // 134: decode to NDS_VFWCVT_F_B using decoder 124
12808 // 134: }
12809 15, 0, // 138: case 0xf: {
12810 OPC_CheckPredicate, 143, 1, // 140: check predicate 143
12811 OPC_Decode, 193, 118, 124, // 143: decode to NDS_VFWCVT_F_BU using decoder 124
12812 // 143: }
12813 // 143: } // switch Inst[19:14]
12814 // 143: }
12815 1, 46, // 147: case 0x1: {
12816 OPC_SwitchField, 20, 5, // 149: switch Inst[24:20] {
12817 0, 15, // 152: case 0x0: {
12818 OPC_CheckPredicate, 144, 1, // 154: check predicate 144
12819 OPC_CheckField, 25, 1, 1, // 157: check Inst[25] == 0x1
12820 OPC_CheckField, 14, 1, 1, // 161: check Inst[14] == 0x1
12821 OPC_Decode, 197, 118, 2, // 165: decode to NDS_VLE4_V using decoder 2
12822 // 165: }
12823 2, 11, // 169: case 0x2: {
12824 OPC_CheckPredicate, 145, 1, // 171: check predicate 145
12825 OPC_CheckField, 14, 1, 1, // 174: check Inst[14] == 0x1
12826 OPC_Decode, 198, 118, 1, // 178: decode to NDS_VLN8_V using decoder 1
12827 // 178: }
12828 3, 0, // 182: case 0x3: {
12829 OPC_CheckPredicate, 145, 1, // 184: check predicate 145
12830 OPC_CheckField, 14, 1, 1, // 187: check Inst[14] == 0x1
12831 OPC_Decode, 199, 118, 1, // 191: decode to NDS_VLNU8_V using decoder 1
12832 // 191: }
12833 // 191: } // switch Inst[24:20]
12834 // 191: }
12835 2, 26, // 195: case 0x2: {
12836 OPC_SwitchField, 14, 1, // 197: switch Inst[14] {
12837 0, 11, // 200: case 0x0: {
12838 OPC_CheckPredicate, 140, 1, // 202: check predicate 140
12839 OPC_CheckField, 25, 1, 1, // 205: check Inst[25] == 0x1
12840 OPC_Decode, 174, 118, 56, // 209: decode to NDS_LEA_H using decoder 56
12841 // 209: }
12842 1, 0, // 213: case 0x1: {
12843 OPC_CheckPredicate, 146, 1, // 215: check predicate 146
12844 OPC_Decode, 191, 118, 143, 1, // 218: decode to NDS_VFPMADT_VF using decoder 143
12845 // 218: }
12846 // 218: } // switch Inst[14]
12847 // 218: }
12848 3, 36, // 223: case 0x3: {
12849 OPC_SwitchField, 14, 1, // 225: switch Inst[14] {
12850 0, 21, // 228: case 0x0: {
12851 OPC_SwitchField, 25, 1, // 230: switch Inst[25] {
12852 0, 7, // 233: case 0x0: {
12853 OPC_CheckPredicate, 140, 1, // 235: check predicate 140
12854 OPC_Decode, 176, 118, 56, // 238: decode to NDS_LEA_W using decoder 56
12855 // 238: }
12856 1, 0, // 242: case 0x1: {
12857 OPC_CheckPredicate, 140, 1, // 244: check predicate 140
12858 OPC_Decode, 172, 118, 56, // 247: decode to NDS_LEA_D using decoder 56
12859 // 247: }
12860 // 247: } // switch Inst[25]
12861 // 247: }
12862 1, 0, // 251: case 0x1: {
12863 OPC_CheckPredicate, 146, 1, // 253: check predicate 146
12864 OPC_Decode, 190, 118, 143, 1, // 256: decode to NDS_VFPMADB_VF using decoder 143
12865 // 256: }
12866 // 256: } // switch Inst[14]
12867 // 256: }
12868 4, 36, // 261: case 0x4: {
12869 OPC_SwitchField, 14, 1, // 263: switch Inst[14] {
12870 0, 21, // 266: case 0x0: {
12871 OPC_SwitchField, 25, 1, // 268: switch Inst[25] {
12872 0, 7, // 271: case 0x0: {
12873 OPC_CheckPredicate, 147, 1, // 273: check predicate 147
12874 OPC_Decode, 171, 118, 56, // 276: decode to NDS_LEA_B_ZE using decoder 56
12875 // 276: }
12876 1, 0, // 280: case 0x1: {
12877 OPC_CheckPredicate, 147, 1, // 282: check predicate 147
12878 OPC_Decode, 175, 118, 56, // 285: decode to NDS_LEA_H_ZE using decoder 56
12879 // 285: }
12880 // 285: } // switch Inst[25]
12881 // 285: }
12882 1, 0, // 289: case 0x1: {
12883 OPC_CheckPredicate, 148, 1, // 291: check predicate 148
12884 OPC_Decode, 187, 118, 208, 1, // 294: decode to NDS_VD4DOTS_VV using decoder 208
12885 // 294: }
12886 // 294: } // switch Inst[14]
12887 // 294: }
12888 5, 36, // 299: case 0x5: {
12889 OPC_SwitchField, 14, 1, // 301: switch Inst[14] {
12890 0, 21, // 304: case 0x0: {
12891 OPC_SwitchField, 25, 1, // 306: switch Inst[25] {
12892 0, 7, // 309: case 0x0: {
12893 OPC_CheckPredicate, 147, 1, // 311: check predicate 147
12894 OPC_Decode, 177, 118, 56, // 314: decode to NDS_LEA_W_ZE using decoder 56
12895 // 314: }
12896 1, 0, // 318: case 0x1: {
12897 OPC_CheckPredicate, 147, 1, // 320: check predicate 147
12898 OPC_Decode, 173, 118, 56, // 323: decode to NDS_LEA_D_ZE using decoder 56
12899 // 323: }
12900 // 323: } // switch Inst[25]
12901 // 323: }
12902 1, 0, // 327: case 0x1: {
12903 OPC_CheckPredicate, 148, 1, // 329: check predicate 148
12904 OPC_Decode, 186, 118, 208, 1, // 332: decode to NDS_VD4DOTSU_VV using decoder 208
12905 // 332: }
12906 // 332: } // switch Inst[14]
12907 // 332: }
12908 7, 12, // 337: case 0x7: {
12909 OPC_CheckPredicate, 148, 1, // 339: check predicate 148
12910 OPC_CheckField, 14, 1, 1, // 342: check Inst[14] == 0x1
12911 OPC_Decode, 188, 118, 208, 1, // 346: decode to NDS_VD4DOTU_VV using decoder 208
12912 // 346: }
12913 8, 29, // 351: case 0x8: {
12914 OPC_SwitchField, 25, 1, // 353: switch Inst[25] {
12915 0, 11, // 356: case 0x0: {
12916 OPC_CheckPredicate, 140, 1, // 358: check predicate 140
12917 OPC_CheckField, 14, 1, 0, // 361: check Inst[14] == 0x0
12918 OPC_Decode, 162, 118, 31, // 365: decode to NDS_FFB using decoder 31
12919 // 365: }
12920 1, 0, // 369: case 0x1: {
12921 OPC_CheckPredicate, 140, 1, // 371: check predicate 140
12922 OPC_CheckField, 14, 1, 0, // 374: check Inst[14] == 0x0
12923 OPC_Decode, 164, 118, 31, // 378: decode to NDS_FFZMISM using decoder 31
12924 // 378: }
12925 // 378: } // switch Inst[25]
12926 // 378: }
12927 9, 0, // 382: case 0x9: {
12928 OPC_SwitchField, 25, 1, // 384: switch Inst[25] {
12929 0, 11, // 387: case 0x0: {
12930 OPC_CheckPredicate, 140, 1, // 389: check predicate 140
12931 OPC_CheckField, 14, 1, 0, // 392: check Inst[14] == 0x0
12932 OPC_Decode, 163, 118, 31, // 396: decode to NDS_FFMISM using decoder 31
12933 // 396: }
12934 1, 0, // 400: case 0x1: {
12935 OPC_CheckPredicate, 140, 1, // 402: check predicate 140
12936 OPC_CheckField, 14, 1, 0, // 405: check Inst[14] == 0x0
12937 OPC_Decode, 165, 118, 31, // 409: decode to NDS_FLMISM using decoder 31
12938 // 409: }
12939 // 409: } // switch Inst[25]
12940 // 409: }
12941 // 409: } // switch Inst[31:26]
12942 // 409: }
12943 // 409: } // switch Inst[6:0]
12944 // 409: }
12945 1, 52, // 413: case 0x1: {
12946 OPC_SwitchField, 0, 7, // 415: switch Inst[6:0] {
12947 11, 8, // 418: case 0xb: {
12948 OPC_CheckPredicate, 140, 1, // 420: check predicate 140
12949 OPC_Decode, 153, 118, 203, 1, // 423: decode to NDS_ADDIGP using decoder 203
12950 // 423: }
12951 43, 23, // 428: case 0x2b: {
12952 OPC_SwitchField, 14, 1, // 430: switch Inst[14] {
12953 0, 8, // 433: case 0x0: {
12954 OPC_CheckPredicate, 140, 1, // 435: check predicate 140
12955 OPC_Decode, 178, 118, 209, 1, // 438: decode to NDS_LHGP using decoder 209
12956 // 438: }
12957 1, 0, // 443: case 0x1: {
12958 OPC_CheckPredicate, 140, 1, // 445: check predicate 140
12959 OPC_Decode, 179, 118, 209, 1, // 448: decode to NDS_LHUGP using decoder 209
12960 // 448: }
12961 // 448: } // switch Inst[14]
12962 // 448: }
12963 91, 0, // 453: case 0x5b: {
12964 OPC_CheckPredicate, 140, 1, // 455: check predicate 140
12965 OPC_CheckField, 14, 1, 1, // 458: check Inst[14] == 0x1
12966 OPC_Decode, 156, 118, 210, 1, // 462: decode to NDS_BEQC using decoder 210
12967 // 462: }
12968 // 462: } // switch Inst[6:0]
12969 // 462: }
12970 2, 63, // 467: case 0x2: {
12971 OPC_SwitchField, 0, 7, // 469: switch Inst[6:0] {
12972 11, 8, // 472: case 0xb: {
12973 OPC_CheckPredicate, 140, 1, // 474: check predicate 140
12974 OPC_Decode, 169, 118, 203, 1, // 477: decode to NDS_LBUGP using decoder 203
12975 // 477: }
12976 43, 23, // 482: case 0x2b: {
12977 OPC_SwitchField, 14, 1, // 484: switch Inst[14] {
12978 0, 8, // 487: case 0x0: {
12979 OPC_CheckPredicate, 140, 1, // 489: check predicate 140
12980 OPC_Decode, 180, 118, 211, 1, // 492: decode to NDS_LWGP using decoder 211
12981 // 492: }
12982 1, 0, // 497: case 0x1: {
12983 OPC_CheckPredicate, 147, 1, // 499: check predicate 147
12984 OPC_Decode, 181, 118, 211, 1, // 502: decode to NDS_LWUGP using decoder 211
12985 // 502: }
12986 // 502: } // switch Inst[14]
12987 // 502: }
12988 91, 0, // 507: case 0x5b: {
12989 OPC_SwitchField, 14, 1, // 509: switch Inst[14] {
12990 0, 8, // 512: case 0x0: {
12991 OPC_CheckPredicate, 140, 1, // 514: check predicate 140
12992 OPC_Decode, 158, 118, 212, 1, // 517: decode to NDS_BFOZ using decoder 212
12993 // 517: }
12994 1, 0, // 522: case 0x1: {
12995 OPC_CheckPredicate, 140, 1, // 524: check predicate 140
12996 OPC_Decode, 159, 118, 210, 1, // 527: decode to NDS_BNEC using decoder 210
12997 // 527: }
12998 // 527: } // switch Inst[14]
12999 // 527: }
13000 // 527: } // switch Inst[6:0]
13001 // 527: }
13002 3, 0, // 532: case 0x3: {
13003 OPC_SwitchField, 0, 7, // 534: switch Inst[6:0] {
13004 11, 8, // 537: case 0xb: {
13005 OPC_CheckPredicate, 140, 1, // 539: check predicate 140
13006 OPC_Decode, 182, 118, 213, 1, // 542: decode to NDS_SBGP using decoder 213
13007 // 542: }
13008 43, 23, // 547: case 0x2b: {
13009 OPC_SwitchField, 14, 1, // 549: switch Inst[14] {
13010 0, 8, // 552: case 0x0: {
13011 OPC_CheckPredicate, 147, 1, // 554: check predicate 147
13012 OPC_Decode, 170, 118, 214, 1, // 557: decode to NDS_LDGP using decoder 214
13013 // 557: }
13014 1, 0, // 562: case 0x1: {
13015 OPC_CheckPredicate, 147, 1, // 564: check predicate 147
13016 OPC_Decode, 183, 118, 215, 1, // 567: decode to NDS_SDGP using decoder 215
13017 // 567: }
13018 // 567: } // switch Inst[14]
13019 // 567: }
13020 91, 0, // 572: case 0x5b: {
13021 OPC_SwitchField, 14, 1, // 574: switch Inst[14] {
13022 0, 8, // 577: case 0x0: {
13023 OPC_CheckPredicate, 140, 1, // 579: check predicate 140
13024 OPC_Decode, 157, 118, 212, 1, // 582: decode to NDS_BFOS using decoder 212
13025 // 582: }
13026 1, 0, // 587: case 0x1: {
13027 OPC_SwitchField, 30, 1, // 589: switch Inst[30] {
13028 0, 8, // 592: case 0x0: {
13029 OPC_CheckPredicate, 140, 1, // 594: check predicate 140
13030 OPC_Decode, 154, 118, 216, 1, // 597: decode to NDS_BBC using decoder 216
13031 // 597: }
13032 1, 0, // 602: case 0x1: {
13033 OPC_CheckPredicate, 140, 1, // 604: check predicate 140
13034 OPC_Decode, 155, 118, 216, 1, // 607: decode to NDS_BBS using decoder 216
13035 // 607: }
13036 // 607: } // switch Inst[30]
13037 // 607: }
13038 // 607: } // switch Inst[14]
13039 // 607: }
13040 // 607: } // switch Inst[6:0]
13041 // 607: }
13042 // 607: } // switch Inst[13:12]
13043};
13044static const uint8_t DecoderTableXCV32[3680] = {
13045 32, // 0: BitWidth 32
13046 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
13047 0, 190, 4, // 4: case 0x0: {
13048 OPC_SwitchField, 0, 7, // 7: switch Inst[6:0] {
13049 11, 8, // 10: case 0xb: {
13050 OPC_CheckPredicate, 149, 1, // 12: check predicate 149
13051 OPC_Decode, 173, 112, 217, 1, // 15: decode to CV_LB_ri_inc using decoder 217
13052 // 15: }
13053 43, 8, // 20: case 0x2b: {
13054 OPC_CheckPredicate, 149, 1, // 22: check predicate 149
13055 OPC_Decode, 242, 112, 218, 1, // 25: decode to CV_SB_ri_inc using decoder 218
13056 // 25: }
13057 91, 33, // 30: case 0x5b: {
13058 OPC_SwitchField, 30, 2, // 32: switch Inst[31:30] {
13059 0, 8, // 35: case 0x0: {
13060 OPC_CheckPredicate, 150, 1, // 37: check predicate 150
13061 OPC_Decode, 156, 112, 219, 1, // 40: decode to CV_EXTRACT using decoder 219
13062 // 40: }
13063 1, 8, // 45: case 0x1: {
13064 OPC_CheckPredicate, 150, 1, // 47: check predicate 150
13065 OPC_Decode, 158, 112, 219, 1, // 50: decode to CV_EXTRACTU using decoder 219
13066 // 50: }
13067 2, 0, // 55: case 0x2: {
13068 OPC_CheckPredicate, 150, 1, // 57: check predicate 150
13069 OPC_Decode, 166, 112, 220, 1, // 60: decode to CV_INSERT using decoder 220
13070 // 60: }
13071 // 60: } // switch Inst[31:30]
13072 // 60: }
13073 123, 0, // 65: case 0x7b: {
13074 OPC_SwitchField, 26, 6, // 67: switch Inst[31:26] {
13075 0, 11, // 70: case 0x0: {
13076 OPC_CheckPredicate, 151, 1, // 72: check predicate 151
13077 OPC_CheckField, 25, 1, 0, // 75: check Inst[25] == 0x0
13078 OPC_Decode, 156, 111, 31, // 79: decode to CV_ADD_H using decoder 31
13079 // 79: }
13080 1, 11, // 83: case 0x1: {
13081 OPC_CheckPredicate, 151, 1, // 85: check predicate 151
13082 OPC_CheckField, 25, 1, 0, // 88: check Inst[25] == 0x0
13083 OPC_Decode, 192, 111, 31, // 92: decode to CV_CMPEQ_H using decoder 31
13084 // 92: }
13085 2, 11, // 96: case 0x2: {
13086 OPC_CheckPredicate, 151, 1, // 98: check predicate 151
13087 OPC_CheckField, 25, 1, 0, // 101: check Inst[25] == 0x0
13088 OPC_Decode, 183, 113, 31, // 105: decode to CV_SUB_H using decoder 31
13089 // 105: }
13090 3, 11, // 109: case 0x3: {
13091 OPC_CheckPredicate, 151, 1, // 111: check predicate 151
13092 OPC_CheckField, 25, 1, 0, // 114: check Inst[25] == 0x0
13093 OPC_Decode, 246, 111, 31, // 118: decode to CV_CMPNE_H using decoder 31
13094 // 118: }
13095 4, 11, // 122: case 0x4: {
13096 OPC_CheckPredicate, 151, 1, // 124: check predicate 151
13097 OPC_CheckField, 25, 1, 0, // 127: check Inst[25] == 0x0
13098 OPC_Decode, 174, 111, 31, // 131: decode to CV_AVG_H using decoder 31
13099 // 131: }
13100 5, 11, // 135: case 0x5: {
13101 OPC_CheckPredicate, 151, 1, // 137: check predicate 151
13102 OPC_CheckField, 25, 1, 0, // 140: check Inst[25] == 0x0
13103 OPC_Decode, 216, 111, 31, // 144: decode to CV_CMPGT_H using decoder 31
13104 // 144: }
13105 6, 11, // 148: case 0x6: {
13106 OPC_CheckPredicate, 151, 1, // 150: check predicate 151
13107 OPC_CheckField, 25, 1, 0, // 153: check Inst[25] == 0x0
13108 OPC_Decode, 168, 111, 31, // 157: decode to CV_AVGU_H using decoder 31
13109 // 157: }
13110 7, 11, // 161: case 0x7: {
13111 OPC_CheckPredicate, 151, 1, // 163: check predicate 151
13112 OPC_CheckField, 25, 1, 0, // 166: check Inst[25] == 0x0
13113 OPC_Decode, 204, 111, 31, // 170: decode to CV_CMPGE_H using decoder 31
13114 // 170: }
13115 8, 11, // 174: case 0x8: {
13116 OPC_CheckPredicate, 151, 1, // 176: check predicate 151
13117 OPC_CheckField, 25, 1, 0, // 179: check Inst[25] == 0x0
13118 OPC_Decode, 217, 112, 31, // 183: decode to CV_MIN_H using decoder 31
13119 // 183: }
13120 9, 11, // 187: case 0x9: {
13121 OPC_CheckPredicate, 151, 1, // 189: check predicate 151
13122 OPC_CheckField, 25, 1, 0, // 192: check Inst[25] == 0x0
13123 OPC_Decode, 240, 111, 31, // 196: decode to CV_CMPLT_H using decoder 31
13124 // 196: }
13125 10, 11, // 200: case 0xa: {
13126 OPC_CheckPredicate, 151, 1, // 202: check predicate 151
13127 OPC_CheckField, 25, 1, 0, // 205: check Inst[25] == 0x0
13128 OPC_Decode, 211, 112, 31, // 209: decode to CV_MINU_H using decoder 31
13129 // 209: }
13130 11, 11, // 213: case 0xb: {
13131 OPC_CheckPredicate, 151, 1, // 215: check predicate 151
13132 OPC_CheckField, 25, 1, 0, // 218: check Inst[25] == 0x0
13133 OPC_Decode, 228, 111, 31, // 222: decode to CV_CMPLE_H using decoder 31
13134 // 222: }
13135 12, 11, // 226: case 0xc: {
13136 OPC_CheckPredicate, 151, 1, // 228: check predicate 151
13137 OPC_CheckField, 25, 1, 0, // 231: check Inst[25] == 0x0
13138 OPC_Decode, 203, 112, 31, // 235: decode to CV_MAX_H using decoder 31
13139 // 235: }
13140 13, 11, // 239: case 0xd: {
13141 OPC_CheckPredicate, 151, 1, // 241: check predicate 151
13142 OPC_CheckField, 25, 1, 0, // 244: check Inst[25] == 0x0
13143 OPC_Decode, 210, 111, 31, // 248: decode to CV_CMPGTU_H using decoder 31
13144 // 248: }
13145 14, 11, // 252: case 0xe: {
13146 OPC_CheckPredicate, 151, 1, // 254: check predicate 151
13147 OPC_CheckField, 25, 1, 0, // 257: check Inst[25] == 0x0
13148 OPC_Decode, 197, 112, 31, // 261: decode to CV_MAXU_H using decoder 31
13149 // 261: }
13150 15, 11, // 265: case 0xf: {
13151 OPC_CheckPredicate, 151, 1, // 267: check predicate 151
13152 OPC_CheckField, 25, 1, 0, // 270: check Inst[25] == 0x0
13153 OPC_Decode, 198, 111, 31, // 274: decode to CV_CMPGEU_H using decoder 31
13154 // 274: }
13155 16, 11, // 278: case 0x10: {
13156 OPC_CheckPredicate, 151, 1, // 280: check predicate 151
13157 OPC_CheckField, 25, 1, 0, // 283: check Inst[25] == 0x0
13158 OPC_Decode, 162, 113, 31, // 287: decode to CV_SRL_H using decoder 31
13159 // 287: }
13160 17, 11, // 291: case 0x11: {
13161 OPC_CheckPredicate, 151, 1, // 293: check predicate 151
13162 OPC_CheckField, 25, 1, 0, // 296: check Inst[25] == 0x0
13163 OPC_Decode, 234, 111, 31, // 300: decode to CV_CMPLTU_H using decoder 31
13164 // 300: }
13165 18, 11, // 304: case 0x12: {
13166 OPC_CheckPredicate, 151, 1, // 306: check predicate 151
13167 OPC_CheckField, 25, 1, 0, // 309: check Inst[25] == 0x0
13168 OPC_Decode, 156, 113, 31, // 313: decode to CV_SRA_H using decoder 31
13169 // 313: }
13170 19, 11, // 317: case 0x13: {
13171 OPC_CheckPredicate, 151, 1, // 319: check predicate 151
13172 OPC_CheckField, 25, 1, 0, // 322: check Inst[25] == 0x0
13173 OPC_Decode, 222, 111, 31, // 326: decode to CV_CMPLEU_H using decoder 31
13174 // 326: }
13175 20, 11, // 330: case 0x14: {
13176 OPC_CheckPredicate, 151, 1, // 332: check predicate 151
13177 OPC_CheckField, 25, 1, 0, // 335: check Inst[25] == 0x0
13178 OPC_Decode, 150, 113, 31, // 339: decode to CV_SLL_H using decoder 31
13179 // 339: }
13180 21, 21, // 343: case 0x15: {
13181 OPC_SwitchField, 25, 1, // 345: switch Inst[25] {
13182 0, 7, // 348: case 0x0: {
13183 OPC_CheckPredicate, 151, 1, // 350: check predicate 151
13184 OPC_Decode, 129, 112, 61, // 353: decode to CV_CPLXMUL_R using decoder 61
13185 // 353: }
13186 1, 0, // 357: case 0x1: {
13187 OPC_CheckPredicate, 151, 1, // 359: check predicate 151
13188 OPC_Decode, 253, 111, 61, // 362: decode to CV_CPLXMUL_I using decoder 61
13189 // 362: }
13190 // 362: } // switch Inst[25]
13191 // 362: }
13192 22, 11, // 366: case 0x16: {
13193 OPC_CheckPredicate, 151, 1, // 368: check predicate 151
13194 OPC_CheckField, 25, 1, 0, // 371: check Inst[25] == 0x0
13195 OPC_Decode, 232, 112, 31, // 375: decode to CV_OR_H using decoder 31
13196 // 375: }
13197 23, 11, // 379: case 0x17: {
13198 OPC_CheckPredicate, 151, 1, // 381: check predicate 151
13199 OPC_CheckField, 20, 6, 0, // 384: check Inst[25:20] == 0x0
13200 OPC_Decode, 252, 111, 17, // 388: decode to CV_CPLXCONJ using decoder 17
13201 // 388: }
13202 24, 11, // 392: case 0x18: {
13203 OPC_CheckPredicate, 151, 1, // 394: check predicate 151
13204 OPC_CheckField, 25, 1, 0, // 397: check Inst[25] == 0x0
13205 OPC_Decode, 192, 113, 31, // 401: decode to CV_XOR_H using decoder 31
13206 // 401: }
13207 25, 11, // 405: case 0x19: {
13208 OPC_CheckPredicate, 151, 1, // 407: check predicate 151
13209 OPC_CheckField, 25, 1, 0, // 410: check Inst[25] == 0x0
13210 OPC_Decode, 171, 113, 31, // 414: decode to CV_SUBROTMJ using decoder 31
13211 // 414: }
13212 26, 11, // 418: case 0x1a: {
13213 OPC_CheckPredicate, 151, 1, // 420: check predicate 151
13214 OPC_CheckField, 25, 1, 0, // 423: check Inst[25] == 0x0
13215 OPC_Decode, 162, 111, 31, // 427: decode to CV_AND_H using decoder 31
13216 // 427: }
13217 28, 11, // 431: case 0x1c: {
13218 OPC_CheckPredicate, 151, 1, // 433: check predicate 151
13219 OPC_CheckField, 20, 6, 0, // 436: check Inst[25:20] == 0x0
13220 OPC_Decode, 143, 111, 17, // 440: decode to CV_ABS_H using decoder 17
13221 // 440: }
13222 32, 11, // 444: case 0x20: {
13223 OPC_CheckPredicate, 151, 1, // 446: check predicate 151
13224 OPC_CheckField, 25, 1, 0, // 449: check Inst[25] == 0x0
13225 OPC_Decode, 140, 112, 31, // 453: decode to CV_DOTUP_H using decoder 31
13226 // 453: }
13227 34, 11, // 457: case 0x22: {
13228 OPC_CheckPredicate, 151, 1, // 459: check predicate 151
13229 OPC_CheckField, 25, 1, 0, // 462: check Inst[25] == 0x0
13230 OPC_Decode, 146, 112, 31, // 466: decode to CV_DOTUSP_H using decoder 31
13231 // 466: }
13232 36, 11, // 470: case 0x24: {
13233 OPC_CheckPredicate, 151, 1, // 472: check predicate 151
13234 OPC_CheckField, 25, 1, 0, // 475: check Inst[25] == 0x0
13235 OPC_Decode, 134, 112, 31, // 479: decode to CV_DOTSP_H using decoder 31
13236 // 479: }
13237 38, 11, // 483: case 0x26: {
13238 OPC_CheckPredicate, 151, 1, // 485: check predicate 151
13239 OPC_CheckField, 25, 1, 0, // 488: check Inst[25] == 0x0
13240 OPC_Decode, 252, 112, 61, // 492: decode to CV_SDOTUP_H using decoder 61
13241 // 492: }
13242 40, 11, // 496: case 0x28: {
13243 OPC_CheckPredicate, 151, 1, // 498: check predicate 151
13244 OPC_CheckField, 25, 1, 0, // 501: check Inst[25] == 0x0
13245 OPC_Decode, 130, 113, 61, // 505: decode to CV_SDOTUSP_H using decoder 61
13246 // 505: }
13247 42, 11, // 509: case 0x2a: {
13248 OPC_CheckPredicate, 151, 1, // 511: check predicate 151
13249 OPC_CheckField, 25, 1, 0, // 514: check Inst[25] == 0x0
13250 OPC_Decode, 246, 112, 61, // 518: decode to CV_SDOTSP_H using decoder 61
13251 // 518: }
13252 46, 8, // 522: case 0x2e: {
13253 OPC_CheckPredicate, 151, 1, // 524: check predicate 151
13254 OPC_Decode, 163, 112, 221, 1, // 527: decode to CV_EXTRACT_H using decoder 221
13255 // 527: }
13256 48, 11, // 532: case 0x30: {
13257 OPC_CheckPredicate, 151, 1, // 534: check predicate 151
13258 OPC_CheckField, 25, 1, 0, // 537: check Inst[25] == 0x0
13259 OPC_Decode, 142, 113, 31, // 541: decode to CV_SHUFFLE_H using decoder 31
13260 // 541: }
13261 56, 11, // 545: case 0x38: {
13262 OPC_CheckPredicate, 151, 1, // 547: check predicate 151
13263 OPC_CheckField, 25, 1, 0, // 550: check Inst[25] == 0x0
13264 OPC_Decode, 136, 113, 61, // 554: decode to CV_SHUFFLE2_H using decoder 61
13265 // 554: }
13266 60, 0, // 558: case 0x3c: {
13267 OPC_SwitchField, 25, 1, // 560: switch Inst[25] {
13268 0, 7, // 563: case 0x0: {
13269 OPC_CheckPredicate, 151, 1, // 565: check predicate 151
13270 OPC_Decode, 237, 112, 31, // 568: decode to CV_PACK using decoder 31
13271 // 568: }
13272 1, 0, // 572: case 0x1: {
13273 OPC_CheckPredicate, 151, 1, // 574: check predicate 151
13274 OPC_Decode, 240, 112, 31, // 577: decode to CV_PACK_H using decoder 31
13275 // 577: }
13276 // 577: } // switch Inst[25]
13277 // 577: }
13278 // 577: } // switch Inst[31:26]
13279 // 577: }
13280 // 577: } // switch Inst[6:0]
13281 // 577: }
13282 1, 141, 4, // 581: case 0x1: {
13283 OPC_SwitchField, 0, 7, // 584: switch Inst[6:0] {
13284 11, 8, // 587: case 0xb: {
13285 OPC_CheckPredicate, 149, 1, // 589: check predicate 149
13286 OPC_Decode, 179, 112, 217, 1, // 592: decode to CV_LH_ri_inc using decoder 217
13287 // 592: }
13288 43, 8, // 597: case 0x2b: {
13289 OPC_CheckPredicate, 149, 1, // 599: check predicate 149
13290 OPC_Decode, 144, 113, 218, 1, // 602: decode to CV_SH_ri_inc using decoder 218
13291 // 602: }
13292 91, 33, // 607: case 0x5b: {
13293 OPC_SwitchField, 30, 2, // 609: switch Inst[31:30] {
13294 0, 8, // 612: case 0x0: {
13295 OPC_CheckPredicate, 150, 1, // 614: check predicate 150
13296 OPC_Decode, 179, 111, 219, 1, // 617: decode to CV_BCLR using decoder 219
13297 // 617: }
13298 1, 8, // 622: case 0x1: {
13299 OPC_CheckPredicate, 150, 1, // 624: check predicate 150
13300 OPC_Decode, 184, 111, 219, 1, // 627: decode to CV_BSET using decoder 219
13301 // 627: }
13302 3, 0, // 632: case 0x3: {
13303 OPC_CheckPredicate, 150, 1, // 634: check predicate 150
13304 OPC_Decode, 182, 111, 222, 1, // 637: decode to CV_BITREV using decoder 222
13305 // 637: }
13306 // 637: } // switch Inst[31:30]
13307 // 637: }
13308 123, 0, // 642: case 0x7b: {
13309 OPC_SwitchField, 26, 6, // 644: switch Inst[31:26] {
13310 0, 11, // 647: case 0x0: {
13311 OPC_CheckPredicate, 151, 1, // 649: check predicate 151
13312 OPC_CheckField, 25, 1, 0, // 652: check Inst[25] == 0x0
13313 OPC_Decode, 152, 111, 31, // 656: decode to CV_ADD_B using decoder 31
13314 // 656: }
13315 1, 11, // 660: case 0x1: {
13316 OPC_CheckPredicate, 151, 1, // 662: check predicate 151
13317 OPC_CheckField, 25, 1, 0, // 665: check Inst[25] == 0x0
13318 OPC_Decode, 191, 111, 31, // 669: decode to CV_CMPEQ_B using decoder 31
13319 // 669: }
13320 2, 11, // 673: case 0x2: {
13321 OPC_CheckPredicate, 151, 1, // 675: check predicate 151
13322 OPC_CheckField, 25, 1, 0, // 678: check Inst[25] == 0x0
13323 OPC_Decode, 179, 113, 31, // 682: decode to CV_SUB_B using decoder 31
13324 // 682: }
13325 3, 11, // 686: case 0x3: {
13326 OPC_CheckPredicate, 151, 1, // 688: check predicate 151
13327 OPC_CheckField, 25, 1, 0, // 691: check Inst[25] == 0x0
13328 OPC_Decode, 245, 111, 31, // 695: decode to CV_CMPNE_B using decoder 31
13329 // 695: }
13330 4, 11, // 699: case 0x4: {
13331 OPC_CheckPredicate, 151, 1, // 701: check predicate 151
13332 OPC_CheckField, 25, 1, 0, // 704: check Inst[25] == 0x0
13333 OPC_Decode, 173, 111, 31, // 708: decode to CV_AVG_B using decoder 31
13334 // 708: }
13335 5, 11, // 712: case 0x5: {
13336 OPC_CheckPredicate, 151, 1, // 714: check predicate 151
13337 OPC_CheckField, 25, 1, 0, // 717: check Inst[25] == 0x0
13338 OPC_Decode, 215, 111, 31, // 721: decode to CV_CMPGT_B using decoder 31
13339 // 721: }
13340 6, 11, // 725: case 0x6: {
13341 OPC_CheckPredicate, 151, 1, // 727: check predicate 151
13342 OPC_CheckField, 25, 1, 0, // 730: check Inst[25] == 0x0
13343 OPC_Decode, 167, 111, 31, // 734: decode to CV_AVGU_B using decoder 31
13344 // 734: }
13345 7, 11, // 738: case 0x7: {
13346 OPC_CheckPredicate, 151, 1, // 740: check predicate 151
13347 OPC_CheckField, 25, 1, 0, // 743: check Inst[25] == 0x0
13348 OPC_Decode, 203, 111, 31, // 747: decode to CV_CMPGE_B using decoder 31
13349 // 747: }
13350 8, 11, // 751: case 0x8: {
13351 OPC_CheckPredicate, 151, 1, // 753: check predicate 151
13352 OPC_CheckField, 25, 1, 0, // 756: check Inst[25] == 0x0
13353 OPC_Decode, 216, 112, 31, // 760: decode to CV_MIN_B using decoder 31
13354 // 760: }
13355 9, 11, // 764: case 0x9: {
13356 OPC_CheckPredicate, 151, 1, // 766: check predicate 151
13357 OPC_CheckField, 25, 1, 0, // 769: check Inst[25] == 0x0
13358 OPC_Decode, 239, 111, 31, // 773: decode to CV_CMPLT_B using decoder 31
13359 // 773: }
13360 10, 11, // 777: case 0xa: {
13361 OPC_CheckPredicate, 151, 1, // 779: check predicate 151
13362 OPC_CheckField, 25, 1, 0, // 782: check Inst[25] == 0x0
13363 OPC_Decode, 210, 112, 31, // 786: decode to CV_MINU_B using decoder 31
13364 // 786: }
13365 11, 11, // 790: case 0xb: {
13366 OPC_CheckPredicate, 151, 1, // 792: check predicate 151
13367 OPC_CheckField, 25, 1, 0, // 795: check Inst[25] == 0x0
13368 OPC_Decode, 227, 111, 31, // 799: decode to CV_CMPLE_B using decoder 31
13369 // 799: }
13370 12, 11, // 803: case 0xc: {
13371 OPC_CheckPredicate, 151, 1, // 805: check predicate 151
13372 OPC_CheckField, 25, 1, 0, // 808: check Inst[25] == 0x0
13373 OPC_Decode, 202, 112, 31, // 812: decode to CV_MAX_B using decoder 31
13374 // 812: }
13375 13, 11, // 816: case 0xd: {
13376 OPC_CheckPredicate, 151, 1, // 818: check predicate 151
13377 OPC_CheckField, 25, 1, 0, // 821: check Inst[25] == 0x0
13378 OPC_Decode, 209, 111, 31, // 825: decode to CV_CMPGTU_B using decoder 31
13379 // 825: }
13380 14, 11, // 829: case 0xe: {
13381 OPC_CheckPredicate, 151, 1, // 831: check predicate 151
13382 OPC_CheckField, 25, 1, 0, // 834: check Inst[25] == 0x0
13383 OPC_Decode, 196, 112, 31, // 838: decode to CV_MAXU_B using decoder 31
13384 // 838: }
13385 15, 11, // 842: case 0xf: {
13386 OPC_CheckPredicate, 151, 1, // 844: check predicate 151
13387 OPC_CheckField, 25, 1, 0, // 847: check Inst[25] == 0x0
13388 OPC_Decode, 197, 111, 31, // 851: decode to CV_CMPGEU_B using decoder 31
13389 // 851: }
13390 16, 11, // 855: case 0x10: {
13391 OPC_CheckPredicate, 151, 1, // 857: check predicate 151
13392 OPC_CheckField, 25, 1, 0, // 860: check Inst[25] == 0x0
13393 OPC_Decode, 161, 113, 31, // 864: decode to CV_SRL_B using decoder 31
13394 // 864: }
13395 17, 11, // 868: case 0x11: {
13396 OPC_CheckPredicate, 151, 1, // 870: check predicate 151
13397 OPC_CheckField, 25, 1, 0, // 873: check Inst[25] == 0x0
13398 OPC_Decode, 233, 111, 31, // 877: decode to CV_CMPLTU_B using decoder 31
13399 // 877: }
13400 18, 11, // 881: case 0x12: {
13401 OPC_CheckPredicate, 151, 1, // 883: check predicate 151
13402 OPC_CheckField, 25, 1, 0, // 886: check Inst[25] == 0x0
13403 OPC_Decode, 155, 113, 31, // 890: decode to CV_SRA_B using decoder 31
13404 // 890: }
13405 19, 11, // 894: case 0x13: {
13406 OPC_CheckPredicate, 151, 1, // 896: check predicate 151
13407 OPC_CheckField, 25, 1, 0, // 899: check Inst[25] == 0x0
13408 OPC_Decode, 221, 111, 31, // 903: decode to CV_CMPLEU_B using decoder 31
13409 // 903: }
13410 20, 11, // 907: case 0x14: {
13411 OPC_CheckPredicate, 151, 1, // 909: check predicate 151
13412 OPC_CheckField, 25, 1, 0, // 912: check Inst[25] == 0x0
13413 OPC_Decode, 149, 113, 31, // 916: decode to CV_SLL_B using decoder 31
13414 // 916: }
13415 22, 11, // 920: case 0x16: {
13416 OPC_CheckPredicate, 151, 1, // 922: check predicate 151
13417 OPC_CheckField, 25, 1, 0, // 925: check Inst[25] == 0x0
13418 OPC_Decode, 231, 112, 31, // 929: decode to CV_OR_B using decoder 31
13419 // 929: }
13420 24, 11, // 933: case 0x18: {
13421 OPC_CheckPredicate, 151, 1, // 935: check predicate 151
13422 OPC_CheckField, 25, 1, 0, // 938: check Inst[25] == 0x0
13423 OPC_Decode, 191, 113, 31, // 942: decode to CV_XOR_B using decoder 31
13424 // 942: }
13425 26, 11, // 946: case 0x1a: {
13426 OPC_CheckPredicate, 151, 1, // 948: check predicate 151
13427 OPC_CheckField, 25, 1, 0, // 951: check Inst[25] == 0x0
13428 OPC_Decode, 161, 111, 31, // 955: decode to CV_AND_B using decoder 31
13429 // 955: }
13430 28, 11, // 959: case 0x1c: {
13431 OPC_CheckPredicate, 151, 1, // 961: check predicate 151
13432 OPC_CheckField, 20, 6, 0, // 964: check Inst[25:20] == 0x0
13433 OPC_Decode, 142, 111, 17, // 968: decode to CV_ABS_B using decoder 17
13434 // 968: }
13435 32, 11, // 972: case 0x20: {
13436 OPC_CheckPredicate, 151, 1, // 974: check predicate 151
13437 OPC_CheckField, 25, 1, 0, // 977: check Inst[25] == 0x0
13438 OPC_Decode, 139, 112, 31, // 981: decode to CV_DOTUP_B using decoder 31
13439 // 981: }
13440 34, 11, // 985: case 0x22: {
13441 OPC_CheckPredicate, 151, 1, // 987: check predicate 151
13442 OPC_CheckField, 25, 1, 0, // 990: check Inst[25] == 0x0
13443 OPC_Decode, 145, 112, 31, // 994: decode to CV_DOTUSP_B using decoder 31
13444 // 994: }
13445 36, 11, // 998: case 0x24: {
13446 OPC_CheckPredicate, 151, 1, // 1000: check predicate 151
13447 OPC_CheckField, 25, 1, 0, // 1003: check Inst[25] == 0x0
13448 OPC_Decode, 133, 112, 31, // 1007: decode to CV_DOTSP_B using decoder 31
13449 // 1007: }
13450 38, 11, // 1011: case 0x26: {
13451 OPC_CheckPredicate, 151, 1, // 1013: check predicate 151
13452 OPC_CheckField, 25, 1, 0, // 1016: check Inst[25] == 0x0
13453 OPC_Decode, 251, 112, 61, // 1020: decode to CV_SDOTUP_B using decoder 61
13454 // 1020: }
13455 40, 11, // 1024: case 0x28: {
13456 OPC_CheckPredicate, 151, 1, // 1026: check predicate 151
13457 OPC_CheckField, 25, 1, 0, // 1029: check Inst[25] == 0x0
13458 OPC_Decode, 129, 113, 61, // 1033: decode to CV_SDOTUSP_B using decoder 61
13459 // 1033: }
13460 42, 11, // 1037: case 0x2a: {
13461 OPC_CheckPredicate, 151, 1, // 1039: check predicate 151
13462 OPC_CheckField, 25, 1, 0, // 1042: check Inst[25] == 0x0
13463 OPC_Decode, 245, 112, 61, // 1046: decode to CV_SDOTSP_B using decoder 61
13464 // 1046: }
13465 46, 8, // 1050: case 0x2e: {
13466 OPC_CheckPredicate, 151, 1, // 1052: check predicate 151
13467 OPC_Decode, 162, 112, 223, 1, // 1055: decode to CV_EXTRACT_B using decoder 223
13468 // 1055: }
13469 48, 11, // 1060: case 0x30: {
13470 OPC_CheckPredicate, 151, 1, // 1062: check predicate 151
13471 OPC_CheckField, 25, 1, 0, // 1065: check Inst[25] == 0x0
13472 OPC_Decode, 141, 113, 31, // 1069: decode to CV_SHUFFLE_B using decoder 31
13473 // 1069: }
13474 56, 11, // 1073: case 0x38: {
13475 OPC_CheckPredicate, 151, 1, // 1075: check predicate 151
13476 OPC_CheckField, 25, 1, 0, // 1078: check Inst[25] == 0x0
13477 OPC_Decode, 135, 113, 61, // 1082: decode to CV_SHUFFLE2_B using decoder 61
13478 // 1082: }
13479 62, 0, // 1086: case 0x3e: {
13480 OPC_SwitchField, 25, 1, // 1088: switch Inst[25] {
13481 0, 7, // 1091: case 0x0: {
13482 OPC_CheckPredicate, 151, 1, // 1093: check predicate 151
13483 OPC_Decode, 239, 112, 61, // 1096: decode to CV_PACKLO_B using decoder 61
13484 // 1096: }
13485 1, 0, // 1100: case 0x1: {
13486 OPC_CheckPredicate, 151, 1, // 1102: check predicate 151
13487 OPC_Decode, 238, 112, 61, // 1105: decode to CV_PACKHI_B using decoder 61
13488 // 1105: }
13489 // 1105: } // switch Inst[25]
13490 // 1105: }
13491 // 1105: } // switch Inst[31:26]
13492 // 1105: }
13493 // 1105: } // switch Inst[6:0]
13494 // 1105: }
13495 2, 145, 1, // 1109: case 0x2: {
13496 OPC_SwitchField, 0, 7, // 1112: switch Inst[6:0] {
13497 11, 8, // 1115: case 0xb: {
13498 OPC_CheckPredicate, 149, 1, // 1117: check predicate 149
13499 OPC_Decode, 182, 112, 217, 1, // 1120: decode to CV_LW_ri_inc using decoder 217
13500 // 1120: }
13501 43, 8, // 1125: case 0x2b: {
13502 OPC_CheckPredicate, 149, 1, // 1127: check predicate 149
13503 OPC_Decode, 188, 113, 218, 1, // 1130: decode to CV_SW_ri_inc using decoder 218
13504 // 1130: }
13505 91, 43, // 1135: case 0x5b: {
13506 OPC_SwitchField, 30, 2, // 1137: switch Inst[31:30] {
13507 0, 8, // 1140: case 0x0: {
13508 OPC_CheckPredicate, 152, 1, // 1142: check predicate 152
13509 OPC_Decode, 144, 111, 224, 1, // 1145: decode to CV_ADDN using decoder 224
13510 // 1145: }
13511 1, 8, // 1150: case 0x1: {
13512 OPC_CheckPredicate, 152, 1, // 1152: check predicate 152
13513 OPC_Decode, 148, 111, 224, 1, // 1155: decode to CV_ADDUN using decoder 224
13514 // 1155: }
13515 2, 8, // 1160: case 0x2: {
13516 OPC_CheckPredicate, 152, 1, // 1162: check predicate 152
13517 OPC_Decode, 146, 111, 224, 1, // 1165: decode to CV_ADDRN using decoder 224
13518 // 1165: }
13519 3, 0, // 1170: case 0x3: {
13520 OPC_CheckPredicate, 152, 1, // 1172: check predicate 152
13521 OPC_Decode, 150, 111, 224, 1, // 1175: decode to CV_ADDURN using decoder 224
13522 // 1175: }
13523 // 1175: } // switch Inst[31:30]
13524 // 1175: }
13525 123, 0, // 1180: case 0x7b: {
13526 OPC_SwitchField, 26, 6, // 1182: switch Inst[31:26] {
13527 21, 21, // 1185: case 0x15: {
13528 OPC_SwitchField, 25, 1, // 1187: switch Inst[25] {
13529 0, 7, // 1190: case 0x0: {
13530 OPC_CheckPredicate, 151, 1, // 1192: check predicate 151
13531 OPC_Decode, 130, 112, 61, // 1195: decode to CV_CPLXMUL_R_DIV2 using decoder 61
13532 // 1195: }
13533 1, 0, // 1199: case 0x1: {
13534 OPC_CheckPredicate, 151, 1, // 1201: check predicate 151
13535 OPC_Decode, 254, 111, 61, // 1204: decode to CV_CPLXMUL_I_DIV2 using decoder 61
13536 // 1204: }
13537 // 1204: } // switch Inst[25]
13538 // 1204: }
13539 25, 11, // 1208: case 0x19: {
13540 OPC_CheckPredicate, 151, 1, // 1210: check predicate 151
13541 OPC_CheckField, 25, 1, 0, // 1213: check Inst[25] == 0x0
13542 OPC_Decode, 172, 113, 31, // 1217: decode to CV_SUBROTMJ_DIV2 using decoder 31
13543 // 1217: }
13544 27, 11, // 1221: case 0x1b: {
13545 OPC_CheckPredicate, 151, 1, // 1223: check predicate 151
13546 OPC_CheckField, 25, 1, 0, // 1226: check Inst[25] == 0x0
13547 OPC_Decode, 153, 111, 31, // 1230: decode to CV_ADD_DIV2 using decoder 31
13548 // 1230: }
13549 29, 11, // 1234: case 0x1d: {
13550 OPC_CheckPredicate, 151, 1, // 1236: check predicate 151
13551 OPC_CheckField, 25, 1, 0, // 1239: check Inst[25] == 0x0
13552 OPC_Decode, 180, 113, 31, // 1243: decode to CV_SUB_DIV2 using decoder 31
13553 // 1243: }
13554 46, 0, // 1247: case 0x2e: {
13555 OPC_CheckPredicate, 151, 1, // 1249: check predicate 151
13556 OPC_Decode, 161, 112, 221, 1, // 1252: decode to CV_EXTRACTU_H using decoder 221
13557 // 1252: }
13558 // 1252: } // switch Inst[31:26]
13559 // 1252: }
13560 // 1252: } // switch Inst[6:0]
13561 // 1252: }
13562 3, 199, 4, // 1257: case 0x3: {
13563 OPC_SwitchField, 0, 7, // 1260: switch Inst[6:0] {
13564 11, 7, // 1263: case 0xb: {
13565 OPC_CheckPredicate, 153, 1, // 1265: check predicate 153
13566 OPC_Decode, 151, 112, 0, // 1268: decode to CV_ELW using decoder 0
13567 // 1268: }
13568 43, 253, 3, // 1272: case 0x2b: {
13569 OPC_SwitchField, 25, 7, // 1275: switch Inst[31:25] {
13570 0, 8, // 1278: case 0x0: {
13571 OPC_CheckPredicate, 149, 1, // 1280: check predicate 149
13572 OPC_Decode, 175, 112, 225, 1, // 1283: decode to CV_LB_rr_inc using decoder 225
13573 // 1283: }
13574 1, 8, // 1288: case 0x1: {
13575 OPC_CheckPredicate, 149, 1, // 1290: check predicate 149
13576 OPC_Decode, 181, 112, 225, 1, // 1293: decode to CV_LH_rr_inc using decoder 225
13577 // 1293: }
13578 2, 8, // 1298: case 0x2: {
13579 OPC_CheckPredicate, 149, 1, // 1300: check predicate 149
13580 OPC_Decode, 184, 112, 225, 1, // 1303: decode to CV_LW_rr_inc using decoder 225
13581 // 1303: }
13582 4, 7, // 1308: case 0x4: {
13583 OPC_CheckPredicate, 149, 1, // 1310: check predicate 149
13584 OPC_Decode, 174, 112, 31, // 1313: decode to CV_LB_rr using decoder 31
13585 // 1313: }
13586 5, 7, // 1317: case 0x5: {
13587 OPC_CheckPredicate, 149, 1, // 1319: check predicate 149
13588 OPC_Decode, 180, 112, 31, // 1322: decode to CV_LH_rr using decoder 31
13589 // 1322: }
13590 6, 7, // 1326: case 0x6: {
13591 OPC_CheckPredicate, 149, 1, // 1328: check predicate 149
13592 OPC_Decode, 183, 112, 31, // 1331: decode to CV_LW_rr using decoder 31
13593 // 1331: }
13594 8, 8, // 1335: case 0x8: {
13595 OPC_CheckPredicate, 149, 1, // 1337: check predicate 149
13596 OPC_Decode, 172, 112, 225, 1, // 1340: decode to CV_LBU_rr_inc using decoder 225
13597 // 1340: }
13598 9, 8, // 1345: case 0x9: {
13599 OPC_CheckPredicate, 149, 1, // 1347: check predicate 149
13600 OPC_Decode, 178, 112, 225, 1, // 1350: decode to CV_LHU_rr_inc using decoder 225
13601 // 1350: }
13602 12, 7, // 1355: case 0xc: {
13603 OPC_CheckPredicate, 149, 1, // 1357: check predicate 149
13604 OPC_Decode, 171, 112, 31, // 1360: decode to CV_LBU_rr using decoder 31
13605 // 1360: }
13606 13, 7, // 1364: case 0xd: {
13607 OPC_CheckPredicate, 149, 1, // 1366: check predicate 149
13608 OPC_Decode, 177, 112, 31, // 1369: decode to CV_LHU_rr using decoder 31
13609 // 1369: }
13610 16, 8, // 1373: case 0x10: {
13611 OPC_CheckPredicate, 149, 1, // 1375: check predicate 149
13612 OPC_Decode, 244, 112, 226, 1, // 1378: decode to CV_SB_rr_inc using decoder 226
13613 // 1378: }
13614 17, 8, // 1383: case 0x11: {
13615 OPC_CheckPredicate, 149, 1, // 1385: check predicate 149
13616 OPC_Decode, 146, 113, 226, 1, // 1388: decode to CV_SH_rr_inc using decoder 226
13617 // 1388: }
13618 18, 8, // 1393: case 0x12: {
13619 OPC_CheckPredicate, 149, 1, // 1395: check predicate 149
13620 OPC_Decode, 190, 113, 226, 1, // 1398: decode to CV_SW_rr_inc using decoder 226
13621 // 1398: }
13622 20, 8, // 1403: case 0x14: {
13623 OPC_CheckPredicate, 149, 1, // 1405: check predicate 149
13624 OPC_Decode, 243, 112, 227, 1, // 1408: decode to CV_SB_rr using decoder 227
13625 // 1408: }
13626 21, 8, // 1413: case 0x15: {
13627 OPC_CheckPredicate, 149, 1, // 1415: check predicate 149
13628 OPC_Decode, 145, 113, 227, 1, // 1418: decode to CV_SH_rr using decoder 227
13629 // 1418: }
13630 22, 8, // 1423: case 0x16: {
13631 OPC_CheckPredicate, 149, 1, // 1425: check predicate 149
13632 OPC_Decode, 189, 113, 227, 1, // 1428: decode to CV_SW_rr using decoder 227
13633 // 1428: }
13634 24, 7, // 1433: case 0x18: {
13635 OPC_CheckPredicate, 150, 1, // 1435: check predicate 150
13636 OPC_Decode, 157, 112, 31, // 1438: decode to CV_EXTRACTR using decoder 31
13637 // 1438: }
13638 25, 7, // 1442: case 0x19: {
13639 OPC_CheckPredicate, 150, 1, // 1444: check predicate 150
13640 OPC_Decode, 159, 112, 31, // 1447: decode to CV_EXTRACTUR using decoder 31
13641 // 1447: }
13642 26, 7, // 1451: case 0x1a: {
13643 OPC_CheckPredicate, 150, 1, // 1453: check predicate 150
13644 OPC_Decode, 167, 112, 61, // 1456: decode to CV_INSERTR using decoder 61
13645 // 1456: }
13646 28, 7, // 1460: case 0x1c: {
13647 OPC_CheckPredicate, 150, 1, // 1462: check predicate 150
13648 OPC_Decode, 180, 111, 31, // 1465: decode to CV_BCLRR using decoder 31
13649 // 1465: }
13650 29, 7, // 1469: case 0x1d: {
13651 OPC_CheckPredicate, 150, 1, // 1471: check predicate 150
13652 OPC_Decode, 185, 111, 31, // 1474: decode to CV_BSETR using decoder 31
13653 // 1474: }
13654 32, 7, // 1478: case 0x20: {
13655 OPC_CheckPredicate, 150, 1, // 1480: check predicate 150
13656 OPC_Decode, 241, 112, 31, // 1483: decode to CV_ROR using decoder 31
13657 // 1483: }
13658 33, 11, // 1487: case 0x21: {
13659 OPC_CheckPredicate, 150, 1, // 1489: check predicate 150
13660 OPC_CheckField, 20, 5, 0, // 1492: check Inst[24:20] == 0x0
13661 OPC_Decode, 164, 112, 17, // 1496: decode to CV_FF1 using decoder 17
13662 // 1496: }
13663 34, 11, // 1500: case 0x22: {
13664 OPC_CheckPredicate, 150, 1, // 1502: check predicate 150
13665 OPC_CheckField, 20, 5, 0, // 1505: check Inst[24:20] == 0x0
13666 OPC_Decode, 165, 112, 17, // 1509: decode to CV_FL1 using decoder 17
13667 // 1509: }
13668 35, 11, // 1513: case 0x23: {
13669 OPC_CheckPredicate, 150, 1, // 1515: check predicate 150
13670 OPC_CheckField, 20, 5, 0, // 1518: check Inst[24:20] == 0x0
13671 OPC_Decode, 186, 111, 17, // 1522: decode to CV_CLB using decoder 17
13672 // 1522: }
13673 36, 11, // 1526: case 0x24: {
13674 OPC_CheckPredicate, 150, 1, // 1528: check predicate 150
13675 OPC_CheckField, 20, 5, 0, // 1531: check Inst[24:20] == 0x0
13676 OPC_Decode, 251, 111, 17, // 1535: decode to CV_CNT using decoder 17
13677 // 1535: }
13678 40, 11, // 1539: case 0x28: {
13679 OPC_CheckPredicate, 152, 1, // 1541: check predicate 152
13680 OPC_CheckField, 20, 5, 0, // 1544: check Inst[24:20] == 0x0
13681 OPC_Decode, 141, 111, 17, // 1548: decode to CV_ABS using decoder 17
13682 // 1548: }
13683 41, 7, // 1552: case 0x29: {
13684 OPC_CheckPredicate, 152, 1, // 1554: check predicate 152
13685 OPC_Decode, 147, 113, 31, // 1557: decode to CV_SLE using decoder 31
13686 // 1557: }
13687 42, 7, // 1561: case 0x2a: {
13688 OPC_CheckPredicate, 152, 1, // 1563: check predicate 152
13689 OPC_Decode, 148, 113, 31, // 1566: decode to CV_SLEU using decoder 31
13690 // 1566: }
13691 43, 7, // 1570: case 0x2b: {
13692 OPC_CheckPredicate, 152, 1, // 1572: check predicate 152
13693 OPC_Decode, 208, 112, 31, // 1575: decode to CV_MIN using decoder 31
13694 // 1575: }
13695 44, 7, // 1579: case 0x2c: {
13696 OPC_CheckPredicate, 152, 1, // 1581: check predicate 152
13697 OPC_Decode, 209, 112, 31, // 1584: decode to CV_MINU using decoder 31
13698 // 1584: }
13699 45, 7, // 1588: case 0x2d: {
13700 OPC_CheckPredicate, 152, 1, // 1590: check predicate 152
13701 OPC_Decode, 194, 112, 31, // 1593: decode to CV_MAX using decoder 31
13702 // 1593: }
13703 46, 7, // 1597: case 0x2e: {
13704 OPC_CheckPredicate, 152, 1, // 1599: check predicate 152
13705 OPC_Decode, 195, 112, 31, // 1602: decode to CV_MAXU using decoder 31
13706 // 1602: }
13707 48, 11, // 1606: case 0x30: {
13708 OPC_CheckPredicate, 152, 1, // 1608: check predicate 152
13709 OPC_CheckField, 20, 5, 0, // 1611: check Inst[24:20] == 0x0
13710 OPC_Decode, 154, 112, 17, // 1615: decode to CV_EXTHS using decoder 17
13711 // 1615: }
13712 49, 11, // 1619: case 0x31: {
13713 OPC_CheckPredicate, 152, 1, // 1621: check predicate 152
13714 OPC_CheckField, 20, 5, 0, // 1624: check Inst[24:20] == 0x0
13715 OPC_Decode, 155, 112, 17, // 1628: decode to CV_EXTHZ using decoder 17
13716 // 1628: }
13717 50, 11, // 1632: case 0x32: {
13718 OPC_CheckPredicate, 152, 1, // 1634: check predicate 152
13719 OPC_CheckField, 20, 5, 0, // 1637: check Inst[24:20] == 0x0
13720 OPC_Decode, 152, 112, 17, // 1641: decode to CV_EXTBS using decoder 17
13721 // 1641: }
13722 51, 11, // 1645: case 0x33: {
13723 OPC_CheckPredicate, 152, 1, // 1647: check predicate 152
13724 OPC_CheckField, 20, 5, 0, // 1650: check Inst[24:20] == 0x0
13725 OPC_Decode, 153, 112, 17, // 1654: decode to CV_EXTBZ using decoder 17
13726 // 1654: }
13727 56, 7, // 1658: case 0x38: {
13728 OPC_CheckPredicate, 152, 1, // 1660: check predicate 152
13729 OPC_Decode, 187, 111, 21, // 1663: decode to CV_CLIP using decoder 21
13730 // 1663: }
13731 57, 7, // 1667: case 0x39: {
13732 OPC_CheckPredicate, 152, 1, // 1669: check predicate 152
13733 OPC_Decode, 189, 111, 21, // 1672: decode to CV_CLIPU using decoder 21
13734 // 1672: }
13735 58, 7, // 1676: case 0x3a: {
13736 OPC_CheckPredicate, 152, 1, // 1678: check predicate 152
13737 OPC_Decode, 188, 111, 31, // 1681: decode to CV_CLIPR using decoder 31
13738 // 1681: }
13739 59, 7, // 1685: case 0x3b: {
13740 OPC_CheckPredicate, 152, 1, // 1687: check predicate 152
13741 OPC_Decode, 190, 111, 31, // 1690: decode to CV_CLIPUR using decoder 31
13742 // 1690: }
13743 64, 7, // 1694: case 0x40: {
13744 OPC_CheckPredicate, 152, 1, // 1696: check predicate 152
13745 OPC_Decode, 145, 111, 61, // 1699: decode to CV_ADDNR using decoder 61
13746 // 1699: }
13747 65, 7, // 1703: case 0x41: {
13748 OPC_CheckPredicate, 152, 1, // 1705: check predicate 152
13749 OPC_Decode, 149, 111, 61, // 1708: decode to CV_ADDUNR using decoder 61
13750 // 1708: }
13751 66, 7, // 1712: case 0x42: {
13752 OPC_CheckPredicate, 152, 1, // 1714: check predicate 152
13753 OPC_Decode, 147, 111, 61, // 1717: decode to CV_ADDRNR using decoder 61
13754 // 1717: }
13755 67, 7, // 1721: case 0x43: {
13756 OPC_CheckPredicate, 152, 1, // 1723: check predicate 152
13757 OPC_Decode, 151, 111, 61, // 1726: decode to CV_ADDURNR using decoder 61
13758 // 1726: }
13759 68, 7, // 1730: case 0x44: {
13760 OPC_CheckPredicate, 152, 1, // 1732: check predicate 152
13761 OPC_Decode, 168, 113, 61, // 1735: decode to CV_SUBNR using decoder 61
13762 // 1735: }
13763 69, 7, // 1739: case 0x45: {
13764 OPC_CheckPredicate, 152, 1, // 1741: check predicate 152
13765 OPC_Decode, 176, 113, 61, // 1744: decode to CV_SUBUNR using decoder 61
13766 // 1744: }
13767 70, 7, // 1748: case 0x46: {
13768 OPC_CheckPredicate, 152, 1, // 1750: check predicate 152
13769 OPC_Decode, 170, 113, 61, // 1753: decode to CV_SUBRNR using decoder 61
13770 // 1753: }
13771 71, 7, // 1757: case 0x47: {
13772 OPC_CheckPredicate, 152, 1, // 1759: check predicate 152
13773 OPC_Decode, 178, 113, 61, // 1762: decode to CV_SUBURNR using decoder 61
13774 // 1762: }
13775 72, 7, // 1766: case 0x48: {
13776 OPC_CheckPredicate, 154, 1, // 1768: check predicate 154
13777 OPC_Decode, 185, 112, 61, // 1771: decode to CV_MAC using decoder 61
13778 // 1771: }
13779 73, 0, // 1775: case 0x49: {
13780 OPC_CheckPredicate, 154, 1, // 1777: check predicate 154
13781 OPC_Decode, 222, 112, 61, // 1780: decode to CV_MSU using decoder 61
13782 // 1780: }
13783 // 1780: } // switch Inst[31:25]
13784 // 1780: }
13785 91, 43, // 1784: case 0x5b: {
13786 OPC_SwitchField, 30, 2, // 1786: switch Inst[31:30] {
13787 0, 8, // 1789: case 0x0: {
13788 OPC_CheckPredicate, 152, 1, // 1791: check predicate 152
13789 OPC_Decode, 167, 113, 224, 1, // 1794: decode to CV_SUBN using decoder 224
13790 // 1794: }
13791 1, 8, // 1799: case 0x1: {
13792 OPC_CheckPredicate, 152, 1, // 1801: check predicate 152
13793 OPC_Decode, 175, 113, 224, 1, // 1804: decode to CV_SUBUN using decoder 224
13794 // 1804: }
13795 2, 8, // 1809: case 0x2: {
13796 OPC_CheckPredicate, 152, 1, // 1811: check predicate 152
13797 OPC_Decode, 169, 113, 224, 1, // 1814: decode to CV_SUBRN using decoder 224
13798 // 1814: }
13799 3, 0, // 1819: case 0x3: {
13800 OPC_CheckPredicate, 152, 1, // 1821: check predicate 152
13801 OPC_Decode, 177, 113, 224, 1, // 1824: decode to CV_SUBURN using decoder 224
13802 // 1824: }
13803 // 1824: } // switch Inst[31:30]
13804 // 1824: }
13805 123, 0, // 1829: case 0x7b: {
13806 OPC_CheckPredicate, 151, 1, // 1831: check predicate 151
13807 OPC_CheckField, 26, 6, 46, // 1834: check Inst[31:26] == 0x2e
13808 OPC_Decode, 160, 112, 223, 1, // 1838: decode to CV_EXTRACTU_B using decoder 223
13809 // 1838: }
13810 // 1838: } // switch Inst[6:0]
13811 // 1838: }
13812 4, 141, 4, // 1843: case 0x4: {
13813 OPC_SwitchField, 0, 7, // 1846: switch Inst[6:0] {
13814 11, 8, // 1849: case 0xb: {
13815 OPC_CheckPredicate, 149, 1, // 1851: check predicate 149
13816 OPC_Decode, 170, 112, 217, 1, // 1854: decode to CV_LBU_ri_inc using decoder 217
13817 // 1854: }
13818 91, 43, // 1859: case 0x5b: {
13819 OPC_SwitchField, 30, 2, // 1861: switch Inst[31:30] {
13820 0, 8, // 1864: case 0x0: {
13821 OPC_CheckPredicate, 154, 1, // 1866: check predicate 154
13822 OPC_Decode, 227, 112, 224, 1, // 1869: decode to CV_MULSN using decoder 224
13823 // 1869: }
13824 1, 8, // 1874: case 0x1: {
13825 OPC_CheckPredicate, 154, 1, // 1876: check predicate 154
13826 OPC_Decode, 223, 112, 224, 1, // 1879: decode to CV_MULHHSN using decoder 224
13827 // 1879: }
13828 2, 8, // 1884: case 0x2: {
13829 OPC_CheckPredicate, 154, 1, // 1886: check predicate 154
13830 OPC_Decode, 228, 112, 224, 1, // 1889: decode to CV_MULSRN using decoder 224
13831 // 1889: }
13832 3, 0, // 1894: case 0x3: {
13833 OPC_CheckPredicate, 154, 1, // 1896: check predicate 154
13834 OPC_Decode, 224, 112, 224, 1, // 1899: decode to CV_MULHHSRN using decoder 224
13835 // 1899: }
13836 // 1899: } // switch Inst[31:30]
13837 // 1899: }
13838 123, 0, // 1904: case 0x7b: {
13839 OPC_SwitchField, 26, 6, // 1906: switch Inst[31:26] {
13840 0, 11, // 1909: case 0x0: {
13841 OPC_CheckPredicate, 151, 1, // 1911: check predicate 151
13842 OPC_CheckField, 25, 1, 0, // 1914: check Inst[25] == 0x0
13843 OPC_Decode, 160, 111, 31, // 1918: decode to CV_ADD_SC_H using decoder 31
13844 // 1918: }
13845 1, 11, // 1922: case 0x1: {
13846 OPC_CheckPredicate, 151, 1, // 1924: check predicate 151
13847 OPC_CheckField, 25, 1, 0, // 1927: check Inst[25] == 0x0
13848 OPC_Decode, 196, 111, 31, // 1931: decode to CV_CMPEQ_SC_H using decoder 31
13849 // 1931: }
13850 2, 11, // 1935: case 0x2: {
13851 OPC_CheckPredicate, 151, 1, // 1937: check predicate 151
13852 OPC_CheckField, 25, 1, 0, // 1940: check Inst[25] == 0x0
13853 OPC_Decode, 187, 113, 31, // 1944: decode to CV_SUB_SC_H using decoder 31
13854 // 1944: }
13855 3, 11, // 1948: case 0x3: {
13856 OPC_CheckPredicate, 151, 1, // 1950: check predicate 151
13857 OPC_CheckField, 25, 1, 0, // 1953: check Inst[25] == 0x0
13858 OPC_Decode, 250, 111, 31, // 1957: decode to CV_CMPNE_SC_H using decoder 31
13859 // 1957: }
13860 4, 11, // 1961: case 0x4: {
13861 OPC_CheckPredicate, 151, 1, // 1963: check predicate 151
13862 OPC_CheckField, 25, 1, 0, // 1966: check Inst[25] == 0x0
13863 OPC_Decode, 178, 111, 31, // 1970: decode to CV_AVG_SC_H using decoder 31
13864 // 1970: }
13865 5, 11, // 1974: case 0x5: {
13866 OPC_CheckPredicate, 151, 1, // 1976: check predicate 151
13867 OPC_CheckField, 25, 1, 0, // 1979: check Inst[25] == 0x0
13868 OPC_Decode, 220, 111, 31, // 1983: decode to CV_CMPGT_SC_H using decoder 31
13869 // 1983: }
13870 6, 11, // 1987: case 0x6: {
13871 OPC_CheckPredicate, 151, 1, // 1989: check predicate 151
13872 OPC_CheckField, 25, 1, 0, // 1992: check Inst[25] == 0x0
13873 OPC_Decode, 172, 111, 31, // 1996: decode to CV_AVGU_SC_H using decoder 31
13874 // 1996: }
13875 7, 11, // 2000: case 0x7: {
13876 OPC_CheckPredicate, 151, 1, // 2002: check predicate 151
13877 OPC_CheckField, 25, 1, 0, // 2005: check Inst[25] == 0x0
13878 OPC_Decode, 208, 111, 31, // 2009: decode to CV_CMPGE_SC_H using decoder 31
13879 // 2009: }
13880 8, 11, // 2013: case 0x8: {
13881 OPC_CheckPredicate, 151, 1, // 2015: check predicate 151
13882 OPC_CheckField, 25, 1, 0, // 2018: check Inst[25] == 0x0
13883 OPC_Decode, 221, 112, 31, // 2022: decode to CV_MIN_SC_H using decoder 31
13884 // 2022: }
13885 9, 11, // 2026: case 0x9: {
13886 OPC_CheckPredicate, 151, 1, // 2028: check predicate 151
13887 OPC_CheckField, 25, 1, 0, // 2031: check Inst[25] == 0x0
13888 OPC_Decode, 244, 111, 31, // 2035: decode to CV_CMPLT_SC_H using decoder 31
13889 // 2035: }
13890 10, 11, // 2039: case 0xa: {
13891 OPC_CheckPredicate, 151, 1, // 2041: check predicate 151
13892 OPC_CheckField, 25, 1, 0, // 2044: check Inst[25] == 0x0
13893 OPC_Decode, 215, 112, 31, // 2048: decode to CV_MINU_SC_H using decoder 31
13894 // 2048: }
13895 11, 11, // 2052: case 0xb: {
13896 OPC_CheckPredicate, 151, 1, // 2054: check predicate 151
13897 OPC_CheckField, 25, 1, 0, // 2057: check Inst[25] == 0x0
13898 OPC_Decode, 232, 111, 31, // 2061: decode to CV_CMPLE_SC_H using decoder 31
13899 // 2061: }
13900 12, 11, // 2065: case 0xc: {
13901 OPC_CheckPredicate, 151, 1, // 2067: check predicate 151
13902 OPC_CheckField, 25, 1, 0, // 2070: check Inst[25] == 0x0
13903 OPC_Decode, 207, 112, 31, // 2074: decode to CV_MAX_SC_H using decoder 31
13904 // 2074: }
13905 13, 11, // 2078: case 0xd: {
13906 OPC_CheckPredicate, 151, 1, // 2080: check predicate 151
13907 OPC_CheckField, 25, 1, 0, // 2083: check Inst[25] == 0x0
13908 OPC_Decode, 214, 111, 31, // 2087: decode to CV_CMPGTU_SC_H using decoder 31
13909 // 2087: }
13910 14, 11, // 2091: case 0xe: {
13911 OPC_CheckPredicate, 151, 1, // 2093: check predicate 151
13912 OPC_CheckField, 25, 1, 0, // 2096: check Inst[25] == 0x0
13913 OPC_Decode, 201, 112, 31, // 2100: decode to CV_MAXU_SC_H using decoder 31
13914 // 2100: }
13915 15, 11, // 2104: case 0xf: {
13916 OPC_CheckPredicate, 151, 1, // 2106: check predicate 151
13917 OPC_CheckField, 25, 1, 0, // 2109: check Inst[25] == 0x0
13918 OPC_Decode, 202, 111, 31, // 2113: decode to CV_CMPGEU_SC_H using decoder 31
13919 // 2113: }
13920 16, 11, // 2117: case 0x10: {
13921 OPC_CheckPredicate, 151, 1, // 2119: check predicate 151
13922 OPC_CheckField, 25, 1, 0, // 2122: check Inst[25] == 0x0
13923 OPC_Decode, 166, 113, 31, // 2126: decode to CV_SRL_SC_H using decoder 31
13924 // 2126: }
13925 17, 11, // 2130: case 0x11: {
13926 OPC_CheckPredicate, 151, 1, // 2132: check predicate 151
13927 OPC_CheckField, 25, 1, 0, // 2135: check Inst[25] == 0x0
13928 OPC_Decode, 238, 111, 31, // 2139: decode to CV_CMPLTU_SC_H using decoder 31
13929 // 2139: }
13930 18, 11, // 2143: case 0x12: {
13931 OPC_CheckPredicate, 151, 1, // 2145: check predicate 151
13932 OPC_CheckField, 25, 1, 0, // 2148: check Inst[25] == 0x0
13933 OPC_Decode, 160, 113, 31, // 2152: decode to CV_SRA_SC_H using decoder 31
13934 // 2152: }
13935 19, 11, // 2156: case 0x13: {
13936 OPC_CheckPredicate, 151, 1, // 2158: check predicate 151
13937 OPC_CheckField, 25, 1, 0, // 2161: check Inst[25] == 0x0
13938 OPC_Decode, 226, 111, 31, // 2165: decode to CV_CMPLEU_SC_H using decoder 31
13939 // 2165: }
13940 20, 11, // 2169: case 0x14: {
13941 OPC_CheckPredicate, 151, 1, // 2171: check predicate 151
13942 OPC_CheckField, 25, 1, 0, // 2174: check Inst[25] == 0x0
13943 OPC_Decode, 154, 113, 31, // 2178: decode to CV_SLL_SC_H using decoder 31
13944 // 2178: }
13945 21, 21, // 2182: case 0x15: {
13946 OPC_SwitchField, 25, 1, // 2184: switch Inst[25] {
13947 0, 7, // 2187: case 0x0: {
13948 OPC_CheckPredicate, 151, 1, // 2189: check predicate 151
13949 OPC_Decode, 131, 112, 61, // 2192: decode to CV_CPLXMUL_R_DIV4 using decoder 61
13950 // 2192: }
13951 1, 0, // 2196: case 0x1: {
13952 OPC_CheckPredicate, 151, 1, // 2198: check predicate 151
13953 OPC_Decode, 255, 111, 61, // 2201: decode to CV_CPLXMUL_I_DIV4 using decoder 61
13954 // 2201: }
13955 // 2201: } // switch Inst[25]
13956 // 2201: }
13957 22, 11, // 2205: case 0x16: {
13958 OPC_CheckPredicate, 151, 1, // 2207: check predicate 151
13959 OPC_CheckField, 25, 1, 0, // 2210: check Inst[25] == 0x0
13960 OPC_Decode, 236, 112, 31, // 2214: decode to CV_OR_SC_H using decoder 31
13961 // 2214: }
13962 24, 11, // 2218: case 0x18: {
13963 OPC_CheckPredicate, 151, 1, // 2220: check predicate 151
13964 OPC_CheckField, 25, 1, 0, // 2223: check Inst[25] == 0x0
13965 OPC_Decode, 196, 113, 31, // 2227: decode to CV_XOR_SC_H using decoder 31
13966 // 2227: }
13967 25, 11, // 2231: case 0x19: {
13968 OPC_CheckPredicate, 151, 1, // 2233: check predicate 151
13969 OPC_CheckField, 25, 1, 0, // 2236: check Inst[25] == 0x0
13970 OPC_Decode, 173, 113, 31, // 2240: decode to CV_SUBROTMJ_DIV4 using decoder 31
13971 // 2240: }
13972 26, 11, // 2244: case 0x1a: {
13973 OPC_CheckPredicate, 151, 1, // 2246: check predicate 151
13974 OPC_CheckField, 25, 1, 0, // 2249: check Inst[25] == 0x0
13975 OPC_Decode, 166, 111, 31, // 2253: decode to CV_AND_SC_H using decoder 31
13976 // 2253: }
13977 27, 11, // 2257: case 0x1b: {
13978 OPC_CheckPredicate, 151, 1, // 2259: check predicate 151
13979 OPC_CheckField, 25, 1, 0, // 2262: check Inst[25] == 0x0
13980 OPC_Decode, 154, 111, 31, // 2266: decode to CV_ADD_DIV4 using decoder 31
13981 // 2266: }
13982 29, 11, // 2270: case 0x1d: {
13983 OPC_CheckPredicate, 151, 1, // 2272: check predicate 151
13984 OPC_CheckField, 25, 1, 0, // 2275: check Inst[25] == 0x0
13985 OPC_Decode, 181, 113, 31, // 2279: decode to CV_SUB_DIV4 using decoder 31
13986 // 2279: }
13987 32, 11, // 2283: case 0x20: {
13988 OPC_CheckPredicate, 151, 1, // 2285: check predicate 151
13989 OPC_CheckField, 25, 1, 0, // 2288: check Inst[25] == 0x0
13990 OPC_Decode, 144, 112, 31, // 2292: decode to CV_DOTUP_SC_H using decoder 31
13991 // 2292: }
13992 34, 11, // 2296: case 0x22: {
13993 OPC_CheckPredicate, 151, 1, // 2298: check predicate 151
13994 OPC_CheckField, 25, 1, 0, // 2301: check Inst[25] == 0x0
13995 OPC_Decode, 150, 112, 31, // 2305: decode to CV_DOTUSP_SC_H using decoder 31
13996 // 2305: }
13997 36, 11, // 2309: case 0x24: {
13998 OPC_CheckPredicate, 151, 1, // 2311: check predicate 151
13999 OPC_CheckField, 25, 1, 0, // 2314: check Inst[25] == 0x0
14000 OPC_Decode, 138, 112, 31, // 2318: decode to CV_DOTSP_SC_H using decoder 31
14001 // 2318: }
14002 38, 11, // 2322: case 0x26: {
14003 OPC_CheckPredicate, 151, 1, // 2324: check predicate 151
14004 OPC_CheckField, 25, 1, 0, // 2327: check Inst[25] == 0x0
14005 OPC_Decode, 128, 113, 61, // 2331: decode to CV_SDOTUP_SC_H using decoder 61
14006 // 2331: }
14007 40, 11, // 2335: case 0x28: {
14008 OPC_CheckPredicate, 151, 1, // 2337: check predicate 151
14009 OPC_CheckField, 25, 1, 0, // 2340: check Inst[25] == 0x0
14010 OPC_Decode, 134, 113, 61, // 2344: decode to CV_SDOTUSP_SC_H using decoder 61
14011 // 2344: }
14012 42, 11, // 2348: case 0x2a: {
14013 OPC_CheckPredicate, 151, 1, // 2350: check predicate 151
14014 OPC_CheckField, 25, 1, 0, // 2353: check Inst[25] == 0x0
14015 OPC_Decode, 250, 112, 61, // 2357: decode to CV_SDOTSP_SC_H using decoder 61
14016 // 2357: }
14017 46, 0, // 2361: case 0x2e: {
14018 OPC_CheckPredicate, 151, 1, // 2363: check predicate 151
14019 OPC_Decode, 169, 112, 228, 1, // 2366: decode to CV_INSERT_H using decoder 228
14020 // 2366: }
14021 // 2366: } // switch Inst[31:26]
14022 // 2366: }
14023 // 2366: } // switch Inst[6:0]
14024 // 2366: }
14025 5, 207, 3, // 2371: case 0x5: {
14026 OPC_SwitchField, 0, 7, // 2374: switch Inst[6:0] {
14027 11, 8, // 2377: case 0xb: {
14028 OPC_CheckPredicate, 149, 1, // 2379: check predicate 149
14029 OPC_Decode, 176, 112, 217, 1, // 2382: decode to CV_LHU_ri_inc using decoder 217
14030 // 2382: }
14031 91, 43, // 2387: case 0x5b: {
14032 OPC_SwitchField, 30, 2, // 2389: switch Inst[31:30] {
14033 0, 8, // 2392: case 0x0: {
14034 OPC_CheckPredicate, 154, 1, // 2394: check predicate 154
14035 OPC_Decode, 229, 112, 224, 1, // 2397: decode to CV_MULUN using decoder 224
14036 // 2397: }
14037 1, 8, // 2402: case 0x1: {
14038 OPC_CheckPredicate, 154, 1, // 2404: check predicate 154
14039 OPC_Decode, 225, 112, 224, 1, // 2407: decode to CV_MULHHUN using decoder 224
14040 // 2407: }
14041 2, 8, // 2412: case 0x2: {
14042 OPC_CheckPredicate, 154, 1, // 2414: check predicate 154
14043 OPC_Decode, 230, 112, 224, 1, // 2417: decode to CV_MULURN using decoder 224
14044 // 2417: }
14045 3, 0, // 2422: case 0x3: {
14046 OPC_CheckPredicate, 154, 1, // 2424: check predicate 154
14047 OPC_Decode, 226, 112, 224, 1, // 2427: decode to CV_MULHHURN using decoder 224
14048 // 2427: }
14049 // 2427: } // switch Inst[31:30]
14050 // 2427: }
14051 123, 0, // 2432: case 0x7b: {
14052 OPC_SwitchField, 26, 6, // 2434: switch Inst[31:26] {
14053 0, 11, // 2437: case 0x0: {
14054 OPC_CheckPredicate, 151, 1, // 2439: check predicate 151
14055 OPC_CheckField, 25, 1, 0, // 2442: check Inst[25] == 0x0
14056 OPC_Decode, 159, 111, 31, // 2446: decode to CV_ADD_SC_B using decoder 31
14057 // 2446: }
14058 1, 11, // 2450: case 0x1: {
14059 OPC_CheckPredicate, 151, 1, // 2452: check predicate 151
14060 OPC_CheckField, 25, 1, 0, // 2455: check Inst[25] == 0x0
14061 OPC_Decode, 195, 111, 31, // 2459: decode to CV_CMPEQ_SC_B using decoder 31
14062 // 2459: }
14063 2, 11, // 2463: case 0x2: {
14064 OPC_CheckPredicate, 151, 1, // 2465: check predicate 151
14065 OPC_CheckField, 25, 1, 0, // 2468: check Inst[25] == 0x0
14066 OPC_Decode, 186, 113, 31, // 2472: decode to CV_SUB_SC_B using decoder 31
14067 // 2472: }
14068 3, 11, // 2476: case 0x3: {
14069 OPC_CheckPredicate, 151, 1, // 2478: check predicate 151
14070 OPC_CheckField, 25, 1, 0, // 2481: check Inst[25] == 0x0
14071 OPC_Decode, 249, 111, 31, // 2485: decode to CV_CMPNE_SC_B using decoder 31
14072 // 2485: }
14073 4, 11, // 2489: case 0x4: {
14074 OPC_CheckPredicate, 151, 1, // 2491: check predicate 151
14075 OPC_CheckField, 25, 1, 0, // 2494: check Inst[25] == 0x0
14076 OPC_Decode, 177, 111, 31, // 2498: decode to CV_AVG_SC_B using decoder 31
14077 // 2498: }
14078 5, 11, // 2502: case 0x5: {
14079 OPC_CheckPredicate, 151, 1, // 2504: check predicate 151
14080 OPC_CheckField, 25, 1, 0, // 2507: check Inst[25] == 0x0
14081 OPC_Decode, 219, 111, 31, // 2511: decode to CV_CMPGT_SC_B using decoder 31
14082 // 2511: }
14083 6, 11, // 2515: case 0x6: {
14084 OPC_CheckPredicate, 151, 1, // 2517: check predicate 151
14085 OPC_CheckField, 25, 1, 0, // 2520: check Inst[25] == 0x0
14086 OPC_Decode, 171, 111, 31, // 2524: decode to CV_AVGU_SC_B using decoder 31
14087 // 2524: }
14088 7, 11, // 2528: case 0x7: {
14089 OPC_CheckPredicate, 151, 1, // 2530: check predicate 151
14090 OPC_CheckField, 25, 1, 0, // 2533: check Inst[25] == 0x0
14091 OPC_Decode, 207, 111, 31, // 2537: decode to CV_CMPGE_SC_B using decoder 31
14092 // 2537: }
14093 8, 11, // 2541: case 0x8: {
14094 OPC_CheckPredicate, 151, 1, // 2543: check predicate 151
14095 OPC_CheckField, 25, 1, 0, // 2546: check Inst[25] == 0x0
14096 OPC_Decode, 220, 112, 31, // 2550: decode to CV_MIN_SC_B using decoder 31
14097 // 2550: }
14098 9, 11, // 2554: case 0x9: {
14099 OPC_CheckPredicate, 151, 1, // 2556: check predicate 151
14100 OPC_CheckField, 25, 1, 0, // 2559: check Inst[25] == 0x0
14101 OPC_Decode, 243, 111, 31, // 2563: decode to CV_CMPLT_SC_B using decoder 31
14102 // 2563: }
14103 10, 11, // 2567: case 0xa: {
14104 OPC_CheckPredicate, 151, 1, // 2569: check predicate 151
14105 OPC_CheckField, 25, 1, 0, // 2572: check Inst[25] == 0x0
14106 OPC_Decode, 214, 112, 31, // 2576: decode to CV_MINU_SC_B using decoder 31
14107 // 2576: }
14108 11, 11, // 2580: case 0xb: {
14109 OPC_CheckPredicate, 151, 1, // 2582: check predicate 151
14110 OPC_CheckField, 25, 1, 0, // 2585: check Inst[25] == 0x0
14111 OPC_Decode, 231, 111, 31, // 2589: decode to CV_CMPLE_SC_B using decoder 31
14112 // 2589: }
14113 12, 11, // 2593: case 0xc: {
14114 OPC_CheckPredicate, 151, 1, // 2595: check predicate 151
14115 OPC_CheckField, 25, 1, 0, // 2598: check Inst[25] == 0x0
14116 OPC_Decode, 206, 112, 31, // 2602: decode to CV_MAX_SC_B using decoder 31
14117 // 2602: }
14118 13, 11, // 2606: case 0xd: {
14119 OPC_CheckPredicate, 151, 1, // 2608: check predicate 151
14120 OPC_CheckField, 25, 1, 0, // 2611: check Inst[25] == 0x0
14121 OPC_Decode, 213, 111, 31, // 2615: decode to CV_CMPGTU_SC_B using decoder 31
14122 // 2615: }
14123 14, 11, // 2619: case 0xe: {
14124 OPC_CheckPredicate, 151, 1, // 2621: check predicate 151
14125 OPC_CheckField, 25, 1, 0, // 2624: check Inst[25] == 0x0
14126 OPC_Decode, 200, 112, 31, // 2628: decode to CV_MAXU_SC_B using decoder 31
14127 // 2628: }
14128 15, 11, // 2632: case 0xf: {
14129 OPC_CheckPredicate, 151, 1, // 2634: check predicate 151
14130 OPC_CheckField, 25, 1, 0, // 2637: check Inst[25] == 0x0
14131 OPC_Decode, 201, 111, 31, // 2641: decode to CV_CMPGEU_SC_B using decoder 31
14132 // 2641: }
14133 16, 11, // 2645: case 0x10: {
14134 OPC_CheckPredicate, 151, 1, // 2647: check predicate 151
14135 OPC_CheckField, 25, 1, 0, // 2650: check Inst[25] == 0x0
14136 OPC_Decode, 165, 113, 31, // 2654: decode to CV_SRL_SC_B using decoder 31
14137 // 2654: }
14138 17, 11, // 2658: case 0x11: {
14139 OPC_CheckPredicate, 151, 1, // 2660: check predicate 151
14140 OPC_CheckField, 25, 1, 0, // 2663: check Inst[25] == 0x0
14141 OPC_Decode, 237, 111, 31, // 2667: decode to CV_CMPLTU_SC_B using decoder 31
14142 // 2667: }
14143 18, 11, // 2671: case 0x12: {
14144 OPC_CheckPredicate, 151, 1, // 2673: check predicate 151
14145 OPC_CheckField, 25, 1, 0, // 2676: check Inst[25] == 0x0
14146 OPC_Decode, 159, 113, 31, // 2680: decode to CV_SRA_SC_B using decoder 31
14147 // 2680: }
14148 19, 11, // 2684: case 0x13: {
14149 OPC_CheckPredicate, 151, 1, // 2686: check predicate 151
14150 OPC_CheckField, 25, 1, 0, // 2689: check Inst[25] == 0x0
14151 OPC_Decode, 225, 111, 31, // 2693: decode to CV_CMPLEU_SC_B using decoder 31
14152 // 2693: }
14153 20, 11, // 2697: case 0x14: {
14154 OPC_CheckPredicate, 151, 1, // 2699: check predicate 151
14155 OPC_CheckField, 25, 1, 0, // 2702: check Inst[25] == 0x0
14156 OPC_Decode, 153, 113, 31, // 2706: decode to CV_SLL_SC_B using decoder 31
14157 // 2706: }
14158 22, 11, // 2710: case 0x16: {
14159 OPC_CheckPredicate, 151, 1, // 2712: check predicate 151
14160 OPC_CheckField, 25, 1, 0, // 2715: check Inst[25] == 0x0
14161 OPC_Decode, 235, 112, 31, // 2719: decode to CV_OR_SC_B using decoder 31
14162 // 2719: }
14163 24, 11, // 2723: case 0x18: {
14164 OPC_CheckPredicate, 151, 1, // 2725: check predicate 151
14165 OPC_CheckField, 25, 1, 0, // 2728: check Inst[25] == 0x0
14166 OPC_Decode, 195, 113, 31, // 2732: decode to CV_XOR_SC_B using decoder 31
14167 // 2732: }
14168 26, 11, // 2736: case 0x1a: {
14169 OPC_CheckPredicate, 151, 1, // 2738: check predicate 151
14170 OPC_CheckField, 25, 1, 0, // 2741: check Inst[25] == 0x0
14171 OPC_Decode, 165, 111, 31, // 2745: decode to CV_AND_SC_B using decoder 31
14172 // 2745: }
14173 32, 11, // 2749: case 0x20: {
14174 OPC_CheckPredicate, 151, 1, // 2751: check predicate 151
14175 OPC_CheckField, 25, 1, 0, // 2754: check Inst[25] == 0x0
14176 OPC_Decode, 143, 112, 31, // 2758: decode to CV_DOTUP_SC_B using decoder 31
14177 // 2758: }
14178 34, 11, // 2762: case 0x22: {
14179 OPC_CheckPredicate, 151, 1, // 2764: check predicate 151
14180 OPC_CheckField, 25, 1, 0, // 2767: check Inst[25] == 0x0
14181 OPC_Decode, 149, 112, 31, // 2771: decode to CV_DOTUSP_SC_B using decoder 31
14182 // 2771: }
14183 36, 11, // 2775: case 0x24: {
14184 OPC_CheckPredicate, 151, 1, // 2777: check predicate 151
14185 OPC_CheckField, 25, 1, 0, // 2780: check Inst[25] == 0x0
14186 OPC_Decode, 137, 112, 31, // 2784: decode to CV_DOTSP_SC_B using decoder 31
14187 // 2784: }
14188 38, 11, // 2788: case 0x26: {
14189 OPC_CheckPredicate, 151, 1, // 2790: check predicate 151
14190 OPC_CheckField, 25, 1, 0, // 2793: check Inst[25] == 0x0
14191 OPC_Decode, 255, 112, 61, // 2797: decode to CV_SDOTUP_SC_B using decoder 61
14192 // 2797: }
14193 40, 11, // 2801: case 0x28: {
14194 OPC_CheckPredicate, 151, 1, // 2803: check predicate 151
14195 OPC_CheckField, 25, 1, 0, // 2806: check Inst[25] == 0x0
14196 OPC_Decode, 133, 113, 61, // 2810: decode to CV_SDOTUSP_SC_B using decoder 61
14197 // 2810: }
14198 42, 11, // 2814: case 0x2a: {
14199 OPC_CheckPredicate, 151, 1, // 2816: check predicate 151
14200 OPC_CheckField, 25, 1, 0, // 2819: check Inst[25] == 0x0
14201 OPC_Decode, 249, 112, 61, // 2823: decode to CV_SDOTSP_SC_B using decoder 61
14202 // 2823: }
14203 46, 0, // 2827: case 0x2e: {
14204 OPC_CheckPredicate, 151, 1, // 2829: check predicate 151
14205 OPC_Decode, 168, 112, 229, 1, // 2832: decode to CV_INSERT_B using decoder 229
14206 // 2832: }
14207 // 2832: } // switch Inst[31:26]
14208 // 2832: }
14209 // 2832: } // switch Inst[6:0]
14210 // 2832: }
14211 6, 179, 3, // 2837: case 0x6: {
14212 OPC_SwitchField, 0, 7, // 2840: switch Inst[6:0] {
14213 11, 8, // 2843: case 0xb: {
14214 OPC_CheckPredicate, 155, 1, // 2845: check predicate 155
14215 OPC_Decode, 181, 111, 230, 1, // 2848: decode to CV_BEQIMM using decoder 230
14216 // 2848: }
14217 91, 43, // 2853: case 0x5b: {
14218 OPC_SwitchField, 30, 2, // 2855: switch Inst[31:30] {
14219 0, 8, // 2858: case 0x0: {
14220 OPC_CheckPredicate, 154, 1, // 2860: check predicate 154
14221 OPC_Decode, 190, 112, 231, 1, // 2863: decode to CV_MACSN using decoder 231
14222 // 2863: }
14223 1, 8, // 2868: case 0x1: {
14224 OPC_CheckPredicate, 154, 1, // 2870: check predicate 154
14225 OPC_Decode, 186, 112, 231, 1, // 2873: decode to CV_MACHHSN using decoder 231
14226 // 2873: }
14227 2, 8, // 2878: case 0x2: {
14228 OPC_CheckPredicate, 154, 1, // 2880: check predicate 154
14229 OPC_Decode, 191, 112, 231, 1, // 2883: decode to CV_MACSRN using decoder 231
14230 // 2883: }
14231 3, 0, // 2888: case 0x3: {
14232 OPC_CheckPredicate, 154, 1, // 2890: check predicate 154
14233 OPC_Decode, 187, 112, 231, 1, // 2893: decode to CV_MACHHSRN using decoder 231
14234 // 2893: }
14235 // 2893: } // switch Inst[31:30]
14236 // 2893: }
14237 123, 0, // 2898: case 0x7b: {
14238 OPC_SwitchField, 26, 6, // 2900: switch Inst[31:26] {
14239 0, 8, // 2903: case 0x0: {
14240 OPC_CheckPredicate, 151, 1, // 2905: check predicate 151
14241 OPC_Decode, 158, 111, 232, 1, // 2908: decode to CV_ADD_SCI_H using decoder 232
14242 // 2908: }
14243 1, 8, // 2913: case 0x1: {
14244 OPC_CheckPredicate, 151, 1, // 2915: check predicate 151
14245 OPC_Decode, 194, 111, 232, 1, // 2918: decode to CV_CMPEQ_SCI_H using decoder 232
14246 // 2918: }
14247 2, 8, // 2923: case 0x2: {
14248 OPC_CheckPredicate, 151, 1, // 2925: check predicate 151
14249 OPC_Decode, 185, 113, 232, 1, // 2928: decode to CV_SUB_SCI_H using decoder 232
14250 // 2928: }
14251 3, 8, // 2933: case 0x3: {
14252 OPC_CheckPredicate, 151, 1, // 2935: check predicate 151
14253 OPC_Decode, 248, 111, 232, 1, // 2938: decode to CV_CMPNE_SCI_H using decoder 232
14254 // 2938: }
14255 4, 8, // 2943: case 0x4: {
14256 OPC_CheckPredicate, 151, 1, // 2945: check predicate 151
14257 OPC_Decode, 176, 111, 232, 1, // 2948: decode to CV_AVG_SCI_H using decoder 232
14258 // 2948: }
14259 5, 8, // 2953: case 0x5: {
14260 OPC_CheckPredicate, 151, 1, // 2955: check predicate 151
14261 OPC_Decode, 218, 111, 232, 1, // 2958: decode to CV_CMPGT_SCI_H using decoder 232
14262 // 2958: }
14263 6, 8, // 2963: case 0x6: {
14264 OPC_CheckPredicate, 151, 1, // 2965: check predicate 151
14265 OPC_Decode, 170, 111, 233, 1, // 2968: decode to CV_AVGU_SCI_H using decoder 233
14266 // 2968: }
14267 7, 8, // 2973: case 0x7: {
14268 OPC_CheckPredicate, 151, 1, // 2975: check predicate 151
14269 OPC_Decode, 206, 111, 232, 1, // 2978: decode to CV_CMPGE_SCI_H using decoder 232
14270 // 2978: }
14271 8, 8, // 2983: case 0x8: {
14272 OPC_CheckPredicate, 151, 1, // 2985: check predicate 151
14273 OPC_Decode, 219, 112, 232, 1, // 2988: decode to CV_MIN_SCI_H using decoder 232
14274 // 2988: }
14275 9, 8, // 2993: case 0x9: {
14276 OPC_CheckPredicate, 151, 1, // 2995: check predicate 151
14277 OPC_Decode, 242, 111, 232, 1, // 2998: decode to CV_CMPLT_SCI_H using decoder 232
14278 // 2998: }
14279 10, 8, // 3003: case 0xa: {
14280 OPC_CheckPredicate, 151, 1, // 3005: check predicate 151
14281 OPC_Decode, 213, 112, 233, 1, // 3008: decode to CV_MINU_SCI_H using decoder 233
14282 // 3008: }
14283 11, 8, // 3013: case 0xb: {
14284 OPC_CheckPredicate, 151, 1, // 3015: check predicate 151
14285 OPC_Decode, 230, 111, 232, 1, // 3018: decode to CV_CMPLE_SCI_H using decoder 232
14286 // 3018: }
14287 12, 8, // 3023: case 0xc: {
14288 OPC_CheckPredicate, 151, 1, // 3025: check predicate 151
14289 OPC_Decode, 205, 112, 232, 1, // 3028: decode to CV_MAX_SCI_H using decoder 232
14290 // 3028: }
14291 13, 8, // 3033: case 0xd: {
14292 OPC_CheckPredicate, 151, 1, // 3035: check predicate 151
14293 OPC_Decode, 212, 111, 233, 1, // 3038: decode to CV_CMPGTU_SCI_H using decoder 233
14294 // 3038: }
14295 14, 8, // 3043: case 0xe: {
14296 OPC_CheckPredicate, 151, 1, // 3045: check predicate 151
14297 OPC_Decode, 199, 112, 233, 1, // 3048: decode to CV_MAXU_SCI_H using decoder 233
14298 // 3048: }
14299 15, 8, // 3053: case 0xf: {
14300 OPC_CheckPredicate, 151, 1, // 3055: check predicate 151
14301 OPC_Decode, 200, 111, 233, 1, // 3058: decode to CV_CMPGEU_SCI_H using decoder 233
14302 // 3058: }
14303 16, 8, // 3063: case 0x10: {
14304 OPC_CheckPredicate, 151, 1, // 3065: check predicate 151
14305 OPC_Decode, 164, 113, 234, 1, // 3068: decode to CV_SRL_SCI_H using decoder 234
14306 // 3068: }
14307 17, 8, // 3073: case 0x11: {
14308 OPC_CheckPredicate, 151, 1, // 3075: check predicate 151
14309 OPC_Decode, 236, 111, 233, 1, // 3078: decode to CV_CMPLTU_SCI_H using decoder 233
14310 // 3078: }
14311 18, 8, // 3083: case 0x12: {
14312 OPC_CheckPredicate, 151, 1, // 3085: check predicate 151
14313 OPC_Decode, 158, 113, 234, 1, // 3088: decode to CV_SRA_SCI_H using decoder 234
14314 // 3088: }
14315 19, 8, // 3093: case 0x13: {
14316 OPC_CheckPredicate, 151, 1, // 3095: check predicate 151
14317 OPC_Decode, 224, 111, 233, 1, // 3098: decode to CV_CMPLEU_SCI_H using decoder 233
14318 // 3098: }
14319 20, 8, // 3103: case 0x14: {
14320 OPC_CheckPredicate, 151, 1, // 3105: check predicate 151
14321 OPC_Decode, 152, 113, 234, 1, // 3108: decode to CV_SLL_SCI_H using decoder 234
14322 // 3108: }
14323 21, 21, // 3113: case 0x15: {
14324 OPC_SwitchField, 25, 1, // 3115: switch Inst[25] {
14325 0, 7, // 3118: case 0x0: {
14326 OPC_CheckPredicate, 151, 1, // 3120: check predicate 151
14327 OPC_Decode, 132, 112, 61, // 3123: decode to CV_CPLXMUL_R_DIV8 using decoder 61
14328 // 3123: }
14329 1, 0, // 3127: case 0x1: {
14330 OPC_CheckPredicate, 151, 1, // 3129: check predicate 151
14331 OPC_Decode, 128, 112, 61, // 3132: decode to CV_CPLXMUL_I_DIV8 using decoder 61
14332 // 3132: }
14333 // 3132: } // switch Inst[25]
14334 // 3132: }
14335 22, 8, // 3136: case 0x16: {
14336 OPC_CheckPredicate, 151, 1, // 3138: check predicate 151
14337 OPC_Decode, 234, 112, 232, 1, // 3141: decode to CV_OR_SCI_H using decoder 232
14338 // 3141: }
14339 24, 8, // 3146: case 0x18: {
14340 OPC_CheckPredicate, 151, 1, // 3148: check predicate 151
14341 OPC_Decode, 194, 113, 232, 1, // 3151: decode to CV_XOR_SCI_H using decoder 232
14342 // 3151: }
14343 25, 11, // 3156: case 0x19: {
14344 OPC_CheckPredicate, 151, 1, // 3158: check predicate 151
14345 OPC_CheckField, 25, 1, 0, // 3161: check Inst[25] == 0x0
14346 OPC_Decode, 174, 113, 31, // 3165: decode to CV_SUBROTMJ_DIV8 using decoder 31
14347 // 3165: }
14348 26, 8, // 3169: case 0x1a: {
14349 OPC_CheckPredicate, 151, 1, // 3171: check predicate 151
14350 OPC_Decode, 164, 111, 232, 1, // 3174: decode to CV_AND_SCI_H using decoder 232
14351 // 3174: }
14352 27, 11, // 3179: case 0x1b: {
14353 OPC_CheckPredicate, 151, 1, // 3181: check predicate 151
14354 OPC_CheckField, 25, 1, 0, // 3184: check Inst[25] == 0x0
14355 OPC_Decode, 155, 111, 31, // 3188: decode to CV_ADD_DIV8 using decoder 31
14356 // 3188: }
14357 29, 11, // 3192: case 0x1d: {
14358 OPC_CheckPredicate, 151, 1, // 3194: check predicate 151
14359 OPC_CheckField, 25, 1, 0, // 3197: check Inst[25] == 0x0
14360 OPC_Decode, 182, 113, 31, // 3201: decode to CV_SUB_DIV8 using decoder 31
14361 // 3201: }
14362 32, 8, // 3205: case 0x20: {
14363 OPC_CheckPredicate, 151, 1, // 3207: check predicate 151
14364 OPC_Decode, 142, 112, 233, 1, // 3210: decode to CV_DOTUP_SCI_H using decoder 233
14365 // 3210: }
14366 34, 8, // 3215: case 0x22: {
14367 OPC_CheckPredicate, 151, 1, // 3217: check predicate 151
14368 OPC_Decode, 148, 112, 232, 1, // 3220: decode to CV_DOTUSP_SCI_H using decoder 232
14369 // 3220: }
14370 36, 8, // 3225: case 0x24: {
14371 OPC_CheckPredicate, 151, 1, // 3227: check predicate 151
14372 OPC_Decode, 136, 112, 232, 1, // 3230: decode to CV_DOTSP_SCI_H using decoder 232
14373 // 3230: }
14374 38, 8, // 3235: case 0x26: {
14375 OPC_CheckPredicate, 151, 1, // 3237: check predicate 151
14376 OPC_Decode, 254, 112, 235, 1, // 3240: decode to CV_SDOTUP_SCI_H using decoder 235
14377 // 3240: }
14378 40, 8, // 3245: case 0x28: {
14379 OPC_CheckPredicate, 151, 1, // 3247: check predicate 151
14380 OPC_Decode, 132, 113, 236, 1, // 3250: decode to CV_SDOTUSP_SCI_H using decoder 236
14381 // 3250: }
14382 42, 8, // 3255: case 0x2a: {
14383 OPC_CheckPredicate, 151, 1, // 3257: check predicate 151
14384 OPC_Decode, 248, 112, 236, 1, // 3260: decode to CV_SDOTSP_SCI_H using decoder 236
14385 // 3260: }
14386 48, 0, // 3265: case 0x30: {
14387 OPC_CheckPredicate, 151, 1, // 3267: check predicate 151
14388 OPC_Decode, 143, 113, 223, 1, // 3270: decode to CV_SHUFFLE_SCI_H using decoder 223
14389 // 3270: }
14390 // 3270: } // switch Inst[31:26]
14391 // 3270: }
14392 // 3270: } // switch Inst[6:0]
14393 // 3270: }
14394 7, 0, // 3275: case 0x7: {
14395 OPC_SwitchField, 0, 7, // 3277: switch Inst[6:0] {
14396 11, 8, // 3280: case 0xb: {
14397 OPC_CheckPredicate, 155, 1, // 3282: check predicate 155
14398 OPC_Decode, 183, 111, 230, 1, // 3285: decode to CV_BNEIMM using decoder 230
14399 // 3285: }
14400 91, 43, // 3290: case 0x5b: {
14401 OPC_SwitchField, 30, 2, // 3292: switch Inst[31:30] {
14402 0, 8, // 3295: case 0x0: {
14403 OPC_CheckPredicate, 154, 1, // 3297: check predicate 154
14404 OPC_Decode, 192, 112, 231, 1, // 3300: decode to CV_MACUN using decoder 231
14405 // 3300: }
14406 1, 8, // 3305: case 0x1: {
14407 OPC_CheckPredicate, 154, 1, // 3307: check predicate 154
14408 OPC_Decode, 188, 112, 231, 1, // 3310: decode to CV_MACHHUN using decoder 231
14409 // 3310: }
14410 2, 8, // 3315: case 0x2: {
14411 OPC_CheckPredicate, 154, 1, // 3317: check predicate 154
14412 OPC_Decode, 193, 112, 231, 1, // 3320: decode to CV_MACURN using decoder 231
14413 // 3320: }
14414 3, 0, // 3325: case 0x3: {
14415 OPC_CheckPredicate, 154, 1, // 3327: check predicate 154
14416 OPC_Decode, 189, 112, 231, 1, // 3330: decode to CV_MACHHURN using decoder 231
14417 // 3330: }
14418 // 3330: } // switch Inst[31:30]
14419 // 3330: }
14420 123, 0, // 3335: case 0x7b: {
14421 OPC_SwitchField, 26, 6, // 3337: switch Inst[31:26] {
14422 0, 8, // 3340: case 0x0: {
14423 OPC_CheckPredicate, 151, 1, // 3342: check predicate 151
14424 OPC_Decode, 157, 111, 232, 1, // 3345: decode to CV_ADD_SCI_B using decoder 232
14425 // 3345: }
14426 1, 8, // 3350: case 0x1: {
14427 OPC_CheckPredicate, 151, 1, // 3352: check predicate 151
14428 OPC_Decode, 193, 111, 232, 1, // 3355: decode to CV_CMPEQ_SCI_B using decoder 232
14429 // 3355: }
14430 2, 8, // 3360: case 0x2: {
14431 OPC_CheckPredicate, 151, 1, // 3362: check predicate 151
14432 OPC_Decode, 184, 113, 232, 1, // 3365: decode to CV_SUB_SCI_B using decoder 232
14433 // 3365: }
14434 3, 8, // 3370: case 0x3: {
14435 OPC_CheckPredicate, 151, 1, // 3372: check predicate 151
14436 OPC_Decode, 247, 111, 232, 1, // 3375: decode to CV_CMPNE_SCI_B using decoder 232
14437 // 3375: }
14438 4, 8, // 3380: case 0x4: {
14439 OPC_CheckPredicate, 151, 1, // 3382: check predicate 151
14440 OPC_Decode, 175, 111, 232, 1, // 3385: decode to CV_AVG_SCI_B using decoder 232
14441 // 3385: }
14442 5, 8, // 3390: case 0x5: {
14443 OPC_CheckPredicate, 151, 1, // 3392: check predicate 151
14444 OPC_Decode, 217, 111, 232, 1, // 3395: decode to CV_CMPGT_SCI_B using decoder 232
14445 // 3395: }
14446 6, 8, // 3400: case 0x6: {
14447 OPC_CheckPredicate, 151, 1, // 3402: check predicate 151
14448 OPC_Decode, 169, 111, 233, 1, // 3405: decode to CV_AVGU_SCI_B using decoder 233
14449 // 3405: }
14450 7, 8, // 3410: case 0x7: {
14451 OPC_CheckPredicate, 151, 1, // 3412: check predicate 151
14452 OPC_Decode, 205, 111, 232, 1, // 3415: decode to CV_CMPGE_SCI_B using decoder 232
14453 // 3415: }
14454 8, 8, // 3420: case 0x8: {
14455 OPC_CheckPredicate, 151, 1, // 3422: check predicate 151
14456 OPC_Decode, 218, 112, 232, 1, // 3425: decode to CV_MIN_SCI_B using decoder 232
14457 // 3425: }
14458 9, 8, // 3430: case 0x9: {
14459 OPC_CheckPredicate, 151, 1, // 3432: check predicate 151
14460 OPC_Decode, 241, 111, 232, 1, // 3435: decode to CV_CMPLT_SCI_B using decoder 232
14461 // 3435: }
14462 10, 8, // 3440: case 0xa: {
14463 OPC_CheckPredicate, 151, 1, // 3442: check predicate 151
14464 OPC_Decode, 212, 112, 233, 1, // 3445: decode to CV_MINU_SCI_B using decoder 233
14465 // 3445: }
14466 11, 8, // 3450: case 0xb: {
14467 OPC_CheckPredicate, 151, 1, // 3452: check predicate 151
14468 OPC_Decode, 229, 111, 232, 1, // 3455: decode to CV_CMPLE_SCI_B using decoder 232
14469 // 3455: }
14470 12, 8, // 3460: case 0xc: {
14471 OPC_CheckPredicate, 151, 1, // 3462: check predicate 151
14472 OPC_Decode, 204, 112, 232, 1, // 3465: decode to CV_MAX_SCI_B using decoder 232
14473 // 3465: }
14474 13, 8, // 3470: case 0xd: {
14475 OPC_CheckPredicate, 151, 1, // 3472: check predicate 151
14476 OPC_Decode, 211, 111, 233, 1, // 3475: decode to CV_CMPGTU_SCI_B using decoder 233
14477 // 3475: }
14478 14, 8, // 3480: case 0xe: {
14479 OPC_CheckPredicate, 151, 1, // 3482: check predicate 151
14480 OPC_Decode, 198, 112, 233, 1, // 3485: decode to CV_MAXU_SCI_B using decoder 233
14481 // 3485: }
14482 15, 8, // 3490: case 0xf: {
14483 OPC_CheckPredicate, 151, 1, // 3492: check predicate 151
14484 OPC_Decode, 199, 111, 233, 1, // 3495: decode to CV_CMPGEU_SCI_B using decoder 233
14485 // 3495: }
14486 16, 8, // 3500: case 0x10: {
14487 OPC_CheckPredicate, 151, 1, // 3502: check predicate 151
14488 OPC_Decode, 163, 113, 237, 1, // 3505: decode to CV_SRL_SCI_B using decoder 237
14489 // 3505: }
14490 17, 8, // 3510: case 0x11: {
14491 OPC_CheckPredicate, 151, 1, // 3512: check predicate 151
14492 OPC_Decode, 235, 111, 233, 1, // 3515: decode to CV_CMPLTU_SCI_B using decoder 233
14493 // 3515: }
14494 18, 8, // 3520: case 0x12: {
14495 OPC_CheckPredicate, 151, 1, // 3522: check predicate 151
14496 OPC_Decode, 157, 113, 237, 1, // 3525: decode to CV_SRA_SCI_B using decoder 237
14497 // 3525: }
14498 19, 8, // 3530: case 0x13: {
14499 OPC_CheckPredicate, 151, 1, // 3532: check predicate 151
14500 OPC_Decode, 223, 111, 233, 1, // 3535: decode to CV_CMPLEU_SCI_B using decoder 233
14501 // 3535: }
14502 20, 8, // 3540: case 0x14: {
14503 OPC_CheckPredicate, 151, 1, // 3542: check predicate 151
14504 OPC_Decode, 151, 113, 237, 1, // 3545: decode to CV_SLL_SCI_B using decoder 237
14505 // 3545: }
14506 22, 8, // 3550: case 0x16: {
14507 OPC_CheckPredicate, 151, 1, // 3552: check predicate 151
14508 OPC_Decode, 233, 112, 232, 1, // 3555: decode to CV_OR_SCI_B using decoder 232
14509 // 3555: }
14510 24, 8, // 3560: case 0x18: {
14511 OPC_CheckPredicate, 151, 1, // 3562: check predicate 151
14512 OPC_Decode, 193, 113, 232, 1, // 3565: decode to CV_XOR_SCI_B using decoder 232
14513 // 3565: }
14514 26, 8, // 3570: case 0x1a: {
14515 OPC_CheckPredicate, 151, 1, // 3572: check predicate 151
14516 OPC_Decode, 163, 111, 232, 1, // 3575: decode to CV_AND_SCI_B using decoder 232
14517 // 3575: }
14518 32, 8, // 3580: case 0x20: {
14519 OPC_CheckPredicate, 151, 1, // 3582: check predicate 151
14520 OPC_Decode, 141, 112, 233, 1, // 3585: decode to CV_DOTUP_SCI_B using decoder 233
14521 // 3585: }
14522 34, 8, // 3590: case 0x22: {
14523 OPC_CheckPredicate, 151, 1, // 3592: check predicate 151
14524 OPC_Decode, 147, 112, 232, 1, // 3595: decode to CV_DOTUSP_SCI_B using decoder 232
14525 // 3595: }
14526 36, 8, // 3600: case 0x24: {
14527 OPC_CheckPredicate, 151, 1, // 3602: check predicate 151
14528 OPC_Decode, 135, 112, 232, 1, // 3605: decode to CV_DOTSP_SCI_B using decoder 232
14529 // 3605: }
14530 38, 8, // 3610: case 0x26: {
14531 OPC_CheckPredicate, 151, 1, // 3612: check predicate 151
14532 OPC_Decode, 253, 112, 235, 1, // 3615: decode to CV_SDOTUP_SCI_B using decoder 235
14533 // 3615: }
14534 40, 8, // 3620: case 0x28: {
14535 OPC_CheckPredicate, 151, 1, // 3622: check predicate 151
14536 OPC_Decode, 131, 113, 236, 1, // 3625: decode to CV_SDOTUSP_SCI_B using decoder 236
14537 // 3625: }
14538 42, 8, // 3630: case 0x2a: {
14539 OPC_CheckPredicate, 151, 1, // 3632: check predicate 151
14540 OPC_Decode, 247, 112, 236, 1, // 3635: decode to CV_SDOTSP_SCI_B using decoder 236
14541 // 3635: }
14542 48, 8, // 3640: case 0x30: {
14543 OPC_CheckPredicate, 151, 1, // 3642: check predicate 151
14544 OPC_Decode, 137, 113, 233, 1, // 3645: decode to CV_SHUFFLEI0_SCI_B using decoder 233
14545 // 3645: }
14546 50, 8, // 3650: case 0x32: {
14547 OPC_CheckPredicate, 151, 1, // 3652: check predicate 151
14548 OPC_Decode, 138, 113, 233, 1, // 3655: decode to CV_SHUFFLEI1_SCI_B using decoder 233
14549 // 3655: }
14550 52, 8, // 3660: case 0x34: {
14551 OPC_CheckPredicate, 151, 1, // 3662: check predicate 151
14552 OPC_Decode, 139, 113, 233, 1, // 3665: decode to CV_SHUFFLEI2_SCI_B using decoder 233
14553 // 3665: }
14554 54, 0, // 3670: case 0x36: {
14555 OPC_CheckPredicate, 151, 1, // 3672: check predicate 151
14556 OPC_Decode, 140, 113, 233, 1, // 3675: decode to CV_SHUFFLEI3_SCI_B using decoder 233
14557 // 3675: }
14558 // 3675: } // switch Inst[31:26]
14559 // 3675: }
14560 // 3675: } // switch Inst[6:0]
14561 // 3675: }
14562 // 3675: } // switch Inst[14:12]
14563};
14564static const uint8_t DecoderTableXMIPS32[152] = {
14565 32, // 0: BitWidth 32
14566 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
14567 0, 16, // 4: case 0x0: {
14568 OPC_CheckPredicate, 156, 1, // 6: check predicate 156
14569 OPC_CheckField, 29, 3, 0, // 9: check Inst[31:29] == 0x0
14570 OPC_CheckField, 0, 7, 11, // 13: check Inst[6:0] == 0xb
14571 OPC_Decode, 179, 117, 238, 1, // 17: decode to MIPS_PREF using decoder 238
14572 // 17: }
14573 1, 43, // 22: case 0x1: {
14574 OPC_SwitchField, 15, 17, // 24: switch Inst[31:15] {
14575 32, 11, // 27: case 0x20: {
14576 OPC_CheckPredicate, 157, 1, // 29: check predicate 157
14577 OPC_CheckField, 0, 12, 19, // 32: check Inst[11:0] == 0x13
14578 OPC_Decode, 175, 117, 14, // 36: decode to MIPS_IHB using decoder 14
14579 // 36: }
14580 96, 11, // 40: case 0x60: {
14581 OPC_CheckPredicate, 157, 1, // 42: check predicate 157
14582 OPC_CheckField, 0, 12, 19, // 45: check Inst[11:0] == 0x13
14583 OPC_Decode, 174, 117, 14, // 49: decode to MIPS_EHB using decoder 14
14584 // 49: }
14585 160, 1, 0, // 53: case 0xa0: {
14586 OPC_CheckPredicate, 157, 1, // 56: check predicate 157
14587 OPC_CheckField, 0, 12, 19, // 59: check Inst[11:0] == 0x13
14588 OPC_Decode, 178, 117, 14, // 63: decode to MIPS_PAUSE using decoder 14
14589 // 63: }
14590 // 63: } // switch Inst[31:15]
14591 // 63: }
14592 3, 16, // 67: case 0x3: {
14593 OPC_CheckPredicate, 158, 1, // 69: check predicate 158
14594 OPC_CheckField, 25, 2, 3, // 72: check Inst[26:25] == 0x3
14595 OPC_CheckField, 0, 7, 11, // 76: check Inst[6:0] == 0xb
14596 OPC_Decode, 173, 117, 239, 1, // 80: decode to MIPS_CCMOV using decoder 239
14597 // 80: }
14598 4, 35, // 85: case 0x4: {
14599 OPC_SwitchField, 20, 2, // 87: switch Inst[21:20] {
14600 0, 16, // 90: case 0x0: {
14601 OPC_CheckPredicate, 159, 1, // 92: check predicate 159
14602 OPC_CheckField, 22, 1, 0, // 95: check Inst[22] == 0x0
14603 OPC_CheckField, 0, 7, 11, // 99: check Inst[6:0] == 0xb
14604 OPC_Decode, 176, 117, 240, 1, // 103: decode to MIPS_LDP using decoder 240
14605 // 103: }
14606 1, 0, // 108: case 0x1: {
14607 OPC_CheckPredicate, 160, 1, // 110: check predicate 160
14608 OPC_CheckField, 0, 7, 11, // 113: check Inst[6:0] == 0xb
14609 OPC_Decode, 177, 117, 241, 1, // 117: decode to MIPS_LWP using decoder 241
14610 // 117: }
14611 // 117: } // switch Inst[21:20]
14612 // 117: }
14613 5, 0, // 122: case 0x5: {
14614 OPC_SwitchField, 0, 9, // 124: switch Inst[8:0] {
14615 11, 12, // 127: case 0xb: {
14616 OPC_CheckPredicate, 159, 1, // 129: check predicate 159
14617 OPC_CheckField, 9, 1, 0, // 132: check Inst[9] == 0x0
14618 OPC_Decode, 180, 117, 242, 1, // 136: decode to MIPS_SDP using decoder 242
14619 // 136: }
14620 139, 1, 0, // 141: case 0x8b: {
14621 OPC_CheckPredicate, 160, 1, // 144: check predicate 160
14622 OPC_Decode, 181, 117, 243, 1, // 147: decode to MIPS_SWP using decoder 243
14623 // 147: }
14624 // 147: } // switch Inst[8:0]
14625 // 147: }
14626 // 147: } // switch Inst[14:12]
14627};
14628static const uint8_t DecoderTableXSMT32[994] = {
14629 32, // 0: BitWidth 32
14630 OPC_SwitchField, 26, 3, // 1: switch Inst[28:26] {
14631 0, 232, 1, // 4: case 0x0: {
14632 OPC_SwitchField, 14, 1, // 7: switch Inst[14] {
14633 0, 183, 1, // 10: case 0x0: {
14634 OPC_SwitchField, 31, 1, // 13: switch Inst[31] {
14635 0, 41, // 16: case 0x0: {
14636 OPC_SwitchField, 29, 2, // 18: switch Inst[30:29] {
14637 2, 17, // 21: case 0x2: {
14638 OPC_CheckPredicate, 161, 1, // 23: check predicate 161
14639 OPC_CheckField, 25, 1, 1, // 26: check Inst[25] == 0x1
14640 OPC_CheckField, 0, 7, 43, // 30: check Inst[6:0] == 0x2b
14641 OPC_Decode, 240, 129, 1, 244, 1, // 34: decode to VNPACK4_VV using decoder 244
14642 // 34: }
14643 3, 0, // 40: case 0x3: {
14644 OPC_CheckPredicate, 161, 1, // 42: check predicate 161
14645 OPC_CheckField, 25, 1, 1, // 45: check Inst[25] == 0x1
14646 OPC_CheckField, 0, 7, 43, // 49: check Inst[6:0] == 0x2b
14647 OPC_Decode, 241, 129, 1, 244, 1, // 53: decode to VNPACK_VV using decoder 244
14648 // 53: }
14649 // 53: } // switch Inst[30:29]
14650 // 53: }
14651 1, 0, // 59: case 0x1: {
14652 OPC_SwitchField, 12, 2, // 61: switch Inst[13:12] {
14653 0, 31, // 64: case 0x0: {
14654 OPC_CheckField, 0, 7, 43, // 66: check Inst[6:0] == 0x2b
14655 OPC_CheckField, 25, 1, 1, // 70: check Inst[25] == 0x1
14656 OPC_Scope, 12, // 74: try {
14657 OPC_CheckField, 29, 2, 3, // 76: check Inst[30:29] == 0x3
14658 OPC_CheckPredicate, 162, 1, // 80: check predicate 162
14659 OPC_Decode, 241, 124, 245, 1, // 83: decode to SMT_VMADOTU using decoder 245
14660 // 83: } else try {
14661 OPC_CheckPredicate, 161, 1, // 88: check predicate 161
14662 OPC_Decode, 144, 129, 1, 246, 1, // 91: decode to VMADOTU using decoder 246
14663 // 91: }
14664 // 91: }
14665 1, 31, // 97: case 0x1: {
14666 OPC_CheckField, 0, 7, 43, // 99: check Inst[6:0] == 0x2b
14667 OPC_CheckField, 25, 1, 1, // 103: check Inst[25] == 0x1
14668 OPC_Scope, 12, // 107: try {
14669 OPC_CheckField, 29, 2, 3, // 109: check Inst[30:29] == 0x3
14670 OPC_CheckPredicate, 162, 1, // 113: check predicate 162
14671 OPC_Decode, 242, 124, 245, 1, // 116: decode to SMT_VMADOTUS using decoder 245
14672 // 116: } else try {
14673 OPC_CheckPredicate, 161, 1, // 121: check predicate 161
14674 OPC_Decode, 145, 129, 1, 246, 1, // 124: decode to VMADOTUS using decoder 246
14675 // 124: }
14676 // 124: }
14677 2, 31, // 130: case 0x2: {
14678 OPC_CheckField, 0, 7, 43, // 132: check Inst[6:0] == 0x2b
14679 OPC_CheckField, 25, 1, 1, // 136: check Inst[25] == 0x1
14680 OPC_Scope, 12, // 140: try {
14681 OPC_CheckField, 29, 2, 3, // 142: check Inst[30:29] == 0x3
14682 OPC_CheckPredicate, 162, 1, // 146: check predicate 162
14683 OPC_Decode, 240, 124, 245, 1, // 149: decode to SMT_VMADOTSU using decoder 245
14684 // 149: } else try {
14685 OPC_CheckPredicate, 161, 1, // 154: check predicate 161
14686 OPC_Decode, 141, 129, 1, 246, 1, // 157: decode to VMADOTSU using decoder 246
14687 // 157: }
14688 // 157: }
14689 3, 0, // 163: case 0x3: {
14690 OPC_CheckField, 0, 7, 43, // 165: check Inst[6:0] == 0x2b
14691 OPC_CheckField, 25, 1, 1, // 169: check Inst[25] == 0x1
14692 OPC_Scope, 12, // 173: try {
14693 OPC_CheckField, 29, 2, 3, // 175: check Inst[30:29] == 0x3
14694 OPC_CheckPredicate, 162, 1, // 179: check predicate 162
14695 OPC_Decode, 227, 124, 245, 1, // 182: decode to SMT_VMADOT using decoder 245
14696 // 182: } else try {
14697 OPC_CheckPredicate, 161, 1, // 187: check predicate 161
14698 OPC_Decode, 128, 129, 1, 246, 1, // 190: decode to VMADOT using decoder 246
14699 // 190: }
14700 // 190: }
14701 // 190: } // switch Inst[13:12]
14702 // 190: }
14703 // 190: } // switch Inst[31]
14704 // 190: }
14705 1, 0, // 196: case 0x1: {
14706 OPC_SwitchField, 29, 3, // 198: switch Inst[31:29] {
14707 2, 17, // 201: case 0x2: {
14708 OPC_CheckPredicate, 161, 1, // 203: check predicate 161
14709 OPC_CheckField, 25, 1, 1, // 206: check Inst[25] == 0x1
14710 OPC_CheckField, 0, 7, 43, // 210: check Inst[6:0] == 0x2b
14711 OPC_Decode, 242, 129, 1, 244, 1, // 214: decode to VNSPACK4_VV using decoder 244
14712 // 214: }
14713 3, 0, // 220: case 0x3: {
14714 OPC_CheckPredicate, 161, 1, // 222: check predicate 161
14715 OPC_CheckField, 25, 1, 1, // 225: check Inst[25] == 0x1
14716 OPC_CheckField, 0, 7, 43, // 229: check Inst[6:0] == 0x2b
14717 OPC_Decode, 243, 129, 1, 244, 1, // 233: decode to VNSPACK_VV using decoder 244
14718 // 233: }
14719 // 233: } // switch Inst[31:29]
14720 // 233: }
14721 // 233: } // switch Inst[14]
14722 // 233: }
14723 1, 246, 3, // 239: case 0x1: {
14724 OPC_SwitchField, 14, 1, // 242: switch Inst[14] {
14725 0, 187, 2, // 245: case 0x0: {
14726 OPC_SwitchField, 31, 1, // 248: switch Inst[31] {
14727 0, 21, // 251: case 0x0: {
14728 OPC_CheckPredicate, 161, 1, // 253: check predicate 161
14729 OPC_CheckField, 29, 2, 3, // 256: check Inst[30:29] == 0x3
14730 OPC_CheckField, 25, 1, 1, // 260: check Inst[25] == 0x1
14731 OPC_CheckField, 0, 7, 43, // 264: check Inst[6:0] == 0x2b
14732 OPC_Decode, 253, 129, 1, 247, 1, // 268: decode to VPACK_VV using decoder 247
14733 // 268: }
14734 1, 0, // 274: case 0x1: {
14735 OPC_SwitchField, 12, 2, // 276: switch Inst[13:12] {
14736 0, 69, // 279: case 0x0: {
14737 OPC_SwitchField, 15, 1, // 281: switch Inst[15] {
14738 0, 31, // 284: case 0x0: {
14739 OPC_CheckField, 0, 7, 43, // 286: check Inst[6:0] == 0x2b
14740 OPC_CheckField, 25, 1, 1, // 290: check Inst[25] == 0x1
14741 OPC_Scope, 12, // 294: try {
14742 OPC_CheckField, 29, 2, 3, // 296: check Inst[30:29] == 0x3
14743 OPC_CheckPredicate, 162, 1, // 300: check predicate 162
14744 OPC_Decode, 230, 124, 248, 1, // 303: decode to SMT_VMADOT1U using decoder 248
14745 // 303: } else try {
14746 OPC_CheckPredicate, 161, 1, // 308: check predicate 161
14747 OPC_Decode, 131, 129, 1, 249, 1, // 311: decode to VMADOT1U using decoder 249
14748 // 311: }
14749 // 311: }
14750 1, 0, // 317: case 0x1: {
14751 OPC_CheckField, 0, 7, 43, // 319: check Inst[6:0] == 0x2b
14752 OPC_CheckField, 25, 1, 1, // 323: check Inst[25] == 0x1
14753 OPC_Scope, 12, // 327: try {
14754 OPC_CheckField, 29, 2, 3, // 329: check Inst[30:29] == 0x3
14755 OPC_CheckPredicate, 162, 1, // 333: check predicate 162
14756 OPC_Decode, 238, 124, 248, 1, // 336: decode to SMT_VMADOT3U using decoder 248
14757 // 336: } else try {
14758 OPC_CheckPredicate, 161, 1, // 341: check predicate 161
14759 OPC_Decode, 139, 129, 1, 249, 1, // 344: decode to VMADOT3U using decoder 249
14760 // 344: }
14761 // 344: }
14762 // 344: } // switch Inst[15]
14763 // 344: }
14764 1, 69, // 350: case 0x1: {
14765 OPC_SwitchField, 15, 1, // 352: switch Inst[15] {
14766 0, 31, // 355: case 0x0: {
14767 OPC_CheckField, 0, 7, 43, // 357: check Inst[6:0] == 0x2b
14768 OPC_CheckField, 25, 1, 1, // 361: check Inst[25] == 0x1
14769 OPC_Scope, 12, // 365: try {
14770 OPC_CheckField, 29, 2, 3, // 367: check Inst[30:29] == 0x3
14771 OPC_CheckPredicate, 162, 1, // 371: check predicate 162
14772 OPC_Decode, 231, 124, 248, 1, // 374: decode to SMT_VMADOT1US using decoder 248
14773 // 374: } else try {
14774 OPC_CheckPredicate, 161, 1, // 379: check predicate 161
14775 OPC_Decode, 132, 129, 1, 249, 1, // 382: decode to VMADOT1US using decoder 249
14776 // 382: }
14777 // 382: }
14778 1, 0, // 388: case 0x1: {
14779 OPC_CheckField, 0, 7, 43, // 390: check Inst[6:0] == 0x2b
14780 OPC_CheckField, 25, 1, 1, // 394: check Inst[25] == 0x1
14781 OPC_Scope, 12, // 398: try {
14782 OPC_CheckField, 29, 2, 3, // 400: check Inst[30:29] == 0x3
14783 OPC_CheckPredicate, 162, 1, // 404: check predicate 162
14784 OPC_Decode, 239, 124, 248, 1, // 407: decode to SMT_VMADOT3US using decoder 248
14785 // 407: } else try {
14786 OPC_CheckPredicate, 161, 1, // 412: check predicate 161
14787 OPC_Decode, 140, 129, 1, 249, 1, // 415: decode to VMADOT3US using decoder 249
14788 // 415: }
14789 // 415: }
14790 // 415: } // switch Inst[15]
14791 // 415: }
14792 2, 69, // 421: case 0x2: {
14793 OPC_SwitchField, 15, 1, // 423: switch Inst[15] {
14794 0, 31, // 426: case 0x0: {
14795 OPC_CheckField, 0, 7, 43, // 428: check Inst[6:0] == 0x2b
14796 OPC_CheckField, 25, 1, 1, // 432: check Inst[25] == 0x1
14797 OPC_Scope, 12, // 436: try {
14798 OPC_CheckField, 29, 2, 3, // 438: check Inst[30:29] == 0x3
14799 OPC_CheckPredicate, 162, 1, // 442: check predicate 162
14800 OPC_Decode, 229, 124, 248, 1, // 445: decode to SMT_VMADOT1SU using decoder 248
14801 // 445: } else try {
14802 OPC_CheckPredicate, 161, 1, // 450: check predicate 161
14803 OPC_Decode, 130, 129, 1, 249, 1, // 453: decode to VMADOT1SU using decoder 249
14804 // 453: }
14805 // 453: }
14806 1, 0, // 459: case 0x1: {
14807 OPC_CheckField, 0, 7, 43, // 461: check Inst[6:0] == 0x2b
14808 OPC_CheckField, 25, 1, 1, // 465: check Inst[25] == 0x1
14809 OPC_Scope, 12, // 469: try {
14810 OPC_CheckField, 29, 2, 3, // 471: check Inst[30:29] == 0x3
14811 OPC_CheckPredicate, 162, 1, // 475: check predicate 162
14812 OPC_Decode, 237, 124, 248, 1, // 478: decode to SMT_VMADOT3SU using decoder 248
14813 // 478: } else try {
14814 OPC_CheckPredicate, 161, 1, // 483: check predicate 161
14815 OPC_Decode, 138, 129, 1, 249, 1, // 486: decode to VMADOT3SU using decoder 249
14816 // 486: }
14817 // 486: }
14818 // 486: } // switch Inst[15]
14819 // 486: }
14820 3, 0, // 492: case 0x3: {
14821 OPC_SwitchField, 15, 1, // 494: switch Inst[15] {
14822 0, 31, // 497: case 0x0: {
14823 OPC_CheckField, 0, 7, 43, // 499: check Inst[6:0] == 0x2b
14824 OPC_CheckField, 25, 1, 1, // 503: check Inst[25] == 0x1
14825 OPC_Scope, 12, // 507: try {
14826 OPC_CheckField, 29, 2, 3, // 509: check Inst[30:29] == 0x3
14827 OPC_CheckPredicate, 162, 1, // 513: check predicate 162
14828 OPC_Decode, 228, 124, 248, 1, // 516: decode to SMT_VMADOT1 using decoder 248
14829 // 516: } else try {
14830 OPC_CheckPredicate, 161, 1, // 521: check predicate 161
14831 OPC_Decode, 129, 129, 1, 249, 1, // 524: decode to VMADOT1 using decoder 249
14832 // 524: }
14833 // 524: }
14834 1, 0, // 530: case 0x1: {
14835 OPC_CheckField, 0, 7, 43, // 532: check Inst[6:0] == 0x2b
14836 OPC_CheckField, 25, 1, 1, // 536: check Inst[25] == 0x1
14837 OPC_Scope, 12, // 540: try {
14838 OPC_CheckField, 29, 2, 3, // 542: check Inst[30:29] == 0x3
14839 OPC_CheckPredicate, 162, 1, // 546: check predicate 162
14840 OPC_Decode, 236, 124, 248, 1, // 549: decode to SMT_VMADOT3 using decoder 248
14841 // 549: } else try {
14842 OPC_CheckPredicate, 161, 1, // 554: check predicate 161
14843 OPC_Decode, 137, 129, 1, 249, 1, // 557: decode to VMADOT3 using decoder 249
14844 // 557: }
14845 // 557: }
14846 // 557: } // switch Inst[15]
14847 // 557: }
14848 // 557: } // switch Inst[13:12]
14849 // 557: }
14850 // 557: } // switch Inst[31]
14851 // 557: }
14852 1, 0, // 563: case 0x1: {
14853 OPC_SwitchField, 31, 1, // 565: switch Inst[31] {
14854 0, 21, // 568: case 0x0: {
14855 OPC_CheckPredicate, 161, 1, // 570: check predicate 161
14856 OPC_CheckField, 29, 2, 3, // 573: check Inst[30:29] == 0x3
14857 OPC_CheckField, 25, 1, 1, // 577: check Inst[25] == 0x1
14858 OPC_CheckField, 0, 7, 43, // 581: check Inst[6:0] == 0x2b
14859 OPC_Decode, 215, 131, 1, 247, 1, // 585: decode to VUPACK_VV using decoder 247
14860 // 585: }
14861 1, 0, // 591: case 0x1: {
14862 OPC_SwitchField, 12, 2, // 593: switch Inst[13:12] {
14863 0, 35, // 596: case 0x0: {
14864 OPC_CheckField, 0, 7, 43, // 598: check Inst[6:0] == 0x2b
14865 OPC_CheckField, 15, 1, 0, // 602: check Inst[15] == 0x0
14866 OPC_CheckField, 25, 1, 1, // 606: check Inst[25] == 0x1
14867 OPC_Scope, 12, // 610: try {
14868 OPC_CheckField, 29, 2, 3, // 612: check Inst[30:29] == 0x3
14869 OPC_CheckPredicate, 162, 1, // 616: check predicate 162
14870 OPC_Decode, 234, 124, 248, 1, // 619: decode to SMT_VMADOT2U using decoder 248
14871 // 619: } else try {
14872 OPC_CheckPredicate, 161, 1, // 624: check predicate 161
14873 OPC_Decode, 135, 129, 1, 249, 1, // 627: decode to VMADOT2U using decoder 249
14874 // 627: }
14875 // 627: }
14876 1, 35, // 633: case 0x1: {
14877 OPC_CheckField, 0, 7, 43, // 635: check Inst[6:0] == 0x2b
14878 OPC_CheckField, 15, 1, 0, // 639: check Inst[15] == 0x0
14879 OPC_CheckField, 25, 1, 1, // 643: check Inst[25] == 0x1
14880 OPC_Scope, 12, // 647: try {
14881 OPC_CheckField, 29, 2, 3, // 649: check Inst[30:29] == 0x3
14882 OPC_CheckPredicate, 162, 1, // 653: check predicate 162
14883 OPC_Decode, 235, 124, 248, 1, // 656: decode to SMT_VMADOT2US using decoder 248
14884 // 656: } else try {
14885 OPC_CheckPredicate, 161, 1, // 661: check predicate 161
14886 OPC_Decode, 136, 129, 1, 249, 1, // 664: decode to VMADOT2US using decoder 249
14887 // 664: }
14888 // 664: }
14889 2, 35, // 670: case 0x2: {
14890 OPC_CheckField, 0, 7, 43, // 672: check Inst[6:0] == 0x2b
14891 OPC_CheckField, 15, 1, 0, // 676: check Inst[15] == 0x0
14892 OPC_CheckField, 25, 1, 1, // 680: check Inst[25] == 0x1
14893 OPC_Scope, 12, // 684: try {
14894 OPC_CheckField, 29, 2, 3, // 686: check Inst[30:29] == 0x3
14895 OPC_CheckPredicate, 162, 1, // 690: check predicate 162
14896 OPC_Decode, 233, 124, 248, 1, // 693: decode to SMT_VMADOT2SU using decoder 248
14897 // 693: } else try {
14898 OPC_CheckPredicate, 161, 1, // 698: check predicate 161
14899 OPC_Decode, 134, 129, 1, 249, 1, // 701: decode to VMADOT2SU using decoder 249
14900 // 701: }
14901 // 701: }
14902 3, 0, // 707: case 0x3: {
14903 OPC_CheckField, 0, 7, 43, // 709: check Inst[6:0] == 0x2b
14904 OPC_CheckField, 15, 1, 0, // 713: check Inst[15] == 0x0
14905 OPC_CheckField, 25, 1, 1, // 717: check Inst[25] == 0x1
14906 OPC_Scope, 12, // 721: try {
14907 OPC_CheckField, 29, 2, 3, // 723: check Inst[30:29] == 0x3
14908 OPC_CheckPredicate, 162, 1, // 727: check predicate 162
14909 OPC_Decode, 232, 124, 248, 1, // 730: decode to SMT_VMADOT2 using decoder 248
14910 // 730: } else try {
14911 OPC_CheckPredicate, 161, 1, // 735: check predicate 161
14912 OPC_Decode, 133, 129, 1, 249, 1, // 738: decode to VMADOT2 using decoder 249
14913 // 738: }
14914 // 738: }
14915 // 738: } // switch Inst[13:12]
14916 // 738: }
14917 // 738: } // switch Inst[31]
14918 // 738: }
14919 // 738: } // switch Inst[14]
14920 // 738: }
14921 2, 79, // 744: case 0x2: {
14922 OPC_SwitchField, 12, 3, // 746: switch Inst[14:12] {
14923 0, 17, // 749: case 0x0: {
14924 OPC_CheckPredicate, 161, 1, // 751: check predicate 161
14925 OPC_CheckField, 31, 1, 1, // 754: check Inst[31] == 0x1
14926 OPC_CheckField, 0, 7, 43, // 758: check Inst[6:0] == 0x2b
14927 OPC_Decode, 149, 129, 1, 250, 1, // 762: decode to VMADOTU_SP using decoder 250
14928 // 762: }
14929 1, 17, // 768: case 0x1: {
14930 OPC_CheckPredicate, 161, 1, // 770: check predicate 161
14931 OPC_CheckField, 31, 1, 1, // 773: check Inst[31] == 0x1
14932 OPC_CheckField, 0, 7, 43, // 777: check Inst[6:0] == 0x2b
14933 OPC_Decode, 147, 129, 1, 250, 1, // 781: decode to VMADOTUS_SP using decoder 250
14934 // 781: }
14935 2, 17, // 787: case 0x2: {
14936 OPC_CheckPredicate, 161, 1, // 789: check predicate 161
14937 OPC_CheckField, 31, 1, 1, // 792: check Inst[31] == 0x1
14938 OPC_CheckField, 0, 7, 43, // 796: check Inst[6:0] == 0x2b
14939 OPC_Decode, 143, 129, 1, 250, 1, // 800: decode to VMADOTSU_SP using decoder 250
14940 // 800: }
14941 3, 0, // 806: case 0x3: {
14942 OPC_CheckPredicate, 161, 1, // 808: check predicate 161
14943 OPC_CheckField, 31, 1, 1, // 811: check Inst[31] == 0x1
14944 OPC_CheckField, 0, 7, 43, // 815: check Inst[6:0] == 0x2b
14945 OPC_Decode, 151, 129, 1, 250, 1, // 819: decode to VMADOT_SP using decoder 250
14946 // 819: }
14947 // 819: } // switch Inst[14:12]
14948 // 819: }
14949 3, 17, // 825: case 0x3: {
14950 OPC_CheckPredicate, 161, 1, // 827: check predicate 161
14951 OPC_CheckField, 31, 1, 1, // 830: check Inst[31] == 0x1
14952 OPC_CheckField, 0, 7, 43, // 834: check Inst[6:0] == 0x2b
14953 OPC_Decode, 148, 129, 1, 251, 1, // 838: decode to VMADOTU_HP using decoder 251
14954 // 838: }
14955 4, 17, // 844: case 0x4: {
14956 OPC_CheckPredicate, 161, 1, // 846: check predicate 161
14957 OPC_CheckField, 31, 1, 1, // 849: check Inst[31] == 0x1
14958 OPC_CheckField, 0, 7, 43, // 853: check Inst[6:0] == 0x2b
14959 OPC_Decode, 150, 129, 1, 251, 1, // 857: decode to VMADOT_HP using decoder 251
14960 // 857: }
14961 5, 17, // 863: case 0x5: {
14962 OPC_CheckPredicate, 161, 1, // 865: check predicate 161
14963 OPC_CheckField, 31, 1, 1, // 868: check Inst[31] == 0x1
14964 OPC_CheckField, 0, 7, 43, // 872: check Inst[6:0] == 0x2b
14965 OPC_Decode, 142, 129, 1, 251, 1, // 876: decode to VMADOTSU_HP using decoder 251
14966 // 876: }
14967 6, 17, // 882: case 0x6: {
14968 OPC_CheckPredicate, 161, 1, // 884: check predicate 161
14969 OPC_CheckField, 31, 1, 1, // 887: check Inst[31] == 0x1
14970 OPC_CheckField, 0, 7, 43, // 891: check Inst[6:0] == 0x2b
14971 OPC_Decode, 146, 129, 1, 251, 1, // 895: decode to VMADOTUS_HP using decoder 251
14972 // 895: }
14973 7, 0, // 901: case 0x7: {
14974 OPC_SwitchField, 12, 3, // 903: switch Inst[14:12] {
14975 4, 20, // 906: case 0x4: {
14976 OPC_CheckPredicate, 161, 1, // 908: check predicate 161
14977 OPC_CheckField, 29, 3, 4, // 911: check Inst[31:29] == 0x4
14978 OPC_CheckField, 25, 1, 1, // 915: check Inst[25] == 0x1
14979 OPC_CheckField, 0, 7, 43, // 919: check Inst[6:0] == 0x2b
14980 OPC_Decode, 171, 127, 245, 1, // 923: decode to VFWMADOT using decoder 245
14981 // 923: }
14982 5, 20, // 928: case 0x5: {
14983 OPC_CheckPredicate, 161, 1, // 930: check predicate 161
14984 OPC_CheckField, 29, 3, 4, // 933: check Inst[31:29] == 0x4
14985 OPC_CheckField, 25, 1, 1, // 937: check Inst[25] == 0x1
14986 OPC_CheckField, 0, 7, 43, // 941: check Inst[6:0] == 0x2b
14987 OPC_Decode, 172, 127, 252, 1, // 945: decode to VFWMADOT1 using decoder 252
14988 // 945: }
14989 6, 20, // 950: case 0x6: {
14990 OPC_CheckPredicate, 161, 1, // 952: check predicate 161
14991 OPC_CheckField, 29, 3, 4, // 955: check Inst[31:29] == 0x4
14992 OPC_CheckField, 25, 1, 1, // 959: check Inst[25] == 0x1
14993 OPC_CheckField, 0, 7, 43, // 963: check Inst[6:0] == 0x2b
14994 OPC_Decode, 173, 127, 252, 1, // 967: decode to VFWMADOT2 using decoder 252
14995 // 967: }
14996 7, 0, // 972: case 0x7: {
14997 OPC_CheckPredicate, 161, 1, // 974: check predicate 161
14998 OPC_CheckField, 29, 3, 4, // 977: check Inst[31:29] == 0x4
14999 OPC_CheckField, 25, 1, 1, // 981: check Inst[25] == 0x1
15000 OPC_CheckField, 0, 7, 43, // 985: check Inst[6:0] == 0x2b
15001 OPC_Decode, 174, 127, 252, 1, // 989: decode to VFWMADOT3 using decoder 252
15002 // 989: }
15003 // 989: } // switch Inst[14:12]
15004 // 989: }
15005 // 989: } // switch Inst[28:26]
15006};
15007static const uint8_t DecoderTableXSfcease32[16] = {
15008 32, // 0: BitWidth 32
15009 OPC_CheckPredicate, 163, 1, // 1: check predicate 163
15010 OPC_CheckField, 0, 32, 243, 128, 192, 130, 3,
15011 // 4: check Inst[31:0] == 0x30500073
15012 OPC_Decode, 244, 123, 14, // 12: decode to SF_CEASE using decoder 14
15013};
15014static const uint8_t DecoderTableXSfsystem32[32] = {
15015 32, // 0: BitWidth 32
15016 OPC_SwitchField, 20, 12, // 1: switch Inst[31:20] {
15017 192, 31, 11, // 4: case 0xfc0: {
15018 OPC_CheckPredicate, 164, 1, // 7: check predicate 164
15019 OPC_CheckField, 0, 15, 115, // 10: check Inst[14:0] == 0x73
15020 OPC_Decode, 245, 123, 15, // 14: decode to SF_CFLUSH_D_L1 using decoder 15
15021 // 14: }
15022 194, 31, 0, // 18: case 0xfc2: {
15023 OPC_CheckPredicate, 165, 1, // 21: check predicate 165
15024 OPC_CheckField, 0, 15, 115, // 24: check Inst[14:0] == 0x73
15025 OPC_Decode, 243, 123, 15, // 28: decode to SF_CDISCARD_D_L1 using decoder 15
15026 // 28: }
15027 // 28: } // switch Inst[31:20]
15028};
15029static const uint8_t DecoderTableXSfvector32[1129] = {
15030 32, // 0: BitWidth 32
15031 OPC_SwitchField, 28, 4, // 1: switch Inst[31:28] {
15032 0, 69, // 4: case 0x0: {
15033 OPC_SwitchField, 12, 3, // 6: switch Inst[14:12] {
15034 3, 31, // 9: case 0x3: {
15035 OPC_SwitchField, 25, 1, // 11: switch Inst[25] {
15036 0, 12, // 14: case 0x0: {
15037 OPC_CheckPredicate, 166, 1, // 16: check predicate 166
15038 OPC_CheckField, 0, 7, 91, // 19: check Inst[6:0] == 0x5b
15039 OPC_Decode, 140, 124, 253, 1, // 23: decode to SF_VC_V_I using decoder 253
15040 // 23: }
15041 1, 0, // 28: case 0x1: {
15042 OPC_CheckPredicate, 166, 1, // 30: check predicate 166
15043 OPC_CheckField, 0, 7, 91, // 33: check Inst[6:0] == 0x5b
15044 OPC_Decode, 130, 124, 254, 1, // 37: decode to SF_VC_I using decoder 254
15045 // 37: }
15046 // 37: } // switch Inst[25]
15047 // 37: }
15048 4, 0, // 42: case 0x4: {
15049 OPC_SwitchField, 25, 1, // 44: switch Inst[25] {
15050 0, 12, // 47: case 0x0: {
15051 OPC_CheckPredicate, 166, 1, // 49: check predicate 166
15052 OPC_CheckField, 0, 7, 91, // 52: check Inst[6:0] == 0x5b
15053 OPC_Decode, 147, 124, 255, 1, // 56: decode to SF_VC_V_X using decoder 255
15054 // 56: }
15055 1, 0, // 61: case 0x1: {
15056 OPC_CheckPredicate, 166, 1, // 63: check predicate 166
15057 OPC_CheckField, 0, 7, 91, // 66: check Inst[6:0] == 0x5b
15058 OPC_Decode, 151, 124, 128, 2, // 70: decode to SF_VC_X using decoder 256
15059 // 70: }
15060 // 70: } // switch Inst[25]
15061 // 70: }
15062 // 70: } // switch Inst[14:12]
15063 // 70: }
15064 1, 33, // 75: case 0x1: {
15065 OPC_SwitchField, 0, 15, // 77: switch Inst[14:0] {
15066 135, 224, 1, 11, // 80: case 0x7007: {
15067 OPC_CheckPredicate, 167, 1, // 84: check predicate 167
15068 OPC_CheckField, 25, 3, 1, // 87: check Inst[27:25] == 0x1
15069 OPC_Decode, 163, 124, 59, // 91: decode to SF_VLTE8 using decoder 59
15070 // 91: }
15071 167, 224, 1, 0, // 95: case 0x7027: {
15072 OPC_CheckPredicate, 167, 1, // 99: check predicate 167
15073 OPC_CheckField, 25, 3, 1, // 102: check Inst[27:25] == 0x1
15074 OPC_Decode, 178, 124, 59, // 106: decode to SF_VSTE8 using decoder 59
15075 // 106: }
15076 // 106: } // switch Inst[14:0]
15077 // 106: }
15078 2, 143, 1, // 110: case 0x2: {
15079 OPC_SwitchField, 12, 3, // 113: switch Inst[14:12] {
15080 0, 31, // 116: case 0x0: {
15081 OPC_SwitchField, 25, 1, // 118: switch Inst[25] {
15082 0, 12, // 121: case 0x0: {
15083 OPC_CheckPredicate, 166, 1, // 123: check predicate 166
15084 OPC_CheckField, 0, 7, 91, // 126: check Inst[6:0] == 0x5b
15085 OPC_Decode, 144, 124, 129, 2, // 130: decode to SF_VC_V_VV using decoder 257
15086 // 130: }
15087 1, 0, // 135: case 0x1: {
15088 OPC_CheckPredicate, 166, 1, // 137: check predicate 166
15089 OPC_CheckField, 0, 7, 91, // 140: check Inst[6:0] == 0x5b
15090 OPC_Decode, 134, 124, 130, 2, // 144: decode to SF_VC_VV using decoder 258
15091 // 144: }
15092 // 144: } // switch Inst[25]
15093 // 144: }
15094 3, 31, // 149: case 0x3: {
15095 OPC_SwitchField, 25, 1, // 151: switch Inst[25] {
15096 0, 12, // 154: case 0x0: {
15097 OPC_CheckPredicate, 166, 1, // 156: check predicate 166
15098 OPC_CheckField, 0, 7, 91, // 159: check Inst[6:0] == 0x5b
15099 OPC_Decode, 141, 124, 131, 2, // 163: decode to SF_VC_V_IV using decoder 259
15100 // 163: }
15101 1, 0, // 168: case 0x1: {
15102 OPC_CheckPredicate, 166, 1, // 170: check predicate 166
15103 OPC_CheckField, 0, 7, 91, // 173: check Inst[6:0] == 0x5b
15104 OPC_Decode, 131, 124, 132, 2, // 177: decode to SF_VC_IV using decoder 260
15105 // 177: }
15106 // 177: } // switch Inst[25]
15107 // 177: }
15108 4, 31, // 182: case 0x4: {
15109 OPC_SwitchField, 25, 1, // 184: switch Inst[25] {
15110 0, 12, // 187: case 0x0: {
15111 OPC_CheckPredicate, 166, 1, // 189: check predicate 166
15112 OPC_CheckField, 0, 7, 91, // 192: check Inst[6:0] == 0x5b
15113 OPC_Decode, 148, 124, 133, 2, // 196: decode to SF_VC_V_XV using decoder 261
15114 // 196: }
15115 1, 0, // 201: case 0x1: {
15116 OPC_CheckPredicate, 166, 1, // 203: check predicate 166
15117 OPC_CheckField, 0, 7, 91, // 206: check Inst[6:0] == 0x5b
15118 OPC_Decode, 152, 124, 134, 2, // 210: decode to SF_VC_XV using decoder 262
15119 // 210: }
15120 // 210: } // switch Inst[25]
15121 // 210: }
15122 5, 0, // 215: case 0x5: {
15123 OPC_SwitchField, 25, 1, // 217: switch Inst[25] {
15124 0, 16, // 220: case 0x0: {
15125 OPC_CheckPredicate, 166, 1, // 222: check predicate 166
15126 OPC_CheckField, 27, 1, 1, // 225: check Inst[27] == 0x1
15127 OPC_CheckField, 0, 7, 91, // 229: check Inst[6:0] == 0x5b
15128 OPC_Decode, 137, 124, 135, 2, // 233: decode to SF_VC_V_FV using decoder 263
15129 // 233: }
15130 1, 0, // 238: case 0x1: {
15131 OPC_CheckPredicate, 166, 1, // 240: check predicate 166
15132 OPC_CheckField, 27, 1, 1, // 243: check Inst[27] == 0x1
15133 OPC_CheckField, 0, 7, 91, // 247: check Inst[6:0] == 0x5b
15134 OPC_Decode, 255, 123, 136, 2, // 251: decode to SF_VC_FV using decoder 264
15135 // 251: }
15136 // 251: } // switch Inst[25]
15137 // 251: }
15138 // 251: } // switch Inst[14:12]
15139 // 251: }
15140 3, 33, // 256: case 0x3: {
15141 OPC_SwitchField, 0, 15, // 258: switch Inst[14:0] {
15142 135, 224, 1, 11, // 261: case 0x7007: {
15143 OPC_CheckPredicate, 167, 1, // 265: check predicate 167
15144 OPC_CheckField, 25, 3, 1, // 268: check Inst[27:25] == 0x1
15145 OPC_Decode, 160, 124, 59, // 272: decode to SF_VLTE16 using decoder 59
15146 // 272: }
15147 167, 224, 1, 0, // 276: case 0x7027: {
15148 OPC_CheckPredicate, 167, 1, // 280: check predicate 167
15149 OPC_CheckField, 25, 3, 1, // 283: check Inst[27:25] == 0x1
15150 OPC_Decode, 175, 124, 59, // 287: decode to SF_VSTE16 using decoder 59
15151 // 287: }
15152 // 287: } // switch Inst[14:0]
15153 // 287: }
15154 4, 95, // 291: case 0x4: {
15155 OPC_SwitchField, 12, 3, // 293: switch Inst[14:12] {
15156 1, 37, // 296: case 0x1: {
15157 OPC_SwitchField, 15, 5, // 298: switch Inst[19:15] {
15158 6, 15, // 301: case 0x6: {
15159 OPC_CheckPredicate, 168, 1, // 303: check predicate 168
15160 OPC_CheckField, 26, 2, 3, // 306: check Inst[27:26] == 0x3
15161 OPC_CheckField, 0, 7, 87, // 310: check Inst[6:0] == 0x57
15162 OPC_Decode, 155, 124, 124, // 314: decode to SF_VFEXPA_V using decoder 124
15163 // 314: }
15164 7, 0, // 318: case 0x7: {
15165 OPC_CheckPredicate, 169, 1, // 320: check predicate 169
15166 OPC_CheckField, 26, 2, 3, // 323: check Inst[27:26] == 0x3
15167 OPC_CheckField, 0, 7, 87, // 327: check Inst[6:0] == 0x57
15168 OPC_Decode, 156, 124, 124, // 331: decode to SF_VFEXP_V using decoder 124
15169 // 331: }
15170 // 331: } // switch Inst[19:15]
15171 // 331: }
15172 6, 0, // 335: case 0x6: {
15173 OPC_SwitchField, 20, 8, // 337: switch Inst[27:20] {
15174 60, 15, // 340: case 0x3c: {
15175 OPC_CheckPredicate, 167, 1, // 342: check predicate 167
15176 OPC_CheckField, 15, 5, 0, // 345: check Inst[19:15] == 0x0
15177 OPC_CheckField, 0, 12, 87, // 349: check Inst[11:0] == 0x57
15178 OPC_Decode, 179, 124, 14, // 353: decode to SF_VTDISCARD using decoder 14
15179 // 353: }
15180 62, 16, // 357: case 0x3e: {
15181 OPC_CheckPredicate, 167, 1, // 359: check predicate 167
15182 OPC_CheckField, 15, 5, 0, // 362: check Inst[19:15] == 0x0
15183 OPC_CheckField, 0, 8, 87, // 366: check Inst[7:0] == 0x57
15184 OPC_Decode, 182, 124, 137, 2, // 370: decode to SF_VTZERO_T using decoder 265
15185 // 370: }
15186 63, 0, // 375: case 0x3f: {
15187 OPC_CheckPredicate, 167, 1, // 377: check predicate 167
15188 OPC_CheckField, 0, 7, 87, // 380: check Inst[6:0] == 0x57
15189 OPC_Decode, 181, 124, 2, // 384: decode to SF_VTMV_V_T using decoder 2
15190 // 384: }
15191 // 384: } // switch Inst[27:20]
15192 // 384: }
15193 // 384: } // switch Inst[14:12]
15194 // 384: }
15195 5, 49, // 388: case 0x5: {
15196 OPC_SwitchField, 0, 15, // 390: switch Inst[14:0] {
15197 215, 192, 1, 12, // 393: case 0x6057: {
15198 OPC_CheckPredicate, 167, 1, // 397: check predicate 167
15199 OPC_CheckField, 25, 3, 7, // 400: check Inst[27:25] == 0x7
15200 OPC_Decode, 180, 124, 138, 2, // 404: decode to SF_VTMV_T_V using decoder 266
15201 // 404: }
15202 135, 224, 1, 11, // 409: case 0x7007: {
15203 OPC_CheckPredicate, 167, 1, // 413: check predicate 167
15204 OPC_CheckField, 25, 3, 1, // 416: check Inst[27:25] == 0x1
15205 OPC_Decode, 161, 124, 59, // 420: decode to SF_VLTE32 using decoder 59
15206 // 420: }
15207 167, 224, 1, 0, // 424: case 0x7027: {
15208 OPC_CheckPredicate, 167, 1, // 428: check predicate 167
15209 OPC_CheckField, 25, 3, 1, // 431: check Inst[27:25] == 0x1
15210 OPC_Decode, 176, 124, 59, // 435: decode to SF_VSTE32 using decoder 59
15211 // 435: }
15212 // 435: } // switch Inst[14:0]
15213 // 435: }
15214 7, 33, // 439: case 0x7: {
15215 OPC_SwitchField, 0, 15, // 441: switch Inst[14:0] {
15216 135, 224, 1, 11, // 444: case 0x7007: {
15217 OPC_CheckPredicate, 167, 1, // 448: check predicate 167
15218 OPC_CheckField, 25, 3, 1, // 451: check Inst[27:25] == 0x1
15219 OPC_Decode, 162, 124, 59, // 455: decode to SF_VLTE64 using decoder 59
15220 // 455: }
15221 167, 224, 1, 0, // 459: case 0x7027: {
15222 OPC_CheckPredicate, 167, 1, // 463: check predicate 167
15223 OPC_CheckField, 25, 3, 1, // 466: check Inst[27:25] == 0x1
15224 OPC_Decode, 177, 124, 59, // 470: decode to SF_VSTE64 using decoder 59
15225 // 470: }
15226 // 470: } // switch Inst[14:0]
15227 // 470: }
15228 8, 95, // 474: case 0x8: {
15229 OPC_SwitchField, 26, 2, // 476: switch Inst[27:26] {
15230 1, 54, // 479: case 0x1: {
15231 OPC_SwitchField, 20, 6, // 481: switch Inst[25:20] {
15232 0, 15, // 484: case 0x0: {
15233 OPC_CheckPredicate, 167, 1, // 486: check predicate 167
15234 OPC_CheckField, 12, 3, 7, // 489: check Inst[14:12] == 0x7
15235 OPC_CheckField, 0, 7, 87, // 493: check Inst[6:0] == 0x57
15236 OPC_Decode, 174, 124, 17, // 497: decode to SF_VSETTN using decoder 17
15237 // 497: }
15238 1, 15, // 501: case 0x1: {
15239 OPC_CheckPredicate, 167, 1, // 503: check predicate 167
15240 OPC_CheckField, 12, 3, 7, // 506: check Inst[14:12] == 0x7
15241 OPC_CheckField, 0, 7, 87, // 510: check Inst[6:0] == 0x57
15242 OPC_Decode, 173, 124, 17, // 514: decode to SF_VSETTM using decoder 17
15243 // 514: }
15244 2, 0, // 518: case 0x2: {
15245 OPC_CheckPredicate, 167, 1, // 520: check predicate 167
15246 OPC_CheckField, 12, 3, 7, // 523: check Inst[14:12] == 0x7
15247 OPC_CheckField, 0, 7, 87, // 527: check Inst[6:0] == 0x57
15248 OPC_Decode, 172, 124, 17, // 531: decode to SF_VSETTK using decoder 17
15249 // 531: }
15250 // 531: } // switch Inst[25:20]
15251 // 531: }
15252 2, 16, // 535: case 0x2: {
15253 OPC_CheckPredicate, 170, 1, // 537: check predicate 170
15254 OPC_CheckField, 12, 3, 5, // 540: check Inst[14:12] == 0x5
15255 OPC_CheckField, 0, 7, 91, // 544: check Inst[6:0] == 0x5b
15256 OPC_Decode, 157, 124, 143, 1, // 548: decode to SF_VFNRCLIP_XU_F_QF using decoder 143
15257 // 548: }
15258 3, 0, // 553: case 0x3: {
15259 OPC_CheckPredicate, 170, 1, // 555: check predicate 170
15260 OPC_CheckField, 12, 3, 5, // 558: check Inst[14:12] == 0x5
15261 OPC_CheckField, 0, 7, 91, // 562: check Inst[6:0] == 0x5b
15262 OPC_Decode, 158, 124, 143, 1, // 566: decode to SF_VFNRCLIP_X_F_QF using decoder 143
15263 // 566: }
15264 // 566: } // switch Inst[27:26]
15265 // 566: }
15266 10, 143, 1, // 571: case 0xa: {
15267 OPC_SwitchField, 12, 3, // 574: switch Inst[14:12] {
15268 0, 31, // 577: case 0x0: {
15269 OPC_SwitchField, 25, 1, // 579: switch Inst[25] {
15270 0, 12, // 582: case 0x0: {
15271 OPC_CheckPredicate, 166, 1, // 584: check predicate 166
15272 OPC_CheckField, 0, 7, 91, // 587: check Inst[6:0] == 0x5b
15273 OPC_Decode, 145, 124, 139, 2, // 591: decode to SF_VC_V_VVV using decoder 267
15274 // 591: }
15275 1, 0, // 596: case 0x1: {
15276 OPC_CheckPredicate, 166, 1, // 598: check predicate 166
15277 OPC_CheckField, 0, 7, 91, // 601: check Inst[6:0] == 0x5b
15278 OPC_Decode, 135, 124, 140, 2, // 605: decode to SF_VC_VVV using decoder 268
15279 // 605: }
15280 // 605: } // switch Inst[25]
15281 // 605: }
15282 3, 31, // 610: case 0x3: {
15283 OPC_SwitchField, 25, 1, // 612: switch Inst[25] {
15284 0, 12, // 615: case 0x0: {
15285 OPC_CheckPredicate, 166, 1, // 617: check predicate 166
15286 OPC_CheckField, 0, 7, 91, // 620: check Inst[6:0] == 0x5b
15287 OPC_Decode, 142, 124, 141, 2, // 624: decode to SF_VC_V_IVV using decoder 269
15288 // 624: }
15289 1, 0, // 629: case 0x1: {
15290 OPC_CheckPredicate, 166, 1, // 631: check predicate 166
15291 OPC_CheckField, 0, 7, 91, // 634: check Inst[6:0] == 0x5b
15292 OPC_Decode, 132, 124, 142, 2, // 638: decode to SF_VC_IVV using decoder 270
15293 // 638: }
15294 // 638: } // switch Inst[25]
15295 // 638: }
15296 4, 31, // 643: case 0x4: {
15297 OPC_SwitchField, 25, 1, // 645: switch Inst[25] {
15298 0, 12, // 648: case 0x0: {
15299 OPC_CheckPredicate, 166, 1, // 650: check predicate 166
15300 OPC_CheckField, 0, 7, 91, // 653: check Inst[6:0] == 0x5b
15301 OPC_Decode, 149, 124, 143, 2, // 657: decode to SF_VC_V_XVV using decoder 271
15302 // 657: }
15303 1, 0, // 662: case 0x1: {
15304 OPC_CheckPredicate, 166, 1, // 664: check predicate 166
15305 OPC_CheckField, 0, 7, 91, // 667: check Inst[6:0] == 0x5b
15306 OPC_Decode, 153, 124, 144, 2, // 671: decode to SF_VC_XVV using decoder 272
15307 // 671: }
15308 // 671: } // switch Inst[25]
15309 // 671: }
15310 5, 0, // 676: case 0x5: {
15311 OPC_SwitchField, 25, 1, // 678: switch Inst[25] {
15312 0, 16, // 681: case 0x0: {
15313 OPC_CheckPredicate, 166, 1, // 683: check predicate 166
15314 OPC_CheckField, 27, 1, 1, // 686: check Inst[27] == 0x1
15315 OPC_CheckField, 0, 7, 91, // 690: check Inst[6:0] == 0x5b
15316 OPC_Decode, 138, 124, 145, 2, // 694: decode to SF_VC_V_FVV using decoder 273
15317 // 694: }
15318 1, 0, // 699: case 0x1: {
15319 OPC_CheckPredicate, 166, 1, // 701: check predicate 166
15320 OPC_CheckField, 27, 1, 1, // 704: check Inst[27] == 0x1
15321 OPC_CheckField, 0, 7, 91, // 708: check Inst[6:0] == 0x5b
15322 OPC_Decode, 128, 124, 146, 2, // 712: decode to SF_VC_FVV using decoder 274
15323 // 712: }
15324 // 712: } // switch Inst[25]
15325 // 712: }
15326 // 712: } // switch Inst[14:12]
15327 // 712: }
15328 11, 71, // 717: case 0xb: {
15329 OPC_SwitchField, 25, 3, // 719: switch Inst[27:25] {
15330 1, 15, // 722: case 0x1: {
15331 OPC_CheckPredicate, 171, 1, // 724: check predicate 171
15332 OPC_CheckField, 12, 3, 2, // 727: check Inst[14:12] == 0x2
15333 OPC_CheckField, 0, 7, 91, // 731: check Inst[6:0] == 0x5b
15334 OPC_Decode, 168, 124, 120, // 735: decode to SF_VQMACCU_2x8x2 using decoder 120
15335 // 735: }
15336 3, 15, // 739: case 0x3: {
15337 OPC_CheckPredicate, 171, 1, // 741: check predicate 171
15338 OPC_CheckField, 12, 3, 2, // 744: check Inst[14:12] == 0x2
15339 OPC_CheckField, 0, 7, 91, // 748: check Inst[6:0] == 0x5b
15340 OPC_Decode, 170, 124, 120, // 752: decode to SF_VQMACC_2x8x2 using decoder 120
15341 // 752: }
15342 5, 15, // 756: case 0x5: {
15343 OPC_CheckPredicate, 171, 1, // 758: check predicate 171
15344 OPC_CheckField, 12, 3, 2, // 761: check Inst[14:12] == 0x2
15345 OPC_CheckField, 0, 7, 91, // 765: check Inst[6:0] == 0x5b
15346 OPC_Decode, 166, 124, 120, // 769: decode to SF_VQMACCUS_2x8x2 using decoder 120
15347 // 769: }
15348 7, 0, // 773: case 0x7: {
15349 OPC_CheckPredicate, 171, 1, // 775: check predicate 171
15350 OPC_CheckField, 12, 3, 2, // 778: check Inst[14:12] == 0x2
15351 OPC_CheckField, 0, 7, 91, // 782: check Inst[6:0] == 0x5b
15352 OPC_Decode, 164, 124, 120, // 786: decode to SF_VQMACCSU_2x8x2 using decoder 120
15353 // 786: }
15354 // 786: } // switch Inst[27:25]
15355 // 786: }
15356 15, 0, // 790: case 0xf: {
15357 OPC_SwitchField, 12, 3, // 792: switch Inst[14:12] {
15358 0, 83, // 795: case 0x0: {
15359 OPC_SwitchField, 0, 7, // 797: switch Inst[6:0] {
15360 91, 23, // 800: case 0x5b: {
15361 OPC_SwitchField, 25, 1, // 802: switch Inst[25] {
15362 0, 8, // 805: case 0x0: {
15363 OPC_CheckPredicate, 166, 1, // 807: check predicate 166
15364 OPC_Decode, 146, 124, 139, 2, // 810: decode to SF_VC_V_VVW using decoder 267
15365 // 810: }
15366 1, 0, // 815: case 0x1: {
15367 OPC_CheckPredicate, 166, 1, // 817: check predicate 166
15368 OPC_Decode, 136, 124, 140, 2, // 820: decode to SF_VC_VVW using decoder 268
15369 // 820: }
15370 // 820: } // switch Inst[25]
15371 // 820: }
15372 119, 0, // 825: case 0x77: {
15373 OPC_SwitchField, 7, 3, // 827: switch Inst[9:7] {
15374 0, 23, // 830: case 0x0: {
15375 OPC_SwitchField, 25, 3, // 832: switch Inst[27:25] {
15376 1, 8, // 835: case 0x1: {
15377 OPC_CheckPredicate, 172, 1, // 837: check predicate 172
15378 OPC_Decode, 254, 123, 147, 2, // 840: decode to SF_MM_U_U using decoder 275
15379 // 840: }
15380 3, 0, // 845: case 0x3: {
15381 OPC_CheckPredicate, 172, 1, // 847: check predicate 172
15382 OPC_Decode, 252, 123, 147, 2, // 850: decode to SF_MM_S_U using decoder 275
15383 // 850: }
15384 // 850: } // switch Inst[27:25]
15385 // 850: }
15386 1, 0, // 855: case 0x1: {
15387 OPC_SwitchField, 25, 3, // 857: switch Inst[27:25] {
15388 1, 8, // 860: case 0x1: {
15389 OPC_CheckPredicate, 172, 1, // 862: check predicate 172
15390 OPC_Decode, 253, 123, 147, 2, // 865: decode to SF_MM_U_S using decoder 275
15391 // 865: }
15392 3, 0, // 870: case 0x3: {
15393 OPC_CheckPredicate, 172, 1, // 872: check predicate 172
15394 OPC_Decode, 251, 123, 147, 2, // 875: decode to SF_MM_S_S using decoder 275
15395 // 875: }
15396 // 875: } // switch Inst[27:25]
15397 // 875: }
15398 // 875: } // switch Inst[9:7]
15399 // 875: }
15400 // 875: } // switch Inst[6:0]
15401 // 875: }
15402 1, 83, // 880: case 0x1: {
15403 OPC_SwitchField, 25, 3, // 882: switch Inst[27:25] {
15404 1, 26, // 885: case 0x1: {
15405 OPC_SwitchField, 0, 7, // 887: switch Inst[6:0] {
15406 91, 7, // 890: case 0x5b: {
15407 OPC_CheckPredicate, 173, 1, // 892: check predicate 173
15408 OPC_Decode, 159, 124, 120, // 895: decode to SF_VFWMACC_4x4x4 using decoder 120
15409 // 895: }
15410 119, 0, // 899: case 0x77: {
15411 OPC_CheckPredicate, 174, 1, // 901: check predicate 174
15412 OPC_CheckField, 7, 2, 0, // 904: check Inst[8:7] == 0x0
15413 OPC_Decode, 250, 123, 148, 2, // 908: decode to SF_MM_F_F using decoder 276
15414 // 908: }
15415 // 908: } // switch Inst[6:0]
15416 // 908: }
15417 5, 24, // 913: case 0x5: {
15418 OPC_SwitchField, 0, 10, // 915: switch Inst[9:0] {
15419 119, 8, // 918: case 0x77: {
15420 OPC_CheckPredicate, 175, 1, // 920: check predicate 175
15421 OPC_Decode, 249, 123, 147, 2, // 923: decode to SF_MM_E5M2_E5M2 using decoder 275
15422 // 923: }
15423 247, 1, 0, // 928: case 0xf7: {
15424 OPC_CheckPredicate, 175, 1, // 931: check predicate 175
15425 OPC_Decode, 248, 123, 147, 2, // 934: decode to SF_MM_E5M2_E4M3 using decoder 275
15426 // 934: }
15427 // 934: } // switch Inst[9:0]
15428 // 934: }
15429 7, 0, // 939: case 0x7: {
15430 OPC_SwitchField, 0, 10, // 941: switch Inst[9:0] {
15431 119, 8, // 944: case 0x77: {
15432 OPC_CheckPredicate, 175, 1, // 946: check predicate 175
15433 OPC_Decode, 247, 123, 147, 2, // 949: decode to SF_MM_E4M3_E5M2 using decoder 275
15434 // 949: }
15435 247, 1, 0, // 954: case 0xf7: {
15436 OPC_CheckPredicate, 175, 1, // 957: check predicate 175
15437 OPC_Decode, 246, 123, 147, 2, // 960: decode to SF_MM_E4M3_E4M3 using decoder 275
15438 // 960: }
15439 // 960: } // switch Inst[9:0]
15440 // 960: }
15441 // 960: } // switch Inst[27:25]
15442 // 960: }
15443 2, 55, // 965: case 0x2: {
15444 OPC_SwitchField, 25, 3, // 967: switch Inst[27:25] {
15445 1, 11, // 970: case 0x1: {
15446 OPC_CheckPredicate, 176, 1, // 972: check predicate 176
15447 OPC_CheckField, 0, 7, 91, // 975: check Inst[6:0] == 0x5b
15448 OPC_Decode, 169, 124, 120, // 979: decode to SF_VQMACCU_4x8x4 using decoder 120
15449 // 979: }
15450 3, 11, // 983: case 0x3: {
15451 OPC_CheckPredicate, 176, 1, // 985: check predicate 176
15452 OPC_CheckField, 0, 7, 91, // 988: check Inst[6:0] == 0x5b
15453 OPC_Decode, 171, 124, 120, // 992: decode to SF_VQMACC_4x8x4 using decoder 120
15454 // 992: }
15455 5, 11, // 996: case 0x5: {
15456 OPC_CheckPredicate, 176, 1, // 998: check predicate 176
15457 OPC_CheckField, 0, 7, 91, // 1001: check Inst[6:0] == 0x5b
15458 OPC_Decode, 167, 124, 120, // 1005: decode to SF_VQMACCUS_4x8x4 using decoder 120
15459 // 1005: }
15460 7, 0, // 1009: case 0x7: {
15461 OPC_CheckPredicate, 176, 1, // 1011: check predicate 176
15462 OPC_CheckField, 0, 7, 91, // 1014: check Inst[6:0] == 0x5b
15463 OPC_Decode, 165, 124, 120, // 1018: decode to SF_VQMACCSU_4x8x4 using decoder 120
15464 // 1018: }
15465 // 1018: } // switch Inst[27:25]
15466 // 1018: }
15467 3, 31, // 1022: case 0x3: {
15468 OPC_SwitchField, 25, 1, // 1024: switch Inst[25] {
15469 0, 12, // 1027: case 0x0: {
15470 OPC_CheckPredicate, 166, 1, // 1029: check predicate 166
15471 OPC_CheckField, 0, 7, 91, // 1032: check Inst[6:0] == 0x5b
15472 OPC_Decode, 143, 124, 141, 2, // 1036: decode to SF_VC_V_IVW using decoder 269
15473 // 1036: }
15474 1, 0, // 1041: case 0x1: {
15475 OPC_CheckPredicate, 166, 1, // 1043: check predicate 166
15476 OPC_CheckField, 0, 7, 91, // 1046: check Inst[6:0] == 0x5b
15477 OPC_Decode, 133, 124, 142, 2, // 1050: decode to SF_VC_IVW using decoder 270
15478 // 1050: }
15479 // 1050: } // switch Inst[25]
15480 // 1050: }
15481 4, 31, // 1055: case 0x4: {
15482 OPC_SwitchField, 25, 1, // 1057: switch Inst[25] {
15483 0, 12, // 1060: case 0x0: {
15484 OPC_CheckPredicate, 166, 1, // 1062: check predicate 166
15485 OPC_CheckField, 0, 7, 91, // 1065: check Inst[6:0] == 0x5b
15486 OPC_Decode, 150, 124, 143, 2, // 1069: decode to SF_VC_V_XVW using decoder 271
15487 // 1069: }
15488 1, 0, // 1074: case 0x1: {
15489 OPC_CheckPredicate, 166, 1, // 1076: check predicate 166
15490 OPC_CheckField, 0, 7, 91, // 1079: check Inst[6:0] == 0x5b
15491 OPC_Decode, 154, 124, 144, 2, // 1083: decode to SF_VC_XVW using decoder 272
15492 // 1083: }
15493 // 1083: } // switch Inst[25]
15494 // 1083: }
15495 5, 0, // 1088: case 0x5: {
15496 OPC_SwitchField, 25, 1, // 1090: switch Inst[25] {
15497 0, 16, // 1093: case 0x0: {
15498 OPC_CheckPredicate, 166, 1, // 1095: check predicate 166
15499 OPC_CheckField, 27, 1, 1, // 1098: check Inst[27] == 0x1
15500 OPC_CheckField, 0, 7, 91, // 1102: check Inst[6:0] == 0x5b
15501 OPC_Decode, 139, 124, 145, 2, // 1106: decode to SF_VC_V_FVW using decoder 273
15502 // 1106: }
15503 1, 0, // 1111: case 0x1: {
15504 OPC_CheckPredicate, 166, 1, // 1113: check predicate 166
15505 OPC_CheckField, 27, 1, 1, // 1116: check Inst[27] == 0x1
15506 OPC_CheckField, 0, 7, 91, // 1120: check Inst[6:0] == 0x5b
15507 OPC_Decode, 129, 124, 146, 2, // 1124: decode to SF_VC_FVW using decoder 274
15508 // 1124: }
15509 // 1124: } // switch Inst[25]
15510 // 1124: }
15511 // 1124: } // switch Inst[14:12]
15512 // 1124: }
15513 // 1124: } // switch Inst[31:28]
15514};
15515static const uint8_t DecoderTableXTHead32[1598] = {
15516 32, // 0: BitWidth 32
15517 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
15518 0, 235, 2, // 4: case 0x0: {
15519 OPC_SwitchField, 25, 7, // 7: switch Inst[31:25] {
15520 0, 168, 1, // 10: case 0x0: {
15521 OPC_SwitchField, 15, 10, // 13: switch Inst[24:15] {
15522 32, 11, // 16: case 0x20: {
15523 OPC_CheckPredicate, 177, 1, // 18: check predicate 177
15524 OPC_CheckField, 0, 12, 11, // 21: check Inst[11:0] == 0xb
15525 OPC_Decode, 154, 125, 14, // 25: decode to TH_DCACHE_CALL using decoder 14
15526 // 25: }
15527 64, 11, // 29: case 0x40: {
15528 OPC_CheckPredicate, 177, 1, // 31: check predicate 177
15529 OPC_CheckField, 0, 12, 11, // 34: check Inst[11:0] == 0xb
15530 OPC_Decode, 164, 125, 14, // 38: decode to TH_DCACHE_IALL using decoder 14
15531 // 38: }
15532 96, 11, // 42: case 0x60: {
15533 OPC_CheckPredicate, 177, 1, // 44: check predicate 177
15534 OPC_CheckField, 0, 12, 11, // 47: check Inst[11:0] == 0xb
15535 OPC_Decode, 155, 125, 14, // 51: decode to TH_DCACHE_CIALL using decoder 14
15536 // 51: }
15537 128, 4, 11, // 55: case 0x200: {
15538 OPC_CheckPredicate, 177, 1, // 58: check predicate 177
15539 OPC_CheckField, 0, 12, 11, // 61: check Inst[11:0] == 0xb
15540 OPC_Decode, 180, 125, 14, // 65: decode to TH_ICACHE_IALL using decoder 14
15541 // 65: }
15542 160, 4, 11, // 69: case 0x220: {
15543 OPC_CheckPredicate, 177, 1, // 72: check predicate 177
15544 OPC_CheckField, 0, 12, 11, // 75: check Inst[11:0] == 0xb
15545 OPC_Decode, 181, 125, 14, // 79: decode to TH_ICACHE_IALLS using decoder 14
15546 // 79: }
15547 160, 5, 11, // 83: case 0x2a0: {
15548 OPC_CheckPredicate, 177, 1, // 86: check predicate 177
15549 OPC_CheckField, 0, 12, 11, // 89: check Inst[11:0] == 0xb
15550 OPC_Decode, 184, 125, 14, // 93: decode to TH_L2CACHE_CALL using decoder 14
15551 // 93: }
15552 192, 5, 11, // 97: case 0x2c0: {
15553 OPC_CheckPredicate, 177, 1, // 100: check predicate 177
15554 OPC_CheckField, 0, 12, 11, // 103: check Inst[11:0] == 0xb
15555 OPC_Decode, 186, 125, 14, // 107: decode to TH_L2CACHE_IALL using decoder 14
15556 // 107: }
15557 224, 5, 11, // 111: case 0x2e0: {
15558 OPC_CheckPredicate, 177, 1, // 114: check predicate 177
15559 OPC_CheckField, 0, 12, 11, // 117: check Inst[11:0] == 0xb
15560 OPC_Decode, 185, 125, 14, // 121: decode to TH_L2CACHE_CIALL using decoder 14
15561 // 121: }
15562 128, 6, 11, // 125: case 0x300: {
15563 OPC_CheckPredicate, 178, 1, // 128: check predicate 178
15564 OPC_CheckField, 0, 12, 11, // 131: check Inst[11:0] == 0xb
15565 OPC_Decode, 249, 125, 14, // 135: decode to TH_SYNC using decoder 14
15566 // 135: }
15567 160, 6, 11, // 139: case 0x320: {
15568 OPC_CheckPredicate, 178, 1, // 142: check predicate 178
15569 OPC_CheckField, 0, 12, 11, // 145: check Inst[11:0] == 0xb
15570 OPC_Decode, 252, 125, 14, // 149: decode to TH_SYNC_S using decoder 14
15571 // 149: }
15572 192, 6, 11, // 153: case 0x340: {
15573 OPC_CheckPredicate, 178, 1, // 156: check predicate 178
15574 OPC_CheckField, 0, 12, 11, // 159: check Inst[11:0] == 0xb
15575 OPC_Decode, 250, 125, 14, // 163: decode to TH_SYNC_I using decoder 14
15576 // 163: }
15577 224, 6, 0, // 167: case 0x360: {
15578 OPC_CheckPredicate, 178, 1, // 170: check predicate 178
15579 OPC_CheckField, 0, 12, 11, // 173: check Inst[11:0] == 0xb
15580 OPC_Decode, 251, 125, 14, // 177: decode to TH_SYNC_IS using decoder 14
15581 // 177: }
15582 // 177: } // switch Inst[24:15]
15583 // 177: }
15584 1, 172, 1, // 181: case 0x1: {
15585 OPC_SwitchField, 20, 5, // 184: switch Inst[24:20] {
15586 1, 11, // 187: case 0x1: {
15587 OPC_CheckPredicate, 177, 1, // 189: check predicate 177
15588 OPC_CheckField, 0, 12, 11, // 192: check Inst[11:0] == 0xb
15589 OPC_Decode, 161, 125, 15, // 196: decode to TH_DCACHE_CSW using decoder 15
15590 // 196: }
15591 2, 11, // 200: case 0x2: {
15592 OPC_CheckPredicate, 177, 1, // 202: check predicate 177
15593 OPC_CheckField, 0, 12, 11, // 205: check Inst[11:0] == 0xb
15594 OPC_Decode, 166, 125, 15, // 209: decode to TH_DCACHE_ISW using decoder 15
15595 // 209: }
15596 3, 11, // 213: case 0x3: {
15597 OPC_CheckPredicate, 177, 1, // 215: check predicate 177
15598 OPC_CheckField, 0, 12, 11, // 218: check Inst[11:0] == 0xb
15599 OPC_Decode, 157, 125, 15, // 222: decode to TH_DCACHE_CISW using decoder 15
15600 // 222: }
15601 4, 11, // 226: case 0x4: {
15602 OPC_CheckPredicate, 177, 1, // 228: check predicate 177
15603 OPC_CheckField, 0, 12, 11, // 231: check Inst[11:0] == 0xb
15604 OPC_Decode, 163, 125, 15, // 235: decode to TH_DCACHE_CVAL1 using decoder 15
15605 // 235: }
15606 5, 11, // 239: case 0x5: {
15607 OPC_CheckPredicate, 177, 1, // 241: check predicate 177
15608 OPC_CheckField, 0, 12, 11, // 244: check Inst[11:0] == 0xb
15609 OPC_Decode, 162, 125, 15, // 248: decode to TH_DCACHE_CVA using decoder 15
15610 // 248: }
15611 6, 11, // 252: case 0x6: {
15612 OPC_CheckPredicate, 177, 1, // 254: check predicate 177
15613 OPC_CheckField, 0, 12, 11, // 257: check Inst[11:0] == 0xb
15614 OPC_Decode, 167, 125, 15, // 261: decode to TH_DCACHE_IVA using decoder 15
15615 // 261: }
15616 7, 11, // 265: case 0x7: {
15617 OPC_CheckPredicate, 177, 1, // 267: check predicate 177
15618 OPC_CheckField, 0, 12, 11, // 270: check Inst[11:0] == 0xb
15619 OPC_Decode, 158, 125, 15, // 274: decode to TH_DCACHE_CIVA using decoder 15
15620 // 274: }
15621 8, 11, // 278: case 0x8: {
15622 OPC_CheckPredicate, 177, 1, // 280: check predicate 177
15623 OPC_CheckField, 0, 12, 11, // 283: check Inst[11:0] == 0xb
15624 OPC_Decode, 160, 125, 15, // 287: decode to TH_DCACHE_CPAL1 using decoder 15
15625 // 287: }
15626 9, 11, // 291: case 0x9: {
15627 OPC_CheckPredicate, 177, 1, // 293: check predicate 177
15628 OPC_CheckField, 0, 12, 11, // 296: check Inst[11:0] == 0xb
15629 OPC_Decode, 159, 125, 15, // 300: decode to TH_DCACHE_CPA using decoder 15
15630 // 300: }
15631 10, 11, // 304: case 0xa: {
15632 OPC_CheckPredicate, 177, 1, // 306: check predicate 177
15633 OPC_CheckField, 0, 12, 11, // 309: check Inst[11:0] == 0xb
15634 OPC_Decode, 165, 125, 15, // 313: decode to TH_DCACHE_IPA using decoder 15
15635 // 313: }
15636 11, 11, // 317: case 0xb: {
15637 OPC_CheckPredicate, 177, 1, // 319: check predicate 177
15638 OPC_CheckField, 0, 12, 11, // 322: check Inst[11:0] == 0xb
15639 OPC_Decode, 156, 125, 15, // 326: decode to TH_DCACHE_CIPA using decoder 15
15640 // 326: }
15641 16, 11, // 330: case 0x10: {
15642 OPC_CheckPredicate, 177, 1, // 332: check predicate 177
15643 OPC_CheckField, 0, 12, 11, // 335: check Inst[11:0] == 0xb
15644 OPC_Decode, 183, 125, 15, // 339: decode to TH_ICACHE_IVA using decoder 15
15645 // 339: }
15646 24, 0, // 343: case 0x18: {
15647 OPC_CheckPredicate, 177, 1, // 345: check predicate 177
15648 OPC_CheckField, 0, 12, 11, // 348: check Inst[11:0] == 0xb
15649 OPC_Decode, 182, 125, 15, // 352: decode to TH_ICACHE_IPA using decoder 15
15650 // 352: }
15651 // 352: } // switch Inst[24:20]
15652 // 352: }
15653 2, 0, // 356: case 0x2: {
15654 OPC_CheckPredicate, 178, 1, // 358: check predicate 178
15655 OPC_CheckField, 0, 12, 11, // 361: check Inst[11:0] == 0xb
15656 OPC_Decode, 233, 125, 156, 1, // 365: decode to TH_SFENCE_VMAS using decoder 156
15657 // 365: }
15658 // 365: } // switch Inst[31:25]
15659 // 365: }
15660 1, 134, 2, // 370: case 0x1: {
15661 OPC_SwitchField, 27, 5, // 373: switch Inst[31:27] {
15662 0, 12, // 376: case 0x0: {
15663 OPC_CheckPredicate, 179, 1, // 378: check predicate 179
15664 OPC_CheckField, 0, 7, 11, // 381: check Inst[6:0] == 0xb
15665 OPC_Decode, 153, 125, 149, 2, // 385: decode to TH_ADDSL using decoder 277
15666 // 385: }
15667 2, 33, // 390: case 0x2: {
15668 OPC_SwitchField, 26, 1, // 392: switch Inst[26] {
15669 0, 11, // 395: case 0x0: {
15670 OPC_CheckPredicate, 180, 1, // 397: check predicate 180
15671 OPC_CheckField, 0, 7, 11, // 400: check Inst[6:0] == 0xb
15672 OPC_Decode, 239, 125, 16, // 404: decode to TH_SRRI using decoder 16
15673 // 404: }
15674 1, 0, // 408: case 0x1: {
15675 OPC_CheckPredicate, 181, 1, // 410: check predicate 181
15676 OPC_CheckField, 25, 1, 0, // 413: check Inst[25] == 0x0
15677 OPC_CheckField, 0, 7, 11, // 417: check Inst[6:0] == 0xb
15678 OPC_Decode, 240, 125, 21, // 421: decode to TH_SRRIW using decoder 21
15679 // 421: }
15680 // 421: } // switch Inst[26]
15681 // 421: }
15682 4, 55, // 425: case 0x4: {
15683 OPC_SwitchField, 25, 2, // 427: switch Inst[26:25] {
15684 0, 11, // 430: case 0x0: {
15685 OPC_CheckPredicate, 182, 1, // 432: check predicate 182
15686 OPC_CheckField, 0, 7, 11, // 435: check Inst[6:0] == 0xb
15687 OPC_Decode, 218, 125, 61, // 439: decode to TH_MULA using decoder 61
15688 // 439: }
15689 1, 11, // 443: case 0x1: {
15690 OPC_CheckPredicate, 182, 1, // 445: check predicate 182
15691 OPC_CheckField, 0, 7, 11, // 448: check Inst[6:0] == 0xb
15692 OPC_Decode, 221, 125, 61, // 452: decode to TH_MULS using decoder 61
15693 // 452: }
15694 2, 11, // 456: case 0x2: {
15695 OPC_CheckPredicate, 183, 1, // 458: check predicate 183
15696 OPC_CheckField, 0, 7, 11, // 461: check Inst[6:0] == 0xb
15697 OPC_Decode, 220, 125, 61, // 465: decode to TH_MULAW using decoder 61
15698 // 465: }
15699 3, 0, // 469: case 0x3: {
15700 OPC_CheckPredicate, 183, 1, // 471: check predicate 183
15701 OPC_CheckField, 0, 7, 11, // 474: check Inst[6:0] == 0xb
15702 OPC_Decode, 223, 125, 61, // 478: decode to TH_MULSW using decoder 61
15703 // 478: }
15704 // 478: } // switch Inst[26:25]
15705 // 478: }
15706 5, 29, // 482: case 0x5: {
15707 OPC_SwitchField, 25, 2, // 484: switch Inst[26:25] {
15708 0, 11, // 487: case 0x0: {
15709 OPC_CheckPredicate, 182, 1, // 489: check predicate 182
15710 OPC_CheckField, 0, 7, 11, // 492: check Inst[6:0] == 0xb
15711 OPC_Decode, 219, 125, 61, // 496: decode to TH_MULAH using decoder 61
15712 // 496: }
15713 1, 0, // 500: case 0x1: {
15714 OPC_CheckPredicate, 182, 1, // 502: check predicate 182
15715 OPC_CheckField, 0, 7, 11, // 505: check Inst[6:0] == 0xb
15716 OPC_Decode, 222, 125, 61, // 509: decode to TH_MULSH using decoder 61
15717 // 509: }
15718 // 509: } // switch Inst[26:25]
15719 // 509: }
15720 8, 29, // 513: case 0x8: {
15721 OPC_SwitchField, 25, 2, // 515: switch Inst[26:25] {
15722 0, 11, // 518: case 0x0: {
15723 OPC_CheckPredicate, 184, 1, // 520: check predicate 184
15724 OPC_CheckField, 0, 7, 11, // 523: check Inst[6:0] == 0xb
15725 OPC_Decode, 224, 125, 61, // 527: decode to TH_MVEQZ using decoder 61
15726 // 527: }
15727 1, 0, // 531: case 0x1: {
15728 OPC_CheckPredicate, 184, 1, // 533: check predicate 184
15729 OPC_CheckField, 0, 7, 11, // 536: check Inst[6:0] == 0xb
15730 OPC_Decode, 225, 125, 61, // 540: decode to TH_MVNEZ using decoder 61
15731 // 540: }
15732 // 540: } // switch Inst[26:25]
15733 // 540: }
15734 16, 55, // 544: case 0x10: {
15735 OPC_SwitchField, 20, 7, // 546: switch Inst[26:20] {
15736 0, 11, // 549: case 0x0: {
15737 OPC_CheckPredicate, 180, 1, // 551: check predicate 180
15738 OPC_CheckField, 0, 7, 11, // 554: check Inst[6:0] == 0xb
15739 OPC_Decode, 254, 125, 17, // 558: decode to TH_TSTNBZ using decoder 17
15740 // 558: }
15741 32, 11, // 562: case 0x20: {
15742 OPC_CheckPredicate, 180, 1, // 564: check predicate 180
15743 OPC_CheckField, 0, 7, 11, // 567: check Inst[6:0] == 0xb
15744 OPC_Decode, 226, 125, 17, // 571: decode to TH_REV using decoder 17
15745 // 571: }
15746 64, 11, // 575: case 0x40: {
15747 OPC_CheckPredicate, 180, 1, // 577: check predicate 180
15748 OPC_CheckField, 0, 7, 11, // 580: check Inst[6:0] == 0xb
15749 OPC_Decode, 170, 125, 17, // 584: decode to TH_FF0 using decoder 17
15750 // 584: }
15751 96, 0, // 588: case 0x60: {
15752 OPC_CheckPredicate, 180, 1, // 590: check predicate 180
15753 OPC_CheckField, 0, 7, 11, // 593: check Inst[6:0] == 0xb
15754 OPC_Decode, 171, 125, 17, // 597: decode to TH_FF1 using decoder 17
15755 // 597: }
15756 // 597: } // switch Inst[26:20]
15757 // 597: }
15758 17, 15, // 601: case 0x11: {
15759 OPC_CheckPredicate, 185, 1, // 603: check predicate 185
15760 OPC_CheckField, 26, 1, 0, // 606: check Inst[26] == 0x0
15761 OPC_CheckField, 0, 7, 11, // 610: check Inst[6:0] == 0xb
15762 OPC_Decode, 253, 125, 16, // 614: decode to TH_TST using decoder 16
15763 // 614: }
15764 18, 0, // 618: case 0x12: {
15765 OPC_CheckPredicate, 181, 1, // 620: check predicate 181
15766 OPC_CheckField, 20, 7, 0, // 623: check Inst[26:20] == 0x0
15767 OPC_CheckField, 0, 7, 11, // 627: check Inst[6:0] == 0xb
15768 OPC_Decode, 227, 125, 17, // 631: decode to TH_REVW using decoder 17
15769 // 631: }
15770 // 631: } // switch Inst[31:27]
15771 // 631: }
15772 2, 12, // 635: case 0x2: {
15773 OPC_CheckPredicate, 180, 1, // 637: check predicate 180
15774 OPC_CheckField, 0, 7, 11, // 640: check Inst[6:0] == 0xb
15775 OPC_Decode, 168, 125, 212, 1, // 644: decode to TH_EXT using decoder 212
15776 // 644: }
15777 3, 12, // 649: case 0x3: {
15778 OPC_CheckPredicate, 180, 1, // 651: check predicate 180
15779 OPC_CheckField, 0, 7, 11, // 654: check Inst[6:0] == 0xb
15780 OPC_Decode, 169, 125, 212, 1, // 658: decode to TH_EXTU using decoder 212
15781 // 658: }
15782 4, 181, 3, // 663: case 0x4: {
15783 OPC_SwitchField, 27, 5, // 666: switch Inst[31:27] {
15784 0, 12, // 669: case 0x0: {
15785 OPC_CheckPredicate, 186, 1, // 671: check predicate 186
15786 OPC_CheckField, 0, 7, 11, // 674: check Inst[6:0] == 0xb
15787 OPC_Decode, 198, 125, 149, 2, // 678: decode to TH_LRB using decoder 277
15788 // 678: }
15789 1, 12, // 683: case 0x1: {
15790 OPC_CheckPredicate, 186, 1, // 685: check predicate 186
15791 OPC_CheckField, 0, 7, 11, // 688: check Inst[6:0] == 0xb
15792 OPC_Decode, 188, 125, 150, 2, // 692: decode to TH_LBIB using decoder 278
15793 // 692: }
15794 2, 12, // 697: case 0x2: {
15795 OPC_CheckPredicate, 186, 1, // 699: check predicate 186
15796 OPC_CheckField, 0, 7, 11, // 702: check Inst[6:0] == 0xb
15797 OPC_Decode, 205, 125, 149, 2, // 706: decode to TH_LURB using decoder 277
15798 // 706: }
15799 3, 12, // 711: case 0x3: {
15800 OPC_CheckPredicate, 186, 1, // 713: check predicate 186
15801 OPC_CheckField, 0, 7, 11, // 716: check Inst[6:0] == 0xb
15802 OPC_Decode, 187, 125, 150, 2, // 720: decode to TH_LBIA using decoder 278
15803 // 720: }
15804 4, 12, // 725: case 0x4: {
15805 OPC_CheckPredicate, 186, 1, // 727: check predicate 186
15806 OPC_CheckField, 0, 7, 11, // 730: check Inst[6:0] == 0xb
15807 OPC_Decode, 201, 125, 149, 2, // 734: decode to TH_LRH using decoder 277
15808 // 734: }
15809 5, 12, // 739: case 0x5: {
15810 OPC_CheckPredicate, 186, 1, // 741: check predicate 186
15811 OPC_CheckField, 0, 7, 11, // 744: check Inst[6:0] == 0xb
15812 OPC_Decode, 195, 125, 150, 2, // 748: decode to TH_LHIB using decoder 278
15813 // 748: }
15814 6, 12, // 753: case 0x6: {
15815 OPC_CheckPredicate, 186, 1, // 755: check predicate 186
15816 OPC_CheckField, 0, 7, 11, // 758: check Inst[6:0] == 0xb
15817 OPC_Decode, 208, 125, 149, 2, // 762: decode to TH_LURH using decoder 277
15818 // 762: }
15819 7, 12, // 767: case 0x7: {
15820 OPC_CheckPredicate, 186, 1, // 769: check predicate 186
15821 OPC_CheckField, 0, 7, 11, // 772: check Inst[6:0] == 0xb
15822 OPC_Decode, 194, 125, 150, 2, // 776: decode to TH_LHIA using decoder 278
15823 // 776: }
15824 8, 12, // 781: case 0x8: {
15825 OPC_CheckPredicate, 186, 1, // 783: check predicate 186
15826 OPC_CheckField, 0, 7, 11, // 786: check Inst[6:0] == 0xb
15827 OPC_Decode, 203, 125, 149, 2, // 790: decode to TH_LRW using decoder 277
15828 // 790: }
15829 9, 12, // 795: case 0x9: {
15830 OPC_CheckPredicate, 186, 1, // 797: check predicate 186
15831 OPC_CheckField, 0, 7, 11, // 800: check Inst[6:0] == 0xb
15832 OPC_Decode, 214, 125, 150, 2, // 804: decode to TH_LWIB using decoder 278
15833 // 804: }
15834 10, 12, // 809: case 0xa: {
15835 OPC_CheckPredicate, 186, 1, // 811: check predicate 186
15836 OPC_CheckField, 0, 7, 11, // 814: check Inst[6:0] == 0xb
15837 OPC_Decode, 210, 125, 149, 2, // 818: decode to TH_LURW using decoder 277
15838 // 818: }
15839 11, 12, // 823: case 0xb: {
15840 OPC_CheckPredicate, 186, 1, // 825: check predicate 186
15841 OPC_CheckField, 0, 7, 11, // 828: check Inst[6:0] == 0xb
15842 OPC_Decode, 213, 125, 150, 2, // 832: decode to TH_LWIA using decoder 278
15843 // 832: }
15844 12, 12, // 837: case 0xc: {
15845 OPC_CheckPredicate, 187, 1, // 839: check predicate 187
15846 OPC_CheckField, 0, 7, 11, // 842: check Inst[6:0] == 0xb
15847 OPC_Decode, 200, 125, 149, 2, // 846: decode to TH_LRD using decoder 277
15848 // 846: }
15849 13, 12, // 851: case 0xd: {
15850 OPC_CheckPredicate, 187, 1, // 853: check predicate 187
15851 OPC_CheckField, 0, 7, 11, // 856: check Inst[6:0] == 0xb
15852 OPC_Decode, 193, 125, 150, 2, // 860: decode to TH_LDIB using decoder 278
15853 // 860: }
15854 14, 12, // 865: case 0xe: {
15855 OPC_CheckPredicate, 187, 1, // 867: check predicate 187
15856 OPC_CheckField, 0, 7, 11, // 870: check Inst[6:0] == 0xb
15857 OPC_Decode, 207, 125, 149, 2, // 874: decode to TH_LURD using decoder 277
15858 // 874: }
15859 15, 12, // 879: case 0xf: {
15860 OPC_CheckPredicate, 187, 1, // 881: check predicate 187
15861 OPC_CheckField, 0, 7, 11, // 884: check Inst[6:0] == 0xb
15862 OPC_Decode, 192, 125, 150, 2, // 888: decode to TH_LDIA using decoder 278
15863 // 888: }
15864 16, 12, // 893: case 0x10: {
15865 OPC_CheckPredicate, 186, 1, // 895: check predicate 186
15866 OPC_CheckField, 0, 7, 11, // 898: check Inst[6:0] == 0xb
15867 OPC_Decode, 199, 125, 149, 2, // 902: decode to TH_LRBU using decoder 277
15868 // 902: }
15869 17, 12, // 907: case 0x11: {
15870 OPC_CheckPredicate, 186, 1, // 909: check predicate 186
15871 OPC_CheckField, 0, 7, 11, // 912: check Inst[6:0] == 0xb
15872 OPC_Decode, 190, 125, 150, 2, // 916: decode to TH_LBUIB using decoder 278
15873 // 916: }
15874 18, 12, // 921: case 0x12: {
15875 OPC_CheckPredicate, 186, 1, // 923: check predicate 186
15876 OPC_CheckField, 0, 7, 11, // 926: check Inst[6:0] == 0xb
15877 OPC_Decode, 206, 125, 149, 2, // 930: decode to TH_LURBU using decoder 277
15878 // 930: }
15879 19, 12, // 935: case 0x13: {
15880 OPC_CheckPredicate, 186, 1, // 937: check predicate 186
15881 OPC_CheckField, 0, 7, 11, // 940: check Inst[6:0] == 0xb
15882 OPC_Decode, 189, 125, 150, 2, // 944: decode to TH_LBUIA using decoder 278
15883 // 944: }
15884 20, 12, // 949: case 0x14: {
15885 OPC_CheckPredicate, 186, 1, // 951: check predicate 186
15886 OPC_CheckField, 0, 7, 11, // 954: check Inst[6:0] == 0xb
15887 OPC_Decode, 202, 125, 149, 2, // 958: decode to TH_LRHU using decoder 277
15888 // 958: }
15889 21, 12, // 963: case 0x15: {
15890 OPC_CheckPredicate, 186, 1, // 965: check predicate 186
15891 OPC_CheckField, 0, 7, 11, // 968: check Inst[6:0] == 0xb
15892 OPC_Decode, 197, 125, 150, 2, // 972: decode to TH_LHUIB using decoder 278
15893 // 972: }
15894 22, 12, // 977: case 0x16: {
15895 OPC_CheckPredicate, 186, 1, // 979: check predicate 186
15896 OPC_CheckField, 0, 7, 11, // 982: check Inst[6:0] == 0xb
15897 OPC_Decode, 209, 125, 149, 2, // 986: decode to TH_LURHU using decoder 277
15898 // 986: }
15899 23, 12, // 991: case 0x17: {
15900 OPC_CheckPredicate, 186, 1, // 993: check predicate 186
15901 OPC_CheckField, 0, 7, 11, // 996: check Inst[6:0] == 0xb
15902 OPC_Decode, 196, 125, 150, 2, // 1000: decode to TH_LHUIA using decoder 278
15903 // 1000: }
15904 24, 12, // 1005: case 0x18: {
15905 OPC_CheckPredicate, 187, 1, // 1007: check predicate 187
15906 OPC_CheckField, 0, 7, 11, // 1010: check Inst[6:0] == 0xb
15907 OPC_Decode, 204, 125, 149, 2, // 1014: decode to TH_LRWU using decoder 277
15908 // 1014: }
15909 25, 12, // 1019: case 0x19: {
15910 OPC_CheckPredicate, 187, 1, // 1021: check predicate 187
15911 OPC_CheckField, 0, 7, 11, // 1024: check Inst[6:0] == 0xb
15912 OPC_Decode, 217, 125, 150, 2, // 1028: decode to TH_LWUIB using decoder 278
15913 // 1028: }
15914 26, 12, // 1033: case 0x1a: {
15915 OPC_CheckPredicate, 187, 1, // 1035: check predicate 187
15916 OPC_CheckField, 0, 7, 11, // 1038: check Inst[6:0] == 0xb
15917 OPC_Decode, 211, 125, 149, 2, // 1042: decode to TH_LURWU using decoder 277
15918 // 1042: }
15919 27, 12, // 1047: case 0x1b: {
15920 OPC_CheckPredicate, 187, 1, // 1049: check predicate 187
15921 OPC_CheckField, 0, 7, 11, // 1052: check Inst[6:0] == 0xb
15922 OPC_Decode, 216, 125, 150, 2, // 1056: decode to TH_LWUIA using decoder 278
15923 // 1056: }
15924 28, 12, // 1061: case 0x1c: {
15925 OPC_CheckPredicate, 188, 1, // 1063: check predicate 188
15926 OPC_CheckField, 0, 7, 11, // 1066: check Inst[6:0] == 0xb
15927 OPC_Decode, 212, 125, 151, 2, // 1070: decode to TH_LWD using decoder 279
15928 // 1070: }
15929 30, 12, // 1075: case 0x1e: {
15930 OPC_CheckPredicate, 188, 1, // 1077: check predicate 188
15931 OPC_CheckField, 0, 7, 11, // 1080: check Inst[6:0] == 0xb
15932 OPC_Decode, 215, 125, 151, 2, // 1084: decode to TH_LWUD using decoder 279
15933 // 1084: }
15934 31, 0, // 1089: case 0x1f: {
15935 OPC_CheckPredicate, 189, 1, // 1091: check predicate 189
15936 OPC_CheckField, 0, 7, 11, // 1094: check Inst[6:0] == 0xb
15937 OPC_Decode, 191, 125, 152, 2, // 1098: decode to TH_LDD using decoder 280
15938 // 1098: }
15939 // 1098: } // switch Inst[31:27]
15940 // 1098: }
15941 5, 255, 1, // 1103: case 0x5: {
15942 OPC_SwitchField, 27, 5, // 1106: switch Inst[31:27] {
15943 0, 12, // 1109: case 0x0: {
15944 OPC_CheckPredicate, 186, 1, // 1111: check predicate 186
15945 OPC_CheckField, 0, 7, 11, // 1114: check Inst[6:0] == 0xb
15946 OPC_Decode, 236, 125, 149, 2, // 1118: decode to TH_SRB using decoder 277
15947 // 1118: }
15948 1, 12, // 1123: case 0x1: {
15949 OPC_CheckPredicate, 186, 1, // 1125: check predicate 186
15950 OPC_CheckField, 0, 7, 11, // 1128: check Inst[6:0] == 0xb
15951 OPC_Decode, 229, 125, 153, 2, // 1132: decode to TH_SBIB using decoder 281
15952 // 1132: }
15953 2, 12, // 1137: case 0x2: {
15954 OPC_CheckPredicate, 186, 1, // 1139: check predicate 186
15955 OPC_CheckField, 0, 7, 11, // 1142: check Inst[6:0] == 0xb
15956 OPC_Decode, 242, 125, 149, 2, // 1146: decode to TH_SURB using decoder 277
15957 // 1146: }
15958 3, 12, // 1151: case 0x3: {
15959 OPC_CheckPredicate, 186, 1, // 1153: check predicate 186
15960 OPC_CheckField, 0, 7, 11, // 1156: check Inst[6:0] == 0xb
15961 OPC_Decode, 228, 125, 153, 2, // 1160: decode to TH_SBIA using decoder 281
15962 // 1160: }
15963 4, 12, // 1165: case 0x4: {
15964 OPC_CheckPredicate, 186, 1, // 1167: check predicate 186
15965 OPC_CheckField, 0, 7, 11, // 1170: check Inst[6:0] == 0xb
15966 OPC_Decode, 238, 125, 149, 2, // 1174: decode to TH_SRH using decoder 277
15967 // 1174: }
15968 5, 12, // 1179: case 0x5: {
15969 OPC_CheckPredicate, 186, 1, // 1181: check predicate 186
15970 OPC_CheckField, 0, 7, 11, // 1184: check Inst[6:0] == 0xb
15971 OPC_Decode, 235, 125, 153, 2, // 1188: decode to TH_SHIB using decoder 281
15972 // 1188: }
15973 6, 12, // 1193: case 0x6: {
15974 OPC_CheckPredicate, 186, 1, // 1195: check predicate 186
15975 OPC_CheckField, 0, 7, 11, // 1198: check Inst[6:0] == 0xb
15976 OPC_Decode, 244, 125, 149, 2, // 1202: decode to TH_SURH using decoder 277
15977 // 1202: }
15978 7, 12, // 1207: case 0x7: {
15979 OPC_CheckPredicate, 186, 1, // 1209: check predicate 186
15980 OPC_CheckField, 0, 7, 11, // 1212: check Inst[6:0] == 0xb
15981 OPC_Decode, 234, 125, 153, 2, // 1216: decode to TH_SHIA using decoder 281
15982 // 1216: }
15983 8, 12, // 1221: case 0x8: {
15984 OPC_CheckPredicate, 186, 1, // 1223: check predicate 186
15985 OPC_CheckField, 0, 7, 11, // 1226: check Inst[6:0] == 0xb
15986 OPC_Decode, 241, 125, 149, 2, // 1230: decode to TH_SRW using decoder 277
15987 // 1230: }
15988 9, 12, // 1235: case 0x9: {
15989 OPC_CheckPredicate, 186, 1, // 1237: check predicate 186
15990 OPC_CheckField, 0, 7, 11, // 1240: check Inst[6:0] == 0xb
15991 OPC_Decode, 248, 125, 153, 2, // 1244: decode to TH_SWIB using decoder 281
15992 // 1244: }
15993 10, 12, // 1249: case 0xa: {
15994 OPC_CheckPredicate, 186, 1, // 1251: check predicate 186
15995 OPC_CheckField, 0, 7, 11, // 1254: check Inst[6:0] == 0xb
15996 OPC_Decode, 245, 125, 149, 2, // 1258: decode to TH_SURW using decoder 277
15997 // 1258: }
15998 11, 12, // 1263: case 0xb: {
15999 OPC_CheckPredicate, 186, 1, // 1265: check predicate 186
16000 OPC_CheckField, 0, 7, 11, // 1268: check Inst[6:0] == 0xb
16001 OPC_Decode, 247, 125, 153, 2, // 1272: decode to TH_SWIA using decoder 281
16002 // 1272: }
16003 12, 12, // 1277: case 0xc: {
16004 OPC_CheckPredicate, 187, 1, // 1279: check predicate 187
16005 OPC_CheckField, 0, 7, 11, // 1282: check Inst[6:0] == 0xb
16006 OPC_Decode, 237, 125, 149, 2, // 1286: decode to TH_SRD using decoder 277
16007 // 1286: }
16008 13, 12, // 1291: case 0xd: {
16009 OPC_CheckPredicate, 187, 1, // 1293: check predicate 187
16010 OPC_CheckField, 0, 7, 11, // 1296: check Inst[6:0] == 0xb
16011 OPC_Decode, 232, 125, 153, 2, // 1300: decode to TH_SDIB using decoder 281
16012 // 1300: }
16013 14, 12, // 1305: case 0xe: {
16014 OPC_CheckPredicate, 187, 1, // 1307: check predicate 187
16015 OPC_CheckField, 0, 7, 11, // 1310: check Inst[6:0] == 0xb
16016 OPC_Decode, 243, 125, 149, 2, // 1314: decode to TH_SURD using decoder 277
16017 // 1314: }
16018 15, 12, // 1319: case 0xf: {
16019 OPC_CheckPredicate, 187, 1, // 1321: check predicate 187
16020 OPC_CheckField, 0, 7, 11, // 1324: check Inst[6:0] == 0xb
16021 OPC_Decode, 231, 125, 153, 2, // 1328: decode to TH_SDIA using decoder 281
16022 // 1328: }
16023 28, 12, // 1333: case 0x1c: {
16024 OPC_CheckPredicate, 188, 1, // 1335: check predicate 188
16025 OPC_CheckField, 0, 7, 11, // 1338: check Inst[6:0] == 0xb
16026 OPC_Decode, 246, 125, 154, 2, // 1342: decode to TH_SWD using decoder 282
16027 // 1342: }
16028 31, 0, // 1347: case 0x1f: {
16029 OPC_CheckPredicate, 189, 1, // 1349: check predicate 189
16030 OPC_CheckField, 0, 7, 11, // 1352: check Inst[6:0] == 0xb
16031 OPC_Decode, 230, 125, 155, 2, // 1356: decode to TH_SDD using decoder 283
16032 // 1356: }
16033 // 1356: } // switch Inst[31:27]
16034 // 1356: }
16035 6, 173, 1, // 1361: case 0x6: {
16036 OPC_SwitchField, 27, 5, // 1364: switch Inst[31:27] {
16037 8, 12, // 1367: case 0x8: {
16038 OPC_CheckPredicate, 190, 1, // 1369: check predicate 190
16039 OPC_CheckField, 0, 7, 11, // 1372: check Inst[6:0] == 0xb
16040 OPC_Decode, 173, 125, 156, 2, // 1376: decode to TH_FLRW using decoder 284
16041 // 1376: }
16042 10, 12, // 1381: case 0xa: {
16043 OPC_CheckPredicate, 191, 1, // 1383: check predicate 191
16044 OPC_CheckField, 0, 7, 11, // 1386: check Inst[6:0] == 0xb
16045 OPC_Decode, 175, 125, 156, 2, // 1390: decode to TH_FLURW using decoder 284
16046 // 1390: }
16047 12, 12, // 1395: case 0xc: {
16048 OPC_CheckPredicate, 192, 1, // 1397: check predicate 192
16049 OPC_CheckField, 0, 7, 11, // 1400: check Inst[6:0] == 0xb
16050 OPC_Decode, 172, 125, 157, 2, // 1404: decode to TH_FLRD using decoder 285
16051 // 1404: }
16052 14, 12, // 1409: case 0xe: {
16053 OPC_CheckPredicate, 193, 1, // 1411: check predicate 193
16054 OPC_CheckField, 0, 7, 11, // 1414: check Inst[6:0] == 0xb
16055 OPC_Decode, 174, 125, 157, 2, // 1418: decode to TH_FLURD using decoder 285
16056 // 1418: }
16057 16, 30, // 1423: case 0x10: {
16058 OPC_SwitchField, 26, 1, // 1425: switch Inst[26] {
16059 0, 11, // 1428: case 0x0: {
16060 OPC_CheckPredicate, 194, 1, // 1430: check predicate 194
16061 OPC_CheckField, 0, 7, 11, // 1433: check Inst[6:0] == 0xb
16062 OPC_Decode, 132, 126, 125, // 1437: decode to TH_VMAQA_VV using decoder 125
16063 // 1437: }
16064 1, 0, // 1441: case 0x1: {
16065 OPC_CheckPredicate, 194, 1, // 1443: check predicate 194
16066 OPC_CheckField, 0, 7, 11, // 1446: check Inst[6:0] == 0xb
16067 OPC_Decode, 133, 126, 149, 1, // 1450: decode to TH_VMAQA_VX using decoder 149
16068 // 1450: }
16069 // 1450: } // switch Inst[26]
16070 // 1450: }
16071 17, 30, // 1455: case 0x11: {
16072 OPC_SwitchField, 26, 1, // 1457: switch Inst[26] {
16073 0, 11, // 1460: case 0x0: {
16074 OPC_CheckPredicate, 194, 1, // 1462: check predicate 194
16075 OPC_CheckField, 0, 7, 11, // 1465: check Inst[6:0] == 0xb
16076 OPC_Decode, 130, 126, 125, // 1469: decode to TH_VMAQAU_VV using decoder 125
16077 // 1469: }
16078 1, 0, // 1473: case 0x1: {
16079 OPC_CheckPredicate, 194, 1, // 1475: check predicate 194
16080 OPC_CheckField, 0, 7, 11, // 1478: check Inst[6:0] == 0xb
16081 OPC_Decode, 131, 126, 149, 1, // 1482: decode to TH_VMAQAU_VX using decoder 149
16082 // 1482: }
16083 // 1482: } // switch Inst[26]
16084 // 1482: }
16085 18, 30, // 1487: case 0x12: {
16086 OPC_SwitchField, 26, 1, // 1489: switch Inst[26] {
16087 0, 11, // 1492: case 0x0: {
16088 OPC_CheckPredicate, 194, 1, // 1494: check predicate 194
16089 OPC_CheckField, 0, 7, 11, // 1497: check Inst[6:0] == 0xb
16090 OPC_Decode, 255, 125, 125, // 1501: decode to TH_VMAQASU_VV using decoder 125
16091 // 1501: }
16092 1, 0, // 1505: case 0x1: {
16093 OPC_CheckPredicate, 194, 1, // 1507: check predicate 194
16094 OPC_CheckField, 0, 7, 11, // 1510: check Inst[6:0] == 0xb
16095 OPC_Decode, 128, 126, 149, 1, // 1514: decode to TH_VMAQASU_VX using decoder 149
16096 // 1514: }
16097 // 1514: } // switch Inst[26]
16098 // 1514: }
16099 19, 0, // 1519: case 0x13: {
16100 OPC_CheckPredicate, 194, 1, // 1521: check predicate 194
16101 OPC_CheckField, 26, 1, 1, // 1524: check Inst[26] == 0x1
16102 OPC_CheckField, 0, 7, 11, // 1528: check Inst[6:0] == 0xb
16103 OPC_Decode, 129, 126, 149, 1, // 1532: decode to TH_VMAQAUS_VX using decoder 149
16104 // 1532: }
16105 // 1532: } // switch Inst[31:27]
16106 // 1532: }
16107 7, 0, // 1537: case 0x7: {
16108 OPC_SwitchField, 27, 5, // 1539: switch Inst[31:27] {
16109 8, 12, // 1542: case 0x8: {
16110 OPC_CheckPredicate, 190, 1, // 1544: check predicate 190
16111 OPC_CheckField, 0, 7, 11, // 1547: check Inst[6:0] == 0xb
16112 OPC_Decode, 177, 125, 156, 2, // 1551: decode to TH_FSRW using decoder 284
16113 // 1551: }
16114 10, 12, // 1556: case 0xa: {
16115 OPC_CheckPredicate, 191, 1, // 1558: check predicate 191
16116 OPC_CheckField, 0, 7, 11, // 1561: check Inst[6:0] == 0xb
16117 OPC_Decode, 179, 125, 156, 2, // 1565: decode to TH_FSURW using decoder 284
16118 // 1565: }
16119 12, 12, // 1570: case 0xc: {
16120 OPC_CheckPredicate, 192, 1, // 1572: check predicate 192
16121 OPC_CheckField, 0, 7, 11, // 1575: check Inst[6:0] == 0xb
16122 OPC_Decode, 176, 125, 157, 2, // 1579: decode to TH_FSRD using decoder 285
16123 // 1579: }
16124 14, 0, // 1584: case 0xe: {
16125 OPC_CheckPredicate, 193, 1, // 1586: check predicate 193
16126 OPC_CheckField, 0, 7, 11, // 1589: check Inst[6:0] == 0xb
16127 OPC_Decode, 178, 125, 157, 2, // 1593: decode to TH_FSURD using decoder 285
16128 // 1593: }
16129 // 1593: } // switch Inst[31:27]
16130 // 1593: }
16131 // 1593: } // switch Inst[14:12]
16132};
16133static const uint8_t DecoderTableXqci32[1203] = {
16134 32, // 0: BitWidth 32
16135 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
16136 11, 143, 4, // 4: case 0xb: {
16137 OPC_SwitchField, 12, 3, // 7: switch Inst[14:12] {
16138 0, 22, // 10: case 0x0: {
16139 OPC_SwitchField, 31, 1, // 12: switch Inst[31] {
16140 0, 8, // 15: case 0x0: {
16141 OPC_CheckPredicate, 195, 1, // 17: check predicate 195
16142 OPC_Decode, 192, 123, 158, 2, // 20: decode to QC_WRAPI using decoder 286
16143 // 20: }
16144 1, 0, // 25: case 0x1: {
16145 OPC_CheckPredicate, 14, // 27: check predicate 14
16146 OPC_Decode, 254, 122, 159, 2, // 29: decode to QC_INSBRI using decoder 287
16147 // 29: }
16148 // 29: } // switch Inst[31]
16149 // 29: }
16150 1, 30, // 34: case 0x1: {
16151 OPC_SwitchField, 30, 2, // 36: switch Inst[31:30] {
16152 0, 7, // 39: case 0x0: {
16153 OPC_CheckPredicate, 14, // 41: check predicate 14
16154 OPC_Decode, 250, 122, 160, 2, // 43: decode to QC_INSBI using decoder 288
16155 // 43: }
16156 1, 7, // 48: case 0x1: {
16157 OPC_CheckPredicate, 14, // 50: check predicate 14
16158 OPC_Decode, 247, 122, 161, 2, // 52: decode to QC_INSB using decoder 289
16159 // 52: }
16160 2, 0, // 57: case 0x2: {
16161 OPC_CheckPredicate, 14, // 59: check predicate 14
16162 OPC_Decode, 248, 122, 161, 2, // 61: decode to QC_INSBH using decoder 289
16163 // 61: }
16164 // 61: } // switch Inst[31:30]
16165 // 61: }
16166 2, 39, // 66: case 0x2: {
16167 OPC_SwitchField, 30, 2, // 68: switch Inst[31:30] {
16168 0, 7, // 71: case 0x0: {
16169 OPC_CheckPredicate, 14, // 73: check predicate 14
16170 OPC_Decode, 221, 122, 162, 2, // 75: decode to QC_EXTU using decoder 290
16171 // 75: }
16172 1, 7, // 80: case 0x1: {
16173 OPC_CheckPredicate, 14, // 82: check predicate 14
16174 OPC_Decode, 212, 122, 162, 2, // 84: decode to QC_EXT using decoder 290
16175 // 84: }
16176 2, 7, // 89: case 0x2: {
16177 OPC_CheckPredicate, 14, // 91: check predicate 14
16178 OPC_Decode, 217, 122, 163, 2, // 93: decode to QC_EXTDU using decoder 291
16179 // 93: }
16180 3, 0, // 98: case 0x3: {
16181 OPC_CheckPredicate, 14, // 100: check predicate 14
16182 OPC_Decode, 213, 122, 163, 2, // 102: decode to QC_EXTD using decoder 291
16183 // 102: }
16184 // 102: } // switch Inst[31:30]
16185 // 102: }
16186 3, 183, 2, // 107: case 0x3: {
16187 OPC_SwitchField, 30, 2, // 110: switch Inst[31:30] {
16188 0, 168, 2, // 113: case 0x0: {
16189 OPC_SwitchField, 25, 5, // 116: switch Inst[29:25] {
16190 0, 20, // 119: case 0x0: {
16191 OPC_Scope, 11, // 121: try {
16192 OPC_CheckField, 20, 5, 0, // 123: check Inst[24:20] == 0x0
16193 OPC_CheckPredicate, 14, // 127: check predicate 14
16194 OPC_Decode, 185, 122, 164, 2, // 129: decode to QC_COMPRESS2 using decoder 292
16195 // 129: } else try {
16196 OPC_CheckPredicate, 14, // 134: check predicate 14
16197 OPC_Decode, 253, 122, 165, 2, // 136: decode to QC_INSBR using decoder 293
16198 // 136: }
16199 // 136: }
16200 1, 20, // 141: case 0x1: {
16201 OPC_Scope, 11, // 143: try {
16202 OPC_CheckField, 20, 5, 0, // 145: check Inst[24:20] == 0x0
16203 OPC_CheckPredicate, 14, // 149: check predicate 14
16204 OPC_Decode, 186, 122, 164, 2, // 151: decode to QC_COMPRESS3 using decoder 292
16205 // 151: } else try {
16206 OPC_CheckPredicate, 14, // 156: check predicate 14
16207 OPC_Decode, 249, 122, 165, 2, // 158: decode to QC_INSBHR using decoder 293
16208 // 158: }
16209 // 158: }
16210 2, 20, // 163: case 0x2: {
16211 OPC_Scope, 11, // 165: try {
16212 OPC_CheckField, 20, 5, 0, // 167: check Inst[24:20] == 0x0
16213 OPC_CheckPredicate, 14, // 171: check predicate 14
16214 OPC_Decode, 210, 122, 164, 2, // 173: decode to QC_EXPAND2 using decoder 292
16215 // 173: } else try {
16216 OPC_CheckPredicate, 14, // 178: check predicate 14
16217 OPC_Decode, 251, 122, 165, 2, // 180: decode to QC_INSBPR using decoder 293
16218 // 180: }
16219 // 180: }
16220 3, 20, // 185: case 0x3: {
16221 OPC_Scope, 11, // 187: try {
16222 OPC_CheckField, 20, 5, 0, // 189: check Inst[24:20] == 0x0
16223 OPC_CheckPredicate, 14, // 193: check predicate 14
16224 OPC_Decode, 211, 122, 164, 2, // 195: decode to QC_EXPAND3 using decoder 292
16225 // 195: } else try {
16226 OPC_CheckPredicate, 14, // 200: check predicate 14
16227 OPC_Decode, 252, 122, 165, 2, // 202: decode to QC_INSBPRH using decoder 293
16228 // 202: }
16229 // 202: }
16230 4, 20, // 207: case 0x4: {
16231 OPC_Scope, 11, // 209: try {
16232 OPC_CheckField, 20, 5, 0, // 211: check Inst[24:20] == 0x0
16233 OPC_CheckPredicate, 14, // 215: check predicate 14
16234 OPC_Decode, 173, 122, 164, 2, // 217: decode to QC_CLO using decoder 292
16235 // 217: } else try {
16236 OPC_CheckPredicate, 14, // 222: check predicate 14
16237 OPC_Decode, 220, 122, 166, 2, // 224: decode to QC_EXTDUR using decoder 294
16238 // 224: }
16239 // 224: }
16240 5, 20, // 229: case 0x5: {
16241 OPC_Scope, 11, // 231: try {
16242 OPC_CheckField, 20, 5, 0, // 233: check Inst[24:20] == 0x0
16243 OPC_CheckPredicate, 14, // 237: check predicate 14
16244 OPC_Decode, 189, 122, 164, 2, // 239: decode to QC_CTO using decoder 292
16245 // 239: } else try {
16246 OPC_CheckPredicate, 14, // 244: check predicate 14
16247 OPC_Decode, 216, 122, 166, 2, // 246: decode to QC_EXTDR using decoder 294
16248 // 246: }
16249 // 246: }
16250 6, 20, // 251: case 0x6: {
16251 OPC_Scope, 11, // 253: try {
16252 OPC_CheckField, 20, 5, 0, // 255: check Inst[24:20] == 0x0
16253 OPC_CheckPredicate, 14, // 259: check predicate 14
16254 OPC_Decode, 172, 122, 164, 2, // 261: decode to QC_BREV32 using decoder 292
16255 // 261: } else try {
16256 OPC_CheckPredicate, 14, // 266: check predicate 14
16257 OPC_Decode, 218, 122, 166, 2, // 268: decode to QC_EXTDUPR using decoder 294
16258 // 268: }
16259 // 268: }
16260 7, 21, // 273: case 0x7: {
16261 OPC_Scope, 12, // 275: try {
16262 OPC_CheckField, 20, 5, 0, // 277: check Inst[24:20] == 0x0
16263 OPC_CheckPredicate, 195, 1, // 281: check predicate 195
16264 OPC_Decode, 161, 123, 164, 2, // 284: decode to QC_NORM using decoder 292
16265 // 284: } else try {
16266 OPC_CheckPredicate, 14, // 289: check predicate 14
16267 OPC_Decode, 219, 122, 166, 2, // 291: decode to QC_EXTDUPRH using decoder 294
16268 // 291: }
16269 // 291: }
16270 8, 21, // 296: case 0x8: {
16271 OPC_Scope, 12, // 298: try {
16272 OPC_CheckField, 20, 5, 0, // 300: check Inst[24:20] == 0x0
16273 OPC_CheckPredicate, 195, 1, // 304: check predicate 195
16274 OPC_Decode, 163, 123, 164, 2, // 307: decode to QC_NORMU using decoder 292
16275 // 307: } else try {
16276 OPC_CheckPredicate, 14, // 312: check predicate 14
16277 OPC_Decode, 214, 122, 166, 2, // 314: decode to QC_EXTDPR using decoder 294
16278 // 314: }
16279 // 314: }
16280 9, 21, // 319: case 0x9: {
16281 OPC_Scope, 12, // 321: try {
16282 OPC_CheckField, 20, 5, 0, // 323: check Inst[24:20] == 0x0
16283 OPC_CheckPredicate, 195, 1, // 327: check predicate 195
16284 OPC_Decode, 162, 123, 164, 2, // 330: decode to QC_NORMEU using decoder 292
16285 // 330: } else try {
16286 OPC_CheckPredicate, 14, // 335: check predicate 14
16287 OPC_Decode, 215, 122, 166, 2, // 337: decode to QC_EXTDPRH using decoder 294
16288 // 337: }
16289 // 337: }
16290 10, 8, // 342: case 0xa: {
16291 OPC_CheckPredicate, 195, 1, // 344: check predicate 195
16292 OPC_Decode, 178, 123, 167, 2, // 347: decode to QC_SHLSAT using decoder 295
16293 // 347: }
16294 12, 8, // 352: case 0xc: {
16295 OPC_CheckPredicate, 195, 1, // 354: check predicate 195
16296 OPC_Decode, 179, 123, 167, 2, // 357: decode to QC_SHLUSAT using decoder 295
16297 // 357: }
16298 14, 8, // 362: case 0xe: {
16299 OPC_CheckPredicate, 195, 1, // 364: check predicate 195
16300 OPC_Decode, 164, 122, 167, 2, // 367: decode to QC_ADDSAT using decoder 295
16301 // 367: }
16302 15, 8, // 372: case 0xf: {
16303 OPC_CheckPredicate, 195, 1, // 374: check predicate 195
16304 OPC_Decode, 165, 122, 167, 2, // 377: decode to QC_ADDUSAT using decoder 295
16305 // 377: }
16306 16, 8, // 382: case 0x10: {
16307 OPC_CheckPredicate, 195, 1, // 384: check predicate 195
16308 OPC_Decode, 183, 123, 167, 2, // 387: decode to QC_SUBSAT using decoder 295
16309 // 387: }
16310 17, 8, // 392: case 0x11: {
16311 OPC_CheckPredicate, 195, 1, // 394: check predicate 195
16312 OPC_Decode, 184, 123, 167, 2, // 397: decode to QC_SUBUSAT using decoder 295
16313 // 397: }
16314 18, 0, // 402: case 0x12: {
16315 OPC_CheckPredicate, 195, 1, // 404: check predicate 195
16316 OPC_Decode, 191, 123, 168, 2, // 407: decode to QC_WRAP using decoder 296
16317 // 407: }
16318 // 407: } // switch Inst[29:25]
16319 // 407: }
16320 1, 0, // 412: case 0x1: {
16321 OPC_CheckPredicate, 15, // 414: check predicate 15
16322 OPC_Decode, 177, 123, 169, 2, // 416: decode to QC_SHLADD using decoder 297
16323 // 416: }
16324 // 416: } // switch Inst[31:30]
16325 // 416: }
16326 4, 8, // 421: case 0x4: {
16327 OPC_CheckPredicate, 196, 1, // 423: check predicate 196
16328 OPC_Decode, 164, 123, 170, 2, // 426: decode to QC_OUTW using decoder 298
16329 // 426: }
16330 5, 8, // 431: case 0x5: {
16331 OPC_CheckPredicate, 196, 1, // 433: check predicate 196
16332 OPC_Decode, 255, 122, 170, 2, // 436: decode to QC_INW using decoder 298
16333 // 436: }
16334 6, 7, // 441: case 0x6: {
16335 OPC_CheckPredicate, 15, // 443: check predicate 15
16336 OPC_Decode, 148, 123, 171, 2, // 445: decode to QC_MULIADD using decoder 299
16337 // 445: }
16338 7, 0, // 450: case 0x7: {
16339 OPC_SwitchField, 30, 2, // 452: switch Inst[31:30] {
16340 0, 8, // 455: case 0x0: {
16341 OPC_CheckPredicate, 197, 1, // 457: check predicate 197
16342 OPC_Decode, 146, 123, 172, 2, // 460: decode to QC_LWM using decoder 300
16343 // 460: }
16344 1, 8, // 465: case 0x1: {
16345 OPC_CheckPredicate, 197, 1, // 467: check predicate 197
16346 OPC_Decode, 147, 123, 173, 2, // 470: decode to QC_LWMI using decoder 301
16347 // 470: }
16348 2, 43, // 475: case 0x2: {
16349 OPC_SwitchField, 28, 2, // 477: switch Inst[29:28] {
16350 0, 8, // 480: case 0x0: {
16351 OPC_CheckPredicate, 198, 1, // 482: check predicate 198
16352 OPC_Decode, 141, 123, 174, 2, // 485: decode to QC_LRB using decoder 302
16353 // 485: }
16354 1, 8, // 490: case 0x1: {
16355 OPC_CheckPredicate, 198, 1, // 492: check predicate 198
16356 OPC_Decode, 143, 123, 174, 2, // 495: decode to QC_LRH using decoder 302
16357 // 495: }
16358 2, 8, // 500: case 0x2: {
16359 OPC_CheckPredicate, 198, 1, // 502: check predicate 198
16360 OPC_Decode, 145, 123, 174, 2, // 505: decode to QC_LRW using decoder 302
16361 // 505: }
16362 3, 0, // 510: case 0x3: {
16363 OPC_CheckPredicate, 198, 1, // 512: check predicate 198
16364 OPC_Decode, 142, 123, 174, 2, // 515: decode to QC_LRBU using decoder 302
16365 // 515: }
16366 // 515: } // switch Inst[29:28]
16367 // 515: }
16368 3, 0, // 520: case 0x3: {
16369 OPC_CheckPredicate, 198, 1, // 522: check predicate 198
16370 OPC_CheckField, 28, 2, 0, // 525: check Inst[29:28] == 0x0
16371 OPC_Decode, 144, 123, 174, 2, // 529: decode to QC_LRHU using decoder 302
16372 // 529: }
16373 // 529: } // switch Inst[31:30]
16374 // 529: }
16375 // 529: } // switch Inst[14:12]
16376 // 529: }
16377 19, 82, // 534: case 0x13: {
16378 OPC_SwitchField, 28, 4, // 536: switch Inst[31:28] {
16379 1, 15, // 539: case 0x1: {
16380 OPC_CheckPredicate, 16, // 541: check predicate 16
16381 OPC_CheckField, 25, 3, 0, // 543: check Inst[27:25] == 0x0
16382 OPC_CheckField, 7, 13, 96, // 547: check Inst[19:7] == 0x60
16383 OPC_Decode, 187, 123, 175, 2, // 551: decode to QC_SYNC using decoder 303
16384 // 551: }
16385 2, 15, // 556: case 0x2: {
16386 OPC_CheckPredicate, 16, // 558: check predicate 16
16387 OPC_CheckField, 25, 3, 0, // 560: check Inst[27:25] == 0x0
16388 OPC_CheckField, 7, 13, 96, // 564: check Inst[19:7] == 0x60
16389 OPC_Decode, 188, 123, 175, 2, // 568: decode to QC_SYNCR using decoder 303
16390 // 568: }
16391 4, 26, // 573: case 0x4: {
16392 OPC_SwitchField, 7, 13, // 575: switch Inst[19:7] {
16393 64, 8, // 578: case 0x40: {
16394 OPC_CheckPredicate, 199, 1, // 580: check predicate 199
16395 OPC_Decode, 165, 123, 176, 2, // 583: decode to QC_PPUTCI using decoder 304
16396 // 583: }
16397 96, 0, // 588: case 0x60: {
16398 OPC_CheckPredicate, 16, // 590: check predicate 16
16399 OPC_CheckField, 25, 3, 0, // 592: check Inst[27:25] == 0x0
16400 OPC_Decode, 189, 123, 175, 2, // 596: decode to QC_SYNCWF using decoder 303
16401 // 596: }
16402 // 596: } // switch Inst[19:7]
16403 // 596: }
16404 8, 0, // 601: case 0x8: {
16405 OPC_CheckPredicate, 16, // 603: check predicate 16
16406 OPC_CheckField, 25, 3, 0, // 605: check Inst[27:25] == 0x0
16407 OPC_CheckField, 7, 13, 96, // 609: check Inst[19:7] == 0x60
16408 OPC_Decode, 190, 123, 175, 2, // 613: decode to QC_SYNCWL using decoder 303
16409 // 613: }
16410 // 613: } // switch Inst[31:28]
16411 // 613: }
16412 27, 8, // 618: case 0x1b: {
16413 OPC_CheckPredicate, 200, 1, // 620: check predicate 200
16414 OPC_Decode, 128, 123, 177, 2, // 623: decode to QC_LI using decoder 305
16415 // 623: }
16416 43, 95, // 628: case 0x2b: {
16417 OPC_SwitchField, 30, 2, // 630: switch Inst[31:30] {
16418 0, 12, // 633: case 0x0: {
16419 OPC_CheckPredicate, 197, 1, // 635: check predicate 197
16420 OPC_CheckField, 12, 3, 7, // 638: check Inst[14:12] == 0x7
16421 OPC_Decode, 185, 123, 172, 2, // 642: decode to QC_SWM using decoder 300
16422 // 642: }
16423 1, 12, // 647: case 0x1: {
16424 OPC_CheckPredicate, 197, 1, // 649: check predicate 197
16425 OPC_CheckField, 12, 3, 7, // 652: check Inst[14:12] == 0x7
16426 OPC_Decode, 186, 123, 173, 2, // 656: decode to QC_SWMI using decoder 301
16427 // 656: }
16428 2, 12, // 661: case 0x2: {
16429 OPC_CheckPredicate, 197, 1, // 663: check predicate 197
16430 OPC_CheckField, 12, 3, 7, // 666: check Inst[14:12] == 0x7
16431 OPC_Decode, 175, 123, 178, 2, // 670: decode to QC_SETWM using decoder 306
16432 // 670: }
16433 3, 0, // 675: case 0x3: {
16434 OPC_SwitchField, 12, 3, // 677: switch Inst[14:12] {
16435 6, 33, // 680: case 0x6: {
16436 OPC_SwitchField, 28, 2, // 682: switch Inst[29:28] {
16437 1, 8, // 685: case 0x1: {
16438 OPC_CheckPredicate, 198, 1, // 687: check predicate 198
16439 OPC_Decode, 180, 123, 174, 2, // 690: decode to QC_SRB using decoder 302
16440 // 690: }
16441 2, 8, // 695: case 0x2: {
16442 OPC_CheckPredicate, 198, 1, // 697: check predicate 198
16443 OPC_Decode, 181, 123, 174, 2, // 700: decode to QC_SRH using decoder 302
16444 // 700: }
16445 3, 0, // 705: case 0x3: {
16446 OPC_CheckPredicate, 198, 1, // 707: check predicate 198
16447 OPC_Decode, 182, 123, 174, 2, // 710: decode to QC_SRW using decoder 302
16448 // 710: }
16449 // 710: } // switch Inst[29:28]
16450 // 710: }
16451 7, 0, // 715: case 0x7: {
16452 OPC_CheckPredicate, 197, 1, // 717: check predicate 197
16453 OPC_Decode, 176, 123, 179, 2, // 720: decode to QC_SETWMI using decoder 307
16454 // 720: }
16455 // 720: } // switch Inst[14:12]
16456 // 720: }
16457 // 720: } // switch Inst[31:30]
16458 // 720: }
16459 91, 223, 2, // 725: case 0x5b: {
16460 OPC_SwitchField, 12, 3, // 728: switch Inst[14:12] {
16461 0, 41, // 731: case 0x0: {
16462 OPC_SwitchField, 25, 2, // 733: switch Inst[26:25] {
16463 0, 7, // 736: case 0x0: {
16464 OPC_CheckPredicate, 17, // 738: check predicate 17
16465 OPC_Decode, 149, 123, 180, 2, // 740: decode to QC_MVEQ using decoder 308
16466 // 740: }
16467 1, 8, // 745: case 0x1: {
16468 OPC_CheckPredicate, 201, 1, // 747: check predicate 201
16469 OPC_Decode, 129, 123, 181, 2, // 750: decode to QC_LIEQ using decoder 309
16470 // 750: }
16471 2, 7, // 755: case 0x2: {
16472 OPC_CheckPredicate, 17, // 757: check predicate 17
16473 OPC_Decode, 150, 123, 182, 2, // 759: decode to QC_MVEQI using decoder 310
16474 // 759: }
16475 3, 0, // 764: case 0x3: {
16476 OPC_CheckPredicate, 201, 1, // 766: check predicate 201
16477 OPC_Decode, 130, 123, 183, 2, // 769: decode to QC_LIEQI using decoder 311
16478 // 769: }
16479 // 769: } // switch Inst[26:25]
16480 // 769: }
16481 1, 41, // 774: case 0x1: {
16482 OPC_SwitchField, 25, 2, // 776: switch Inst[26:25] {
16483 0, 7, // 779: case 0x0: {
16484 OPC_CheckPredicate, 17, // 781: check predicate 17
16485 OPC_Decode, 159, 123, 180, 2, // 783: decode to QC_MVNE using decoder 308
16486 // 783: }
16487 1, 8, // 788: case 0x1: {
16488 OPC_CheckPredicate, 201, 1, // 790: check predicate 201
16489 OPC_Decode, 139, 123, 181, 2, // 793: decode to QC_LINE using decoder 309
16490 // 793: }
16491 2, 7, // 798: case 0x2: {
16492 OPC_CheckPredicate, 17, // 800: check predicate 17
16493 OPC_Decode, 160, 123, 182, 2, // 802: decode to QC_MVNEI using decoder 310
16494 // 802: }
16495 3, 0, // 807: case 0x3: {
16496 OPC_CheckPredicate, 201, 1, // 809: check predicate 201
16497 OPC_Decode, 140, 123, 183, 2, // 812: decode to QC_LINEI using decoder 311
16498 // 812: }
16499 // 812: } // switch Inst[26:25]
16500 // 812: }
16501 2, 43, // 817: case 0x2: {
16502 OPC_SwitchField, 25, 2, // 819: switch Inst[26:25] {
16503 0, 8, // 822: case 0x0: {
16504 OPC_CheckPredicate, 202, 1, // 824: check predicate 202
16505 OPC_Decode, 169, 123, 183, 2, // 827: decode to QC_SELECTIIEQ using decoder 311
16506 // 827: }
16507 1, 8, // 832: case 0x1: {
16508 OPC_CheckPredicate, 202, 1, // 834: check predicate 202
16509 OPC_Decode, 167, 123, 181, 2, // 837: decode to QC_SELECTIEQ using decoder 309
16510 // 837: }
16511 2, 8, // 842: case 0x2: {
16512 OPC_CheckPredicate, 202, 1, // 844: check predicate 202
16513 OPC_Decode, 166, 123, 184, 2, // 847: decode to QC_SELECTEQI using decoder 312
16514 // 847: }
16515 3, 0, // 852: case 0x3: {
16516 OPC_CheckPredicate, 202, 1, // 854: check predicate 202
16517 OPC_Decode, 168, 123, 185, 2, // 857: decode to QC_SELECTIEQI using decoder 313
16518 // 857: }
16519 // 857: } // switch Inst[26:25]
16520 // 857: }
16521 3, 43, // 862: case 0x3: {
16522 OPC_SwitchField, 25, 2, // 864: switch Inst[26:25] {
16523 0, 8, // 867: case 0x0: {
16524 OPC_CheckPredicate, 202, 1, // 869: check predicate 202
16525 OPC_Decode, 170, 123, 183, 2, // 872: decode to QC_SELECTIINE using decoder 311
16526 // 872: }
16527 1, 8, // 877: case 0x1: {
16528 OPC_CheckPredicate, 202, 1, // 879: check predicate 202
16529 OPC_Decode, 171, 123, 181, 2, // 882: decode to QC_SELECTINE using decoder 309
16530 // 882: }
16531 2, 8, // 887: case 0x2: {
16532 OPC_CheckPredicate, 202, 1, // 889: check predicate 202
16533 OPC_Decode, 173, 123, 184, 2, // 892: decode to QC_SELECTNEI using decoder 312
16534 // 892: }
16535 3, 0, // 897: case 0x3: {
16536 OPC_CheckPredicate, 202, 1, // 899: check predicate 202
16537 OPC_Decode, 172, 123, 185, 2, // 902: decode to QC_SELECTINEI using decoder 313
16538 // 902: }
16539 // 902: } // switch Inst[26:25]
16540 // 902: }
16541 4, 41, // 907: case 0x4: {
16542 OPC_SwitchField, 25, 2, // 909: switch Inst[26:25] {
16543 0, 7, // 912: case 0x0: {
16544 OPC_CheckPredicate, 17, // 914: check predicate 17
16545 OPC_Decode, 155, 123, 180, 2, // 916: decode to QC_MVLT using decoder 308
16546 // 916: }
16547 1, 8, // 921: case 0x1: {
16548 OPC_CheckPredicate, 201, 1, // 923: check predicate 201
16549 OPC_Decode, 135, 123, 181, 2, // 926: decode to QC_LILT using decoder 309
16550 // 926: }
16551 2, 7, // 931: case 0x2: {
16552 OPC_CheckPredicate, 17, // 933: check predicate 17
16553 OPC_Decode, 156, 123, 182, 2, // 935: decode to QC_MVLTI using decoder 310
16554 // 935: }
16555 3, 0, // 940: case 0x3: {
16556 OPC_CheckPredicate, 201, 1, // 942: check predicate 201
16557 OPC_Decode, 136, 123, 183, 2, // 945: decode to QC_LILTI using decoder 311
16558 // 945: }
16559 // 945: } // switch Inst[26:25]
16560 // 945: }
16561 5, 41, // 950: case 0x5: {
16562 OPC_SwitchField, 25, 2, // 952: switch Inst[26:25] {
16563 0, 7, // 955: case 0x0: {
16564 OPC_CheckPredicate, 17, // 957: check predicate 17
16565 OPC_Decode, 151, 123, 180, 2, // 959: decode to QC_MVGE using decoder 308
16566 // 959: }
16567 1, 8, // 964: case 0x1: {
16568 OPC_CheckPredicate, 201, 1, // 966: check predicate 201
16569 OPC_Decode, 131, 123, 181, 2, // 969: decode to QC_LIGE using decoder 309
16570 // 969: }
16571 2, 7, // 974: case 0x2: {
16572 OPC_CheckPredicate, 17, // 976: check predicate 17
16573 OPC_Decode, 152, 123, 182, 2, // 978: decode to QC_MVGEI using decoder 310
16574 // 978: }
16575 3, 0, // 983: case 0x3: {
16576 OPC_CheckPredicate, 201, 1, // 985: check predicate 201
16577 OPC_Decode, 132, 123, 183, 2, // 988: decode to QC_LIGEI using decoder 311
16578 // 988: }
16579 // 988: } // switch Inst[26:25]
16580 // 988: }
16581 6, 41, // 993: case 0x6: {
16582 OPC_SwitchField, 25, 2, // 995: switch Inst[26:25] {
16583 0, 7, // 998: case 0x0: {
16584 OPC_CheckPredicate, 17, // 1000: check predicate 17
16585 OPC_Decode, 157, 123, 180, 2, // 1002: decode to QC_MVLTU using decoder 308
16586 // 1002: }
16587 1, 8, // 1007: case 0x1: {
16588 OPC_CheckPredicate, 201, 1, // 1009: check predicate 201
16589 OPC_Decode, 137, 123, 181, 2, // 1012: decode to QC_LILTU using decoder 309
16590 // 1012: }
16591 2, 7, // 1017: case 0x2: {
16592 OPC_CheckPredicate, 17, // 1019: check predicate 17
16593 OPC_Decode, 158, 123, 186, 2, // 1021: decode to QC_MVLTUI using decoder 314
16594 // 1021: }
16595 3, 0, // 1026: case 0x3: {
16596 OPC_CheckPredicate, 201, 1, // 1028: check predicate 201
16597 OPC_Decode, 138, 123, 187, 2, // 1031: decode to QC_LILTUI using decoder 315
16598 // 1031: }
16599 // 1031: } // switch Inst[26:25]
16600 // 1031: }
16601 7, 0, // 1036: case 0x7: {
16602 OPC_SwitchField, 25, 2, // 1038: switch Inst[26:25] {
16603 0, 7, // 1041: case 0x0: {
16604 OPC_CheckPredicate, 17, // 1043: check predicate 17
16605 OPC_Decode, 153, 123, 180, 2, // 1045: decode to QC_MVGEU using decoder 308
16606 // 1045: }
16607 1, 8, // 1050: case 0x1: {
16608 OPC_CheckPredicate, 201, 1, // 1052: check predicate 201
16609 OPC_Decode, 133, 123, 181, 2, // 1055: decode to QC_LIGEU using decoder 309
16610 // 1055: }
16611 2, 7, // 1060: case 0x2: {
16612 OPC_CheckPredicate, 17, // 1062: check predicate 17
16613 OPC_Decode, 154, 123, 186, 2, // 1064: decode to QC_MVGEUI using decoder 314
16614 // 1064: }
16615 3, 0, // 1069: case 0x3: {
16616 OPC_CheckPredicate, 201, 1, // 1071: check predicate 201
16617 OPC_Decode, 134, 123, 187, 2, // 1074: decode to QC_LIGEUI using decoder 315
16618 // 1074: }
16619 // 1074: } // switch Inst[26:25]
16620 // 1074: }
16621 // 1074: } // switch Inst[14:12]
16622 // 1074: }
16623 115, 57, // 1079: case 0x73: {
16624 OPC_SwitchField, 25, 7, // 1081: switch Inst[31:25] {
16625 70, 12, // 1084: case 0x46: {
16626 OPC_CheckPredicate, 203, 1, // 1086: check predicate 203
16627 OPC_CheckField, 12, 3, 0, // 1089: check Inst[14:12] == 0x0
16628 OPC_Decode, 187, 122, 188, 2, // 1093: decode to QC_CSRRWR using decoder 316
16629 // 1093: }
16630 71, 12, // 1098: case 0x47: {
16631 OPC_CheckPredicate, 203, 1, // 1100: check predicate 203
16632 OPC_CheckField, 12, 3, 0, // 1103: check Inst[14:12] == 0x0
16633 OPC_Decode, 188, 122, 189, 2, // 1107: decode to QC_CSRRWRI using decoder 317
16634 // 1107: }
16635 102, 11, // 1112: case 0x66: {
16636 OPC_CheckPredicate, 13, // 1114: check predicate 13
16637 OPC_CheckField, 7, 8, 0, // 1116: check Inst[14:7] == 0x0
16638 OPC_Decode, 174, 123, 190, 2, // 1120: decode to QC_SETINTI using decoder 318
16639 // 1120: }
16640 103, 0, // 1125: case 0x67: {
16641 OPC_CheckPredicate, 13, // 1127: check predicate 13
16642 OPC_CheckField, 7, 8, 0, // 1129: check Inst[14:7] == 0x0
16643 OPC_Decode, 174, 122, 190, 2, // 1133: decode to QC_CLRINTI using decoder 318
16644 // 1133: }
16645 // 1133: } // switch Inst[31:25]
16646 // 1133: }
16647 123, 0, // 1138: case 0x7b: {
16648 OPC_SwitchField, 12, 3, // 1140: switch Inst[14:12] {
16649 0, 8, // 1143: case 0x0: {
16650 OPC_CheckPredicate, 204, 1, // 1145: check predicate 204
16651 OPC_Decode, 166, 122, 191, 2, // 1148: decode to QC_BEQI using decoder 319
16652 // 1148: }
16653 1, 8, // 1153: case 0x1: {
16654 OPC_CheckPredicate, 204, 1, // 1155: check predicate 204
16655 OPC_Decode, 171, 122, 191, 2, // 1158: decode to QC_BNEI using decoder 319
16656 // 1158: }
16657 4, 8, // 1163: case 0x4: {
16658 OPC_CheckPredicate, 204, 1, // 1165: check predicate 204
16659 OPC_Decode, 169, 122, 191, 2, // 1168: decode to QC_BLTI using decoder 319
16660 // 1168: }
16661 5, 8, // 1173: case 0x5: {
16662 OPC_CheckPredicate, 204, 1, // 1175: check predicate 204
16663 OPC_Decode, 167, 122, 191, 2, // 1178: decode to QC_BGEI using decoder 319
16664 // 1178: }
16665 6, 8, // 1183: case 0x6: {
16666 OPC_CheckPredicate, 204, 1, // 1185: check predicate 204
16667 OPC_Decode, 170, 122, 192, 2, // 1188: decode to QC_BLTUI using decoder 320
16668 // 1188: }
16669 7, 0, // 1193: case 0x7: {
16670 OPC_CheckPredicate, 204, 1, // 1195: check predicate 204
16671 OPC_Decode, 168, 122, 192, 2, // 1198: decode to QC_BGEUI using decoder 320
16672 // 1198: }
16673 // 1198: } // switch Inst[14:12]
16674 // 1198: }
16675 // 1198: } // switch Inst[6:0]
16676};
16677static const uint8_t DecoderTableZdinxGPRPairRV3232[34] = {
16678 32, // 0: BitWidth 32
16679 OPC_SwitchField, 20, 12, // 1: switch Inst[31:20] {
16680 162, 8, 12, // 4: case 0x422: {
16681 OPC_CheckPredicate, 205, 1, // 7: check predicate 205
16682 OPC_CheckField, 0, 7, 83, // 10: check Inst[6:0] == 0x53
16683 OPC_Decode, 171, 114, 193, 2, // 14: decode to FCVT_D_H_IN32X using decoder 321
16684 // 14: }
16685 193, 8, 0, // 19: case 0x441: {
16686 OPC_CheckPredicate, 205, 1, // 22: check predicate 205
16687 OPC_CheckField, 0, 7, 83, // 25: check Inst[6:0] == 0x53
16688 OPC_Decode, 188, 114, 194, 2, // 29: decode to FCVT_H_D_IN32X using decoder 322
16689 // 29: }
16690 // 29: } // switch Inst[31:20]
16691};
16692static const uint8_t DecoderTableZdinxRV32Only32[310] = {
16693 32, // 0: BitWidth 32
16694 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
16695 67, 12, // 4: case 0x43: {
16696 OPC_CheckPredicate, 206, 1, // 6: check predicate 206
16697 OPC_CheckField, 25, 2, 1, // 9: check Inst[26:25] == 0x1
16698 OPC_Decode, 177, 115, 195, 2, // 13: decode to FMADD_D_IN32X using decoder 323
16699 // 13: }
16700 71, 12, // 18: case 0x47: {
16701 OPC_CheckPredicate, 206, 1, // 20: check predicate 206
16702 OPC_CheckField, 25, 2, 1, // 23: check Inst[26:25] == 0x1
16703 OPC_Decode, 209, 115, 195, 2, // 27: decode to FMSUB_D_IN32X using decoder 323
16704 // 27: }
16705 75, 12, // 32: case 0x4b: {
16706 OPC_CheckPredicate, 206, 1, // 34: check predicate 206
16707 OPC_CheckField, 25, 2, 1, // 37: check Inst[26:25] == 0x1
16708 OPC_Decode, 244, 115, 195, 2, // 41: decode to FNMSUB_D_IN32X using decoder 323
16709 // 41: }
16710 79, 12, // 46: case 0x4f: {
16711 OPC_CheckPredicate, 206, 1, // 48: check predicate 206
16712 OPC_CheckField, 25, 2, 1, // 51: check Inst[26:25] == 0x1
16713 OPC_Decode, 236, 115, 195, 2, // 55: decode to FNMADD_D_IN32X using decoder 323
16714 // 55: }
16715 83, 0, // 60: case 0x53: {
16716 OPC_SwitchField, 25, 7, // 62: switch Inst[31:25] {
16717 1, 8, // 65: case 0x1: {
16718 OPC_CheckPredicate, 206, 1, // 67: check predicate 206
16719 OPC_Decode, 153, 114, 196, 2, // 70: decode to FADD_D_IN32X using decoder 324
16720 // 70: }
16721 5, 8, // 75: case 0x5: {
16722 OPC_CheckPredicate, 206, 1, // 77: check predicate 206
16723 OPC_Decode, 167, 116, 196, 2, // 80: decode to FSUB_D_IN32X using decoder 324
16724 // 80: }
16725 9, 8, // 85: case 0x9: {
16726 OPC_CheckPredicate, 206, 1, // 87: check predicate 206
16727 OPC_Decode, 217, 115, 196, 2, // 90: decode to FMUL_D_IN32X using decoder 324
16728 // 90: }
16729 13, 8, // 95: case 0xd: {
16730 OPC_CheckPredicate, 206, 1, // 97: check predicate 206
16731 OPC_Decode, 254, 114, 196, 2, // 100: decode to FDIV_D_IN32X using decoder 324
16732 // 100: }
16733 17, 33, // 105: case 0x11: {
16734 OPC_SwitchField, 12, 3, // 107: switch Inst[14:12] {
16735 0, 8, // 110: case 0x0: {
16736 OPC_CheckPredicate, 206, 1, // 112: check predicate 206
16737 OPC_Decode, 149, 116, 197, 2, // 115: decode to FSGNJ_D_IN32X using decoder 325
16738 // 115: }
16739 1, 8, // 120: case 0x1: {
16740 OPC_CheckPredicate, 206, 1, // 122: check predicate 206
16741 OPC_Decode, 133, 116, 197, 2, // 125: decode to FSGNJN_D_IN32X using decoder 325
16742 // 125: }
16743 2, 0, // 130: case 0x2: {
16744 OPC_CheckPredicate, 206, 1, // 132: check predicate 206
16745 OPC_Decode, 141, 116, 197, 2, // 135: decode to FSGNJX_D_IN32X using decoder 325
16746 // 135: }
16747 // 135: } // switch Inst[14:12]
16748 // 135: }
16749 21, 23, // 140: case 0x15: {
16750 OPC_SwitchField, 12, 3, // 142: switch Inst[14:12] {
16751 0, 8, // 145: case 0x0: {
16752 OPC_CheckPredicate, 206, 1, // 147: check predicate 206
16753 OPC_Decode, 201, 115, 197, 2, // 150: decode to FMIN_D_IN32X using decoder 325
16754 // 150: }
16755 1, 0, // 155: case 0x1: {
16756 OPC_CheckPredicate, 206, 1, // 157: check predicate 206
16757 OPC_Decode, 189, 115, 197, 2, // 160: decode to FMAX_D_IN32X using decoder 325
16758 // 160: }
16759 // 160: } // switch Inst[14:12]
16760 // 160: }
16761 32, 12, // 165: case 0x20: {
16762 OPC_CheckPredicate, 206, 1, // 167: check predicate 206
16763 OPC_CheckField, 20, 5, 1, // 170: check Inst[24:20] == 0x1
16764 OPC_Decode, 224, 114, 198, 2, // 174: decode to FCVT_S_D_IN32X using decoder 326
16765 // 174: }
16766 33, 12, // 179: case 0x21: {
16767 OPC_CheckPredicate, 206, 1, // 181: check predicate 206
16768 OPC_CheckField, 20, 5, 0, // 184: check Inst[24:20] == 0x0
16769 OPC_Decode, 179, 114, 199, 2, // 188: decode to FCVT_D_S_IN32X using decoder 327
16770 // 188: }
16771 45, 12, // 193: case 0x2d: {
16772 OPC_CheckPredicate, 206, 1, // 195: check predicate 206
16773 OPC_CheckField, 20, 5, 0, // 198: check Inst[24:20] == 0x0
16774 OPC_Decode, 159, 116, 200, 2, // 202: decode to FSQRT_D_IN32X using decoder 328
16775 // 202: }
16776 81, 33, // 207: case 0x51: {
16777 OPC_SwitchField, 12, 3, // 209: switch Inst[14:12] {
16778 0, 8, // 212: case 0x0: {
16779 OPC_CheckPredicate, 206, 1, // 214: check predicate 206
16780 OPC_Decode, 150, 115, 201, 2, // 217: decode to FLE_D_IN32X using decoder 329
16781 // 217: }
16782 1, 8, // 222: case 0x1: {
16783 OPC_CheckPredicate, 206, 1, // 224: check predicate 206
16784 OPC_Decode, 168, 115, 201, 2, // 227: decode to FLT_D_IN32X using decoder 329
16785 // 227: }
16786 2, 0, // 232: case 0x2: {
16787 OPC_CheckPredicate, 206, 1, // 234: check predicate 206
16788 OPC_Decode, 137, 115, 201, 2, // 237: decode to FEQ_D_IN32X using decoder 329
16789 // 237: }
16790 // 237: } // switch Inst[14:12]
16791 // 237: }
16792 97, 23, // 242: case 0x61: {
16793 OPC_SwitchField, 20, 5, // 244: switch Inst[24:20] {
16794 0, 8, // 247: case 0x0: {
16795 OPC_CheckPredicate, 206, 1, // 249: check predicate 206
16796 OPC_Decode, 246, 114, 202, 2, // 252: decode to FCVT_W_D_IN32X using decoder 330
16797 // 252: }
16798 1, 0, // 257: case 0x1: {
16799 OPC_CheckPredicate, 206, 1, // 259: check predicate 206
16800 OPC_Decode, 238, 114, 202, 2, // 262: decode to FCVT_WU_D_IN32X using decoder 330
16801 // 262: }
16802 // 262: } // switch Inst[24:20]
16803 // 262: }
16804 105, 23, // 267: case 0x69: {
16805 OPC_SwitchField, 20, 5, // 269: switch Inst[24:20] {
16806 0, 8, // 272: case 0x0: {
16807 OPC_CheckPredicate, 206, 1, // 274: check predicate 206
16808 OPC_Decode, 185, 114, 203, 2, // 277: decode to FCVT_D_W_IN32X using decoder 331
16809 // 277: }
16810 1, 0, // 282: case 0x1: {
16811 OPC_CheckPredicate, 206, 1, // 284: check predicate 206
16812 OPC_Decode, 183, 114, 203, 2, // 287: decode to FCVT_D_WU_IN32X using decoder 331
16813 // 287: }
16814 // 287: } // switch Inst[24:20]
16815 // 287: }
16816 113, 0, // 292: case 0x71: {
16817 OPC_CheckPredicate, 206, 1, // 294: check predicate 206
16818 OPC_CheckField, 20, 5, 0, // 297: check Inst[24:20] == 0x0
16819 OPC_CheckField, 12, 3, 1, // 301: check Inst[14:12] == 0x1
16820 OPC_Decode, 161, 114, 204, 2, // 305: decode to FCLASS_D_IN32X using decoder 332
16821 // 305: }
16822 // 305: } // switch Inst[31:25]
16823 // 305: }
16824 // 305: } // switch Inst[6:0]
16825};
16826static const uint8_t DecoderTableZfinx32[986] = {
16827 32, // 0: BitWidth 32
16828 OPC_SwitchField, 0, 7, // 1: switch Inst[6:0] {
16829 67, 33, // 4: case 0x43: {
16830 OPC_SwitchField, 25, 2, // 6: switch Inst[26:25] {
16831 0, 8, // 9: case 0x0: {
16832 OPC_CheckPredicate, 207, 1, // 11: check predicate 207
16833 OPC_Decode, 183, 115, 205, 2, // 14: decode to FMADD_S_INX using decoder 333
16834 // 14: }
16835 1, 8, // 19: case 0x1: {
16836 OPC_CheckPredicate, 208, 1, // 21: check predicate 208
16837 OPC_Decode, 178, 115, 206, 2, // 24: decode to FMADD_D_INX using decoder 334
16838 // 24: }
16839 2, 0, // 29: case 0x2: {
16840 OPC_CheckPredicate, 209, 1, // 31: check predicate 209
16841 OPC_Decode, 180, 115, 207, 2, // 34: decode to FMADD_H_INX using decoder 335
16842 // 34: }
16843 // 34: } // switch Inst[26:25]
16844 // 34: }
16845 71, 33, // 39: case 0x47: {
16846 OPC_SwitchField, 25, 2, // 41: switch Inst[26:25] {
16847 0, 8, // 44: case 0x0: {
16848 OPC_CheckPredicate, 207, 1, // 46: check predicate 207
16849 OPC_Decode, 215, 115, 205, 2, // 49: decode to FMSUB_S_INX using decoder 333
16850 // 49: }
16851 1, 8, // 54: case 0x1: {
16852 OPC_CheckPredicate, 208, 1, // 56: check predicate 208
16853 OPC_Decode, 210, 115, 206, 2, // 59: decode to FMSUB_D_INX using decoder 334
16854 // 59: }
16855 2, 0, // 64: case 0x2: {
16856 OPC_CheckPredicate, 209, 1, // 66: check predicate 209
16857 OPC_Decode, 212, 115, 207, 2, // 69: decode to FMSUB_H_INX using decoder 335
16858 // 69: }
16859 // 69: } // switch Inst[26:25]
16860 // 69: }
16861 75, 33, // 74: case 0x4b: {
16862 OPC_SwitchField, 25, 2, // 76: switch Inst[26:25] {
16863 0, 8, // 79: case 0x0: {
16864 OPC_CheckPredicate, 207, 1, // 81: check predicate 207
16865 OPC_Decode, 250, 115, 205, 2, // 84: decode to FNMSUB_S_INX using decoder 333
16866 // 84: }
16867 1, 8, // 89: case 0x1: {
16868 OPC_CheckPredicate, 208, 1, // 91: check predicate 208
16869 OPC_Decode, 245, 115, 206, 2, // 94: decode to FNMSUB_D_INX using decoder 334
16870 // 94: }
16871 2, 0, // 99: case 0x2: {
16872 OPC_CheckPredicate, 209, 1, // 101: check predicate 209
16873 OPC_Decode, 247, 115, 207, 2, // 104: decode to FNMSUB_H_INX using decoder 335
16874 // 104: }
16875 // 104: } // switch Inst[26:25]
16876 // 104: }
16877 79, 33, // 109: case 0x4f: {
16878 OPC_SwitchField, 25, 2, // 111: switch Inst[26:25] {
16879 0, 8, // 114: case 0x0: {
16880 OPC_CheckPredicate, 207, 1, // 116: check predicate 207
16881 OPC_Decode, 242, 115, 205, 2, // 119: decode to FNMADD_S_INX using decoder 333
16882 // 119: }
16883 1, 8, // 124: case 0x1: {
16884 OPC_CheckPredicate, 208, 1, // 126: check predicate 208
16885 OPC_Decode, 237, 115, 206, 2, // 129: decode to FNMADD_D_INX using decoder 334
16886 // 129: }
16887 2, 0, // 134: case 0x2: {
16888 OPC_CheckPredicate, 209, 1, // 136: check predicate 209
16889 OPC_Decode, 239, 115, 207, 2, // 139: decode to FNMADD_H_INX using decoder 335
16890 // 139: }
16891 // 139: } // switch Inst[26:25]
16892 // 139: }
16893 83, 0, // 144: case 0x53: {
16894 OPC_SwitchField, 25, 7, // 146: switch Inst[31:25] {
16895 0, 8, // 149: case 0x0: {
16896 OPC_CheckPredicate, 207, 1, // 151: check predicate 207
16897 OPC_Decode, 159, 114, 208, 2, // 154: decode to FADD_S_INX using decoder 336
16898 // 154: }
16899 1, 8, // 159: case 0x1: {
16900 OPC_CheckPredicate, 208, 1, // 161: check predicate 208
16901 OPC_Decode, 154, 114, 209, 2, // 164: decode to FADD_D_INX using decoder 337
16902 // 164: }
16903 2, 8, // 169: case 0x2: {
16904 OPC_CheckPredicate, 209, 1, // 171: check predicate 209
16905 OPC_Decode, 156, 114, 210, 2, // 174: decode to FADD_H_INX using decoder 338
16906 // 174: }
16907 4, 8, // 179: case 0x4: {
16908 OPC_CheckPredicate, 207, 1, // 181: check predicate 207
16909 OPC_Decode, 173, 116, 208, 2, // 184: decode to FSUB_S_INX using decoder 336
16910 // 184: }
16911 5, 8, // 189: case 0x5: {
16912 OPC_CheckPredicate, 208, 1, // 191: check predicate 208
16913 OPC_Decode, 168, 116, 209, 2, // 194: decode to FSUB_D_INX using decoder 337
16914 // 194: }
16915 6, 8, // 199: case 0x6: {
16916 OPC_CheckPredicate, 209, 1, // 201: check predicate 209
16917 OPC_Decode, 170, 116, 210, 2, // 204: decode to FSUB_H_INX using decoder 338
16918 // 204: }
16919 8, 8, // 209: case 0x8: {
16920 OPC_CheckPredicate, 207, 1, // 211: check predicate 207
16921 OPC_Decode, 223, 115, 208, 2, // 214: decode to FMUL_S_INX using decoder 336
16922 // 214: }
16923 9, 8, // 219: case 0x9: {
16924 OPC_CheckPredicate, 208, 1, // 221: check predicate 208
16925 OPC_Decode, 218, 115, 209, 2, // 224: decode to FMUL_D_INX using decoder 337
16926 // 224: }
16927 10, 8, // 229: case 0xa: {
16928 OPC_CheckPredicate, 209, 1, // 231: check predicate 209
16929 OPC_Decode, 220, 115, 210, 2, // 234: decode to FMUL_H_INX using decoder 338
16930 // 234: }
16931 12, 8, // 239: case 0xc: {
16932 OPC_CheckPredicate, 207, 1, // 241: check predicate 207
16933 OPC_Decode, 132, 115, 208, 2, // 244: decode to FDIV_S_INX using decoder 336
16934 // 244: }
16935 13, 8, // 249: case 0xd: {
16936 OPC_CheckPredicate, 208, 1, // 251: check predicate 208
16937 OPC_Decode, 255, 114, 209, 2, // 254: decode to FDIV_D_INX using decoder 337
16938 // 254: }
16939 14, 8, // 259: case 0xe: {
16940 OPC_CheckPredicate, 209, 1, // 261: check predicate 209
16941 OPC_Decode, 129, 115, 210, 2, // 264: decode to FDIV_H_INX using decoder 338
16942 // 264: }
16943 16, 33, // 269: case 0x10: {
16944 OPC_SwitchField, 12, 3, // 271: switch Inst[14:12] {
16945 0, 8, // 274: case 0x0: {
16946 OPC_CheckPredicate, 207, 1, // 276: check predicate 207
16947 OPC_Decode, 155, 116, 211, 2, // 279: decode to FSGNJ_S_INX using decoder 339
16948 // 279: }
16949 1, 8, // 284: case 0x1: {
16950 OPC_CheckPredicate, 207, 1, // 286: check predicate 207
16951 OPC_Decode, 139, 116, 211, 2, // 289: decode to FSGNJN_S_INX using decoder 339
16952 // 289: }
16953 2, 0, // 294: case 0x2: {
16954 OPC_CheckPredicate, 207, 1, // 296: check predicate 207
16955 OPC_Decode, 147, 116, 211, 2, // 299: decode to FSGNJX_S_INX using decoder 339
16956 // 299: }
16957 // 299: } // switch Inst[14:12]
16958 // 299: }
16959 17, 30, // 304: case 0x11: {
16960 OPC_SwitchField, 12, 3, // 306: switch Inst[14:12] {
16961 0, 7, // 309: case 0x0: {
16962 OPC_CheckPredicate, 208, 1, // 311: check predicate 208
16963 OPC_Decode, 150, 116, 31, // 314: decode to FSGNJ_D_INX using decoder 31
16964 // 314: }
16965 1, 7, // 318: case 0x1: {
16966 OPC_CheckPredicate, 208, 1, // 320: check predicate 208
16967 OPC_Decode, 134, 116, 31, // 323: decode to FSGNJN_D_INX using decoder 31
16968 // 323: }
16969 2, 0, // 327: case 0x2: {
16970 OPC_CheckPredicate, 208, 1, // 329: check predicate 208
16971 OPC_Decode, 142, 116, 31, // 332: decode to FSGNJX_D_INX using decoder 31
16972 // 332: }
16973 // 332: } // switch Inst[14:12]
16974 // 332: }
16975 18, 33, // 336: case 0x12: {
16976 OPC_SwitchField, 12, 3, // 338: switch Inst[14:12] {
16977 0, 8, // 341: case 0x0: {
16978 OPC_CheckPredicate, 209, 1, // 343: check predicate 209
16979 OPC_Decode, 152, 116, 212, 2, // 346: decode to FSGNJ_H_INX using decoder 340
16980 // 346: }
16981 1, 8, // 351: case 0x1: {
16982 OPC_CheckPredicate, 209, 1, // 353: check predicate 209
16983 OPC_Decode, 136, 116, 212, 2, // 356: decode to FSGNJN_H_INX using decoder 340
16984 // 356: }
16985 2, 0, // 361: case 0x2: {
16986 OPC_CheckPredicate, 209, 1, // 363: check predicate 209
16987 OPC_Decode, 144, 116, 212, 2, // 366: decode to FSGNJX_H_INX using decoder 340
16988 // 366: }
16989 // 366: } // switch Inst[14:12]
16990 // 366: }
16991 20, 23, // 371: case 0x14: {
16992 OPC_SwitchField, 12, 3, // 373: switch Inst[14:12] {
16993 0, 8, // 376: case 0x0: {
16994 OPC_CheckPredicate, 207, 1, // 378: check predicate 207
16995 OPC_Decode, 207, 115, 211, 2, // 381: decode to FMIN_S_INX using decoder 339
16996 // 381: }
16997 1, 0, // 386: case 0x1: {
16998 OPC_CheckPredicate, 207, 1, // 388: check predicate 207
16999 OPC_Decode, 195, 115, 211, 2, // 391: decode to FMAX_S_INX using decoder 339
17000 // 391: }
17001 // 391: } // switch Inst[14:12]
17002 // 391: }
17003 21, 21, // 396: case 0x15: {
17004 OPC_SwitchField, 12, 3, // 398: switch Inst[14:12] {
17005 0, 7, // 401: case 0x0: {
17006 OPC_CheckPredicate, 208, 1, // 403: check predicate 208
17007 OPC_Decode, 202, 115, 31, // 406: decode to FMIN_D_INX using decoder 31
17008 // 406: }
17009 1, 0, // 410: case 0x1: {
17010 OPC_CheckPredicate, 208, 1, // 412: check predicate 208
17011 OPC_Decode, 190, 115, 31, // 415: decode to FMAX_D_INX using decoder 31
17012 // 415: }
17013 // 415: } // switch Inst[14:12]
17014 // 415: }
17015 22, 23, // 419: case 0x16: {
17016 OPC_SwitchField, 12, 3, // 421: switch Inst[14:12] {
17017 0, 8, // 424: case 0x0: {
17018 OPC_CheckPredicate, 209, 1, // 426: check predicate 209
17019 OPC_Decode, 204, 115, 212, 2, // 429: decode to FMIN_H_INX using decoder 340
17020 // 429: }
17021 1, 0, // 434: case 0x1: {
17022 OPC_CheckPredicate, 209, 1, // 436: check predicate 209
17023 OPC_Decode, 192, 115, 212, 2, // 439: decode to FMAX_H_INX using decoder 340
17024 // 439: }
17025 // 439: } // switch Inst[14:12]
17026 // 439: }
17027 32, 23, // 444: case 0x20: {
17028 OPC_SwitchField, 20, 5, // 446: switch Inst[24:20] {
17029 1, 8, // 449: case 0x1: {
17030 OPC_CheckPredicate, 208, 1, // 451: check predicate 208
17031 OPC_Decode, 225, 114, 213, 2, // 454: decode to FCVT_S_D_INX using decoder 341
17032 // 454: }
17033 2, 0, // 459: case 0x2: {
17034 OPC_CheckPredicate, 210, 1, // 461: check predicate 210
17035 OPC_Decode, 227, 114, 214, 2, // 464: decode to FCVT_S_H_INX using decoder 342
17036 // 464: }
17037 // 464: } // switch Inst[24:20]
17038 // 464: }
17039 33, 23, // 469: case 0x21: {
17040 OPC_SwitchField, 20, 5, // 471: switch Inst[24:20] {
17041 0, 8, // 474: case 0x0: {
17042 OPC_CheckPredicate, 208, 1, // 476: check predicate 208
17043 OPC_Decode, 180, 114, 215, 2, // 479: decode to FCVT_D_S_INX using decoder 343
17044 // 479: }
17045 2, 0, // 484: case 0x2: {
17046 OPC_CheckPredicate, 211, 1, // 486: check predicate 211
17047 OPC_Decode, 172, 114, 216, 2, // 489: decode to FCVT_D_H_INX using decoder 344
17048 // 489: }
17049 // 489: } // switch Inst[24:20]
17050 // 489: }
17051 34, 23, // 494: case 0x22: {
17052 OPC_SwitchField, 20, 5, // 496: switch Inst[24:20] {
17053 0, 8, // 499: case 0x0: {
17054 OPC_CheckPredicate, 210, 1, // 501: check predicate 210
17055 OPC_Decode, 196, 114, 217, 2, // 504: decode to FCVT_H_S_INX using decoder 345
17056 // 504: }
17057 1, 0, // 509: case 0x1: {
17058 OPC_CheckPredicate, 211, 1, // 511: check predicate 211
17059 OPC_Decode, 189, 114, 218, 2, // 514: decode to FCVT_H_D_INX using decoder 346
17060 // 514: }
17061 // 514: } // switch Inst[24:20]
17062 // 514: }
17063 44, 12, // 519: case 0x2c: {
17064 OPC_CheckPredicate, 207, 1, // 521: check predicate 207
17065 OPC_CheckField, 20, 5, 0, // 524: check Inst[24:20] == 0x0
17066 OPC_Decode, 165, 116, 219, 2, // 528: decode to FSQRT_S_INX using decoder 347
17067 // 528: }
17068 45, 12, // 533: case 0x2d: {
17069 OPC_CheckPredicate, 208, 1, // 535: check predicate 208
17070 OPC_CheckField, 20, 5, 0, // 538: check Inst[24:20] == 0x0
17071 OPC_Decode, 160, 116, 220, 2, // 542: decode to FSQRT_D_INX using decoder 348
17072 // 542: }
17073 46, 12, // 547: case 0x2e: {
17074 OPC_CheckPredicate, 209, 1, // 549: check predicate 209
17075 OPC_CheckField, 20, 5, 0, // 552: check Inst[24:20] == 0x0
17076 OPC_Decode, 162, 116, 221, 2, // 556: decode to FSQRT_H_INX using decoder 349
17077 // 556: }
17078 80, 33, // 561: case 0x50: {
17079 OPC_SwitchField, 12, 3, // 563: switch Inst[14:12] {
17080 0, 8, // 566: case 0x0: {
17081 OPC_CheckPredicate, 207, 1, // 568: check predicate 207
17082 OPC_Decode, 156, 115, 222, 2, // 571: decode to FLE_S_INX using decoder 350
17083 // 571: }
17084 1, 8, // 576: case 0x1: {
17085 OPC_CheckPredicate, 207, 1, // 578: check predicate 207
17086 OPC_Decode, 174, 115, 222, 2, // 581: decode to FLT_S_INX using decoder 350
17087 // 581: }
17088 2, 0, // 586: case 0x2: {
17089 OPC_CheckPredicate, 207, 1, // 588: check predicate 207
17090 OPC_Decode, 143, 115, 222, 2, // 591: decode to FEQ_S_INX using decoder 350
17091 // 591: }
17092 // 591: } // switch Inst[14:12]
17093 // 591: }
17094 81, 30, // 596: case 0x51: {
17095 OPC_SwitchField, 12, 3, // 598: switch Inst[14:12] {
17096 0, 7, // 601: case 0x0: {
17097 OPC_CheckPredicate, 208, 1, // 603: check predicate 208
17098 OPC_Decode, 151, 115, 31, // 606: decode to FLE_D_INX using decoder 31
17099 // 606: }
17100 1, 7, // 610: case 0x1: {
17101 OPC_CheckPredicate, 208, 1, // 612: check predicate 208
17102 OPC_Decode, 169, 115, 31, // 615: decode to FLT_D_INX using decoder 31
17103 // 615: }
17104 2, 0, // 619: case 0x2: {
17105 OPC_CheckPredicate, 208, 1, // 621: check predicate 208
17106 OPC_Decode, 138, 115, 31, // 624: decode to FEQ_D_INX using decoder 31
17107 // 624: }
17108 // 624: } // switch Inst[14:12]
17109 // 624: }
17110 82, 33, // 628: case 0x52: {
17111 OPC_SwitchField, 12, 3, // 630: switch Inst[14:12] {
17112 0, 8, // 633: case 0x0: {
17113 OPC_CheckPredicate, 209, 1, // 635: check predicate 209
17114 OPC_Decode, 153, 115, 223, 2, // 638: decode to FLE_H_INX using decoder 351
17115 // 638: }
17116 1, 8, // 643: case 0x1: {
17117 OPC_CheckPredicate, 209, 1, // 645: check predicate 209
17118 OPC_Decode, 171, 115, 223, 2, // 648: decode to FLT_H_INX using decoder 351
17119 // 648: }
17120 2, 0, // 653: case 0x2: {
17121 OPC_CheckPredicate, 209, 1, // 655: check predicate 209
17122 OPC_Decode, 140, 115, 223, 2, // 658: decode to FEQ_H_INX using decoder 351
17123 // 658: }
17124 // 658: } // switch Inst[14:12]
17125 // 658: }
17126 96, 43, // 663: case 0x60: {
17127 OPC_SwitchField, 20, 5, // 665: switch Inst[24:20] {
17128 0, 8, // 668: case 0x0: {
17129 OPC_CheckPredicate, 207, 1, // 670: check predicate 207
17130 OPC_Decode, 252, 114, 215, 2, // 673: decode to FCVT_W_S_INX using decoder 343
17131 // 673: }
17132 1, 8, // 678: case 0x1: {
17133 OPC_CheckPredicate, 207, 1, // 680: check predicate 207
17134 OPC_Decode, 244, 114, 215, 2, // 683: decode to FCVT_WU_S_INX using decoder 343
17135 // 683: }
17136 2, 8, // 688: case 0x2: {
17137 OPC_CheckPredicate, 212, 1, // 690: check predicate 212
17138 OPC_Decode, 214, 114, 215, 2, // 693: decode to FCVT_L_S_INX using decoder 343
17139 // 693: }
17140 3, 0, // 698: case 0x3: {
17141 OPC_CheckPredicate, 212, 1, // 700: check predicate 212
17142 OPC_Decode, 207, 114, 215, 2, // 703: decode to FCVT_LU_S_INX using decoder 343
17143 // 703: }
17144 // 703: } // switch Inst[24:20]
17145 // 703: }
17146 97, 43, // 708: case 0x61: {
17147 OPC_SwitchField, 20, 5, // 710: switch Inst[24:20] {
17148 0, 8, // 713: case 0x0: {
17149 OPC_CheckPredicate, 208, 1, // 715: check predicate 208
17150 OPC_Decode, 247, 114, 220, 2, // 718: decode to FCVT_W_D_INX using decoder 348
17151 // 718: }
17152 1, 8, // 723: case 0x1: {
17153 OPC_CheckPredicate, 208, 1, // 725: check predicate 208
17154 OPC_Decode, 239, 114, 220, 2, // 728: decode to FCVT_WU_D_INX using decoder 348
17155 // 728: }
17156 2, 8, // 733: case 0x2: {
17157 OPC_CheckPredicate, 213, 1, // 735: check predicate 213
17158 OPC_Decode, 209, 114, 220, 2, // 738: decode to FCVT_L_D_INX using decoder 348
17159 // 738: }
17160 3, 0, // 743: case 0x3: {
17161 OPC_CheckPredicate, 213, 1, // 745: check predicate 213
17162 OPC_Decode, 202, 114, 220, 2, // 748: decode to FCVT_LU_D_INX using decoder 348
17163 // 748: }
17164 // 748: } // switch Inst[24:20]
17165 // 748: }
17166 98, 43, // 753: case 0x62: {
17167 OPC_SwitchField, 20, 5, // 755: switch Inst[24:20] {
17168 0, 8, // 758: case 0x0: {
17169 OPC_CheckPredicate, 209, 1, // 760: check predicate 209
17170 OPC_Decode, 249, 114, 216, 2, // 763: decode to FCVT_W_H_INX using decoder 344
17171 // 763: }
17172 1, 8, // 768: case 0x1: {
17173 OPC_CheckPredicate, 209, 1, // 770: check predicate 209
17174 OPC_Decode, 241, 114, 216, 2, // 773: decode to FCVT_WU_H_INX using decoder 344
17175 // 773: }
17176 2, 8, // 778: case 0x2: {
17177 OPC_CheckPredicate, 214, 1, // 780: check predicate 214
17178 OPC_Decode, 211, 114, 216, 2, // 783: decode to FCVT_L_H_INX using decoder 344
17179 // 783: }
17180 3, 0, // 788: case 0x3: {
17181 OPC_CheckPredicate, 214, 1, // 790: check predicate 214
17182 OPC_Decode, 204, 114, 216, 2, // 793: decode to FCVT_LU_H_INX using decoder 344
17183 // 793: }
17184 // 793: } // switch Inst[24:20]
17185 // 793: }
17186 104, 43, // 798: case 0x68: {
17187 OPC_SwitchField, 20, 5, // 800: switch Inst[24:20] {
17188 0, 8, // 803: case 0x0: {
17189 OPC_CheckPredicate, 207, 1, // 805: check predicate 207
17190 OPC_Decode, 236, 114, 213, 2, // 808: decode to FCVT_S_W_INX using decoder 341
17191 // 808: }
17192 1, 8, // 813: case 0x1: {
17193 OPC_CheckPredicate, 207, 1, // 815: check predicate 207
17194 OPC_Decode, 235, 114, 213, 2, // 818: decode to FCVT_S_WU_INX using decoder 341
17195 // 818: }
17196 2, 8, // 823: case 0x2: {
17197 OPC_CheckPredicate, 212, 1, // 825: check predicate 212
17198 OPC_Decode, 231, 114, 213, 2, // 828: decode to FCVT_S_L_INX using decoder 341
17199 // 828: }
17200 3, 0, // 833: case 0x3: {
17201 OPC_CheckPredicate, 212, 1, // 835: check predicate 212
17202 OPC_Decode, 230, 114, 213, 2, // 838: decode to FCVT_S_LU_INX using decoder 341
17203 // 838: }
17204 // 838: } // switch Inst[24:20]
17205 // 838: }
17206 105, 43, // 843: case 0x69: {
17207 OPC_SwitchField, 20, 5, // 845: switch Inst[24:20] {
17208 0, 8, // 848: case 0x0: {
17209 OPC_CheckPredicate, 208, 1, // 850: check predicate 208
17210 OPC_Decode, 186, 114, 220, 2, // 853: decode to FCVT_D_W_INX using decoder 348
17211 // 853: }
17212 1, 8, // 858: case 0x1: {
17213 OPC_CheckPredicate, 208, 1, // 860: check predicate 208
17214 OPC_Decode, 184, 114, 220, 2, // 863: decode to FCVT_D_WU_INX using decoder 348
17215 // 863: }
17216 2, 8, // 868: case 0x2: {
17217 OPC_CheckPredicate, 213, 1, // 870: check predicate 213
17218 OPC_Decode, 176, 114, 220, 2, // 873: decode to FCVT_D_L_INX using decoder 348
17219 // 873: }
17220 3, 0, // 878: case 0x3: {
17221 OPC_CheckPredicate, 213, 1, // 880: check predicate 213
17222 OPC_Decode, 175, 114, 220, 2, // 883: decode to FCVT_D_LU_INX using decoder 348
17223 // 883: }
17224 // 883: } // switch Inst[24:20]
17225 // 883: }
17226 106, 43, // 888: case 0x6a: {
17227 OPC_SwitchField, 20, 5, // 890: switch Inst[24:20] {
17228 0, 8, // 893: case 0x0: {
17229 OPC_CheckPredicate, 209, 1, // 895: check predicate 209
17230 OPC_Decode, 200, 114, 218, 2, // 898: decode to FCVT_H_W_INX using decoder 346
17231 // 898: }
17232 1, 8, // 903: case 0x1: {
17233 OPC_CheckPredicate, 209, 1, // 905: check predicate 209
17234 OPC_Decode, 199, 114, 218, 2, // 908: decode to FCVT_H_WU_INX using decoder 346
17235 // 908: }
17236 2, 8, // 913: case 0x2: {
17237 OPC_CheckPredicate, 214, 1, // 915: check predicate 214
17238 OPC_Decode, 193, 114, 218, 2, // 918: decode to FCVT_H_L_INX using decoder 346
17239 // 918: }
17240 3, 0, // 923: case 0x3: {
17241 OPC_CheckPredicate, 214, 1, // 925: check predicate 214
17242 OPC_Decode, 192, 114, 218, 2, // 928: decode to FCVT_H_LU_INX using decoder 346
17243 // 928: }
17244 // 928: } // switch Inst[24:20]
17245 // 928: }
17246 112, 16, // 933: case 0x70: {
17247 OPC_CheckPredicate, 207, 1, // 935: check predicate 207
17248 OPC_CheckField, 20, 5, 0, // 938: check Inst[24:20] == 0x0
17249 OPC_CheckField, 12, 3, 1, // 942: check Inst[14:12] == 0x1
17250 OPC_Decode, 167, 114, 224, 2, // 946: decode to FCLASS_S_INX using decoder 352
17251 // 946: }
17252 113, 15, // 951: case 0x71: {
17253 OPC_CheckPredicate, 208, 1, // 953: check predicate 208
17254 OPC_CheckField, 20, 5, 0, // 956: check Inst[24:20] == 0x0
17255 OPC_CheckField, 12, 3, 1, // 960: check Inst[14:12] == 0x1
17256 OPC_Decode, 162, 114, 17, // 964: decode to FCLASS_D_INX using decoder 17
17257 // 964: }
17258 114, 0, // 968: case 0x72: {
17259 OPC_CheckPredicate, 209, 1, // 970: check predicate 209
17260 OPC_CheckField, 20, 5, 0, // 973: check Inst[24:20] == 0x0
17261 OPC_CheckField, 12, 3, 1, // 977: check Inst[14:12] == 0x1
17262 OPC_Decode, 164, 114, 225, 2, // 981: decode to FCLASS_H_INX using decoder 353
17263 // 981: }
17264 // 981: } // switch Inst[31:25]
17265 // 981: }
17266 // 981: } // switch Inst[6:0]
17267};
17268// Handling 354 cases.
17269template <typename InsnType>
17270static std::enable_if_t<InsnBitWidth<InsnType> == 32, DecodeStatus>
17271decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
17272 DecodeComplete = true;
17273 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
17274 TmpType tmp;
17275 switch (Idx) {
17276 default: llvm_unreachable("Invalid decoder index!");
17277 case 0:
17278 tmp = fieldFromInstruction(insn, 7, 5);
17279 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17280 tmp = fieldFromInstruction(insn, 15, 5);
17281 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17282 tmp = fieldFromInstruction(insn, 20, 12);
17283 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17284 return S;
17285 case 1:
17286 tmp = fieldFromInstruction(insn, 7, 5);
17287 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17288 tmp = fieldFromInstruction(insn, 15, 5);
17289 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17290 tmp = fieldFromInstruction(insn, 25, 1);
17291 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17292 return S;
17293 case 2:
17294 tmp = fieldFromInstruction(insn, 7, 5);
17295 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17296 tmp = fieldFromInstruction(insn, 15, 5);
17297 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17298 return S;
17299 case 3:
17300 tmp = fieldFromInstruction(insn, 7, 5);
17301 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17302 tmp = fieldFromInstruction(insn, 15, 5);
17303 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17304 tmp = fieldFromInstruction(insn, 20, 5);
17305 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17306 tmp = fieldFromInstruction(insn, 25, 1);
17307 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17308 return S;
17309 case 4:
17310 tmp = fieldFromInstruction(insn, 7, 5);
17311 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17312 tmp = fieldFromInstruction(insn, 15, 5);
17313 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17314 tmp = fieldFromInstruction(insn, 20, 5);
17315 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17316 tmp = fieldFromInstruction(insn, 25, 1);
17317 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17318 return S;
17319 case 5:
17320 tmp = fieldFromInstruction(insn, 7, 5);
17321 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17322 tmp = fieldFromInstruction(insn, 15, 5);
17323 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17324 return S;
17325 case 6:
17326 tmp = fieldFromInstruction(insn, 7, 5);
17327 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM4RegClassID, 32, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17328 tmp = fieldFromInstruction(insn, 15, 5);
17329 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17330 return S;
17331 case 7:
17332 tmp = fieldFromInstruction(insn, 7, 5);
17333 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17334 tmp = fieldFromInstruction(insn, 15, 5);
17335 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17336 return S;
17337 case 8:
17338 tmp = fieldFromInstruction(insn, 7, 5);
17339 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17340 tmp = fieldFromInstruction(insn, 15, 5);
17341 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17342 tmp = fieldFromInstruction(insn, 20, 12);
17343 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17344 return S;
17345 case 9:
17346 tmp = fieldFromInstruction(insn, 7, 5);
17347 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17348 tmp = fieldFromInstruction(insn, 15, 5);
17349 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17350 tmp = fieldFromInstruction(insn, 20, 12);
17351 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17352 return S;
17353 case 10:
17354 tmp = fieldFromInstruction(insn, 7, 5);
17355 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17356 tmp = fieldFromInstruction(insn, 15, 5);
17357 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17358 tmp = fieldFromInstruction(insn, 20, 12);
17359 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17360 return S;
17361 case 11:
17362 tmp = fieldFromInstruction(insn, 7, 5);
17363 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17364 tmp = fieldFromInstruction(insn, 15, 5);
17365 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17366 tmp = fieldFromInstruction(insn, 20, 12);
17367 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17368 return S;
17369 case 12:
17370 tmp = fieldFromInstruction(insn, 7, 5);
17371 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17372 tmp = fieldFromInstruction(insn, 15, 5);
17373 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17374 tmp = fieldFromInstruction(insn, 20, 5);
17375 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17376 tmp = fieldFromInstruction(insn, 29, 3);
17377 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17378 tmp = fieldFromInstruction(insn, 25, 1);
17379 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17380 return S;
17381 case 13:
17382 tmp = fieldFromInstruction(insn, 24, 4);
17383 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17384 tmp = fieldFromInstruction(insn, 20, 4);
17385 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17386 return S;
17387 case 14:
17388 return S;
17389 case 15:
17390 tmp = fieldFromInstruction(insn, 15, 5);
17391 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17392 return S;
17393 case 16:
17394 tmp = fieldFromInstruction(insn, 7, 5);
17395 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17396 tmp = fieldFromInstruction(insn, 15, 5);
17397 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17398 tmp = fieldFromInstruction(insn, 20, 6);
17399 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17400 return S;
17401 case 17:
17402 tmp = fieldFromInstruction(insn, 7, 5);
17403 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17404 tmp = fieldFromInstruction(insn, 15, 5);
17405 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17406 return S;
17407 case 18:
17408 tmp = fieldFromInstruction(insn, 7, 5);
17409 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17410 tmp = fieldFromInstruction(insn, 15, 5);
17411 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17412 tmp = fieldFromInstruction(insn, 20, 4);
17413 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17414 return S;
17415 case 19:
17416 tmp = fieldFromInstruction(insn, 15, 5);
17417 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17418 tmp = fieldFromInstruction(insn, 25, 7) << 5;
17419 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17420 return S;
17421 case 20:
17422 tmp = fieldFromInstruction(insn, 7, 5);
17423 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17424 tmp = fieldFromInstruction(insn, 12, 20);
17425 if (!Check(S, decodeUImm20Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17426 return S;
17427 case 21:
17428 tmp = fieldFromInstruction(insn, 7, 5);
17429 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17430 tmp = fieldFromInstruction(insn, 15, 5);
17431 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17432 tmp = fieldFromInstruction(insn, 20, 5);
17433 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17434 return S;
17435 case 22:
17436 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17437 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17438 tmp = fieldFromInstruction(insn, 15, 5);
17439 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17440 tmp = fieldFromInstruction(insn, 20, 4);
17441 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17442 return S;
17443 case 23:
17444 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17445 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17446 tmp = fieldFromInstruction(insn, 15, 5);
17447 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17448 tmp = fieldFromInstruction(insn, 20, 5);
17449 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17450 return S;
17451 case 24:
17452 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17453 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17454 tmp = fieldFromInstruction(insn, 15, 5);
17455 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17456 tmp = fieldFromInstruction(insn, 20, 5);
17457 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17458 return S;
17459 case 25:
17460 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17461 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17462 tmp = fieldFromInstruction(insn, 15, 5);
17463 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17464 tmp = fieldFromInstruction(insn, 20, 6);
17465 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17466 return S;
17467 case 26:
17468 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17469 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17470 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17471 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17472 tmp = fieldFromInstruction(insn, 15, 5);
17473 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17474 tmp = fieldFromInstruction(insn, 20, 5);
17475 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17476 return S;
17477 case 27:
17478 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17479 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17480 tmp = 0x0;
17481 tmp |= fieldFromInstruction(insn, 15, 1) << 9;
17482 tmp |= fieldFromInstruction(insn, 16, 9);
17483 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17484 return S;
17485 case 28:
17486 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17487 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17488 tmp = fieldFromInstruction(insn, 16, 8);
17489 if (!Check(S, decodeSImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17490 return S;
17491 case 29:
17492 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17493 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17494 tmp = 0x0;
17495 tmp |= fieldFromInstruction(insn, 15, 9) << 1;
17496 tmp |= fieldFromInstruction(insn, 24, 1);
17497 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17498 return S;
17499 case 30:
17500 tmp = fieldFromInstruction(insn, 7, 5);
17501 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17502 tmp = fieldFromInstruction(insn, 15, 5);
17503 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17504 tmp = fieldFromInstruction(insn, 20, 3);
17505 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17506 return S;
17507 case 31:
17508 tmp = fieldFromInstruction(insn, 7, 5);
17509 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17510 tmp = fieldFromInstruction(insn, 15, 5);
17511 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17512 tmp = fieldFromInstruction(insn, 20, 5);
17513 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17514 return S;
17515 case 32:
17516 tmp = fieldFromInstruction(insn, 7, 5);
17517 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17518 tmp = 0x0;
17519 tmp |= fieldFromInstruction(insn, 15, 1) << 9;
17520 tmp |= fieldFromInstruction(insn, 16, 9);
17521 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17522 return S;
17523 case 33:
17524 tmp = fieldFromInstruction(insn, 7, 5);
17525 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17526 tmp = fieldFromInstruction(insn, 16, 8);
17527 if (!Check(S, decodeSImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17528 return S;
17529 case 34:
17530 tmp = fieldFromInstruction(insn, 7, 5);
17531 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17532 tmp = 0x0;
17533 tmp |= fieldFromInstruction(insn, 15, 9) << 1;
17534 tmp |= fieldFromInstruction(insn, 24, 1);
17535 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17536 return S;
17537 case 35:
17538 tmp = fieldFromInstruction(insn, 7, 5);
17539 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17540 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17541 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17542 tmp = fieldFromInstruction(insn, 20, 4);
17543 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17544 return S;
17545 case 36:
17546 tmp = fieldFromInstruction(insn, 7, 5);
17547 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17548 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17549 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17550 tmp = fieldFromInstruction(insn, 20, 5);
17551 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17552 return S;
17553 case 37:
17554 tmp = fieldFromInstruction(insn, 7, 5);
17555 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17556 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17557 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17558 tmp = fieldFromInstruction(insn, 20, 6);
17559 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17560 return S;
17561 case 38:
17562 tmp = fieldFromInstruction(insn, 7, 5);
17563 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17564 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17565 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17566 tmp = fieldFromInstruction(insn, 20, 5);
17567 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17568 return S;
17569 case 39:
17570 tmp = fieldFromInstruction(insn, 7, 5);
17571 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17572 tmp = fieldFromInstruction(insn, 15, 5);
17573 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17574 tmp = fieldFromInstruction(insn, 20, 6);
17575 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17576 return S;
17577 case 40:
17578 tmp = fieldFromInstruction(insn, 7, 5);
17579 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17580 tmp = fieldFromInstruction(insn, 15, 5);
17581 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17582 tmp = fieldFromInstruction(insn, 20, 4);
17583 if (!Check(S, decodeUImmPlus1Operand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17584 return S;
17585 case 41:
17586 tmp = fieldFromInstruction(insn, 7, 5);
17587 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17588 tmp = fieldFromInstruction(insn, 15, 5);
17589 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17590 tmp = fieldFromInstruction(insn, 20, 5);
17591 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17592 return S;
17593 case 42:
17594 tmp = fieldFromInstruction(insn, 7, 5);
17595 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17596 tmp = fieldFromInstruction(insn, 15, 5);
17597 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17598 tmp = fieldFromInstruction(insn, 20, 6);
17599 if (!Check(S, decodeUImmPlus1Operand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17600 return S;
17601 case 43:
17602 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17603 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17604 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17605 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17606 tmp = fieldFromInstruction(insn, 20, 3);
17607 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17608 return S;
17609 case 44:
17610 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17611 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17612 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17613 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17614 tmp = fieldFromInstruction(insn, 20, 4);
17615 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17616 return S;
17617 case 45:
17618 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17619 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17620 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17621 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17622 tmp = fieldFromInstruction(insn, 20, 5);
17623 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17624 return S;
17625 case 46:
17626 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17627 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17628 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17629 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17630 tmp = fieldFromInstruction(insn, 20, 5);
17631 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17632 return S;
17633 case 47:
17634 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17635 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17636 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17637 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17638 return S;
17639 case 48:
17640 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17641 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17642 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17643 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17644 tmp = fieldFromInstruction(insn, 20, 4);
17645 if (!Check(S, decodeUImmPlus1Operand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17646 return S;
17647 case 49:
17648 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17649 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17650 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17651 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17652 tmp = fieldFromInstruction(insn, 20, 5);
17653 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17654 return S;
17655 case 50:
17656 tmp = fieldFromInstruction(insn, 8, 4) << 1;
17657 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17658 tmp = fieldFromInstruction(insn, 16, 4) << 1;
17659 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17660 tmp = fieldFromInstruction(insn, 21, 4) << 1;
17661 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17662 return S;
17663 case 51:
17664 tmp = fieldFromInstruction(insn, 20, 5);
17665 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17666 tmp = fieldFromInstruction(insn, 15, 5);
17667 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17668 tmp = 0x0;
17669 tmp |= fieldFromInstruction(insn, 7, 5);
17670 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17671 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17672 return S;
17673 case 52:
17674 tmp = fieldFromInstruction(insn, 20, 5);
17675 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17676 tmp = fieldFromInstruction(insn, 15, 5);
17677 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17678 tmp = 0x0;
17679 tmp |= fieldFromInstruction(insn, 7, 5);
17680 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17681 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17682 return S;
17683 case 53:
17684 tmp = fieldFromInstruction(insn, 20, 5);
17685 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17686 tmp = fieldFromInstruction(insn, 15, 5);
17687 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17688 tmp = 0x0;
17689 tmp |= fieldFromInstruction(insn, 7, 5);
17690 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17691 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17692 return S;
17693 case 54:
17694 tmp = fieldFromInstruction(insn, 20, 5);
17695 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17696 tmp = fieldFromInstruction(insn, 15, 5);
17697 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17698 tmp = 0x0;
17699 tmp |= fieldFromInstruction(insn, 7, 5);
17700 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17701 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17702 return S;
17703 case 55:
17704 tmp = fieldFromInstruction(insn, 20, 5);
17705 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17706 tmp = fieldFromInstruction(insn, 15, 5);
17707 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17708 tmp = 0x0;
17709 tmp |= fieldFromInstruction(insn, 7, 5);
17710 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
17711 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17712 return S;
17713 case 56:
17714 tmp = fieldFromInstruction(insn, 7, 5);
17715 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17716 tmp = fieldFromInstruction(insn, 20, 5);
17717 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17718 tmp = fieldFromInstruction(insn, 15, 5);
17719 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17720 return S;
17721 case 57:
17722 tmp = fieldFromInstruction(insn, 7, 5);
17723 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17724 tmp = fieldFromInstruction(insn, 7, 5);
17725 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17726 tmp = fieldFromInstruction(insn, 20, 5);
17727 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17728 tmp = fieldFromInstruction(insn, 15, 5);
17729 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17730 return S;
17731 case 58:
17732 tmp = fieldFromInstruction(insn, 7, 5);
17733 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17734 tmp = fieldFromInstruction(insn, 7, 5);
17735 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17736 tmp = fieldFromInstruction(insn, 20, 5);
17737 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17738 tmp = fieldFromInstruction(insn, 15, 5);
17739 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17740 return S;
17741 case 59:
17742 tmp = fieldFromInstruction(insn, 20, 5);
17743 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17744 tmp = fieldFromInstruction(insn, 15, 5);
17745 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17746 return S;
17747 case 60:
17748 tmp = fieldFromInstruction(insn, 7, 5);
17749 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17750 tmp = fieldFromInstruction(insn, 15, 5);
17751 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17752 tmp = fieldFromInstruction(insn, 20, 5);
17753 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17754 tmp = fieldFromInstruction(insn, 30, 2);
17755 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17756 return S;
17757 case 61:
17758 tmp = fieldFromInstruction(insn, 7, 5);
17759 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17760 tmp = fieldFromInstruction(insn, 7, 5);
17761 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17762 tmp = fieldFromInstruction(insn, 15, 5);
17763 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17764 tmp = fieldFromInstruction(insn, 20, 5);
17765 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17766 return S;
17767 case 62:
17768 tmp = fieldFromInstruction(insn, 7, 5);
17769 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17770 tmp = fieldFromInstruction(insn, 15, 5);
17771 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17772 tmp = fieldFromInstruction(insn, 20, 5);
17773 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17774 tmp = fieldFromInstruction(insn, 27, 5);
17775 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17776 tmp = fieldFromInstruction(insn, 12, 3);
17777 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17778 return S;
17779 case 63:
17780 tmp = fieldFromInstruction(insn, 7, 5);
17781 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17782 tmp = fieldFromInstruction(insn, 15, 5);
17783 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17784 tmp = fieldFromInstruction(insn, 20, 5);
17785 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17786 tmp = fieldFromInstruction(insn, 27, 5);
17787 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17788 tmp = fieldFromInstruction(insn, 12, 3);
17789 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17790 return S;
17791 case 64:
17792 tmp = fieldFromInstruction(insn, 7, 5);
17793 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17794 tmp = fieldFromInstruction(insn, 15, 5);
17795 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17796 tmp = fieldFromInstruction(insn, 20, 5);
17797 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17798 tmp = fieldFromInstruction(insn, 27, 5);
17799 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17800 tmp = fieldFromInstruction(insn, 12, 3);
17801 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17802 return S;
17803 case 65:
17804 tmp = fieldFromInstruction(insn, 7, 5);
17805 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17806 tmp = fieldFromInstruction(insn, 15, 5);
17807 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17808 tmp = fieldFromInstruction(insn, 20, 5);
17809 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17810 tmp = fieldFromInstruction(insn, 27, 5);
17811 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17812 tmp = fieldFromInstruction(insn, 12, 3);
17813 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17814 return S;
17815 case 66:
17816 tmp = fieldFromInstruction(insn, 7, 5);
17817 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17818 tmp = fieldFromInstruction(insn, 15, 5);
17819 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17820 tmp = fieldFromInstruction(insn, 20, 5);
17821 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17822 tmp = fieldFromInstruction(insn, 12, 3);
17823 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17824 return S;
17825 case 67:
17826 tmp = fieldFromInstruction(insn, 7, 5);
17827 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17828 tmp = fieldFromInstruction(insn, 15, 5);
17829 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17830 tmp = fieldFromInstruction(insn, 20, 5);
17831 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17832 tmp = fieldFromInstruction(insn, 12, 3);
17833 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17834 return S;
17835 case 68:
17836 tmp = fieldFromInstruction(insn, 7, 5);
17837 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17838 tmp = fieldFromInstruction(insn, 15, 5);
17839 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17840 tmp = fieldFromInstruction(insn, 20, 5);
17841 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17842 tmp = fieldFromInstruction(insn, 12, 3);
17843 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17844 return S;
17845 case 69:
17846 tmp = fieldFromInstruction(insn, 7, 5);
17847 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17848 tmp = fieldFromInstruction(insn, 15, 5);
17849 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17850 tmp = fieldFromInstruction(insn, 20, 5);
17851 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17852 tmp = fieldFromInstruction(insn, 12, 3);
17853 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17854 return S;
17855 case 70:
17856 tmp = fieldFromInstruction(insn, 7, 5);
17857 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17858 tmp = fieldFromInstruction(insn, 15, 5);
17859 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17860 tmp = fieldFromInstruction(insn, 20, 5);
17861 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17862 return S;
17863 case 71:
17864 tmp = fieldFromInstruction(insn, 7, 5);
17865 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17866 tmp = fieldFromInstruction(insn, 15, 5);
17867 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17868 tmp = fieldFromInstruction(insn, 20, 5);
17869 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17870 return S;
17871 case 72:
17872 tmp = fieldFromInstruction(insn, 7, 5);
17873 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17874 tmp = fieldFromInstruction(insn, 15, 5);
17875 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17876 tmp = fieldFromInstruction(insn, 20, 5);
17877 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17878 return S;
17879 case 73:
17880 tmp = fieldFromInstruction(insn, 7, 5);
17881 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17882 tmp = fieldFromInstruction(insn, 15, 5);
17883 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17884 tmp = fieldFromInstruction(insn, 20, 5);
17885 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17886 return S;
17887 case 74:
17888 tmp = fieldFromInstruction(insn, 7, 5);
17889 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17890 tmp = fieldFromInstruction(insn, 15, 5);
17891 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17892 tmp = fieldFromInstruction(insn, 12, 3);
17893 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17894 return S;
17895 case 75:
17896 tmp = fieldFromInstruction(insn, 7, 5);
17897 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17898 tmp = fieldFromInstruction(insn, 15, 5);
17899 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17900 tmp = fieldFromInstruction(insn, 12, 3);
17901 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17902 return S;
17903 case 76:
17904 tmp = fieldFromInstruction(insn, 7, 5);
17905 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17906 tmp = fieldFromInstruction(insn, 15, 5);
17907 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17908 tmp = fieldFromInstruction(insn, 12, 3);
17909 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17910 return S;
17911 case 77:
17912 tmp = fieldFromInstruction(insn, 7, 5);
17913 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17914 tmp = fieldFromInstruction(insn, 15, 5);
17915 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17916 tmp = fieldFromInstruction(insn, 12, 3);
17917 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17918 return S;
17919 case 78:
17920 tmp = fieldFromInstruction(insn, 7, 5);
17921 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17922 tmp = fieldFromInstruction(insn, 15, 5);
17923 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17924 tmp = fieldFromInstruction(insn, 12, 3);
17925 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17926 return S;
17927 case 79:
17928 tmp = fieldFromInstruction(insn, 7, 5);
17929 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17930 tmp = fieldFromInstruction(insn, 15, 5);
17931 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17932 tmp = fieldFromInstruction(insn, 12, 3);
17933 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17934 return S;
17935 case 80:
17936 tmp = fieldFromInstruction(insn, 7, 5);
17937 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17938 tmp = fieldFromInstruction(insn, 15, 5);
17939 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17940 tmp = fieldFromInstruction(insn, 12, 3);
17941 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17942 return S;
17943 case 81:
17944 tmp = fieldFromInstruction(insn, 7, 5);
17945 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17946 tmp = fieldFromInstruction(insn, 15, 5);
17947 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17948 tmp = fieldFromInstruction(insn, 12, 3);
17949 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17950 return S;
17951 case 82:
17952 tmp = fieldFromInstruction(insn, 7, 5);
17953 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17954 tmp = fieldFromInstruction(insn, 15, 5);
17955 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17956 tmp = fieldFromInstruction(insn, 12, 3);
17957 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17958 return S;
17959 case 83:
17960 tmp = fieldFromInstruction(insn, 7, 5);
17961 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17962 tmp = fieldFromInstruction(insn, 15, 5);
17963 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17964 tmp = fieldFromInstruction(insn, 12, 3);
17965 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17966 return S;
17967 case 84:
17968 tmp = fieldFromInstruction(insn, 7, 5);
17969 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17970 tmp = fieldFromInstruction(insn, 15, 5);
17971 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17972 tmp = fieldFromInstruction(insn, 12, 3);
17973 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17974 return S;
17975 case 85:
17976 tmp = fieldFromInstruction(insn, 7, 5);
17977 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17978 tmp = fieldFromInstruction(insn, 15, 5);
17979 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17980 tmp = fieldFromInstruction(insn, 12, 3);
17981 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17982 return S;
17983 case 86:
17984 tmp = fieldFromInstruction(insn, 7, 5);
17985 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17986 tmp = fieldFromInstruction(insn, 15, 5);
17987 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17988 tmp = fieldFromInstruction(insn, 12, 3);
17989 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17990 return S;
17991 case 87:
17992 tmp = fieldFromInstruction(insn, 7, 5);
17993 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17994 tmp = fieldFromInstruction(insn, 15, 5);
17995 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17996 tmp = fieldFromInstruction(insn, 12, 3);
17997 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
17998 return S;
17999 case 88:
18000 tmp = fieldFromInstruction(insn, 7, 5);
18001 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18002 tmp = fieldFromInstruction(insn, 15, 5);
18003 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18004 tmp = fieldFromInstruction(insn, 12, 3);
18005 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18006 return S;
18007 case 89:
18008 tmp = fieldFromInstruction(insn, 7, 5);
18009 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18010 tmp = fieldFromInstruction(insn, 15, 5);
18011 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18012 tmp = fieldFromInstruction(insn, 12, 3);
18013 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18014 return S;
18015 case 90:
18016 tmp = fieldFromInstruction(insn, 7, 5);
18017 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18018 tmp = fieldFromInstruction(insn, 15, 5);
18019 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18020 tmp = fieldFromInstruction(insn, 20, 5);
18021 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18022 return S;
18023 case 91:
18024 tmp = fieldFromInstruction(insn, 7, 5);
18025 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18026 tmp = fieldFromInstruction(insn, 15, 5);
18027 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18028 tmp = fieldFromInstruction(insn, 20, 5);
18029 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18030 return S;
18031 case 92:
18032 tmp = fieldFromInstruction(insn, 7, 5);
18033 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18034 tmp = fieldFromInstruction(insn, 15, 5);
18035 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18036 tmp = fieldFromInstruction(insn, 20, 5);
18037 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18038 return S;
18039 case 93:
18040 tmp = fieldFromInstruction(insn, 7, 5);
18041 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18042 tmp = fieldFromInstruction(insn, 15, 5);
18043 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18044 tmp = fieldFromInstruction(insn, 20, 5);
18045 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18046 return S;
18047 case 94:
18048 tmp = fieldFromInstruction(insn, 7, 5);
18049 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18050 tmp = fieldFromInstruction(insn, 15, 5);
18051 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18052 tmp = fieldFromInstruction(insn, 20, 5);
18053 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18054 return S;
18055 case 95:
18056 tmp = fieldFromInstruction(insn, 7, 5);
18057 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18058 tmp = fieldFromInstruction(insn, 15, 5);
18059 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18060 tmp = fieldFromInstruction(insn, 20, 5);
18061 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18062 return S;
18063 case 96:
18064 tmp = fieldFromInstruction(insn, 7, 5);
18065 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18066 tmp = fieldFromInstruction(insn, 15, 5);
18067 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18068 tmp = fieldFromInstruction(insn, 12, 3);
18069 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18070 return S;
18071 case 97:
18072 tmp = fieldFromInstruction(insn, 7, 5);
18073 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18074 tmp = fieldFromInstruction(insn, 15, 5);
18075 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18076 tmp = fieldFromInstruction(insn, 12, 3);
18077 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18078 return S;
18079 case 98:
18080 tmp = fieldFromInstruction(insn, 7, 5);
18081 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18082 tmp = fieldFromInstruction(insn, 15, 5);
18083 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18084 tmp = 0x1;
18085 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18086 return S;
18087 case 99:
18088 tmp = fieldFromInstruction(insn, 7, 5);
18089 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18090 tmp = fieldFromInstruction(insn, 15, 5);
18091 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18092 tmp = fieldFromInstruction(insn, 12, 3);
18093 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18094 return S;
18095 case 100:
18096 tmp = fieldFromInstruction(insn, 7, 5);
18097 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18098 tmp = fieldFromInstruction(insn, 15, 5);
18099 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18100 tmp = fieldFromInstruction(insn, 12, 3);
18101 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18102 return S;
18103 case 101:
18104 tmp = fieldFromInstruction(insn, 7, 5);
18105 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18106 tmp = fieldFromInstruction(insn, 15, 5);
18107 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18108 tmp = fieldFromInstruction(insn, 12, 3);
18109 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18110 return S;
18111 case 102:
18112 tmp = fieldFromInstruction(insn, 7, 5);
18113 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18114 tmp = fieldFromInstruction(insn, 15, 5);
18115 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18116 tmp = fieldFromInstruction(insn, 12, 3);
18117 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18118 return S;
18119 case 103:
18120 tmp = fieldFromInstruction(insn, 7, 5);
18121 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18122 tmp = fieldFromInstruction(insn, 15, 5);
18123 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18124 tmp = fieldFromInstruction(insn, 12, 3);
18125 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18126 return S;
18127 case 104:
18128 tmp = fieldFromInstruction(insn, 7, 5);
18129 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18130 tmp = fieldFromInstruction(insn, 15, 5);
18131 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18132 tmp = fieldFromInstruction(insn, 12, 3);
18133 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18134 return S;
18135 case 105:
18136 tmp = fieldFromInstruction(insn, 7, 5);
18137 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18138 tmp = fieldFromInstruction(insn, 15, 5);
18139 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18140 return S;
18141 case 106:
18142 tmp = fieldFromInstruction(insn, 7, 5);
18143 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18144 tmp = fieldFromInstruction(insn, 15, 5);
18145 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18146 return S;
18147 case 107:
18148 tmp = fieldFromInstruction(insn, 7, 5);
18149 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18150 tmp = fieldFromInstruction(insn, 15, 5);
18151 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18152 return S;
18153 case 108:
18154 tmp = fieldFromInstruction(insn, 7, 5);
18155 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18156 tmp = fieldFromInstruction(insn, 15, 5);
18157 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18158 return S;
18159 case 109:
18160 tmp = fieldFromInstruction(insn, 7, 5);
18161 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18162 tmp = fieldFromInstruction(insn, 15, 5);
18163 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18164 return S;
18165 case 110:
18166 tmp = fieldFromInstruction(insn, 7, 5);
18167 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18168 tmp = fieldFromInstruction(insn, 15, 5);
18169 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
18170 return S;
18171 case 111:
18172 tmp = fieldFromInstruction(insn, 7, 5);
18173 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18174 tmp = fieldFromInstruction(insn, 15, 5);
18175 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18176 return S;
18177 case 112:
18178 tmp = fieldFromInstruction(insn, 7, 5);
18179 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18180 tmp = fieldFromInstruction(insn, 15, 5);
18181 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
18182 return S;
18183 case 113:
18184 tmp = fieldFromInstruction(insn, 7, 5);
18185 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18186 tmp = fieldFromInstruction(insn, 15, 5);
18187 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18188 return S;
18189 case 114:
18190 tmp = fieldFromInstruction(insn, 7, 5);
18191 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18192 tmp = fieldFromInstruction(insn, 15, 5);
18193 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
18194 return S;
18195 case 115:
18196 tmp = fieldFromInstruction(insn, 7, 5);
18197 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18198 tmp = fieldFromInstruction(insn, 15, 5);
18199 MI.addOperand(Op: MCOperand::createImm(Val: tmp));
18200 return S;
18201 case 116:
18202 tmp = fieldFromInstruction(insn, 7, 5);
18203 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18204 tmp = fieldFromInstruction(insn, 20, 5);
18205 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18206 tmp = fieldFromInstruction(insn, 15, 5);
18207 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18208 tmp = fieldFromInstruction(insn, 25, 1);
18209 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18210 return S;
18211 case 117:
18212 tmp = fieldFromInstruction(insn, 7, 5);
18213 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18214 tmp = fieldFromInstruction(insn, 20, 5);
18215 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18216 tmp = fieldFromInstruction(insn, 15, 5);
18217 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18218 tmp = 0x0;
18219 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18220 return S;
18221 case 118:
18222 tmp = fieldFromInstruction(insn, 7, 5);
18223 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18224 tmp = fieldFromInstruction(insn, 20, 5);
18225 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18226 tmp = fieldFromInstruction(insn, 15, 5);
18227 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18228 return S;
18229 case 119:
18230 tmp = fieldFromInstruction(insn, 7, 5);
18231 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18232 tmp = fieldFromInstruction(insn, 15, 5);
18233 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18234 return S;
18235 case 120:
18236 tmp = fieldFromInstruction(insn, 7, 5);
18237 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18238 tmp = fieldFromInstruction(insn, 7, 5);
18239 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18240 tmp = fieldFromInstruction(insn, 15, 5);
18241 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18242 tmp = fieldFromInstruction(insn, 20, 5);
18243 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18244 return S;
18245 case 121:
18246 tmp = fieldFromInstruction(insn, 7, 5);
18247 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18248 tmp = fieldFromInstruction(insn, 7, 5);
18249 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18250 tmp = fieldFromInstruction(insn, 15, 5);
18251 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18252 tmp = fieldFromInstruction(insn, 20, 5);
18253 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18254 tmp = 0x0;
18255 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18256 return S;
18257 case 122:
18258 tmp = fieldFromInstruction(insn, 7, 5);
18259 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18260 tmp = fieldFromInstruction(insn, 7, 5);
18261 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18262 tmp = fieldFromInstruction(insn, 20, 5);
18263 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18264 tmp = fieldFromInstruction(insn, 15, 5);
18265 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18266 tmp = fieldFromInstruction(insn, 25, 1);
18267 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18268 return S;
18269 case 123:
18270 tmp = fieldFromInstruction(insn, 7, 5);
18271 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18272 tmp = fieldFromInstruction(insn, 20, 5);
18273 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18274 return S;
18275 case 124:
18276 tmp = fieldFromInstruction(insn, 7, 5);
18277 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18278 tmp = fieldFromInstruction(insn, 20, 5);
18279 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18280 tmp = fieldFromInstruction(insn, 25, 1);
18281 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18282 return S;
18283 case 125:
18284 tmp = fieldFromInstruction(insn, 7, 5);
18285 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18286 tmp = fieldFromInstruction(insn, 7, 5);
18287 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18288 tmp = fieldFromInstruction(insn, 15, 5);
18289 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18290 tmp = fieldFromInstruction(insn, 20, 5);
18291 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18292 tmp = fieldFromInstruction(insn, 25, 1);
18293 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18294 return S;
18295 case 126:
18296 tmp = fieldFromInstruction(insn, 7, 5);
18297 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18298 tmp = fieldFromInstruction(insn, 20, 5);
18299 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18300 return S;
18301 case 127:
18302 tmp = fieldFromInstruction(insn, 7, 5);
18303 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18304 tmp = fieldFromInstruction(insn, 20, 5);
18305 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18306 tmp = fieldFromInstruction(insn, 25, 1);
18307 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18308 return S;
18309 case 128:
18310 tmp = fieldFromInstruction(insn, 7, 5);
18311 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18312 tmp = fieldFromInstruction(insn, 25, 1);
18313 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18314 return S;
18315 case 129:
18316 tmp = fieldFromInstruction(insn, 7, 5);
18317 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18318 tmp = fieldFromInstruction(insn, 20, 5);
18319 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18320 tmp = fieldFromInstruction(insn, 15, 5);
18321 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18322 tmp = fieldFromInstruction(insn, 25, 1);
18323 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18324 return S;
18325 case 130:
18326 tmp = fieldFromInstruction(insn, 7, 5);
18327 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18328 tmp = fieldFromInstruction(insn, 20, 5);
18329 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18330 tmp = fieldFromInstruction(insn, 15, 5);
18331 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18332 tmp = fieldFromInstruction(insn, 25, 1);
18333 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18334 return S;
18335 case 131:
18336 tmp = fieldFromInstruction(insn, 7, 5);
18337 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18338 tmp = fieldFromInstruction(insn, 20, 5);
18339 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18340 tmp = fieldFromInstruction(insn, 15, 5);
18341 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18342 tmp = 0x0;
18343 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18344 return S;
18345 case 132:
18346 tmp = fieldFromInstruction(insn, 7, 5);
18347 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18348 tmp = fieldFromInstruction(insn, 20, 5);
18349 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18350 tmp = fieldFromInstruction(insn, 15, 5);
18351 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18352 return S;
18353 case 133:
18354 tmp = fieldFromInstruction(insn, 7, 5);
18355 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18356 tmp = fieldFromInstruction(insn, 20, 5);
18357 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18358 tmp = 0x0;
18359 tmp |= fieldFromInstruction(insn, 15, 5);
18360 tmp |= fieldFromInstruction(insn, 26, 1) << 5;
18361 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18362 tmp = fieldFromInstruction(insn, 25, 1);
18363 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18364 return S;
18365 case 134:
18366 tmp = fieldFromInstruction(insn, 7, 5);
18367 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18368 tmp = fieldFromInstruction(insn, 15, 5);
18369 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18370 return S;
18371 case 135:
18372 tmp = fieldFromInstruction(insn, 7, 5);
18373 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18374 tmp = fieldFromInstruction(insn, 20, 5);
18375 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18376 return S;
18377 case 136:
18378 tmp = fieldFromInstruction(insn, 7, 5);
18379 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18380 tmp = fieldFromInstruction(insn, 20, 5);
18381 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18382 return S;
18383 case 137:
18384 tmp = fieldFromInstruction(insn, 7, 5);
18385 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM4RegClassID, 32, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18386 tmp = fieldFromInstruction(insn, 20, 5);
18387 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM4RegClassID, 32, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18388 return S;
18389 case 138:
18390 tmp = fieldFromInstruction(insn, 7, 5);
18391 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18392 tmp = fieldFromInstruction(insn, 20, 5);
18393 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18394 return S;
18395 case 139:
18396 tmp = fieldFromInstruction(insn, 7, 5);
18397 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18398 tmp = fieldFromInstruction(insn, 20, 5);
18399 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18400 tmp = fieldFromInstruction(insn, 15, 5);
18401 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18402 tmp = fieldFromInstruction(insn, 25, 1);
18403 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18404 return S;
18405 case 140:
18406 tmp = fieldFromInstruction(insn, 7, 5);
18407 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18408 tmp = fieldFromInstruction(insn, 20, 5);
18409 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18410 tmp = fieldFromInstruction(insn, 15, 5);
18411 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18412 tmp = 0x0;
18413 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18414 return S;
18415 case 141:
18416 tmp = fieldFromInstruction(insn, 7, 5);
18417 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18418 tmp = fieldFromInstruction(insn, 20, 5);
18419 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18420 tmp = fieldFromInstruction(insn, 15, 5);
18421 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18422 return S;
18423 case 142:
18424 tmp = fieldFromInstruction(insn, 7, 5);
18425 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18426 tmp = fieldFromInstruction(insn, 7, 5);
18427 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18428 tmp = fieldFromInstruction(insn, 20, 5);
18429 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18430 tmp = fieldFromInstruction(insn, 15, 5);
18431 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18432 tmp = fieldFromInstruction(insn, 25, 1);
18433 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18434 return S;
18435 case 143:
18436 tmp = fieldFromInstruction(insn, 7, 5);
18437 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18438 tmp = fieldFromInstruction(insn, 20, 5);
18439 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18440 tmp = fieldFromInstruction(insn, 15, 5);
18441 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18442 tmp = fieldFromInstruction(insn, 25, 1);
18443 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18444 return S;
18445 case 144:
18446 tmp = fieldFromInstruction(insn, 7, 5);
18447 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18448 tmp = fieldFromInstruction(insn, 7, 5);
18449 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18450 tmp = fieldFromInstruction(insn, 15, 5);
18451 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18452 return S;
18453 case 145:
18454 tmp = fieldFromInstruction(insn, 7, 5);
18455 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18456 tmp = fieldFromInstruction(insn, 20, 5);
18457 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18458 tmp = fieldFromInstruction(insn, 15, 5);
18459 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18460 tmp = 0x0;
18461 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18462 return S;
18463 case 146:
18464 tmp = fieldFromInstruction(insn, 7, 5);
18465 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18466 tmp = fieldFromInstruction(insn, 15, 5);
18467 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18468 return S;
18469 case 147:
18470 tmp = fieldFromInstruction(insn, 7, 5);
18471 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18472 tmp = fieldFromInstruction(insn, 7, 5);
18473 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18474 tmp = fieldFromInstruction(insn, 15, 5);
18475 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18476 tmp = fieldFromInstruction(insn, 20, 5);
18477 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18478 tmp = fieldFromInstruction(insn, 25, 1);
18479 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18480 return S;
18481 case 148:
18482 tmp = fieldFromInstruction(insn, 7, 5);
18483 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18484 tmp = fieldFromInstruction(insn, 7, 5);
18485 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18486 tmp = fieldFromInstruction(insn, 15, 5);
18487 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18488 return S;
18489 case 149:
18490 tmp = fieldFromInstruction(insn, 7, 5);
18491 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18492 tmp = fieldFromInstruction(insn, 7, 5);
18493 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18494 tmp = fieldFromInstruction(insn, 15, 5);
18495 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18496 tmp = fieldFromInstruction(insn, 20, 5);
18497 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18498 tmp = fieldFromInstruction(insn, 25, 1);
18499 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18500 return S;
18501 case 150:
18502 tmp = fieldFromInstruction(insn, 7, 5);
18503 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18504 tmp = fieldFromInstruction(insn, 15, 5);
18505 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18506 tmp = fieldFromInstruction(insn, 20, 11);
18507 if (!Check(S, decodeUImmOperand<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18508 return S;
18509 case 151:
18510 tmp = fieldFromInstruction(insn, 7, 5);
18511 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18512 tmp = fieldFromInstruction(insn, 15, 5);
18513 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18514 tmp = fieldFromInstruction(insn, 20, 10);
18515 if (!Check(S, decodeUImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18516 return S;
18517 case 152:
18518 tmp = fieldFromInstruction(insn, 15, 5);
18519 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18520 tmp = fieldFromInstruction(insn, 20, 5);
18521 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18522 tmp = 0x0;
18523 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
18524 tmp |= fieldFromInstruction(insn, 8, 4);
18525 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
18526 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
18527 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18528 return S;
18529 case 153:
18530 tmp = fieldFromInstruction(insn, 15, 5);
18531 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18532 tmp = fieldFromInstruction(insn, 20, 5);
18533 if (!Check(S, decodeImmZibiOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18534 tmp = 0x0;
18535 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
18536 tmp |= fieldFromInstruction(insn, 8, 4);
18537 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
18538 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
18539 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18540 return S;
18541 case 154:
18542 tmp = fieldFromInstruction(insn, 7, 5);
18543 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18544 tmp = 0x0;
18545 tmp |= fieldFromInstruction(insn, 12, 8) << 11;
18546 tmp |= fieldFromInstruction(insn, 20, 1) << 10;
18547 tmp |= fieldFromInstruction(insn, 21, 10);
18548 tmp |= fieldFromInstruction(insn, 31, 1) << 19;
18549 if (!Check(S, decodeSImmOperandAndLslN<21, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18550 return S;
18551 case 155:
18552 tmp = fieldFromInstruction(insn, 7, 5);
18553 if (!Check(S, DecodeSingleRegister<RISCV::X2, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18554 tmp = fieldFromInstruction(insn, 15, 5);
18555 if (!Check(S, DecodeSingleRegister<RISCV::X2, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18556 return S;
18557 case 156:
18558 tmp = fieldFromInstruction(insn, 15, 5);
18559 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18560 tmp = fieldFromInstruction(insn, 20, 5);
18561 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18562 return S;
18563 case 157:
18564 tmp = fieldFromInstruction(insn, 7, 5);
18565 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18566 tmp = fieldFromInstruction(insn, 20, 12);
18567 if (!Check(S, decodeUImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18568 tmp = fieldFromInstruction(insn, 15, 5);
18569 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18570 return S;
18571 case 158:
18572 tmp = fieldFromInstruction(insn, 15, 5);
18573 if (!Check(S, DecodeGPRX1X5RegisterClass(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; }
18574 return S;
18575 case 159:
18576 tmp = fieldFromInstruction(insn, 7, 5);
18577 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; }
18578 return S;
18579 case 160:
18580 tmp = fieldFromInstruction(insn, 20, 5);
18581 if (!Check(S, DecodeGPRX1X5RegisterClass(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; }
18582 return S;
18583 case 161:
18584 tmp = fieldFromInstruction(insn, 7, 5);
18585 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18586 tmp = fieldFromInstruction(insn, 20, 12);
18587 if (!Check(S, decodeUImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18588 tmp = fieldFromInstruction(insn, 15, 5);
18589 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18590 return S;
18591 case 162:
18592 tmp = fieldFromInstruction(insn, 7, 5);
18593 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18594 tmp = fieldFromInstruction(insn, 20, 5);
18595 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18596 tmp = fieldFromInstruction(insn, 15, 5);
18597 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18598 return S;
18599 case 163:
18600 tmp = fieldFromInstruction(insn, 7, 5);
18601 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18602 tmp = fieldFromInstruction(insn, 7, 5);
18603 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18604 tmp = fieldFromInstruction(insn, 20, 5);
18605 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18606 tmp = fieldFromInstruction(insn, 15, 5);
18607 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18608 return S;
18609 case 164:
18610 tmp = fieldFromInstruction(insn, 7, 5);
18611 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18612 tmp = fieldFromInstruction(insn, 7, 5);
18613 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18614 tmp = fieldFromInstruction(insn, 20, 5);
18615 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18616 return S;
18617 case 165:
18618 tmp = fieldFromInstruction(insn, 7, 5);
18619 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18620 tmp = fieldFromInstruction(insn, 7, 5);
18621 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18622 tmp = fieldFromInstruction(insn, 20, 5);
18623 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18624 tmp = fieldFromInstruction(insn, 15, 5);
18625 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18626 return S;
18627 case 166:
18628 tmp = fieldFromInstruction(insn, 7, 5);
18629 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18630 tmp = fieldFromInstruction(insn, 7, 5);
18631 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18632 tmp = fieldFromInstruction(insn, 23, 2) << 3;
18633 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM8RegClassID, 32, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18634 tmp = fieldFromInstruction(insn, 15, 5);
18635 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18636 tmp = fieldFromInstruction(insn, 20, 3) << 3;
18637 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18638 tmp = fieldFromInstruction(insn, 25, 1);
18639 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18640 return S;
18641 case 167:
18642 tmp = fieldFromInstruction(insn, 7, 5);
18643 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18644 tmp = fieldFromInstruction(insn, 15, 5);
18645 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18646 tmp = fieldFromInstruction(insn, 20, 5);
18647 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18648 return S;
18649 case 168:
18650 tmp = fieldFromInstruction(insn, 7, 5);
18651 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18652 tmp = fieldFromInstruction(insn, 15, 5);
18653 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18654 return S;
18655 case 169:
18656 tmp = fieldFromInstruction(insn, 7, 5);
18657 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18658 tmp = fieldFromInstruction(insn, 15, 5);
18659 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18660 tmp = fieldFromInstruction(insn, 20, 5);
18661 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18662 return S;
18663 case 170:
18664 tmp = fieldFromInstruction(insn, 7, 5);
18665 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18666 tmp = fieldFromInstruction(insn, 15, 5);
18667 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18668 tmp = fieldFromInstruction(insn, 20, 5);
18669 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18670 return S;
18671 case 171:
18672 tmp = fieldFromInstruction(insn, 7, 5);
18673 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18674 tmp = fieldFromInstruction(insn, 15, 5);
18675 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18676 tmp = fieldFromInstruction(insn, 20, 5);
18677 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18678 return S;
18679 case 172:
18680 tmp = fieldFromInstruction(insn, 7, 5);
18681 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18682 tmp = fieldFromInstruction(insn, 15, 5);
18683 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18684 tmp = fieldFromInstruction(insn, 20, 5);
18685 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18686 return S;
18687 case 173:
18688 tmp = fieldFromInstruction(insn, 7, 5);
18689 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18690 tmp = fieldFromInstruction(insn, 20, 5);
18691 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18692 return S;
18693 case 174:
18694 tmp = fieldFromInstruction(insn, 7, 5);
18695 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18696 tmp = fieldFromInstruction(insn, 15, 5);
18697 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18698 return S;
18699 case 175:
18700 tmp = fieldFromInstruction(insn, 7, 5);
18701 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18702 tmp = fieldFromInstruction(insn, 15, 5);
18703 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18704 tmp = fieldFromInstruction(insn, 20, 12);
18705 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18706 return S;
18707 case 176:
18708 tmp = fieldFromInstruction(insn, 7, 5);
18709 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18710 tmp = fieldFromInstruction(insn, 15, 5);
18711 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_Y, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18712 tmp = fieldFromInstruction(insn, 20, 9);
18713 if (!Check(S, DecodeYBNDSWImm(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18714 return S;
18715 case 177:
18716 tmp = fieldFromInstruction(insn, 7, 5);
18717 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18718 tmp = fieldFromInstruction(insn, 15, 5);
18719 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18720 tmp = fieldFromInstruction(insn, 20, 12);
18721 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18722 return S;
18723 case 178:
18724 tmp = fieldFromInstruction(insn, 20, 5);
18725 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18726 tmp = fieldFromInstruction(insn, 15, 5);
18727 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18728 tmp = 0x0;
18729 tmp |= fieldFromInstruction(insn, 7, 5);
18730 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
18731 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18732 return S;
18733 case 179:
18734 tmp = fieldFromInstruction(insn, 7, 5);
18735 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18736 tmp = fieldFromInstruction(insn, 20, 12);
18737 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18738 tmp = fieldFromInstruction(insn, 15, 5);
18739 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18740 return S;
18741 case 180:
18742 tmp = fieldFromInstruction(insn, 7, 5);
18743 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18744 tmp = fieldFromInstruction(insn, 15, 5);
18745 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18746 tmp = fieldFromInstruction(insn, 20, 5);
18747 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18748 return S;
18749 case 181:
18750 tmp = fieldFromInstruction(insn, 7, 5);
18751 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18752 tmp = fieldFromInstruction(insn, 15, 5);
18753 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18754 tmp = fieldFromInstruction(insn, 20, 5);
18755 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18756 return S;
18757 case 182:
18758 tmp = fieldFromInstruction(insn, 7, 5);
18759 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18760 tmp = fieldFromInstruction(insn, 15, 5);
18761 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18762 return S;
18763 case 183:
18764 tmp = fieldFromInstruction(insn, 20, 5);
18765 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18766 tmp = 0x0;
18767 tmp |= fieldFromInstruction(insn, 7, 5);
18768 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
18769 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18770 tmp = fieldFromInstruction(insn, 15, 5);
18771 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18772 return S;
18773 case 184:
18774 tmp = fieldFromInstruction(insn, 7, 5);
18775 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18776 tmp = fieldFromInstruction(insn, 12, 20);
18777 if (!Check(S, decodeUImm20Operand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18778 return S;
18779 case 185:
18780 tmp = fieldFromInstruction(insn, 7, 5);
18781 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18782 tmp = fieldFromInstruction(insn, 15, 5);
18783 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18784 tmp = 0x0;
18785 tmp |= fieldFromInstruction(insn, 20, 5);
18786 tmp |= fieldFromInstruction(insn, 27, 5) << 5;
18787 if (!Check(S, decodeSImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18788 return S;
18789 case 186:
18790 tmp = fieldFromInstruction(insn, 7, 5);
18791 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18792 tmp = fieldFromInstruction(insn, 15, 5);
18793 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18794 tmp = fieldFromInstruction(insn, 20, 5);
18795 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18796 tmp = fieldFromInstruction(insn, 27, 5);
18797 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18798 return S;
18799 case 187:
18800 tmp = fieldFromInstruction(insn, 7, 5);
18801 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18802 tmp = fieldFromInstruction(insn, 15, 5);
18803 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18804 tmp = fieldFromInstruction(insn, 20, 5);
18805 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18806 tmp = fieldFromInstruction(insn, 27, 5);
18807 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18808 tmp = fieldFromInstruction(insn, 12, 3);
18809 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18810 return S;
18811 case 188:
18812 tmp = fieldFromInstruction(insn, 7, 5);
18813 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18814 tmp = fieldFromInstruction(insn, 15, 5);
18815 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18816 tmp = fieldFromInstruction(insn, 20, 5);
18817 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18818 return S;
18819 case 189:
18820 tmp = fieldFromInstruction(insn, 7, 5);
18821 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18822 tmp = fieldFromInstruction(insn, 15, 5);
18823 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18824 tmp = fieldFromInstruction(insn, 20, 5);
18825 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18826 tmp = fieldFromInstruction(insn, 12, 3);
18827 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18828 return S;
18829 case 190:
18830 tmp = fieldFromInstruction(insn, 7, 5);
18831 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18832 tmp = fieldFromInstruction(insn, 15, 5);
18833 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18834 return S;
18835 case 191:
18836 tmp = fieldFromInstruction(insn, 7, 5);
18837 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18838 tmp = fieldFromInstruction(insn, 15, 5);
18839 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18840 tmp = fieldFromInstruction(insn, 20, 5);
18841 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18842 return S;
18843 case 192:
18844 tmp = fieldFromInstruction(insn, 7, 5);
18845 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18846 tmp = fieldFromInstruction(insn, 15, 5);
18847 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18848 tmp = fieldFromInstruction(insn, 20, 5);
18849 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18850 return S;
18851 case 193:
18852 tmp = fieldFromInstruction(insn, 7, 5);
18853 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18854 tmp = fieldFromInstruction(insn, 15, 3);
18855 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18856 return S;
18857 case 194:
18858 tmp = fieldFromInstruction(insn, 7, 3);
18859 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18860 tmp = fieldFromInstruction(insn, 15, 5);
18861 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18862 tmp = 0x0;
18863 tmp |= fieldFromInstruction(insn, 12, 3);
18864 tmp |= fieldFromInstruction(insn, 20, 5) << 3;
18865 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18866 return S;
18867 case 195:
18868 tmp = fieldFromInstruction(insn, 7, 5);
18869 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18870 tmp = fieldFromInstruction(insn, 15, 5);
18871 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18872 tmp = fieldFromInstruction(insn, 12, 3);
18873 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18874 return S;
18875 case 196:
18876 tmp = fieldFromInstruction(insn, 7, 5);
18877 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18878 tmp = fieldFromInstruction(insn, 15, 3);
18879 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18880 tmp = fieldFromInstruction(insn, 20, 3);
18881 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18882 tmp = 0x0;
18883 tmp |= fieldFromInstruction(insn, 18, 2);
18884 tmp |= fieldFromInstruction(insn, 23, 2) << 2;
18885 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18886 return S;
18887 case 197:
18888 tmp = fieldFromInstruction(insn, 7, 3);
18889 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18890 tmp = fieldFromInstruction(insn, 15, 3);
18891 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18892 return S;
18893 case 198:
18894 tmp = fieldFromInstruction(insn, 7, 3);
18895 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18896 tmp = fieldFromInstruction(insn, 15, 3);
18897 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18898 tmp = fieldFromInstruction(insn, 20, 3);
18899 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18900 return S;
18901 case 199:
18902 tmp = fieldFromInstruction(insn, 7, 5);
18903 if (!Check(S, DecodeSimpleRegisterClass<RISCV::M0, 8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18904 tmp = fieldFromInstruction(insn, 15, 5);
18905 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18906 return S;
18907 case 200:
18908 tmp = fieldFromInstruction(insn, 7, 5);
18909 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18910 return S;
18911 case 201:
18912 tmp = fieldFromInstruction(insn, 7, 5);
18913 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18914 tmp = fieldFromInstruction(insn, 15, 5);
18915 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18916 tmp = fieldFromInstruction(insn, 20, 3);
18917 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18918 return S;
18919 case 202:
18920 tmp = fieldFromInstruction(insn, 7, 5);
18921 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18922 tmp = fieldFromInstruction(insn, 15, 5);
18923 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_Q2, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18924 tmp = 0x0;
18925 tmp |= fieldFromInstruction(insn, 12, 3);
18926 tmp |= fieldFromInstruction(insn, 20, 5) << 3;
18927 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18928 return S;
18929 case 203:
18930 tmp = fieldFromInstruction(insn, 7, 5);
18931 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18932 tmp = 0x0;
18933 tmp |= fieldFromInstruction(insn, 14, 1);
18934 tmp |= fieldFromInstruction(insn, 15, 2) << 15;
18935 tmp |= fieldFromInstruction(insn, 17, 3) << 12;
18936 tmp |= fieldFromInstruction(insn, 20, 1) << 11;
18937 tmp |= fieldFromInstruction(insn, 21, 10) << 1;
18938 tmp |= fieldFromInstruction(insn, 31, 1) << 17;
18939 if (!Check(S, decodeSImmOperand<18>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18940 return S;
18941 case 204:
18942 tmp = fieldFromInstruction(insn, 20, 5);
18943 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18944 tmp = 0x0;
18945 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
18946 tmp |= fieldFromInstruction(insn, 8, 4);
18947 tmp |= fieldFromInstruction(insn, 15, 2) << 14;
18948 tmp |= fieldFromInstruction(insn, 17, 3) << 11;
18949 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
18950 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18951 if (!Check(S, decodeSImmOperandAndLslN<18, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18952 return S;
18953 case 205:
18954 tmp = fieldFromInstruction(insn, 20, 5);
18955 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18956 tmp = 0x0;
18957 tmp |= fieldFromInstruction(insn, 7, 1) << 9;
18958 tmp |= fieldFromInstruction(insn, 8, 1) << 15;
18959 tmp |= fieldFromInstruction(insn, 9, 3);
18960 tmp |= fieldFromInstruction(insn, 15, 2) << 13;
18961 tmp |= fieldFromInstruction(insn, 17, 3) << 10;
18962 tmp |= fieldFromInstruction(insn, 25, 6) << 3;
18963 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18964 if (!Check(S, decodeSImmOperandAndLslN<19, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18965 return S;
18966 case 206:
18967 tmp = fieldFromInstruction(insn, 7, 5);
18968 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18969 tmp = fieldFromInstruction(insn, 20, 5);
18970 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18971 return S;
18972 case 207:
18973 tmp = fieldFromInstruction(insn, 7, 5);
18974 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_H, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18975 tmp = fieldFromInstruction(insn, 20, 5);
18976 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18977 return S;
18978 case 208:
18979 tmp = fieldFromInstruction(insn, 7, 5);
18980 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18981 tmp = fieldFromInstruction(insn, 15, 5);
18982 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18983 tmp = fieldFromInstruction(insn, 20, 5);
18984 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18985 tmp = fieldFromInstruction(insn, 25, 1);
18986 if (!Check(S, decodeVMaskReg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18987 return S;
18988 case 209:
18989 tmp = fieldFromInstruction(insn, 7, 5);
18990 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18991 tmp = 0x0;
18992 tmp |= fieldFromInstruction(insn, 15, 2) << 14;
18993 tmp |= fieldFromInstruction(insn, 17, 3) << 11;
18994 tmp |= fieldFromInstruction(insn, 20, 1) << 10;
18995 tmp |= fieldFromInstruction(insn, 21, 10);
18996 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
18997 if (!Check(S, decodeSImmOperandAndLslN<18, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
18998 return S;
18999 case 210:
19000 tmp = fieldFromInstruction(insn, 15, 5);
19001 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19002 tmp = 0x0;
19003 tmp |= fieldFromInstruction(insn, 7, 1) << 5;
19004 tmp |= fieldFromInstruction(insn, 20, 5);
19005 tmp |= fieldFromInstruction(insn, 30, 1) << 6;
19006 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19007 tmp = 0x0;
19008 tmp |= fieldFromInstruction(insn, 8, 4);
19009 tmp |= fieldFromInstruction(insn, 25, 5) << 4;
19010 tmp |= fieldFromInstruction(insn, 31, 1) << 9;
19011 if (!Check(S, decodeSImmOperandAndLslN<11, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19012 return S;
19013 case 211:
19014 tmp = fieldFromInstruction(insn, 7, 5);
19015 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19016 tmp = 0x0;
19017 tmp |= fieldFromInstruction(insn, 15, 2) << 13;
19018 tmp |= fieldFromInstruction(insn, 17, 3) << 10;
19019 tmp |= fieldFromInstruction(insn, 20, 1) << 9;
19020 tmp |= fieldFromInstruction(insn, 21, 1) << 15;
19021 tmp |= fieldFromInstruction(insn, 22, 9);
19022 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
19023 if (!Check(S, decodeSImmOperandAndLslN<19, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19024 return S;
19025 case 212:
19026 tmp = fieldFromInstruction(insn, 7, 5);
19027 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19028 tmp = fieldFromInstruction(insn, 15, 5);
19029 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19030 tmp = fieldFromInstruction(insn, 26, 6);
19031 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19032 tmp = fieldFromInstruction(insn, 20, 6);
19033 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19034 return S;
19035 case 213:
19036 tmp = fieldFromInstruction(insn, 20, 5);
19037 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19038 tmp = 0x0;
19039 tmp |= fieldFromInstruction(insn, 7, 1) << 11;
19040 tmp |= fieldFromInstruction(insn, 8, 4) << 1;
19041 tmp |= fieldFromInstruction(insn, 14, 1);
19042 tmp |= fieldFromInstruction(insn, 15, 2) << 15;
19043 tmp |= fieldFromInstruction(insn, 17, 3) << 12;
19044 tmp |= fieldFromInstruction(insn, 25, 6) << 5;
19045 tmp |= fieldFromInstruction(insn, 31, 1) << 17;
19046 if (!Check(S, decodeSImmOperand<18>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19047 return S;
19048 case 214:
19049 tmp = fieldFromInstruction(insn, 7, 5);
19050 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19051 tmp = 0x0;
19052 tmp |= fieldFromInstruction(insn, 15, 2) << 12;
19053 tmp |= fieldFromInstruction(insn, 17, 3) << 9;
19054 tmp |= fieldFromInstruction(insn, 20, 1) << 8;
19055 tmp |= fieldFromInstruction(insn, 21, 2) << 14;
19056 tmp |= fieldFromInstruction(insn, 23, 8);
19057 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
19058 if (!Check(S, decodeSImmOperandAndLslN<20, 3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19059 return S;
19060 case 215:
19061 tmp = fieldFromInstruction(insn, 20, 5);
19062 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19063 tmp = 0x0;
19064 tmp |= fieldFromInstruction(insn, 7, 1) << 8;
19065 tmp |= fieldFromInstruction(insn, 8, 2) << 14;
19066 tmp |= fieldFromInstruction(insn, 10, 2);
19067 tmp |= fieldFromInstruction(insn, 15, 2) << 12;
19068 tmp |= fieldFromInstruction(insn, 17, 3) << 9;
19069 tmp |= fieldFromInstruction(insn, 25, 6) << 2;
19070 tmp |= fieldFromInstruction(insn, 31, 1) << 16;
19071 if (!Check(S, decodeSImmOperandAndLslN<20, 3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19072 return S;
19073 case 216:
19074 tmp = fieldFromInstruction(insn, 15, 5);
19075 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19076 tmp = 0x0;
19077 tmp |= fieldFromInstruction(insn, 7, 1) << 5;
19078 tmp |= fieldFromInstruction(insn, 20, 5);
19079 if (!Check(S, decodeUImmLog2XLenOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19080 tmp = 0x0;
19081 tmp |= fieldFromInstruction(insn, 8, 4);
19082 tmp |= fieldFromInstruction(insn, 25, 5) << 4;
19083 tmp |= fieldFromInstruction(insn, 31, 1) << 9;
19084 if (!Check(S, decodeSImmOperandAndLslN<11, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19085 return S;
19086 case 217:
19087 tmp = fieldFromInstruction(insn, 7, 5);
19088 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19089 tmp = fieldFromInstruction(insn, 15, 5);
19090 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19091 tmp = fieldFromInstruction(insn, 15, 5);
19092 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19093 tmp = fieldFromInstruction(insn, 20, 12);
19094 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19095 return S;
19096 case 218:
19097 tmp = fieldFromInstruction(insn, 15, 5);
19098 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19099 tmp = fieldFromInstruction(insn, 20, 5);
19100 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19101 tmp = fieldFromInstruction(insn, 15, 5);
19102 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19103 tmp = 0x0;
19104 tmp |= fieldFromInstruction(insn, 7, 5);
19105 tmp |= fieldFromInstruction(insn, 25, 7) << 5;
19106 if (!Check(S, decodeSImmOperand<12>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19107 return S;
19108 case 219:
19109 tmp = fieldFromInstruction(insn, 7, 5);
19110 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19111 tmp = fieldFromInstruction(insn, 15, 5);
19112 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19113 tmp = fieldFromInstruction(insn, 25, 5);
19114 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19115 tmp = fieldFromInstruction(insn, 20, 5);
19116 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19117 return S;
19118 case 220:
19119 tmp = fieldFromInstruction(insn, 7, 5);
19120 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19121 tmp = fieldFromInstruction(insn, 7, 5);
19122 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19123 tmp = fieldFromInstruction(insn, 15, 5);
19124 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19125 tmp = fieldFromInstruction(insn, 25, 5);
19126 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19127 tmp = fieldFromInstruction(insn, 20, 5);
19128 if (!Check(S, decodeCVInsertIs2Operand(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; }
19129 return S;
19130 case 221:
19131 tmp = fieldFromInstruction(insn, 7, 5);
19132 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19133 tmp = fieldFromInstruction(insn, 15, 5);
19134 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19135 tmp = 0x0;
19136 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19137 tmp |= fieldFromInstruction(insn, 25, 1);
19138 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19139 return S;
19140 case 222:
19141 tmp = fieldFromInstruction(insn, 7, 5);
19142 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19143 tmp = fieldFromInstruction(insn, 15, 5);
19144 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19145 tmp = fieldFromInstruction(insn, 25, 5);
19146 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19147 tmp = fieldFromInstruction(insn, 20, 5);
19148 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19149 return S;
19150 case 223:
19151 tmp = fieldFromInstruction(insn, 7, 5);
19152 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19153 tmp = fieldFromInstruction(insn, 15, 5);
19154 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19155 tmp = 0x0;
19156 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19157 tmp |= fieldFromInstruction(insn, 25, 1);
19158 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19159 return S;
19160 case 224:
19161 tmp = fieldFromInstruction(insn, 7, 5);
19162 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19163 tmp = fieldFromInstruction(insn, 15, 5);
19164 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19165 tmp = fieldFromInstruction(insn, 20, 5);
19166 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19167 tmp = fieldFromInstruction(insn, 25, 5);
19168 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19169 return S;
19170 case 225:
19171 tmp = fieldFromInstruction(insn, 7, 5);
19172 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19173 tmp = fieldFromInstruction(insn, 15, 5);
19174 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19175 tmp = fieldFromInstruction(insn, 15, 5);
19176 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19177 tmp = fieldFromInstruction(insn, 20, 5);
19178 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19179 return S;
19180 case 226:
19181 tmp = fieldFromInstruction(insn, 15, 5);
19182 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19183 tmp = fieldFromInstruction(insn, 20, 5);
19184 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19185 tmp = fieldFromInstruction(insn, 15, 5);
19186 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19187 tmp = fieldFromInstruction(insn, 7, 5);
19188 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19189 return S;
19190 case 227:
19191 tmp = fieldFromInstruction(insn, 20, 5);
19192 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19193 tmp = fieldFromInstruction(insn, 15, 5);
19194 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19195 tmp = fieldFromInstruction(insn, 7, 5);
19196 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19197 return S;
19198 case 228:
19199 tmp = fieldFromInstruction(insn, 7, 5);
19200 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19201 tmp = fieldFromInstruction(insn, 7, 5);
19202 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19203 tmp = fieldFromInstruction(insn, 15, 5);
19204 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19205 tmp = 0x0;
19206 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19207 tmp |= fieldFromInstruction(insn, 25, 1);
19208 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19209 return S;
19210 case 229:
19211 tmp = fieldFromInstruction(insn, 7, 5);
19212 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19213 tmp = fieldFromInstruction(insn, 7, 5);
19214 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19215 tmp = fieldFromInstruction(insn, 15, 5);
19216 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19217 tmp = 0x0;
19218 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19219 tmp |= fieldFromInstruction(insn, 25, 1);
19220 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19221 return S;
19222 case 230:
19223 tmp = fieldFromInstruction(insn, 15, 5);
19224 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19225 tmp = fieldFromInstruction(insn, 20, 5);
19226 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19227 tmp = 0x0;
19228 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
19229 tmp |= fieldFromInstruction(insn, 8, 4);
19230 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
19231 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
19232 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19233 return S;
19234 case 231:
19235 tmp = fieldFromInstruction(insn, 7, 5);
19236 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19237 tmp = fieldFromInstruction(insn, 7, 5);
19238 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19239 tmp = fieldFromInstruction(insn, 15, 5);
19240 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19241 tmp = fieldFromInstruction(insn, 20, 5);
19242 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19243 tmp = fieldFromInstruction(insn, 25, 5);
19244 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19245 return S;
19246 case 232:
19247 tmp = fieldFromInstruction(insn, 7, 5);
19248 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19249 tmp = fieldFromInstruction(insn, 15, 5);
19250 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19251 tmp = 0x0;
19252 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19253 tmp |= fieldFromInstruction(insn, 25, 1);
19254 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19255 return S;
19256 case 233:
19257 tmp = fieldFromInstruction(insn, 7, 5);
19258 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19259 tmp = fieldFromInstruction(insn, 15, 5);
19260 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19261 tmp = 0x0;
19262 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19263 tmp |= fieldFromInstruction(insn, 25, 1);
19264 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19265 return S;
19266 case 234:
19267 tmp = fieldFromInstruction(insn, 7, 5);
19268 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19269 tmp = fieldFromInstruction(insn, 15, 5);
19270 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19271 tmp = 0x0;
19272 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19273 tmp |= fieldFromInstruction(insn, 25, 1);
19274 if (!Check(S, decodeUImmOperand<4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19275 return S;
19276 case 235:
19277 tmp = fieldFromInstruction(insn, 7, 5);
19278 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19279 tmp = fieldFromInstruction(insn, 7, 5);
19280 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19281 tmp = fieldFromInstruction(insn, 15, 5);
19282 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19283 tmp = 0x0;
19284 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19285 tmp |= fieldFromInstruction(insn, 25, 1);
19286 if (!Check(S, decodeUImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19287 return S;
19288 case 236:
19289 tmp = fieldFromInstruction(insn, 7, 5);
19290 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19291 tmp = fieldFromInstruction(insn, 7, 5);
19292 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19293 tmp = fieldFromInstruction(insn, 15, 5);
19294 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19295 tmp = 0x0;
19296 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19297 tmp |= fieldFromInstruction(insn, 25, 1);
19298 if (!Check(S, decodeSImmOperand<6>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19299 return S;
19300 case 237:
19301 tmp = fieldFromInstruction(insn, 7, 5);
19302 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19303 tmp = fieldFromInstruction(insn, 15, 5);
19304 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19305 tmp = 0x0;
19306 tmp |= fieldFromInstruction(insn, 20, 5) << 1;
19307 tmp |= fieldFromInstruction(insn, 25, 1);
19308 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19309 return S;
19310 case 238:
19311 tmp = fieldFromInstruction(insn, 15, 5);
19312 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19313 tmp = fieldFromInstruction(insn, 20, 9);
19314 if (!Check(S, decodeUImmOperand<9>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19315 tmp = fieldFromInstruction(insn, 7, 5);
19316 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19317 return S;
19318 case 239:
19319 tmp = fieldFromInstruction(insn, 7, 5);
19320 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19321 tmp = fieldFromInstruction(insn, 15, 5);
19322 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19323 tmp = fieldFromInstruction(insn, 20, 5);
19324 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19325 tmp = fieldFromInstruction(insn, 27, 5);
19326 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19327 return S;
19328 case 240:
19329 tmp = fieldFromInstruction(insn, 7, 5);
19330 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19331 tmp = fieldFromInstruction(insn, 27, 5);
19332 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19333 tmp = fieldFromInstruction(insn, 15, 5);
19334 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19335 tmp = fieldFromInstruction(insn, 23, 4) << 3;
19336 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19337 return S;
19338 case 241:
19339 tmp = fieldFromInstruction(insn, 7, 5);
19340 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19341 tmp = fieldFromInstruction(insn, 27, 5);
19342 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19343 tmp = fieldFromInstruction(insn, 15, 5);
19344 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19345 tmp = fieldFromInstruction(insn, 22, 5) << 2;
19346 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19347 return S;
19348 case 242:
19349 tmp = fieldFromInstruction(insn, 20, 5);
19350 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19351 tmp = fieldFromInstruction(insn, 27, 5);
19352 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19353 tmp = fieldFromInstruction(insn, 15, 5);
19354 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19355 tmp = 0x0;
19356 tmp |= fieldFromInstruction(insn, 10, 2) << 3;
19357 tmp |= fieldFromInstruction(insn, 25, 2) << 5;
19358 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19359 return S;
19360 case 243:
19361 tmp = fieldFromInstruction(insn, 20, 5);
19362 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19363 tmp = fieldFromInstruction(insn, 27, 5);
19364 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19365 tmp = fieldFromInstruction(insn, 15, 5);
19366 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19367 tmp = 0x0;
19368 tmp |= fieldFromInstruction(insn, 9, 3) << 2;
19369 tmp |= fieldFromInstruction(insn, 25, 2) << 5;
19370 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19371 return S;
19372 case 244:
19373 tmp = fieldFromInstruction(insn, 7, 5);
19374 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19375 tmp = fieldFromInstruction(insn, 15, 5);
19376 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19377 tmp = fieldFromInstruction(insn, 20, 5);
19378 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19379 tmp = fieldFromInstruction(insn, 12, 2);
19380 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19381 return S;
19382 case 245:
19383 tmp = fieldFromInstruction(insn, 7, 5);
19384 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19385 tmp = fieldFromInstruction(insn, 7, 5);
19386 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19387 tmp = fieldFromInstruction(insn, 15, 5);
19388 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19389 tmp = fieldFromInstruction(insn, 20, 5);
19390 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19391 return S;
19392 case 246:
19393 tmp = fieldFromInstruction(insn, 7, 5);
19394 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19395 tmp = fieldFromInstruction(insn, 7, 5);
19396 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19397 tmp = fieldFromInstruction(insn, 15, 5);
19398 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19399 tmp = fieldFromInstruction(insn, 20, 5);
19400 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19401 tmp = fieldFromInstruction(insn, 29, 2);
19402 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19403 return S;
19404 case 247:
19405 tmp = fieldFromInstruction(insn, 7, 5);
19406 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19407 tmp = fieldFromInstruction(insn, 15, 5);
19408 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19409 tmp = fieldFromInstruction(insn, 20, 5);
19410 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19411 tmp = fieldFromInstruction(insn, 12, 2);
19412 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19413 return S;
19414 case 248:
19415 tmp = fieldFromInstruction(insn, 7, 5);
19416 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19417 tmp = fieldFromInstruction(insn, 7, 5);
19418 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19419 tmp = fieldFromInstruction(insn, 16, 4) << 1;
19420 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19421 tmp = fieldFromInstruction(insn, 20, 5);
19422 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19423 return S;
19424 case 249:
19425 tmp = fieldFromInstruction(insn, 7, 5);
19426 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19427 tmp = fieldFromInstruction(insn, 7, 5);
19428 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19429 tmp = fieldFromInstruction(insn, 16, 4) << 1;
19430 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19431 tmp = fieldFromInstruction(insn, 20, 5);
19432 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19433 tmp = fieldFromInstruction(insn, 29, 2);
19434 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19435 return S;
19436 case 250:
19437 tmp = fieldFromInstruction(insn, 8, 4) << 1;
19438 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19439 tmp = fieldFromInstruction(insn, 8, 4) << 1;
19440 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19441 tmp = fieldFromInstruction(insn, 16, 4) << 1;
19442 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19443 tmp = fieldFromInstruction(insn, 20, 5);
19444 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19445 tmp = fieldFromInstruction(insn, 25, 1);
19446 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19447 tmp = 0x0;
19448 tmp |= fieldFromInstruction(insn, 7, 1);
19449 tmp |= fieldFromInstruction(insn, 15, 1) << 1;
19450 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19451 tmp = fieldFromInstruction(insn, 29, 2);
19452 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19453 return S;
19454 case 251:
19455 tmp = fieldFromInstruction(insn, 7, 5);
19456 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19457 tmp = fieldFromInstruction(insn, 7, 5);
19458 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19459 tmp = fieldFromInstruction(insn, 15, 5);
19460 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19461 tmp = fieldFromInstruction(insn, 20, 5);
19462 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19463 tmp = fieldFromInstruction(insn, 25, 1);
19464 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19465 tmp = fieldFromInstruction(insn, 12, 3);
19466 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19467 tmp = fieldFromInstruction(insn, 29, 2);
19468 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19469 return S;
19470 case 252:
19471 tmp = fieldFromInstruction(insn, 7, 5);
19472 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19473 tmp = fieldFromInstruction(insn, 7, 5);
19474 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19475 tmp = fieldFromInstruction(insn, 15, 5);
19476 if (!Check(S, DecodeVectorRegisterClass<RISCV::VRM2RegClassID, 32, 2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19477 tmp = fieldFromInstruction(insn, 20, 5);
19478 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19479 return S;
19480 case 253:
19481 tmp = fieldFromInstruction(insn, 7, 5);
19482 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19483 tmp = fieldFromInstruction(insn, 26, 2);
19484 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19485 tmp = fieldFromInstruction(insn, 20, 5);
19486 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19487 tmp = fieldFromInstruction(insn, 15, 5);
19488 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19489 return S;
19490 case 254:
19491 tmp = fieldFromInstruction(insn, 26, 2);
19492 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19493 tmp = fieldFromInstruction(insn, 20, 5);
19494 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19495 tmp = fieldFromInstruction(insn, 7, 5);
19496 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19497 tmp = fieldFromInstruction(insn, 15, 5);
19498 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19499 return S;
19500 case 255:
19501 tmp = fieldFromInstruction(insn, 7, 5);
19502 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19503 tmp = fieldFromInstruction(insn, 26, 2);
19504 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19505 tmp = fieldFromInstruction(insn, 20, 5);
19506 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19507 tmp = fieldFromInstruction(insn, 15, 5);
19508 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19509 return S;
19510 case 256:
19511 tmp = fieldFromInstruction(insn, 26, 2);
19512 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19513 tmp = fieldFromInstruction(insn, 20, 5);
19514 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19515 tmp = fieldFromInstruction(insn, 7, 5);
19516 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19517 tmp = fieldFromInstruction(insn, 15, 5);
19518 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19519 return S;
19520 case 257:
19521 tmp = fieldFromInstruction(insn, 7, 5);
19522 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19523 tmp = fieldFromInstruction(insn, 26, 2);
19524 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19525 tmp = fieldFromInstruction(insn, 20, 5);
19526 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19527 tmp = fieldFromInstruction(insn, 15, 5);
19528 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19529 return S;
19530 case 258:
19531 tmp = fieldFromInstruction(insn, 26, 2);
19532 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19533 tmp = fieldFromInstruction(insn, 7, 5);
19534 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19535 tmp = fieldFromInstruction(insn, 20, 5);
19536 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19537 tmp = fieldFromInstruction(insn, 15, 5);
19538 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19539 return S;
19540 case 259:
19541 tmp = fieldFromInstruction(insn, 7, 5);
19542 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19543 tmp = fieldFromInstruction(insn, 26, 2);
19544 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19545 tmp = fieldFromInstruction(insn, 20, 5);
19546 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19547 tmp = fieldFromInstruction(insn, 15, 5);
19548 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19549 return S;
19550 case 260:
19551 tmp = fieldFromInstruction(insn, 26, 2);
19552 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19553 tmp = fieldFromInstruction(insn, 7, 5);
19554 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19555 tmp = fieldFromInstruction(insn, 20, 5);
19556 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19557 tmp = fieldFromInstruction(insn, 15, 5);
19558 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19559 return S;
19560 case 261:
19561 tmp = fieldFromInstruction(insn, 7, 5);
19562 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19563 tmp = fieldFromInstruction(insn, 26, 2);
19564 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19565 tmp = fieldFromInstruction(insn, 20, 5);
19566 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19567 tmp = fieldFromInstruction(insn, 15, 5);
19568 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19569 return S;
19570 case 262:
19571 tmp = fieldFromInstruction(insn, 26, 2);
19572 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19573 tmp = fieldFromInstruction(insn, 7, 5);
19574 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19575 tmp = fieldFromInstruction(insn, 20, 5);
19576 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19577 tmp = fieldFromInstruction(insn, 15, 5);
19578 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19579 return S;
19580 case 263:
19581 tmp = fieldFromInstruction(insn, 7, 5);
19582 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19583 tmp = fieldFromInstruction(insn, 26, 1);
19584 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19585 tmp = fieldFromInstruction(insn, 20, 5);
19586 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19587 tmp = fieldFromInstruction(insn, 15, 5);
19588 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19589 return S;
19590 case 264:
19591 tmp = fieldFromInstruction(insn, 26, 1);
19592 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19593 tmp = fieldFromInstruction(insn, 7, 5);
19594 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19595 tmp = fieldFromInstruction(insn, 20, 5);
19596 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19597 tmp = fieldFromInstruction(insn, 15, 5);
19598 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19599 return S;
19600 case 265:
19601 tmp = fieldFromInstruction(insn, 8, 4);
19602 if (!Check(S, DecodeSimpleRegisterClass<RISCV::T0, 16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19603 return S;
19604 case 266:
19605 tmp = fieldFromInstruction(insn, 15, 5);
19606 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19607 tmp = fieldFromInstruction(insn, 20, 5);
19608 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19609 return S;
19610 case 267:
19611 tmp = fieldFromInstruction(insn, 7, 5);
19612 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19613 tmp = fieldFromInstruction(insn, 26, 2);
19614 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19615 tmp = fieldFromInstruction(insn, 7, 5);
19616 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19617 tmp = fieldFromInstruction(insn, 20, 5);
19618 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19619 tmp = fieldFromInstruction(insn, 15, 5);
19620 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19621 return S;
19622 case 268:
19623 tmp = fieldFromInstruction(insn, 26, 2);
19624 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19625 tmp = fieldFromInstruction(insn, 7, 5);
19626 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19627 tmp = fieldFromInstruction(insn, 20, 5);
19628 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19629 tmp = fieldFromInstruction(insn, 15, 5);
19630 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19631 return S;
19632 case 269:
19633 tmp = fieldFromInstruction(insn, 7, 5);
19634 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19635 tmp = fieldFromInstruction(insn, 26, 2);
19636 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19637 tmp = fieldFromInstruction(insn, 7, 5);
19638 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19639 tmp = fieldFromInstruction(insn, 20, 5);
19640 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19641 tmp = fieldFromInstruction(insn, 15, 5);
19642 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19643 return S;
19644 case 270:
19645 tmp = fieldFromInstruction(insn, 26, 2);
19646 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19647 tmp = fieldFromInstruction(insn, 7, 5);
19648 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19649 tmp = fieldFromInstruction(insn, 20, 5);
19650 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19651 tmp = fieldFromInstruction(insn, 15, 5);
19652 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19653 return S;
19654 case 271:
19655 tmp = fieldFromInstruction(insn, 7, 5);
19656 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19657 tmp = fieldFromInstruction(insn, 26, 2);
19658 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19659 tmp = fieldFromInstruction(insn, 7, 5);
19660 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19661 tmp = fieldFromInstruction(insn, 20, 5);
19662 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19663 tmp = fieldFromInstruction(insn, 15, 5);
19664 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19665 return S;
19666 case 272:
19667 tmp = fieldFromInstruction(insn, 26, 2);
19668 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19669 tmp = fieldFromInstruction(insn, 7, 5);
19670 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19671 tmp = fieldFromInstruction(insn, 20, 5);
19672 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19673 tmp = fieldFromInstruction(insn, 15, 5);
19674 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19675 return S;
19676 case 273:
19677 tmp = fieldFromInstruction(insn, 7, 5);
19678 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19679 tmp = fieldFromInstruction(insn, 26, 1);
19680 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19681 tmp = fieldFromInstruction(insn, 7, 5);
19682 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19683 tmp = fieldFromInstruction(insn, 20, 5);
19684 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19685 tmp = fieldFromInstruction(insn, 15, 5);
19686 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19687 return S;
19688 case 274:
19689 tmp = fieldFromInstruction(insn, 26, 1);
19690 if (!Check(S, decodeUImmOperand<1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19691 tmp = fieldFromInstruction(insn, 7, 5);
19692 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19693 tmp = fieldFromInstruction(insn, 20, 5);
19694 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19695 tmp = fieldFromInstruction(insn, 15, 5);
19696 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19697 return S;
19698 case 275:
19699 tmp = fieldFromInstruction(insn, 10, 2) << 2;
19700 if (!Check(S, DecodeTRM4RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19701 tmp = fieldFromInstruction(insn, 20, 5);
19702 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19703 tmp = fieldFromInstruction(insn, 15, 5);
19704 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19705 return S;
19706 case 276:
19707 tmp = fieldFromInstruction(insn, 9, 3) << 1;
19708 if (!Check(S, DecodeTRM2RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19709 tmp = fieldFromInstruction(insn, 20, 5);
19710 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19711 tmp = fieldFromInstruction(insn, 15, 5);
19712 if (!Check(S, DecodeSimpleRegisterClass<RISCV::V0, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19713 return S;
19714 case 277:
19715 tmp = fieldFromInstruction(insn, 7, 5);
19716 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19717 tmp = fieldFromInstruction(insn, 15, 5);
19718 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19719 tmp = fieldFromInstruction(insn, 20, 5);
19720 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19721 tmp = fieldFromInstruction(insn, 25, 2);
19722 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19723 return S;
19724 case 278:
19725 tmp = fieldFromInstruction(insn, 7, 5);
19726 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19727 tmp = fieldFromInstruction(insn, 15, 5);
19728 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19729 tmp = fieldFromInstruction(insn, 15, 5);
19730 if (!Check(S, decodeTHMemIdxRs1Operand(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; }
19731 tmp = fieldFromInstruction(insn, 20, 5);
19732 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19733 tmp = fieldFromInstruction(insn, 25, 2);
19734 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19735 return S;
19736 case 279:
19737 tmp = fieldFromInstruction(insn, 7, 5);
19738 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19739 tmp = fieldFromInstruction(insn, 20, 5);
19740 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19741 tmp = fieldFromInstruction(insn, 15, 5);
19742 if (!Check(S, decodeTHMemPairRs1Operand(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; }
19743 tmp = fieldFromInstruction(insn, 25, 2);
19744 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19745 if (!Check(Out&: S, In: decodeFixedImmOperand<3>(Inst&: MI, Decoder)))
19746 return MCDisassembler::Fail;
19747 return S;
19748 case 280:
19749 tmp = fieldFromInstruction(insn, 7, 5);
19750 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19751 tmp = fieldFromInstruction(insn, 20, 5);
19752 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19753 tmp = fieldFromInstruction(insn, 15, 5);
19754 if (!Check(S, decodeTHMemPairRs1Operand(MI, tmp, Address, Decoder))) { DecodeComplete = false; return MCDisassembler::Fail; }
19755 tmp = fieldFromInstruction(insn, 25, 2);
19756 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19757 if (!Check(Out&: S, In: decodeFixedImmOperand<4>(Inst&: MI, Decoder)))
19758 return MCDisassembler::Fail;
19759 return S;
19760 case 281:
19761 tmp = fieldFromInstruction(insn, 15, 5);
19762 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19763 tmp = fieldFromInstruction(insn, 7, 5);
19764 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19765 tmp = fieldFromInstruction(insn, 15, 5);
19766 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19767 tmp = fieldFromInstruction(insn, 20, 5);
19768 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19769 tmp = fieldFromInstruction(insn, 25, 2);
19770 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19771 return S;
19772 case 282:
19773 tmp = fieldFromInstruction(insn, 7, 5);
19774 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19775 tmp = fieldFromInstruction(insn, 20, 5);
19776 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19777 tmp = fieldFromInstruction(insn, 15, 5);
19778 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19779 tmp = fieldFromInstruction(insn, 25, 2);
19780 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19781 if (!Check(Out&: S, In: decodeFixedImmOperand<3>(Inst&: MI, Decoder)))
19782 return MCDisassembler::Fail;
19783 return S;
19784 case 283:
19785 tmp = fieldFromInstruction(insn, 7, 5);
19786 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19787 tmp = fieldFromInstruction(insn, 20, 5);
19788 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19789 tmp = fieldFromInstruction(insn, 15, 5);
19790 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19791 tmp = fieldFromInstruction(insn, 25, 2);
19792 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19793 if (!Check(Out&: S, In: decodeFixedImmOperand<4>(Inst&: MI, Decoder)))
19794 return MCDisassembler::Fail;
19795 return S;
19796 case 284:
19797 tmp = fieldFromInstruction(insn, 7, 5);
19798 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_F, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19799 tmp = fieldFromInstruction(insn, 15, 5);
19800 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19801 tmp = fieldFromInstruction(insn, 20, 5);
19802 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19803 tmp = fieldFromInstruction(insn, 25, 2);
19804 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19805 return S;
19806 case 285:
19807 tmp = fieldFromInstruction(insn, 7, 5);
19808 if (!Check(S, DecodeSimpleRegisterClass<RISCV::F0_D, 32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19809 tmp = fieldFromInstruction(insn, 15, 5);
19810 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19811 tmp = fieldFromInstruction(insn, 20, 5);
19812 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19813 tmp = fieldFromInstruction(insn, 25, 2);
19814 if (!Check(S, decodeUImmOperand<2>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19815 return S;
19816 case 286:
19817 tmp = fieldFromInstruction(insn, 7, 5);
19818 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19819 tmp = fieldFromInstruction(insn, 15, 5);
19820 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19821 tmp = fieldFromInstruction(insn, 20, 11);
19822 if (!Check(S, decodeUImmOperand<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19823 return S;
19824 case 287:
19825 tmp = fieldFromInstruction(insn, 7, 5);
19826 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19827 tmp = fieldFromInstruction(insn, 7, 5);
19828 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19829 tmp = fieldFromInstruction(insn, 15, 5);
19830 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19831 tmp = fieldFromInstruction(insn, 20, 11);
19832 if (!Check(S, decodeSImmOperand<11>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19833 return S;
19834 case 288:
19835 tmp = fieldFromInstruction(insn, 7, 5);
19836 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19837 tmp = fieldFromInstruction(insn, 7, 5);
19838 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19839 tmp = fieldFromInstruction(insn, 15, 5);
19840 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19841 tmp = fieldFromInstruction(insn, 25, 5);
19842 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19843 tmp = fieldFromInstruction(insn, 20, 5);
19844 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19845 return S;
19846 case 289:
19847 tmp = fieldFromInstruction(insn, 7, 5);
19848 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19849 tmp = fieldFromInstruction(insn, 7, 5);
19850 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19851 tmp = fieldFromInstruction(insn, 15, 5);
19852 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19853 tmp = fieldFromInstruction(insn, 25, 5);
19854 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19855 tmp = fieldFromInstruction(insn, 20, 5);
19856 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19857 return S;
19858 case 290:
19859 tmp = fieldFromInstruction(insn, 7, 5);
19860 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19861 tmp = fieldFromInstruction(insn, 15, 5);
19862 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19863 tmp = fieldFromInstruction(insn, 25, 5);
19864 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19865 tmp = fieldFromInstruction(insn, 20, 5);
19866 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19867 return S;
19868 case 291:
19869 tmp = fieldFromInstruction(insn, 7, 5);
19870 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19871 tmp = fieldFromInstruction(insn, 15, 5);
19872 if (!Check(S, DecodeGPRNoX31RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19873 tmp = fieldFromInstruction(insn, 25, 5);
19874 if (!Check(S, decodeUImmPlus1Operand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19875 tmp = fieldFromInstruction(insn, 20, 5);
19876 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19877 return S;
19878 case 292:
19879 tmp = fieldFromInstruction(insn, 7, 5);
19880 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19881 tmp = fieldFromInstruction(insn, 15, 5);
19882 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19883 return S;
19884 case 293:
19885 tmp = fieldFromInstruction(insn, 7, 5);
19886 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19887 tmp = fieldFromInstruction(insn, 7, 5);
19888 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19889 tmp = fieldFromInstruction(insn, 15, 5);
19890 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19891 tmp = fieldFromInstruction(insn, 20, 5);
19892 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19893 return S;
19894 case 294:
19895 tmp = fieldFromInstruction(insn, 7, 5);
19896 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19897 tmp = fieldFromInstruction(insn, 15, 5);
19898 if (!Check(S, DecodeGPRNoX31RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19899 tmp = fieldFromInstruction(insn, 20, 5);
19900 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19901 return S;
19902 case 295:
19903 tmp = fieldFromInstruction(insn, 7, 5);
19904 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19905 tmp = fieldFromInstruction(insn, 15, 5);
19906 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19907 tmp = fieldFromInstruction(insn, 20, 5);
19908 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19909 return S;
19910 case 296:
19911 tmp = fieldFromInstruction(insn, 7, 5);
19912 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19913 tmp = fieldFromInstruction(insn, 15, 5);
19914 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19915 tmp = fieldFromInstruction(insn, 20, 5);
19916 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19917 return S;
19918 case 297:
19919 tmp = fieldFromInstruction(insn, 7, 5);
19920 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19921 tmp = fieldFromInstruction(insn, 15, 5);
19922 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19923 tmp = fieldFromInstruction(insn, 20, 5);
19924 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19925 tmp = fieldFromInstruction(insn, 25, 5);
19926 if (!Check(S, decodeUImmOperand<5, 4>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19927 return S;
19928 case 298:
19929 tmp = fieldFromInstruction(insn, 7, 5);
19930 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19931 tmp = fieldFromInstruction(insn, 15, 5);
19932 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19933 tmp = fieldFromInstruction(insn, 20, 12) << 2;
19934 if (!Check(S, decodeUImmOperand<14>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19935 return S;
19936 case 299:
19937 tmp = fieldFromInstruction(insn, 7, 5);
19938 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19939 tmp = fieldFromInstruction(insn, 7, 5);
19940 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19941 tmp = fieldFromInstruction(insn, 15, 5);
19942 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19943 tmp = fieldFromInstruction(insn, 20, 12);
19944 if (!Check(S, decodeSImm12LoOperand(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19945 return S;
19946 case 300:
19947 tmp = fieldFromInstruction(insn, 7, 5);
19948 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19949 tmp = fieldFromInstruction(insn, 15, 5);
19950 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19951 tmp = fieldFromInstruction(insn, 20, 5);
19952 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19953 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19954 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19955 return S;
19956 case 301:
19957 tmp = fieldFromInstruction(insn, 7, 5);
19958 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19959 tmp = fieldFromInstruction(insn, 15, 5);
19960 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19961 tmp = fieldFromInstruction(insn, 20, 5);
19962 if (!Check(S, decodeUImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19963 tmp = fieldFromInstruction(insn, 25, 5) << 2;
19964 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19965 return S;
19966 case 302:
19967 tmp = fieldFromInstruction(insn, 7, 5);
19968 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19969 tmp = fieldFromInstruction(insn, 15, 5);
19970 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19971 tmp = fieldFromInstruction(insn, 20, 5);
19972 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19973 tmp = fieldFromInstruction(insn, 25, 3);
19974 if (!Check(S, decodeUImmOperand<3>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19975 return S;
19976 case 303:
19977 tmp = fieldFromInstruction(insn, 20, 5);
19978 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19979 return S;
19980 case 304:
19981 tmp = fieldFromInstruction(insn, 20, 8);
19982 if (!Check(S, decodeUImmOperand<8>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19983 return S;
19984 case 305:
19985 tmp = fieldFromInstruction(insn, 7, 5);
19986 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19987 tmp = 0x0;
19988 tmp |= fieldFromInstruction(insn, 12, 4) << 15;
19989 tmp |= fieldFromInstruction(insn, 16, 15);
19990 tmp |= fieldFromInstruction(insn, 31, 1) << 19;
19991 if (!Check(S, decodeSImmOperand<20>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19992 return S;
19993 case 306:
19994 tmp = fieldFromInstruction(insn, 7, 5);
19995 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19996 tmp = fieldFromInstruction(insn, 15, 5);
19997 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
19998 tmp = fieldFromInstruction(insn, 20, 5);
19999 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20000 tmp = fieldFromInstruction(insn, 25, 5) << 2;
20001 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20002 return S;
20003 case 307:
20004 tmp = fieldFromInstruction(insn, 7, 5);
20005 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20006 tmp = fieldFromInstruction(insn, 15, 5);
20007 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20008 tmp = fieldFromInstruction(insn, 20, 5);
20009 if (!Check(S, decodeUImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20010 tmp = fieldFromInstruction(insn, 25, 5) << 2;
20011 if (!Check(S, decodeUImmOperand<7>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20012 return S;
20013 case 308:
20014 tmp = fieldFromInstruction(insn, 7, 5);
20015 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20016 tmp = fieldFromInstruction(insn, 7, 5);
20017 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20018 tmp = fieldFromInstruction(insn, 15, 5);
20019 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20020 tmp = fieldFromInstruction(insn, 20, 5);
20021 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20022 tmp = fieldFromInstruction(insn, 27, 5);
20023 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20024 return S;
20025 case 309:
20026 tmp = fieldFromInstruction(insn, 7, 5);
20027 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20028 tmp = fieldFromInstruction(insn, 7, 5);
20029 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20030 tmp = fieldFromInstruction(insn, 15, 5);
20031 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20032 tmp = fieldFromInstruction(insn, 20, 5);
20033 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20034 tmp = fieldFromInstruction(insn, 27, 5);
20035 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20036 return S;
20037 case 310:
20038 tmp = fieldFromInstruction(insn, 7, 5);
20039 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20040 tmp = fieldFromInstruction(insn, 7, 5);
20041 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20042 tmp = fieldFromInstruction(insn, 15, 5);
20043 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20044 tmp = fieldFromInstruction(insn, 20, 5);
20045 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20046 tmp = fieldFromInstruction(insn, 27, 5);
20047 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20048 return S;
20049 case 311:
20050 tmp = fieldFromInstruction(insn, 7, 5);
20051 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20052 tmp = fieldFromInstruction(insn, 7, 5);
20053 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20054 tmp = fieldFromInstruction(insn, 15, 5);
20055 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20056 tmp = fieldFromInstruction(insn, 20, 5);
20057 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20058 tmp = fieldFromInstruction(insn, 27, 5);
20059 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20060 return S;
20061 case 312:
20062 tmp = fieldFromInstruction(insn, 7, 5);
20063 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20064 tmp = fieldFromInstruction(insn, 7, 5);
20065 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20066 tmp = fieldFromInstruction(insn, 15, 5);
20067 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20068 tmp = fieldFromInstruction(insn, 20, 5);
20069 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20070 tmp = fieldFromInstruction(insn, 27, 5);
20071 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20072 return S;
20073 case 313:
20074 tmp = fieldFromInstruction(insn, 7, 5);
20075 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20076 tmp = fieldFromInstruction(insn, 7, 5);
20077 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20078 tmp = fieldFromInstruction(insn, 15, 5);
20079 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20080 tmp = fieldFromInstruction(insn, 20, 5);
20081 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20082 tmp = fieldFromInstruction(insn, 27, 5);
20083 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20084 return S;
20085 case 314:
20086 tmp = fieldFromInstruction(insn, 7, 5);
20087 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20088 tmp = fieldFromInstruction(insn, 7, 5);
20089 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20090 tmp = fieldFromInstruction(insn, 15, 5);
20091 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20092 tmp = fieldFromInstruction(insn, 20, 5);
20093 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20094 tmp = fieldFromInstruction(insn, 27, 5);
20095 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20096 return S;
20097 case 315:
20098 tmp = fieldFromInstruction(insn, 7, 5);
20099 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20100 tmp = fieldFromInstruction(insn, 7, 5);
20101 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20102 tmp = fieldFromInstruction(insn, 15, 5);
20103 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20104 tmp = fieldFromInstruction(insn, 20, 5);
20105 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20106 tmp = fieldFromInstruction(insn, 27, 5);
20107 if (!Check(S, decodeSImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20108 return S;
20109 case 316:
20110 tmp = fieldFromInstruction(insn, 7, 5);
20111 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20112 tmp = fieldFromInstruction(insn, 15, 5);
20113 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20114 tmp = fieldFromInstruction(insn, 20, 5);
20115 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20116 return S;
20117 case 317:
20118 tmp = fieldFromInstruction(insn, 7, 5);
20119 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20120 tmp = fieldFromInstruction(insn, 15, 5);
20121 if (!Check(S, decodeUImmOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20122 tmp = fieldFromInstruction(insn, 20, 5);
20123 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20124 return S;
20125 case 318:
20126 tmp = fieldFromInstruction(insn, 15, 10);
20127 if (!Check(S, decodeUImmOperand<10>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20128 return S;
20129 case 319:
20130 tmp = fieldFromInstruction(insn, 15, 5);
20131 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20132 tmp = fieldFromInstruction(insn, 20, 5);
20133 if (!Check(S, decodeSImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20134 tmp = 0x0;
20135 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20136 tmp |= fieldFromInstruction(insn, 8, 4);
20137 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20138 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20139 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20140 return S;
20141 case 320:
20142 tmp = fieldFromInstruction(insn, 15, 5);
20143 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20144 tmp = fieldFromInstruction(insn, 20, 5);
20145 if (!Check(S, decodeUImmNonZeroOperand<5>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20146 tmp = 0x0;
20147 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20148 tmp |= fieldFromInstruction(insn, 8, 4);
20149 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20150 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20151 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20152 return S;
20153 case 321:
20154 tmp = fieldFromInstruction(insn, 7, 5);
20155 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20156 tmp = fieldFromInstruction(insn, 15, 5);
20157 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20158 tmp = fieldFromInstruction(insn, 12, 3);
20159 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20160 return S;
20161 case 322:
20162 tmp = fieldFromInstruction(insn, 7, 5);
20163 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20164 tmp = fieldFromInstruction(insn, 15, 5);
20165 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20166 tmp = fieldFromInstruction(insn, 12, 3);
20167 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20168 return S;
20169 case 323:
20170 tmp = fieldFromInstruction(insn, 7, 5);
20171 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20172 tmp = fieldFromInstruction(insn, 15, 5);
20173 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20174 tmp = fieldFromInstruction(insn, 20, 5);
20175 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20176 tmp = fieldFromInstruction(insn, 27, 5);
20177 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20178 tmp = fieldFromInstruction(insn, 12, 3);
20179 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20180 return S;
20181 case 324:
20182 tmp = fieldFromInstruction(insn, 7, 5);
20183 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20184 tmp = fieldFromInstruction(insn, 15, 5);
20185 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20186 tmp = fieldFromInstruction(insn, 20, 5);
20187 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20188 tmp = fieldFromInstruction(insn, 12, 3);
20189 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20190 return S;
20191 case 325:
20192 tmp = fieldFromInstruction(insn, 7, 5);
20193 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20194 tmp = fieldFromInstruction(insn, 15, 5);
20195 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20196 tmp = fieldFromInstruction(insn, 20, 5);
20197 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20198 return S;
20199 case 326:
20200 tmp = fieldFromInstruction(insn, 7, 5);
20201 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20202 tmp = fieldFromInstruction(insn, 15, 5);
20203 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20204 tmp = fieldFromInstruction(insn, 12, 3);
20205 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20206 return S;
20207 case 327:
20208 tmp = fieldFromInstruction(insn, 7, 5);
20209 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20210 tmp = fieldFromInstruction(insn, 15, 5);
20211 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20212 tmp = fieldFromInstruction(insn, 12, 3);
20213 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20214 return S;
20215 case 328:
20216 tmp = fieldFromInstruction(insn, 7, 5);
20217 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20218 tmp = fieldFromInstruction(insn, 15, 5);
20219 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20220 tmp = fieldFromInstruction(insn, 12, 3);
20221 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20222 return S;
20223 case 329:
20224 tmp = fieldFromInstruction(insn, 7, 5);
20225 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20226 tmp = fieldFromInstruction(insn, 15, 5);
20227 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20228 tmp = fieldFromInstruction(insn, 20, 5);
20229 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20230 return S;
20231 case 330:
20232 tmp = fieldFromInstruction(insn, 7, 5);
20233 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20234 tmp = fieldFromInstruction(insn, 15, 5);
20235 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20236 tmp = fieldFromInstruction(insn, 12, 3);
20237 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20238 return S;
20239 case 331:
20240 tmp = fieldFromInstruction(insn, 7, 5);
20241 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20242 tmp = fieldFromInstruction(insn, 15, 5);
20243 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20244 tmp = fieldFromInstruction(insn, 12, 3);
20245 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20246 return S;
20247 case 332:
20248 tmp = fieldFromInstruction(insn, 7, 5);
20249 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20250 tmp = fieldFromInstruction(insn, 15, 5);
20251 if (!Check(S, DecodeGPRPairRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20252 return S;
20253 case 333:
20254 tmp = fieldFromInstruction(insn, 7, 5);
20255 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20256 tmp = fieldFromInstruction(insn, 15, 5);
20257 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20258 tmp = fieldFromInstruction(insn, 20, 5);
20259 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20260 tmp = fieldFromInstruction(insn, 27, 5);
20261 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20262 tmp = fieldFromInstruction(insn, 12, 3);
20263 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20264 return S;
20265 case 334:
20266 tmp = fieldFromInstruction(insn, 7, 5);
20267 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20268 tmp = fieldFromInstruction(insn, 15, 5);
20269 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20270 tmp = fieldFromInstruction(insn, 20, 5);
20271 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20272 tmp = fieldFromInstruction(insn, 27, 5);
20273 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20274 tmp = fieldFromInstruction(insn, 12, 3);
20275 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20276 return S;
20277 case 335:
20278 tmp = fieldFromInstruction(insn, 7, 5);
20279 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20280 tmp = fieldFromInstruction(insn, 15, 5);
20281 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20282 tmp = fieldFromInstruction(insn, 20, 5);
20283 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20284 tmp = fieldFromInstruction(insn, 27, 5);
20285 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20286 tmp = fieldFromInstruction(insn, 12, 3);
20287 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20288 return S;
20289 case 336:
20290 tmp = fieldFromInstruction(insn, 7, 5);
20291 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20292 tmp = fieldFromInstruction(insn, 15, 5);
20293 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20294 tmp = fieldFromInstruction(insn, 20, 5);
20295 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20296 tmp = fieldFromInstruction(insn, 12, 3);
20297 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20298 return S;
20299 case 337:
20300 tmp = fieldFromInstruction(insn, 7, 5);
20301 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20302 tmp = fieldFromInstruction(insn, 15, 5);
20303 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20304 tmp = fieldFromInstruction(insn, 20, 5);
20305 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20306 tmp = fieldFromInstruction(insn, 12, 3);
20307 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20308 return S;
20309 case 338:
20310 tmp = fieldFromInstruction(insn, 7, 5);
20311 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20312 tmp = fieldFromInstruction(insn, 15, 5);
20313 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20314 tmp = fieldFromInstruction(insn, 20, 5);
20315 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20316 tmp = fieldFromInstruction(insn, 12, 3);
20317 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20318 return S;
20319 case 339:
20320 tmp = fieldFromInstruction(insn, 7, 5);
20321 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20322 tmp = fieldFromInstruction(insn, 15, 5);
20323 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20324 tmp = fieldFromInstruction(insn, 20, 5);
20325 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20326 return S;
20327 case 340:
20328 tmp = fieldFromInstruction(insn, 7, 5);
20329 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20330 tmp = fieldFromInstruction(insn, 15, 5);
20331 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20332 tmp = fieldFromInstruction(insn, 20, 5);
20333 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20334 return S;
20335 case 341:
20336 tmp = fieldFromInstruction(insn, 7, 5);
20337 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20338 tmp = fieldFromInstruction(insn, 15, 5);
20339 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20340 tmp = fieldFromInstruction(insn, 12, 3);
20341 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20342 return S;
20343 case 342:
20344 tmp = fieldFromInstruction(insn, 7, 5);
20345 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20346 tmp = fieldFromInstruction(insn, 15, 5);
20347 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20348 tmp = fieldFromInstruction(insn, 12, 3);
20349 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20350 return S;
20351 case 343:
20352 tmp = fieldFromInstruction(insn, 7, 5);
20353 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20354 tmp = fieldFromInstruction(insn, 15, 5);
20355 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20356 tmp = fieldFromInstruction(insn, 12, 3);
20357 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20358 return S;
20359 case 344:
20360 tmp = fieldFromInstruction(insn, 7, 5);
20361 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20362 tmp = fieldFromInstruction(insn, 15, 5);
20363 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20364 tmp = fieldFromInstruction(insn, 12, 3);
20365 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20366 return S;
20367 case 345:
20368 tmp = fieldFromInstruction(insn, 7, 5);
20369 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20370 tmp = fieldFromInstruction(insn, 15, 5);
20371 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20372 tmp = fieldFromInstruction(insn, 12, 3);
20373 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20374 return S;
20375 case 346:
20376 tmp = fieldFromInstruction(insn, 7, 5);
20377 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20378 tmp = fieldFromInstruction(insn, 15, 5);
20379 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20380 tmp = fieldFromInstruction(insn, 12, 3);
20381 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20382 return S;
20383 case 347:
20384 tmp = fieldFromInstruction(insn, 7, 5);
20385 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20386 tmp = fieldFromInstruction(insn, 15, 5);
20387 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20388 tmp = fieldFromInstruction(insn, 12, 3);
20389 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20390 return S;
20391 case 348:
20392 tmp = fieldFromInstruction(insn, 7, 5);
20393 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20394 tmp = fieldFromInstruction(insn, 15, 5);
20395 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20396 tmp = fieldFromInstruction(insn, 12, 3);
20397 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20398 return S;
20399 case 349:
20400 tmp = fieldFromInstruction(insn, 7, 5);
20401 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20402 tmp = fieldFromInstruction(insn, 15, 5);
20403 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20404 tmp = fieldFromInstruction(insn, 12, 3);
20405 if (!Check(S, decodeFRMArg(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20406 return S;
20407 case 350:
20408 tmp = fieldFromInstruction(insn, 7, 5);
20409 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20410 tmp = fieldFromInstruction(insn, 15, 5);
20411 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20412 tmp = fieldFromInstruction(insn, 20, 5);
20413 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20414 return S;
20415 case 351:
20416 tmp = fieldFromInstruction(insn, 7, 5);
20417 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20418 tmp = fieldFromInstruction(insn, 15, 5);
20419 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20420 tmp = fieldFromInstruction(insn, 20, 5);
20421 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20422 return S;
20423 case 352:
20424 tmp = fieldFromInstruction(insn, 7, 5);
20425 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20426 tmp = fieldFromInstruction(insn, 15, 5);
20427 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_W, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20428 return S;
20429 case 353:
20430 tmp = fieldFromInstruction(insn, 7, 5);
20431 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20432 tmp = fieldFromInstruction(insn, 15, 5);
20433 if (!Check(S, DecodeSimpleRegisterClass<RISCV::X0_H, 32, /*RVELimit=*/16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20434 return S;
20435 }
20436}
20437static const uint8_t DecoderTableXqci48[368] = {
20438 48, // 0: BitWidth 48
20439 OPC_SwitchField, 12, 3, // 1: switch Inst[14:12] {
20440 0, 15, // 4: case 0x0: {
20441 OPC_CheckPredicate, 200, 1, // 6: check predicate 200
20442 OPC_CheckField, 15, 1, 0, // 9: check Inst[15] == 0x0
20443 OPC_CheckField, 0, 7, 31, // 13: check Inst[6:0] == 0x1f
20444 OPC_Decode, 238, 122, 0, // 17: decode to QC_E_LI using decoder 0
20445 // 17: }
20446 1, 29, // 21: case 0x1: {
20447 OPC_SwitchField, 15, 1, // 23: switch Inst[15] {
20448 0, 11, // 26: case 0x0: {
20449 OPC_CheckPredicate, 215, 1, // 28: check predicate 215
20450 OPC_CheckField, 0, 7, 31, // 31: check Inst[6:0] == 0x1f
20451 OPC_Decode, 245, 122, 1, // 35: decode to QC_E_XORAI using decoder 1
20452 // 35: }
20453 1, 0, // 39: case 0x1: {
20454 OPC_CheckPredicate, 215, 1, // 41: check predicate 215
20455 OPC_CheckField, 0, 7, 31, // 44: check Inst[6:0] == 0x1f
20456 OPC_Decode, 240, 122, 1, // 48: decode to QC_E_ORAI using decoder 1
20457 // 48: }
20458 // 48: } // switch Inst[15]
20459 // 48: }
20460 2, 29, // 52: case 0x2: {
20461 OPC_SwitchField, 15, 1, // 54: switch Inst[15] {
20462 0, 11, // 57: case 0x0: {
20463 OPC_CheckPredicate, 215, 1, // 59: check predicate 215
20464 OPC_CheckField, 0, 7, 31, // 62: check Inst[6:0] == 0x1f
20465 OPC_Decode, 222, 122, 1, // 66: decode to QC_E_ADDAI using decoder 1
20466 // 66: }
20467 1, 0, // 70: case 0x1: {
20468 OPC_CheckPredicate, 215, 1, // 72: check predicate 215
20469 OPC_CheckField, 0, 7, 31, // 75: check Inst[6:0] == 0x1f
20470 OPC_Decode, 224, 122, 1, // 79: decode to QC_E_ANDAI using decoder 1
20471 // 79: }
20472 // 79: } // switch Inst[15]
20473 // 79: }
20474 3, 55, // 83: case 0x3: {
20475 OPC_SwitchField, 30, 2, // 85: switch Inst[31:30] {
20476 0, 11, // 88: case 0x0: {
20477 OPC_CheckPredicate, 215, 1, // 90: check predicate 215
20478 OPC_CheckField, 0, 7, 31, // 93: check Inst[6:0] == 0x1f
20479 OPC_Decode, 246, 122, 2, // 97: decode to QC_E_XORI using decoder 2
20480 // 97: }
20481 1, 11, // 101: case 0x1: {
20482 OPC_CheckPredicate, 215, 1, // 103: check predicate 215
20483 OPC_CheckField, 0, 7, 31, // 106: check Inst[6:0] == 0x1f
20484 OPC_Decode, 241, 122, 2, // 110: decode to QC_E_ORI using decoder 2
20485 // 110: }
20486 2, 11, // 114: case 0x2: {
20487 OPC_CheckPredicate, 215, 1, // 116: check predicate 215
20488 OPC_CheckField, 0, 7, 31, // 119: check Inst[6:0] == 0x1f
20489 OPC_Decode, 223, 122, 2, // 123: decode to QC_E_ADDI using decoder 2
20490 // 123: }
20491 3, 0, // 127: case 0x3: {
20492 OPC_CheckPredicate, 215, 1, // 129: check predicate 215
20493 OPC_CheckField, 0, 7, 31, // 132: check Inst[6:0] == 0x1f
20494 OPC_Decode, 225, 122, 2, // 136: decode to QC_E_ANDI using decoder 2
20495 // 136: }
20496 // 136: } // switch Inst[31:30]
20497 // 136: }
20498 4, 112, // 140: case 0x4: {
20499 OPC_SwitchField, 20, 5, // 142: switch Inst[24:20] {
20500 0, 29, // 145: case 0x0: {
20501 OPC_SwitchField, 15, 2, // 147: switch Inst[16:15] {
20502 0, 11, // 150: case 0x0: {
20503 OPC_CheckPredicate, 216, 1, // 152: check predicate 216
20504 OPC_CheckField, 0, 7, 31, // 155: check Inst[6:0] == 0x1f
20505 OPC_Decode, 232, 122, 3, // 159: decode to QC_E_J using decoder 3
20506 // 159: }
20507 1, 0, // 163: case 0x1: {
20508 OPC_CheckPredicate, 216, 1, // 165: check predicate 216
20509 OPC_CheckField, 0, 7, 31, // 168: check Inst[6:0] == 0x1f
20510 OPC_Decode, 233, 122, 3, // 172: decode to QC_E_JAL using decoder 3
20511 // 172: }
20512 // 172: } // switch Inst[16:15]
20513 // 172: }
20514 24, 11, // 176: case 0x18: {
20515 OPC_CheckPredicate, 204, 1, // 178: check predicate 204
20516 OPC_CheckField, 0, 7, 31, // 181: check Inst[6:0] == 0x1f
20517 OPC_Decode, 226, 122, 4, // 185: decode to QC_E_BEQI using decoder 4
20518 // 185: }
20519 25, 11, // 189: case 0x19: {
20520 OPC_CheckPredicate, 204, 1, // 191: check predicate 204
20521 OPC_CheckField, 0, 7, 31, // 194: check Inst[6:0] == 0x1f
20522 OPC_Decode, 231, 122, 4, // 198: decode to QC_E_BNEI using decoder 4
20523 // 198: }
20524 28, 11, // 202: case 0x1c: {
20525 OPC_CheckPredicate, 204, 1, // 204: check predicate 204
20526 OPC_CheckField, 0, 7, 31, // 207: check Inst[6:0] == 0x1f
20527 OPC_Decode, 229, 122, 4, // 211: decode to QC_E_BLTI using decoder 4
20528 // 211: }
20529 29, 11, // 215: case 0x1d: {
20530 OPC_CheckPredicate, 204, 1, // 217: check predicate 204
20531 OPC_CheckField, 0, 7, 31, // 220: check Inst[6:0] == 0x1f
20532 OPC_Decode, 227, 122, 4, // 224: decode to QC_E_BGEI using decoder 4
20533 // 224: }
20534 30, 11, // 228: case 0x1e: {
20535 OPC_CheckPredicate, 204, 1, // 230: check predicate 204
20536 OPC_CheckField, 0, 7, 31, // 233: check Inst[6:0] == 0x1f
20537 OPC_Decode, 230, 122, 5, // 237: decode to QC_E_BLTUI using decoder 5
20538 // 237: }
20539 31, 0, // 241: case 0x1f: {
20540 OPC_CheckPredicate, 204, 1, // 243: check predicate 204
20541 OPC_CheckField, 0, 7, 31, // 246: check Inst[6:0] == 0x1f
20542 OPC_Decode, 228, 122, 5, // 250: decode to QC_E_BGEUI using decoder 5
20543 // 250: }
20544 // 250: } // switch Inst[24:20]
20545 // 250: }
20546 5, 55, // 254: case 0x5: {
20547 OPC_SwitchField, 30, 2, // 256: switch Inst[31:30] {
20548 0, 11, // 259: case 0x0: {
20549 OPC_CheckPredicate, 217, 1, // 261: check predicate 217
20550 OPC_CheckField, 0, 7, 31, // 264: check Inst[6:0] == 0x1f
20551 OPC_Decode, 234, 122, 6, // 268: decode to QC_E_LB using decoder 6
20552 // 268: }
20553 1, 11, // 272: case 0x1: {
20554 OPC_CheckPredicate, 217, 1, // 274: check predicate 217
20555 OPC_CheckField, 0, 7, 31, // 277: check Inst[6:0] == 0x1f
20556 OPC_Decode, 235, 122, 6, // 281: decode to QC_E_LBU using decoder 6
20557 // 281: }
20558 2, 11, // 285: case 0x2: {
20559 OPC_CheckPredicate, 217, 1, // 287: check predicate 217
20560 OPC_CheckField, 0, 7, 31, // 290: check Inst[6:0] == 0x1f
20561 OPC_Decode, 236, 122, 6, // 294: decode to QC_E_LH using decoder 6
20562 // 294: }
20563 3, 0, // 298: case 0x3: {
20564 OPC_CheckPredicate, 217, 1, // 300: check predicate 217
20565 OPC_CheckField, 0, 7, 31, // 303: check Inst[6:0] == 0x1f
20566 OPC_Decode, 237, 122, 6, // 307: decode to QC_E_LHU using decoder 6
20567 // 307: }
20568 // 307: } // switch Inst[31:30]
20569 // 307: }
20570 6, 0, // 311: case 0x6: {
20571 OPC_SwitchField, 30, 2, // 313: switch Inst[31:30] {
20572 0, 11, // 316: case 0x0: {
20573 OPC_CheckPredicate, 217, 1, // 318: check predicate 217
20574 OPC_CheckField, 0, 7, 31, // 321: check Inst[6:0] == 0x1f
20575 OPC_Decode, 239, 122, 6, // 325: decode to QC_E_LW using decoder 6
20576 // 325: }
20577 1, 11, // 329: case 0x1: {
20578 OPC_CheckPredicate, 217, 1, // 331: check predicate 217
20579 OPC_CheckField, 0, 7, 31, // 334: check Inst[6:0] == 0x1f
20580 OPC_Decode, 242, 122, 7, // 338: decode to QC_E_SB using decoder 7
20581 // 338: }
20582 2, 11, // 342: case 0x2: {
20583 OPC_CheckPredicate, 217, 1, // 344: check predicate 217
20584 OPC_CheckField, 0, 7, 31, // 347: check Inst[6:0] == 0x1f
20585 OPC_Decode, 243, 122, 7, // 351: decode to QC_E_SH using decoder 7
20586 // 351: }
20587 3, 0, // 355: case 0x3: {
20588 OPC_CheckPredicate, 217, 1, // 357: check predicate 217
20589 OPC_CheckField, 0, 7, 31, // 360: check Inst[6:0] == 0x1f
20590 OPC_Decode, 244, 122, 7, // 364: decode to QC_E_SW using decoder 7
20591 // 364: }
20592 // 364: } // switch Inst[31:30]
20593 // 364: }
20594 // 364: } // switch Inst[14:12]
20595};
20596// Handling 8 cases.
20597template <typename InsnType>
20598static std::enable_if_t<InsnBitWidth<InsnType> == 48, DecodeStatus>
20599decodeToMCInst(unsigned Idx, DecodeStatus S, InsnType insn, MCInst &MI, uint64_t Address, const MCDisassembler *Decoder, bool &DecodeComplete) {
20600 DecodeComplete = true;
20601 using TmpType = std::conditional_t<std::is_integral<InsnType>::value, InsnType, uint64_t>;
20602 TmpType tmp;
20603 switch (Idx) {
20604 default: llvm_unreachable("Invalid decoder index!");
20605 case 0:
20606 tmp = fieldFromInstruction(insn, 7, 5);
20607 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20608 tmp = fieldFromInstruction(insn, 16, 32);
20609 if (!Check(S, decodeSImmOperand<32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20610 return S;
20611 case 1:
20612 tmp = fieldFromInstruction(insn, 7, 5);
20613 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20614 tmp = fieldFromInstruction(insn, 7, 5);
20615 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20616 tmp = fieldFromInstruction(insn, 16, 32);
20617 if (!Check(S, decodeSImmOperand<32>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20618 return S;
20619 case 2:
20620 tmp = fieldFromInstruction(insn, 7, 5);
20621 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20622 tmp = fieldFromInstruction(insn, 15, 5);
20623 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20624 tmp = 0x0;
20625 tmp |= fieldFromInstruction(insn, 20, 10);
20626 tmp |= fieldFromInstruction(insn, 32, 16) << 10;
20627 if (!Check(S, decodeSImmOperand<26>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20628 return S;
20629 case 3:
20630 tmp = 0x0;
20631 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20632 tmp |= fieldFromInstruction(insn, 8, 4);
20633 tmp |= fieldFromInstruction(insn, 17, 3) << 12;
20634 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20635 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20636 tmp |= fieldFromInstruction(insn, 32, 16) << 15;
20637 if (!Check(S, decodeSImmOperandAndLslN<32, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20638 return S;
20639 case 4:
20640 tmp = fieldFromInstruction(insn, 15, 5);
20641 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20642 tmp = fieldFromInstruction(insn, 32, 16);
20643 if (!Check(S, decodeSImmNonZeroOperand<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20644 tmp = 0x0;
20645 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20646 tmp |= fieldFromInstruction(insn, 8, 4);
20647 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20648 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20649 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20650 return S;
20651 case 5:
20652 tmp = fieldFromInstruction(insn, 15, 5);
20653 if (!Check(S, DecodeGPRNoX0RegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20654 tmp = fieldFromInstruction(insn, 32, 16);
20655 if (!Check(S, decodeUImmNonZeroOperand<16>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20656 tmp = 0x0;
20657 tmp |= fieldFromInstruction(insn, 7, 1) << 10;
20658 tmp |= fieldFromInstruction(insn, 8, 4);
20659 tmp |= fieldFromInstruction(insn, 25, 6) << 4;
20660 tmp |= fieldFromInstruction(insn, 31, 1) << 11;
20661 if (!Check(S, decodeSImmOperandAndLslN<13, 1>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20662 return S;
20663 case 6:
20664 tmp = fieldFromInstruction(insn, 7, 5);
20665 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20666 tmp = fieldFromInstruction(insn, 15, 5);
20667 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20668 tmp = 0x0;
20669 tmp |= fieldFromInstruction(insn, 20, 10);
20670 tmp |= fieldFromInstruction(insn, 32, 16) << 10;
20671 if (!Check(S, decodeSImmOperand<26>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20672 return S;
20673 case 7:
20674 tmp = fieldFromInstruction(insn, 20, 5);
20675 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20676 tmp = fieldFromInstruction(insn, 15, 5);
20677 if (!Check(S, DecodeGPRRegisterClass(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20678 tmp = 0x0;
20679 tmp |= fieldFromInstruction(insn, 7, 5);
20680 tmp |= fieldFromInstruction(insn, 25, 5) << 5;
20681 tmp |= fieldFromInstruction(insn, 32, 16) << 10;
20682 if (!Check(S, decodeSImmOperand<26>(MI, tmp, Address, Decoder))) { return MCDisassembler::Fail; }
20683 return S;
20684 }
20685}
20686static bool checkDecoderPredicate(unsigned Idx, const FeatureBitset &FB) {
20687 switch (Idx) {
20688 default: llvm_unreachable("Invalid index!");
20689 case 0:
20690 return FB[RISCV::FeatureStdExtZca];
20691 case 1:
20692 return FB[RISCV::FeatureStdExtZcd];
20693 case 2:
20694 return FB[RISCV::FeatureStdExtZca] && FB[RISCV::Feature64Bit];
20695 case 3:
20696 return FB[RISCV::FeatureStdExtZcmop];
20697 case 4:
20698 return FB[RISCV::FeatureStdExtZcb];
20699 case 5:
20700 return FB[RISCV::FeatureStdExtZcb] && FB[RISCV::FeatureStdExtZmmul];
20701 case 6:
20702 return FB[RISCV::FeatureStdExtZcb] && FB[RISCV::FeatureStdExtZbb];
20703 case 7:
20704 return FB[RISCV::FeatureStdExtZcb] && FB[RISCV::FeatureStdExtZba] && FB[RISCV::Feature64Bit];
20705 case 8:
20706 return FB[RISCV::FeatureStdExtZcf] && !(FB[RISCV::Feature64Bit]);
20707 case 9:
20708 return FB[RISCV::FeatureStdExtZca] && !(FB[RISCV::Feature64Bit]);
20709 case 10:
20710 return FB[RISCV::FeatureVendorXqccmi] && !(FB[RISCV::Feature64Bit]);
20711 case 11:
20712 return FB[RISCV::FeatureVendorXqccmp];
20713 case 12:
20714 return FB[RISCV::FeatureVendorXqccmt];
20715 case 13:
20716 return FB[RISCV::FeatureVendorXqciint] && !(FB[RISCV::Feature64Bit]);
20717 case 14:
20718 return FB[RISCV::FeatureVendorXqcibm] && !(FB[RISCV::Feature64Bit]);
20719 case 15:
20720 return FB[RISCV::FeatureVendorXqciac] && !(FB[RISCV::Feature64Bit]);
20721 case 16:
20722 return FB[RISCV::FeatureVendorXqcisync] && !(FB[RISCV::Feature64Bit]);
20723 case 17:
20724 return FB[RISCV::FeatureVendorXqcicm] && !(FB[RISCV::Feature64Bit]);
20725 case 18:
20726 return FB[RISCV::FeatureVendorXwchc];
20727 case 19:
20728 return FB[RISCV::FeatureStdExtZclsd] && !(FB[RISCV::Feature64Bit]);
20729 case 20:
20730 return FB[RISCV::FeatureStdExtZcmt];
20731 case 21:
20732 return FB[RISCV::FeatureStdExtZcmp];
20733 case 22:
20734 return FB[RISCV::Feature64Bit];
20735 case 23:
20736 return FB[RISCV::FeatureStdExtZve32x];
20737 case 24:
20738 return FB[RISCV::FeatureStdExtZfh] || FB[RISCV::FeatureStdExtZfhmin] || FB[RISCV::FeatureStdExtZfbfmin];
20739 case 25:
20740 return FB[RISCV::FeatureStdExtF];
20741 case 26:
20742 return FB[RISCV::FeatureStdExtD];
20743 case 27:
20744 return FB[RISCV::FeatureStdExtQ];
20745 case 28:
20746 return FB[RISCV::FeatureStdExtZve64x];
20747 case 29:
20748 return FB[RISCV::Feature64Bit] && FB[RISCV::FeatureStdExtZve64x];
20749 case 30:
20750 return FB[RISCV::FeatureStdExtZve64x] && FB[RISCV::Feature64Bit];
20751 case 31:
20752 return FB[RISCV::FeatureStdExtZvvmtls];
20753 case 32:
20754 return FB[RISCV::FeatureStdExtZvvmttls];
20755 case 33:
20756 return FB[RISCV::FeatureStdExtZicbom];
20757 case 34:
20758 return FB[RISCV::FeatureStdExtZicboz];
20759 case 35:
20760 return FB[RISCV::FeatureStdExtZbkb] && !(FB[RISCV::Feature64Bit]);
20761 case 36:
20762 return FB[RISCV::FeatureStdExtZknh];
20763 case 37:
20764 return FB[RISCV::FeatureStdExtZknh] && FB[RISCV::Feature64Bit];
20765 case 38:
20766 return FB[RISCV::FeatureStdExtZksh];
20767 case 39:
20768 return FB[RISCV::FeatureStdExtZbs];
20769 case 40:
20770 return FB[RISCV::FeatureStdExtZknd] && FB[RISCV::Feature64Bit];
20771 case 41:
20772 return (FB[RISCV::FeatureStdExtZknd] || FB[RISCV::FeatureStdExtZkne]) && FB[RISCV::Feature64Bit];
20773 case 42:
20774 return FB[RISCV::FeatureStdExtZbb];
20775 case 43:
20776 return FB[RISCV::FeatureStdExtP];
20777 case 44:
20778 return FB[RISCV::FeatureStdExtZbb] || FB[RISCV::FeatureStdExtZbkb];
20779 case 45:
20780 return FB[RISCV::FeatureStdExtZbkb];
20781 case 46:
20782 return (FB[RISCV::FeatureStdExtZbb] || FB[RISCV::FeatureStdExtZbkb]) && !(FB[RISCV::Feature64Bit]);
20783 case 47:
20784 return FB[RISCV::FeatureStdExtP] && !(FB[RISCV::Feature64Bit]);
20785 case 48:
20786 return FB[RISCV::FeatureStdExtP] && FB[RISCV::Feature64Bit];
20787 case 49:
20788 return (FB[RISCV::FeatureStdExtZbb] || FB[RISCV::FeatureStdExtZbkb]) && FB[RISCV::Feature64Bit];
20789 case 50:
20790 return FB[RISCV::FeatureStdExtZba] && FB[RISCV::Feature64Bit];
20791 case 51:
20792 return FB[RISCV::FeatureStdExtZbb] && FB[RISCV::Feature64Bit];
20793 case 52:
20794 return FB[RISCV::FeatureStdExtZabha];
20795 case 53:
20796 return FB[RISCV::FeatureStdExtZaamo];
20797 case 54:
20798 return FB[RISCV::FeatureStdExtZaamo] && FB[RISCV::Feature64Bit];
20799 case 55:
20800 return FB[RISCV::FeatureStdExtZalrsc];
20801 case 56:
20802 return FB[RISCV::FeatureStdExtZalrsc] && FB[RISCV::Feature64Bit];
20803 case 57:
20804 return FB[RISCV::FeatureStdExtZabha] && FB[RISCV::FeatureStdExtZacas];
20805 case 58:
20806 return FB[RISCV::FeatureStdExtZacas];
20807 case 59:
20808 return FB[RISCV::FeatureStdExtZacas] && FB[RISCV::Feature64Bit];
20809 case 60:
20810 return FB[RISCV::FeatureStdExtZalasr];
20811 case 61:
20812 return FB[RISCV::FeatureStdExtZalasr] && FB[RISCV::Feature64Bit];
20813 case 62:
20814 return FB[RISCV::FeatureStdExtZicfiss];
20815 case 63:
20816 return FB[RISCV::FeatureStdExtZicfiss] && FB[RISCV::Feature64Bit];
20817 case 64:
20818 return FB[RISCV::FeatureStdExtZilx];
20819 case 65:
20820 return FB[RISCV::FeatureStdExtZilx] && FB[RISCV::Feature64Bit];
20821 case 66:
20822 return FB[RISCV::FeatureStdExtZmmul];
20823 case 67:
20824 return FB[RISCV::FeatureStdExtM];
20825 case 68:
20826 return FB[RISCV::FeatureStdExtZbkb] || FB[RISCV::FeatureStdExtP];
20827 case 69:
20828 return FB[RISCV::FeatureStdExtZbkc];
20829 case 70:
20830 return FB[RISCV::FeatureStdExtZbc];
20831 case 71:
20832 return FB[RISCV::FeatureStdExtZicond];
20833 case 72:
20834 return FB[RISCV::FeatureStdExtZknh] && !(FB[RISCV::Feature64Bit]);
20835 case 73:
20836 return FB[RISCV::FeatureStdExtZba];
20837 case 74:
20838 return FB[RISCV::FeatureStdExtZkne] && !(FB[RISCV::Feature64Bit]);
20839 case 75:
20840 return FB[RISCV::FeatureStdExtZbkx];
20841 case 76:
20842 return FB[RISCV::FeatureStdExtZknd] && !(FB[RISCV::Feature64Bit]);
20843 case 77:
20844 return FB[RISCV::FeatureStdExtZksed];
20845 case 78:
20846 return FB[RISCV::FeatureStdExtZkne] && FB[RISCV::Feature64Bit];
20847 case 79:
20848 return FB[RISCV::FeatureStdExtZmmul] && FB[RISCV::Feature64Bit];
20849 case 80:
20850 return FB[RISCV::FeatureStdExtM] && FB[RISCV::Feature64Bit];
20851 case 81:
20852 return FB[RISCV::FeatureStdExtZbkb] && FB[RISCV::Feature64Bit];
20853 case 82:
20854 return FB[RISCV::FeatureStdExtZfh];
20855 case 83:
20856 return FB[RISCV::FeatureStdExtZfa];
20857 case 84:
20858 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtD];
20859 case 85:
20860 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtZfh];
20861 case 86:
20862 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtQ];
20863 case 87:
20864 return FB[RISCV::FeatureStdExtZfhmin];
20865 case 88:
20866 return FB[RISCV::FeatureStdExtZfbfmin];
20867 case 89:
20868 return FB[RISCV::FeatureStdExtZfhmin] && FB[RISCV::FeatureStdExtD];
20869 case 90:
20870 return FB[RISCV::FeatureStdExtZfhmin] && FB[RISCV::FeatureStdExtQ];
20871 case 91:
20872 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtD] && !(FB[RISCV::Feature64Bit]);
20873 case 92:
20874 return FB[RISCV::FeatureStdExtZfa] && FB[RISCV::FeatureStdExtQ] && FB[RISCV::Feature64Bit];
20875 case 93:
20876 return FB[RISCV::FeatureStdExtF] && FB[RISCV::Feature64Bit];
20877 case 94:
20878 return FB[RISCV::FeatureStdExtD] && FB[RISCV::Feature64Bit];
20879 case 95:
20880 return FB[RISCV::FeatureStdExtZfh] && FB[RISCV::Feature64Bit];
20881 case 96:
20882 return FB[RISCV::FeatureStdExtQ] && FB[RISCV::Feature64Bit];
20883 case 97:
20884 return FB[RISCV::FeatureStdExtZfa] && (FB[RISCV::FeatureStdExtZfh] || FB[RISCV::FeatureStdExtZvfh]);
20885 case 98:
20886 return FB[RISCV::FeatureStdExtZvkb];
20887 case 99:
20888 return FB[RISCV::FeatureStdExtZvzip];
20889 case 100:
20890 return FB[RISCV::FeatureStdExtZvbb];
20891 case 101:
20892 return FB[RISCV::FeatureStdExtZvvmm];
20893 case 102:
20894 return FB[RISCV::FeatureStdExtZvvfmm];
20895 case 103:
20896 return FB[RISCV::FeatureStdExtZvabd];
20897 case 104:
20898 return FB[RISCV::FeatureStdExtZve32f];
20899 case 105:
20900 return FB[RISCV::FeatureStdExtZvfbfmin] || FB[RISCV::FeatureStdExtZvfofp8min];
20901 case 106:
20902 return FB[RISCV::FeatureStdExtZvfofp8min];
20903 case 107:
20904 return FB[RISCV::FeatureStdExtZvfbfwma];
20905 case 108:
20906 return FB[RISCV::FeatureStdExtZvbc] || FB[RISCV::FeatureStdExtZvbc32e];
20907 case 109:
20908 return FB[RISCV::FeatureStdExtZvdot4a8i];
20909 case 110:
20910 return FB[RISCV::FeatureStdExtZibi];
20911 case 111:
20912 return FB[RISCV::FeatureStdExtZawrs];
20913 case 112:
20914 return FB[RISCV::FeatureStdExtSmctr] || FB[RISCV::FeatureStdExtSsctr];
20915 case 113:
20916 return FB[RISCV::FeatureStdExtSsip];
20917 case 114:
20918 return FB[RISCV::FeatureStdExtSscsps];
20919 case 115:
20920 return FB[RISCV::FeatureStdExtSvinval];
20921 case 116:
20922 return FB[RISCV::FeatureStdExtH];
20923 case 117:
20924 return FB[RISCV::FeatureStdExtSvinval] && FB[RISCV::FeatureStdExtH];
20925 case 118:
20926 return FB[RISCV::FeatureStdExtSmip];
20927 case 119:
20928 return FB[RISCV::FeatureStdExtSmcsps];
20929 case 120:
20930 return FB[RISCV::FeatureStdExtSmrnmi];
20931 case 121:
20932 return FB[RISCV::Feature64Bit] && FB[RISCV::FeatureStdExtH];
20933 case 122:
20934 return FB[RISCV::FeatureStdExtZimop];
20935 case 123:
20936 return FB[RISCV::FeatureStdExtZvksh];
20937 case 124:
20938 return FB[RISCV::FeatureStdExtZvksed];
20939 case 125:
20940 return FB[RISCV::FeatureStdExtZvkned];
20941 case 126:
20942 return FB[RISCV::FeatureStdExtZvkgs];
20943 case 127:
20944 return FB[RISCV::FeatureStdExtZvfwdota16bf];
20945 case 128:
20946 return FB[RISCV::FeatureStdExtZvqwdota8i] || FB[RISCV::FeatureStdExtZvqwdota16i];
20947 case 129:
20948 return FB[RISCV::FeatureStdExtZvfqwdota8f];
20949 case 130:
20950 return FB[RISCV::FeatureStdExtZvkg];
20951 case 131:
20952 return FB[RISCV::FeatureStdExtZvfbdota32f];
20953 case 132:
20954 return FB[RISCV::FeatureStdExtZvfwbdota16bf];
20955 case 133:
20956 return FB[RISCV::FeatureStdExtZvknha];
20957 case 134:
20958 return FB[RISCV::FeatureStdExtZvqwbdota8i] || FB[RISCV::FeatureStdExtZvqwbdota16i];
20959 case 135:
20960 return FB[RISCV::FeatureStdExtZvfqwbdota8f];
20961 case 136:
20962 return FB[RISCV::FeatureStdExtY];
20963 case 137:
20964 return FB[RISCV::FeatureStdExtZilsd] && !(FB[RISCV::Feature64Bit]);
20965 case 138:
20966 return FB[RISCV::FeatureStdExtZacas] && !(FB[RISCV::Feature64Bit]);
20967 case 139:
20968 return FB[RISCV::FeatureVendorXAIFET];
20969 case 140:
20970 return FB[RISCV::FeatureVendorXAndesPerf];
20971 case 141:
20972 return FB[RISCV::FeatureVendorXAndesVBFHCvt];
20973 case 142:
20974 return FB[RISCV::FeatureVendorXAndesBFHCvt];
20975 case 143:
20976 return FB[RISCV::FeatureVendorXAndesVSIntH] && FB[RISCV::FeatureStdExtZve32f];
20977 case 144:
20978 return FB[RISCV::FeatureVendorXAndesVSIntH];
20979 case 145:
20980 return FB[RISCV::FeatureVendorXAndesVSIntLoad];
20981 case 146:
20982 return FB[RISCV::FeatureVendorXAndesVPackFPH];
20983 case 147:
20984 return FB[RISCV::FeatureVendorXAndesPerf] && FB[RISCV::Feature64Bit];
20985 case 148:
20986 return FB[RISCV::FeatureVendorXAndesVDot];
20987 case 149:
20988 return FB[RISCV::FeatureVendorXCVmem] && !(FB[RISCV::Feature64Bit]);
20989 case 150:
20990 return FB[RISCV::FeatureVendorXCVbitmanip] && !(FB[RISCV::Feature64Bit]);
20991 case 151:
20992 return FB[RISCV::FeatureVendorXCVsimd] && !(FB[RISCV::Feature64Bit]);
20993 case 152:
20994 return FB[RISCV::FeatureVendorXCValu] && !(FB[RISCV::Feature64Bit]);
20995 case 153:
20996 return FB[RISCV::FeatureVendorXCVelw] && !(FB[RISCV::Feature64Bit]);
20997 case 154:
20998 return FB[RISCV::FeatureVendorXCVmac] && !(FB[RISCV::Feature64Bit]);
20999 case 155:
21000 return FB[RISCV::FeatureVendorXCVbi] && !(FB[RISCV::Feature64Bit]);
21001 case 156:
21002 return FB[RISCV::FeatureVendorXMIPSCBOP];
21003 case 157:
21004 return FB[RISCV::FeatureVendorXMIPSEXECTL];
21005 case 158:
21006 return FB[RISCV::FeatureVendorXMIPSCMov];
21007 case 159:
21008 return FB[RISCV::FeatureVendorXMIPSLSP] && FB[RISCV::Feature64Bit];
21009 case 160:
21010 return FB[RISCV::FeatureVendorXMIPSLSP];
21011 case 161:
21012 return FB[RISCV::FeatureVendorXSMTVDotII] && FB[RISCV::Feature64Bit];
21013 case 162:
21014 return FB[RISCV::FeatureVendorXSMTVDot] && FB[RISCV::Feature64Bit];
21015 case 163:
21016 return FB[RISCV::FeatureVendorXSfcease];
21017 case 164:
21018 return FB[RISCV::FeatureVendorXSiFivecflushdlone];
21019 case 165:
21020 return FB[RISCV::FeatureVendorXSiFivecdiscarddlone];
21021 case 166:
21022 return FB[RISCV::FeatureVendorXSfvcp];
21023 case 167:
21024 return FB[RISCV::FeatureVendorXSfmmbase];
21025 case 168:
21026 return FB[RISCV::FeatureVendorXSfvfexpa];
21027 case 169:
21028 return FB[RISCV::FeatureVendorXSfvfbfexp16e] || FB[RISCV::FeatureVendorXSfvfexp16e] || FB[RISCV::FeatureVendorXSfvfexp32e];
21029 case 170:
21030 return FB[RISCV::FeatureVendorXSfvfnrclipxfqf];
21031 case 171:
21032 return FB[RISCV::FeatureVendorXSfvqmaccdod];
21033 case 172:
21034 return FB[RISCV::FeatureVendorXSfmm32a8i];
21035 case 173:
21036 return FB[RISCV::FeatureVendorXSfvfwmaccqqq];
21037 case 174:
21038 return FB[RISCV::FeatureVendorXSfmm32a16f] || FB[RISCV::FeatureVendorXSfmm32a32f] || FB[RISCV::FeatureVendorXSfmm64a64f];
21039 case 175:
21040 return FB[RISCV::FeatureVendorXSfmm32a8f];
21041 case 176:
21042 return FB[RISCV::FeatureVendorXSfvqmaccqoq];
21043 case 177:
21044 return FB[RISCV::FeatureVendorXTHeadCmo];
21045 case 178:
21046 return FB[RISCV::FeatureVendorXTHeadSync];
21047 case 179:
21048 return FB[RISCV::FeatureVendorXTHeadBa];
21049 case 180:
21050 return FB[RISCV::FeatureVendorXTHeadBb];
21051 case 181:
21052 return FB[RISCV::FeatureVendorXTHeadBb] && FB[RISCV::Feature64Bit];
21053 case 182:
21054 return FB[RISCV::FeatureVendorXTHeadMac];
21055 case 183:
21056 return FB[RISCV::FeatureVendorXTHeadMac] && FB[RISCV::Feature64Bit];
21057 case 184:
21058 return FB[RISCV::FeatureVendorXTHeadCondMov];
21059 case 185:
21060 return FB[RISCV::FeatureVendorXTHeadBs];
21061 case 186:
21062 return FB[RISCV::FeatureVendorXTHeadMemIdx];
21063 case 187:
21064 return FB[RISCV::FeatureVendorXTHeadMemIdx] && FB[RISCV::Feature64Bit];
21065 case 188:
21066 return FB[RISCV::FeatureVendorXTHeadMemPair];
21067 case 189:
21068 return FB[RISCV::FeatureVendorXTHeadMemPair] && FB[RISCV::Feature64Bit];
21069 case 190:
21070 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtF];
21071 case 191:
21072 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtF] && FB[RISCV::Feature64Bit];
21073 case 192:
21074 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtD];
21075 case 193:
21076 return FB[RISCV::FeatureVendorXTHeadFMemIdx] && FB[RISCV::FeatureStdExtD] && FB[RISCV::Feature64Bit];
21077 case 194:
21078 return FB[RISCV::FeatureVendorXTHeadVdot];
21079 case 195:
21080 return FB[RISCV::FeatureVendorXqcia] && !(FB[RISCV::Feature64Bit]);
21081 case 196:
21082 return FB[RISCV::FeatureVendorXqciio] && !(FB[RISCV::Feature64Bit]);
21083 case 197:
21084 return FB[RISCV::FeatureVendorXqcilsm] && !(FB[RISCV::Feature64Bit]);
21085 case 198:
21086 return FB[RISCV::FeatureVendorXqcisls] && !(FB[RISCV::Feature64Bit]);
21087 case 199:
21088 return FB[RISCV::FeatureVendorXqcisim] && !(FB[RISCV::Feature64Bit]);
21089 case 200:
21090 return FB[RISCV::FeatureVendorXqcili] && !(FB[RISCV::Feature64Bit]);
21091 case 201:
21092 return FB[RISCV::FeatureVendorXqcicli] && !(FB[RISCV::Feature64Bit]);
21093 case 202:
21094 return FB[RISCV::FeatureVendorXqcics] && !(FB[RISCV::Feature64Bit]);
21095 case 203:
21096 return FB[RISCV::FeatureVendorXqcicsr] && !(FB[RISCV::Feature64Bit]);
21097 case 204:
21098 return FB[RISCV::FeatureVendorXqcibi] && !(FB[RISCV::Feature64Bit]);
21099 case 205:
21100 return FB[RISCV::FeatureStdExtZhinxmin] && FB[RISCV::FeatureStdExtZdinx] && !(FB[RISCV::Feature64Bit]);
21101 case 206:
21102 return FB[RISCV::FeatureStdExtZdinx] && !(FB[RISCV::Feature64Bit]);
21103 case 207:
21104 return FB[RISCV::FeatureStdExtZfinx];
21105 case 208:
21106 return FB[RISCV::FeatureStdExtZdinx] && FB[RISCV::Feature64Bit];
21107 case 209:
21108 return FB[RISCV::FeatureStdExtZhinx];
21109 case 210:
21110 return FB[RISCV::FeatureStdExtZhinxmin];
21111 case 211:
21112 return FB[RISCV::FeatureStdExtZhinxmin] && FB[RISCV::FeatureStdExtZdinx] && FB[RISCV::Feature64Bit];
21113 case 212:
21114 return FB[RISCV::FeatureStdExtZfinx] && FB[RISCV::Feature64Bit];
21115 case 213:
21116 return FB[RISCV::FeatureStdExtZdinx] && FB[RISCV::Feature64Bit] && FB[RISCV::Feature64Bit];
21117 case 214:
21118 return FB[RISCV::FeatureStdExtZhinx] && FB[RISCV::Feature64Bit];
21119 case 215:
21120 return FB[RISCV::FeatureVendorXqcilia] && !(FB[RISCV::Feature64Bit]);
21121 case 216:
21122 return FB[RISCV::FeatureVendorXqcilb] && !(FB[RISCV::Feature64Bit]);
21123 case 217:
21124 return FB[RISCV::FeatureVendorXqcilo] && !(FB[RISCV::Feature64Bit]);
21125 }
21126}
21127
21128
21129template <typename InsnType>
21130static DecodeStatus decodeInstruction(const uint8_t DecodeTable[], MCInst &MI,
21131 InsnType insn, uint64_t Address,
21132 const MCDisassembler *DisAsm,
21133 const MCSubtargetInfo &STI) {
21134 const FeatureBitset &Bits = STI.getFeatureBits();
21135 const uint8_t *Ptr = DecodeTable;
21136
21137 [[maybe_unused]] uint32_t BitWidth = decodeULEB128AndIncUnsafe(p&: Ptr);
21138 assert(InsnBitWidth<InsnType> == BitWidth &&
21139 "Table and instruction bitwidth mismatch");
21140
21141 SmallVector<const uint8_t *, 8> ScopeStack;
21142 DecodeStatus S = MCDisassembler::Success;
21143 while (true) {
21144 ptrdiff_t Loc = Ptr - DecodeTable;
21145 const uint8_t DecoderOp = *Ptr++;
21146 switch (DecoderOp) {
21147 default:
21148 errs() << Loc << ": Unexpected decode table opcode: "
21149 << (int)DecoderOp << '\n';
21150 return MCDisassembler::Fail;
21151 case OPC_Scope: {
21152 unsigned NumToSkip = decodeULEB128AndIncUnsafe(p&: Ptr);
21153 const uint8_t *SkipTo = Ptr + NumToSkip;
21154 ScopeStack.push_back(Elt: SkipTo);
21155 LLVM_DEBUG(dbgs() << Loc << ": OPC_Scope(" << SkipTo - DecodeTable
21156 << ")\n");
21157 continue;
21158 }
21159 case OPC_SwitchField: {
21160 // Decode the start value.
21161 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
21162 unsigned Len = *Ptr++;
21163 uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
21164 uint64_t CaseValue;
21165 unsigned CaseSize;
21166 while (true) {
21167 CaseValue = decodeULEB128AndIncUnsafe(p&: Ptr);
21168 CaseSize = decodeULEB128AndIncUnsafe(p&: Ptr);
21169 if (FieldValue == CaseValue || !CaseSize)
21170 break;
21171 Ptr += CaseSize;
21172 }
21173 if (FieldValue == CaseValue) {
21174 LLVM_DEBUG(dbgs() << Loc << ": OPC_SwitchField(" << Start << ", " << Len
21175 << "): " << FieldValue << '\n');
21176 continue;
21177 }
21178 break;
21179 }
21180 case OPC_CheckField: {
21181 // Decode the start value.
21182 unsigned Start = decodeULEB128AndIncUnsafe(p&: Ptr);
21183 unsigned Len = *Ptr;
21184 uint64_t FieldValue = fieldFromInstruction(insn, Start, Len);
21185 // Decode the field value.
21186 unsigned PtrLen = 0;
21187 uint64_t ExpectedValue = decodeULEB128(p: ++Ptr, n: &PtrLen);
21188 Ptr += PtrLen;
21189 bool Failed = ExpectedValue != FieldValue;
21190
21191 LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckField(" << Start << ", " << Len
21192 << ", " << ExpectedValue << "): FieldValue = "
21193 << FieldValue << ", ExpectedValue = " << ExpectedValue
21194 << ": " << (Failed ? "FAIL, " : "PASS\n"););
21195 if (!Failed)
21196 continue;
21197 break;
21198 }
21199 case OPC_CheckPredicate: {
21200 // Decode the Predicate Index value.
21201 unsigned PIdx = decodeULEB128AndIncUnsafe(p&: Ptr);
21202 // Check the predicate.
21203 bool Failed = !checkDecoderPredicate(Idx: PIdx, FB: Bits);
21204
21205 LLVM_DEBUG(dbgs() << Loc << ": OPC_CheckPredicate(" << PIdx << "): "
21206 << (Failed ? "FAIL, " : "PASS\n"););
21207 if (!Failed)
21208 continue;
21209 break;
21210 }
21211 case OPC_Decode: {
21212 // Decode the Opcode value.
21213 unsigned Opc = decodeULEB128AndIncUnsafe(p&: Ptr);
21214 unsigned DecodeIdx = decodeULEB128AndIncUnsafe(p&: Ptr);
21215
21216 MI.clear();
21217 MI.setOpcode(Opc);
21218 bool DecodeComplete;
21219 S = decodeToMCInst(DecodeIdx, S, insn, MI, Address, DisAsm,
21220 DecodeComplete);
21221 LLVM_DEBUG(dbgs() << Loc << ": OPC_Decode: opcode " << Opc
21222 << ", using decoder " << DecodeIdx << ": "
21223 << (S ? "PASS, " : "FAIL, "));
21224
21225 if (DecodeComplete) {
21226 LLVM_DEBUG(dbgs() << "decoding complete\n");
21227 return S;
21228 }
21229 assert(S == MCDisassembler::Fail);
21230 // Reset decode status. This also drops a SoftFail status that could be
21231 // set before the decode attempt.
21232 S = MCDisassembler::Success;
21233 break;
21234 }
21235 }
21236 if (ScopeStack.empty()) {
21237 LLVM_DEBUG(dbgs() << "returning Fail\n");
21238 return MCDisassembler::Fail;
21239 }
21240 Ptr = ScopeStack.pop_back_val();
21241 LLVM_DEBUG(dbgs() << "continuing at " << Ptr - DecodeTable << '\n');
21242 }
21243 llvm_unreachable("bogosity detected in disassembler state machine!");
21244}
21245
21246
21247} // namespace
21248