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, 141, 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, 203, 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, 245, 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, 246, 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, 201, 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, 130, 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, 211, 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, 204, 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, 212, 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, 233, 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, 231, 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, 234, 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, 224, 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, 134, 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, 240, 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, 133, 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, 241, 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, 242, 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, 237, 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, 238, 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, 239, 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, 202, 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, 232, 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, 225, 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, 223, 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, 229, 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, 228, 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, 249, 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, 128, 114, 17, // 299: decode to C_SH using decoder 17
180 // 299: }
181 // 299: } // switch Inst[12:10]
182 // 299: }
183 1, 161, 1, // 303: case 0x1: {
184 OPC_SwitchField, 10, 2, // 306: switch Inst[11:10] {
185 0, 6, // 309: case 0x0: {
186 OPC_CheckPredicate, 0, // 311: check predicate 0
187 OPC_Decode, 132, 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, 131, 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, 207, 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, 135, 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, 136, 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, 142, 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, 205, 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, 248, 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, 243, 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, 206, 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, 143, 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, 254, 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, 144, 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, 255, 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, 145, 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, 247, 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, 222, 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, 244, 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, 210, 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, 221, 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, 200, 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, 215, 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, 219, 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, 216, 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, 137, 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, 208, 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, 138, 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, 250, 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, 209, 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, 251, 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, 213, 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, 217, 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, 220, 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, 214, 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, 218, 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, 176, 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, 180, 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, 179, 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, 184, 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, 185, 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, 181, 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, 183, 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, 182, 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, 178, 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, 177, 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, 199, 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, 200, 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, 203, 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, 202, 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, 201, 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, 194, 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, 196, 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, 195, 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, 197, 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, 206, 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, 193, 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, 198, 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, 204, 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, 207, 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, 208, 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, 209, 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, 191, 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, 210, 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, 192, 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, 205, 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, 194, 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, 196, 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, 195, 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, 197, 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, 199, 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, 201, 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, 198, 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, 200, 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, 227, 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, 226, 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, 253, 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, 252, 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, 255, 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, 254, 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, 131, 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, 128, 111, 36, // 108: decode to CM_POP using decoder 36
682 // 108: }
683 // 108: } // switch Inst[9:8]
684 // 108: }
685 7, 0, // 112: case 0x7: {
686 OPC_SwitchField, 8, 2, // 114: switch Inst[9:8] {
687 0, 10, // 117: case 0x0: {
688 OPC_CheckPredicate, 21, // 119: check predicate 21
689 OPC_CheckField, 0, 2, 2, // 121: check Inst[1:0] == 0x2
690 OPC_Decode, 130, 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, 129, 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, 253, 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, 252, 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[20935] = {
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, 222, 116, 0, // 11: decode to LB using decoder 0
1176 // 11: }
1177 1, 4, // 15: case 0x1: {
1178 OPC_Decode, 230, 116, 0, // 17: decode to LH using decoder 0
1179 // 17: }
1180 2, 4, // 21: case 0x2: {
1181 OPC_Decode, 244, 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, 226, 116, 0, // 31: decode to LD using decoder 0
1186 // 31: }
1187 4, 4, // 35: case 0x4: {
1188 OPC_Decode, 223, 116, 0, // 37: decode to LBU using decoder 0
1189 // 37: }
1190 5, 4, // 41: case 0x5: {
1191 OPC_Decode, 231, 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, 245, 116, 0, // 51: decode to LWU using decoder 0
1196 // 51: }
1197 // 51: } // switch Inst[14:12]
1198 // 51: }
1199 7, 196, 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, 221, 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, 201, 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, 222, 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, 220, 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, 218, 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, 130, 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, 226, 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, 138, 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, 205, 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, 137, 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, 222, 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, 190, 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, 230, 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, 146, 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, 145, 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, 226, 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, 194, 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, 234, 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, 154, 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, 209, 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, 153, 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, 230, 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, 198, 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, 238, 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, 162, 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, 161, 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, 234, 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, 202, 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, 242, 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, 170, 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, 169, 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, 238, 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, 206, 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, 246, 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, 178, 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, 177, 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, 242, 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, 210, 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, 250, 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, 186, 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, 213, 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, 185, 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, 246, 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, 214, 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, 254, 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, 158, 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, 176, 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, 145, 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, 163, 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, 215, 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, 198, 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, 214, 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, 215, 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, 255, 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, 223, 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, 132, 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, 202, 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, 131, 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, 219, 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, 187, 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, 227, 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, 140, 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, 139, 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, 223, 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, 191, 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, 231, 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, 148, 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, 206, 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, 147, 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, 227, 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, 195, 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, 235, 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, 156, 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, 155, 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, 231, 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, 199, 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, 239, 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, 164, 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, 163, 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, 235, 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, 203, 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, 243, 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, 172, 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, 171, 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, 239, 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, 207, 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, 247, 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, 180, 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, 210, 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, 179, 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, 243, 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, 211, 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, 251, 127, 3, // 988: decode to VLOXSEG8EI16_V using decoder 3
1651 // 988: }
1652 // 988: } // switch Inst[31:26]
1653 // 988: }
1654 6, 185, 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, 217, 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, 199, 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, 216, 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, 216, 128, 1, 3, // 1035: decode to VLUXEI32_V using decoder 3
1676 // 1035: }
1677 2, 7, // 1040: case 0x2: {
1678 OPC_CheckPredicate, 23, // 1042: check predicate 23
1679 OPC_Decode, 128, 128, 1, 4, // 1044: decode to VLSE32_V using decoder 4
1680 // 1044: }
1681 3, 6, // 1049: case 0x3: {
1682 OPC_CheckPredicate, 23, // 1051: check predicate 23
1683 OPC_Decode, 224, 127, 3, // 1053: decode to VLOXEI32_V using decoder 3
1684 // 1053: }
1685 8, 33, // 1057: case 0x8: {
1686 OPC_SwitchField, 20, 5, // 1059: switch Inst[24:20] {
1687 0, 7, // 1062: case 0x0: {
1688 OPC_CheckPredicate, 23, // 1064: check predicate 23
1689 OPC_Decode, 134, 128, 1, 1, // 1066: decode to VLSEG2E32_V using decoder 1
1690 // 1066: }
1691 8, 10, // 1071: case 0x8: {
1692 OPC_CheckPredicate, 23, // 1073: check predicate 23
1693 OPC_CheckField, 25, 1, 1, // 1075: check Inst[25] == 0x1
1694 OPC_Decode, 203, 127, 5, // 1079: decode to VL2RE32_V using decoder 5
1695 // 1079: }
1696 16, 0, // 1083: case 0x10: {
1697 OPC_CheckPredicate, 23, // 1085: check predicate 23
1698 OPC_Decode, 133, 128, 1, 1, // 1087: decode to VLSEG2E32FF_V using decoder 1
1699 // 1087: }
1700 // 1087: } // switch Inst[24:20]
1701 // 1087: }
1702 9, 7, // 1092: case 0x9: {
1703 OPC_CheckPredicate, 23, // 1094: check predicate 23
1704 OPC_Decode, 220, 128, 1, 3, // 1096: decode to VLUXSEG2EI32_V using decoder 3
1705 // 1096: }
1706 10, 7, // 1101: case 0xa: {
1707 OPC_CheckPredicate, 23, // 1103: check predicate 23
1708 OPC_Decode, 188, 128, 1, 4, // 1105: decode to VLSSEG2E32_V using decoder 4
1709 // 1105: }
1710 11, 6, // 1110: case 0xb: {
1711 OPC_CheckPredicate, 23, // 1112: check predicate 23
1712 OPC_Decode, 228, 127, 3, // 1114: decode to VLOXSEG2EI32_V using decoder 3
1713 // 1114: }
1714 16, 21, // 1118: case 0x10: {
1715 OPC_SwitchField, 20, 5, // 1120: switch Inst[24:20] {
1716 0, 7, // 1123: case 0x0: {
1717 OPC_CheckPredicate, 23, // 1125: check predicate 23
1718 OPC_Decode, 142, 128, 1, 1, // 1127: decode to VLSEG3E32_V using decoder 1
1719 // 1127: }
1720 16, 0, // 1132: case 0x10: {
1721 OPC_CheckPredicate, 23, // 1134: check predicate 23
1722 OPC_Decode, 141, 128, 1, 1, // 1136: decode to VLSEG3E32FF_V using decoder 1
1723 // 1136: }
1724 // 1136: } // switch Inst[24:20]
1725 // 1136: }
1726 17, 7, // 1141: case 0x11: {
1727 OPC_CheckPredicate, 23, // 1143: check predicate 23
1728 OPC_Decode, 224, 128, 1, 3, // 1145: decode to VLUXSEG3EI32_V using decoder 3
1729 // 1145: }
1730 18, 7, // 1150: case 0x12: {
1731 OPC_CheckPredicate, 23, // 1152: check predicate 23
1732 OPC_Decode, 192, 128, 1, 4, // 1154: decode to VLSSEG3E32_V using decoder 4
1733 // 1154: }
1734 19, 6, // 1159: case 0x13: {
1735 OPC_CheckPredicate, 23, // 1161: check predicate 23
1736 OPC_Decode, 232, 127, 3, // 1163: decode to VLOXSEG3EI32_V using decoder 3
1737 // 1163: }
1738 24, 33, // 1167: case 0x18: {
1739 OPC_SwitchField, 20, 5, // 1169: switch Inst[24:20] {
1740 0, 7, // 1172: case 0x0: {
1741 OPC_CheckPredicate, 23, // 1174: check predicate 23
1742 OPC_Decode, 150, 128, 1, 1, // 1176: decode to VLSEG4E32_V using decoder 1
1743 // 1176: }
1744 8, 10, // 1181: case 0x8: {
1745 OPC_CheckPredicate, 23, // 1183: check predicate 23
1746 OPC_CheckField, 25, 1, 1, // 1185: check Inst[25] == 0x1
1747 OPC_Decode, 207, 127, 6, // 1189: decode to VL4RE32_V using decoder 6
1748 // 1189: }
1749 16, 0, // 1193: case 0x10: {
1750 OPC_CheckPredicate, 23, // 1195: check predicate 23
1751 OPC_Decode, 149, 128, 1, 1, // 1197: decode to VLSEG4E32FF_V using decoder 1
1752 // 1197: }
1753 // 1197: } // switch Inst[24:20]
1754 // 1197: }
1755 25, 7, // 1202: case 0x19: {
1756 OPC_CheckPredicate, 23, // 1204: check predicate 23
1757 OPC_Decode, 228, 128, 1, 3, // 1206: decode to VLUXSEG4EI32_V using decoder 3
1758 // 1206: }
1759 26, 7, // 1211: case 0x1a: {
1760 OPC_CheckPredicate, 23, // 1213: check predicate 23
1761 OPC_Decode, 196, 128, 1, 4, // 1215: decode to VLSSEG4E32_V using decoder 4
1762 // 1215: }
1763 27, 6, // 1220: case 0x1b: {
1764 OPC_CheckPredicate, 23, // 1222: check predicate 23
1765 OPC_Decode, 236, 127, 3, // 1224: decode to VLOXSEG4EI32_V using decoder 3
1766 // 1224: }
1767 32, 21, // 1228: case 0x20: {
1768 OPC_SwitchField, 20, 5, // 1230: switch Inst[24:20] {
1769 0, 7, // 1233: case 0x0: {
1770 OPC_CheckPredicate, 23, // 1235: check predicate 23
1771 OPC_Decode, 158, 128, 1, 1, // 1237: decode to VLSEG5E32_V using decoder 1
1772 // 1237: }
1773 16, 0, // 1242: case 0x10: {
1774 OPC_CheckPredicate, 23, // 1244: check predicate 23
1775 OPC_Decode, 157, 128, 1, 1, // 1246: decode to VLSEG5E32FF_V using decoder 1
1776 // 1246: }
1777 // 1246: } // switch Inst[24:20]
1778 // 1246: }
1779 33, 7, // 1251: case 0x21: {
1780 OPC_CheckPredicate, 23, // 1253: check predicate 23
1781 OPC_Decode, 232, 128, 1, 3, // 1255: decode to VLUXSEG5EI32_V using decoder 3
1782 // 1255: }
1783 34, 7, // 1260: case 0x22: {
1784 OPC_CheckPredicate, 23, // 1262: check predicate 23
1785 OPC_Decode, 200, 128, 1, 4, // 1264: decode to VLSSEG5E32_V using decoder 4
1786 // 1264: }
1787 35, 6, // 1269: case 0x23: {
1788 OPC_CheckPredicate, 23, // 1271: check predicate 23
1789 OPC_Decode, 240, 127, 3, // 1273: decode to VLOXSEG5EI32_V using decoder 3
1790 // 1273: }
1791 40, 21, // 1277: case 0x28: {
1792 OPC_SwitchField, 20, 5, // 1279: switch Inst[24:20] {
1793 0, 7, // 1282: case 0x0: {
1794 OPC_CheckPredicate, 23, // 1284: check predicate 23
1795 OPC_Decode, 166, 128, 1, 1, // 1286: decode to VLSEG6E32_V using decoder 1
1796 // 1286: }
1797 16, 0, // 1291: case 0x10: {
1798 OPC_CheckPredicate, 23, // 1293: check predicate 23
1799 OPC_Decode, 165, 128, 1, 1, // 1295: decode to VLSEG6E32FF_V using decoder 1
1800 // 1295: }
1801 // 1295: } // switch Inst[24:20]
1802 // 1295: }
1803 41, 7, // 1300: case 0x29: {
1804 OPC_CheckPredicate, 23, // 1302: check predicate 23
1805 OPC_Decode, 236, 128, 1, 3, // 1304: decode to VLUXSEG6EI32_V using decoder 3
1806 // 1304: }
1807 42, 7, // 1309: case 0x2a: {
1808 OPC_CheckPredicate, 23, // 1311: check predicate 23
1809 OPC_Decode, 204, 128, 1, 4, // 1313: decode to VLSSEG6E32_V using decoder 4
1810 // 1313: }
1811 43, 6, // 1318: case 0x2b: {
1812 OPC_CheckPredicate, 23, // 1320: check predicate 23
1813 OPC_Decode, 244, 127, 3, // 1322: decode to VLOXSEG6EI32_V using decoder 3
1814 // 1322: }
1815 48, 21, // 1326: case 0x30: {
1816 OPC_SwitchField, 20, 5, // 1328: switch Inst[24:20] {
1817 0, 7, // 1331: case 0x0: {
1818 OPC_CheckPredicate, 23, // 1333: check predicate 23
1819 OPC_Decode, 174, 128, 1, 1, // 1335: decode to VLSEG7E32_V using decoder 1
1820 // 1335: }
1821 16, 0, // 1340: case 0x10: {
1822 OPC_CheckPredicate, 23, // 1342: check predicate 23
1823 OPC_Decode, 173, 128, 1, 1, // 1344: decode to VLSEG7E32FF_V using decoder 1
1824 // 1344: }
1825 // 1344: } // switch Inst[24:20]
1826 // 1344: }
1827 49, 7, // 1349: case 0x31: {
1828 OPC_CheckPredicate, 23, // 1351: check predicate 23
1829 OPC_Decode, 240, 128, 1, 3, // 1353: decode to VLUXSEG7EI32_V using decoder 3
1830 // 1353: }
1831 50, 7, // 1358: case 0x32: {
1832 OPC_CheckPredicate, 23, // 1360: check predicate 23
1833 OPC_Decode, 208, 128, 1, 4, // 1362: decode to VLSSEG7E32_V using decoder 4
1834 // 1362: }
1835 51, 6, // 1367: case 0x33: {
1836 OPC_CheckPredicate, 23, // 1369: check predicate 23
1837 OPC_Decode, 248, 127, 3, // 1371: decode to VLOXSEG7EI32_V using decoder 3
1838 // 1371: }
1839 56, 33, // 1375: case 0x38: {
1840 OPC_SwitchField, 20, 5, // 1377: switch Inst[24:20] {
1841 0, 7, // 1380: case 0x0: {
1842 OPC_CheckPredicate, 23, // 1382: check predicate 23
1843 OPC_Decode, 182, 128, 1, 1, // 1384: decode to VLSEG8E32_V using decoder 1
1844 // 1384: }
1845 8, 10, // 1389: case 0x8: {
1846 OPC_CheckPredicate, 23, // 1391: check predicate 23
1847 OPC_CheckField, 25, 1, 1, // 1393: check Inst[25] == 0x1
1848 OPC_Decode, 211, 127, 7, // 1397: decode to VL8RE32_V using decoder 7
1849 // 1397: }
1850 16, 0, // 1401: case 0x10: {
1851 OPC_CheckPredicate, 23, // 1403: check predicate 23
1852 OPC_Decode, 181, 128, 1, 1, // 1405: decode to VLSEG8E32FF_V using decoder 1
1853 // 1405: }
1854 // 1405: } // switch Inst[24:20]
1855 // 1405: }
1856 57, 7, // 1410: case 0x39: {
1857 OPC_CheckPredicate, 23, // 1412: check predicate 23
1858 OPC_Decode, 244, 128, 1, 3, // 1414: decode to VLUXSEG8EI32_V using decoder 3
1859 // 1414: }
1860 58, 7, // 1419: case 0x3a: {
1861 OPC_CheckPredicate, 23, // 1421: check predicate 23
1862 OPC_Decode, 212, 128, 1, 4, // 1423: decode to VLSSEG8E32_V using decoder 4
1863 // 1423: }
1864 59, 0, // 1428: case 0x3b: {
1865 OPC_CheckPredicate, 23, // 1430: check predicate 23
1866 OPC_Decode, 252, 127, 3, // 1432: decode to VLOXSEG8EI32_V using decoder 3
1867 // 1432: }
1868 // 1432: } // switch Inst[31:26]
1869 // 1432: }
1870 7, 0, // 1436: case 0x7: {
1871 OPC_SwitchField, 26, 3, // 1438: switch Inst[28:26] {
1872 0, 233, 1, // 1441: case 0x0: {
1873 OPC_SwitchField, 29, 3, // 1444: switch Inst[31:29] {
1874 0, 31, // 1447: case 0x0: {
1875 OPC_SwitchField, 20, 5, // 1449: switch Inst[24:20] {
1876 0, 6, // 1452: case 0x0: {
1877 OPC_CheckPredicate, 28, // 1454: check predicate 28
1878 OPC_Decode, 219, 127, 1, // 1456: decode to VLE64_V using decoder 1
1879 // 1456: }
1880 8, 10, // 1460: case 0x8: {
1881 OPC_CheckPredicate, 28, // 1462: check predicate 28
1882 OPC_CheckField, 25, 1, 1, // 1464: check Inst[25] == 0x1
1883 OPC_Decode, 200, 127, 2, // 1468: decode to VL1RE64_V using decoder 2
1884 // 1468: }
1885 16, 0, // 1472: case 0x10: {
1886 OPC_CheckPredicate, 28, // 1474: check predicate 28
1887 OPC_Decode, 218, 127, 1, // 1476: decode to VLE64FF_V using decoder 1
1888 // 1476: }
1889 // 1476: } // switch Inst[24:20]
1890 // 1476: }
1891 1, 33, // 1480: case 0x1: {
1892 OPC_SwitchField, 20, 5, // 1482: switch Inst[24:20] {
1893 0, 7, // 1485: case 0x0: {
1894 OPC_CheckPredicate, 28, // 1487: check predicate 28
1895 OPC_Decode, 136, 128, 1, 1, // 1489: decode to VLSEG2E64_V using decoder 1
1896 // 1489: }
1897 8, 10, // 1494: case 0x8: {
1898 OPC_CheckPredicate, 28, // 1496: check predicate 28
1899 OPC_CheckField, 25, 1, 1, // 1498: check Inst[25] == 0x1
1900 OPC_Decode, 204, 127, 5, // 1502: decode to VL2RE64_V using decoder 5
1901 // 1502: }
1902 16, 0, // 1506: case 0x10: {
1903 OPC_CheckPredicate, 28, // 1508: check predicate 28
1904 OPC_Decode, 135, 128, 1, 1, // 1510: decode to VLSEG2E64FF_V using decoder 1
1905 // 1510: }
1906 // 1510: } // switch Inst[24:20]
1907 // 1510: }
1908 2, 21, // 1515: case 0x2: {
1909 OPC_SwitchField, 20, 5, // 1517: switch Inst[24:20] {
1910 0, 7, // 1520: case 0x0: {
1911 OPC_CheckPredicate, 28, // 1522: check predicate 28
1912 OPC_Decode, 144, 128, 1, 1, // 1524: decode to VLSEG3E64_V using decoder 1
1913 // 1524: }
1914 16, 0, // 1529: case 0x10: {
1915 OPC_CheckPredicate, 28, // 1531: check predicate 28
1916 OPC_Decode, 143, 128, 1, 1, // 1533: decode to VLSEG3E64FF_V using decoder 1
1917 // 1533: }
1918 // 1533: } // switch Inst[24:20]
1919 // 1533: }
1920 3, 33, // 1538: case 0x3: {
1921 OPC_SwitchField, 20, 5, // 1540: switch Inst[24:20] {
1922 0, 7, // 1543: case 0x0: {
1923 OPC_CheckPredicate, 28, // 1545: check predicate 28
1924 OPC_Decode, 152, 128, 1, 1, // 1547: decode to VLSEG4E64_V using decoder 1
1925 // 1547: }
1926 8, 10, // 1552: case 0x8: {
1927 OPC_CheckPredicate, 28, // 1554: check predicate 28
1928 OPC_CheckField, 25, 1, 1, // 1556: check Inst[25] == 0x1
1929 OPC_Decode, 208, 127, 6, // 1560: decode to VL4RE64_V using decoder 6
1930 // 1560: }
1931 16, 0, // 1564: case 0x10: {
1932 OPC_CheckPredicate, 28, // 1566: check predicate 28
1933 OPC_Decode, 151, 128, 1, 1, // 1568: decode to VLSEG4E64FF_V using decoder 1
1934 // 1568: }
1935 // 1568: } // switch Inst[24:20]
1936 // 1568: }
1937 4, 21, // 1573: case 0x4: {
1938 OPC_SwitchField, 20, 5, // 1575: switch Inst[24:20] {
1939 0, 7, // 1578: case 0x0: {
1940 OPC_CheckPredicate, 28, // 1580: check predicate 28
1941 OPC_Decode, 160, 128, 1, 1, // 1582: decode to VLSEG5E64_V using decoder 1
1942 // 1582: }
1943 16, 0, // 1587: case 0x10: {
1944 OPC_CheckPredicate, 28, // 1589: check predicate 28
1945 OPC_Decode, 159, 128, 1, 1, // 1591: decode to VLSEG5E64FF_V using decoder 1
1946 // 1591: }
1947 // 1591: } // switch Inst[24:20]
1948 // 1591: }
1949 5, 21, // 1596: case 0x5: {
1950 OPC_SwitchField, 20, 5, // 1598: switch Inst[24:20] {
1951 0, 7, // 1601: case 0x0: {
1952 OPC_CheckPredicate, 28, // 1603: check predicate 28
1953 OPC_Decode, 168, 128, 1, 1, // 1605: decode to VLSEG6E64_V using decoder 1
1954 // 1605: }
1955 16, 0, // 1610: case 0x10: {
1956 OPC_CheckPredicate, 28, // 1612: check predicate 28
1957 OPC_Decode, 167, 128, 1, 1, // 1614: decode to VLSEG6E64FF_V using decoder 1
1958 // 1614: }
1959 // 1614: } // switch Inst[24:20]
1960 // 1614: }
1961 6, 21, // 1619: case 0x6: {
1962 OPC_SwitchField, 20, 5, // 1621: switch Inst[24:20] {
1963 0, 7, // 1624: case 0x0: {
1964 OPC_CheckPredicate, 28, // 1626: check predicate 28
1965 OPC_Decode, 176, 128, 1, 1, // 1628: decode to VLSEG7E64_V using decoder 1
1966 // 1628: }
1967 16, 0, // 1633: case 0x10: {
1968 OPC_CheckPredicate, 28, // 1635: check predicate 28
1969 OPC_Decode, 175, 128, 1, 1, // 1637: decode to VLSEG7E64FF_V using decoder 1
1970 // 1637: }
1971 // 1637: } // switch Inst[24:20]
1972 // 1637: }
1973 7, 0, // 1642: case 0x7: {
1974 OPC_SwitchField, 20, 5, // 1644: switch Inst[24:20] {
1975 0, 7, // 1647: case 0x0: {
1976 OPC_CheckPredicate, 28, // 1649: check predicate 28
1977 OPC_Decode, 184, 128, 1, 1, // 1651: decode to VLSEG8E64_V using decoder 1
1978 // 1651: }
1979 8, 10, // 1656: case 0x8: {
1980 OPC_CheckPredicate, 28, // 1658: check predicate 28
1981 OPC_CheckField, 25, 1, 1, // 1660: check Inst[25] == 0x1
1982 OPC_Decode, 212, 127, 7, // 1664: decode to VL8RE64_V using decoder 7
1983 // 1664: }
1984 16, 0, // 1668: case 0x10: {
1985 OPC_CheckPredicate, 28, // 1670: check predicate 28
1986 OPC_Decode, 183, 128, 1, 1, // 1672: decode to VLSEG8E64FF_V using decoder 1
1987 // 1672: }
1988 // 1672: } // switch Inst[24:20]
1989 // 1672: }
1990 // 1672: } // switch Inst[31:29]
1991 // 1672: }
1992 1, 75, // 1677: case 0x1: {
1993 OPC_SwitchField, 29, 3, // 1679: switch Inst[31:29] {
1994 0, 7, // 1682: case 0x0: {
1995 OPC_CheckPredicate, 29, // 1684: check predicate 29
1996 OPC_Decode, 217, 128, 1, 3, // 1686: decode to VLUXEI64_V using decoder 3
1997 // 1686: }
1998 1, 7, // 1691: case 0x1: {
1999 OPC_CheckPredicate, 30, // 1693: check predicate 30
2000 OPC_Decode, 221, 128, 1, 3, // 1695: decode to VLUXSEG2EI64_V using decoder 3
2001 // 1695: }
2002 2, 7, // 1700: case 0x2: {
2003 OPC_CheckPredicate, 30, // 1702: check predicate 30
2004 OPC_Decode, 225, 128, 1, 3, // 1704: decode to VLUXSEG3EI64_V using decoder 3
2005 // 1704: }
2006 3, 7, // 1709: case 0x3: {
2007 OPC_CheckPredicate, 30, // 1711: check predicate 30
2008 OPC_Decode, 229, 128, 1, 3, // 1713: decode to VLUXSEG4EI64_V using decoder 3
2009 // 1713: }
2010 4, 7, // 1718: case 0x4: {
2011 OPC_CheckPredicate, 30, // 1720: check predicate 30
2012 OPC_Decode, 233, 128, 1, 3, // 1722: decode to VLUXSEG5EI64_V using decoder 3
2013 // 1722: }
2014 5, 7, // 1727: case 0x5: {
2015 OPC_CheckPredicate, 30, // 1729: check predicate 30
2016 OPC_Decode, 237, 128, 1, 3, // 1731: decode to VLUXSEG6EI64_V using decoder 3
2017 // 1731: }
2018 6, 7, // 1736: case 0x6: {
2019 OPC_CheckPredicate, 30, // 1738: check predicate 30
2020 OPC_Decode, 241, 128, 1, 3, // 1740: decode to VLUXSEG7EI64_V using decoder 3
2021 // 1740: }
2022 7, 0, // 1745: case 0x7: {
2023 OPC_CheckPredicate, 30, // 1747: check predicate 30
2024 OPC_Decode, 245, 128, 1, 3, // 1749: decode to VLUXSEG8EI64_V using decoder 3
2025 // 1749: }
2026 // 1749: } // switch Inst[31:29]
2027 // 1749: }
2028 2, 75, // 1754: case 0x2: {
2029 OPC_SwitchField, 29, 3, // 1756: switch Inst[31:29] {
2030 0, 7, // 1759: case 0x0: {
2031 OPC_CheckPredicate, 28, // 1761: check predicate 28
2032 OPC_Decode, 129, 128, 1, 4, // 1763: decode to VLSE64_V using decoder 4
2033 // 1763: }
2034 1, 7, // 1768: case 0x1: {
2035 OPC_CheckPredicate, 28, // 1770: check predicate 28
2036 OPC_Decode, 189, 128, 1, 4, // 1772: decode to VLSSEG2E64_V using decoder 4
2037 // 1772: }
2038 2, 7, // 1777: case 0x2: {
2039 OPC_CheckPredicate, 28, // 1779: check predicate 28
2040 OPC_Decode, 193, 128, 1, 4, // 1781: decode to VLSSEG3E64_V using decoder 4
2041 // 1781: }
2042 3, 7, // 1786: case 0x3: {
2043 OPC_CheckPredicate, 28, // 1788: check predicate 28
2044 OPC_Decode, 197, 128, 1, 4, // 1790: decode to VLSSEG4E64_V using decoder 4
2045 // 1790: }
2046 4, 7, // 1795: case 0x4: {
2047 OPC_CheckPredicate, 28, // 1797: check predicate 28
2048 OPC_Decode, 201, 128, 1, 4, // 1799: decode to VLSSEG5E64_V using decoder 4
2049 // 1799: }
2050 5, 7, // 1804: case 0x5: {
2051 OPC_CheckPredicate, 28, // 1806: check predicate 28
2052 OPC_Decode, 205, 128, 1, 4, // 1808: decode to VLSSEG6E64_V using decoder 4
2053 // 1808: }
2054 6, 7, // 1813: case 0x6: {
2055 OPC_CheckPredicate, 28, // 1815: check predicate 28
2056 OPC_Decode, 209, 128, 1, 4, // 1817: decode to VLSSEG7E64_V using decoder 4
2057 // 1817: }
2058 7, 0, // 1822: case 0x7: {
2059 OPC_CheckPredicate, 28, // 1824: check predicate 28
2060 OPC_Decode, 213, 128, 1, 4, // 1826: decode to VLSSEG8E64_V using decoder 4
2061 // 1826: }
2062 // 1826: } // switch Inst[31:29]
2063 // 1826: }
2064 3, 67, // 1831: case 0x3: {
2065 OPC_SwitchField, 29, 3, // 1833: switch Inst[31:29] {
2066 0, 6, // 1836: case 0x0: {
2067 OPC_CheckPredicate, 29, // 1838: check predicate 29
2068 OPC_Decode, 225, 127, 3, // 1840: decode to VLOXEI64_V using decoder 3
2069 // 1840: }
2070 1, 6, // 1844: case 0x1: {
2071 OPC_CheckPredicate, 30, // 1846: check predicate 30
2072 OPC_Decode, 229, 127, 3, // 1848: decode to VLOXSEG2EI64_V using decoder 3
2073 // 1848: }
2074 2, 6, // 1852: case 0x2: {
2075 OPC_CheckPredicate, 30, // 1854: check predicate 30
2076 OPC_Decode, 233, 127, 3, // 1856: decode to VLOXSEG3EI64_V using decoder 3
2077 // 1856: }
2078 3, 6, // 1860: case 0x3: {
2079 OPC_CheckPredicate, 30, // 1862: check predicate 30
2080 OPC_Decode, 237, 127, 3, // 1864: decode to VLOXSEG4EI64_V using decoder 3
2081 // 1864: }
2082 4, 6, // 1868: case 0x4: {
2083 OPC_CheckPredicate, 30, // 1870: check predicate 30
2084 OPC_Decode, 241, 127, 3, // 1872: decode to VLOXSEG5EI64_V using decoder 3
2085 // 1872: }
2086 5, 6, // 1876: case 0x5: {
2087 OPC_CheckPredicate, 30, // 1878: check predicate 30
2088 OPC_Decode, 245, 127, 3, // 1880: decode to VLOXSEG6EI64_V using decoder 3
2089 // 1880: }
2090 6, 6, // 1884: case 0x6: {
2091 OPC_CheckPredicate, 30, // 1886: check predicate 30
2092 OPC_Decode, 249, 127, 3, // 1888: decode to VLOXSEG7EI64_V using decoder 3
2093 // 1888: }
2094 7, 0, // 1892: case 0x7: {
2095 OPC_CheckPredicate, 30, // 1894: check predicate 30
2096 OPC_Decode, 253, 127, 3, // 1896: decode to VLOXSEG8EI64_V using decoder 3
2097 // 1896: }
2098 // 1896: } // switch Inst[31:29]
2099 // 1896: }
2100 4, 7, // 1900: case 0x4: {
2101 OPC_CheckPredicate, 31, // 1902: check predicate 31
2102 OPC_Decode, 208, 129, 1, 12, // 1904: decode to VMTL_V using decoder 12
2103 // 1904: }
2104 5, 0, // 1909: case 0x5: {
2105 OPC_CheckPredicate, 32, // 1911: check predicate 32
2106 OPC_Decode, 210, 129, 1, 12, // 1913: decode to VMTTL_V using decoder 12
2107 // 1913: }
2108 // 1913: } // switch Inst[28:26]
2109 // 1913: }
2110 // 1913: } // switch Inst[14:12]
2111 // 1913: }
2112 15, 76, // 1918: case 0xf: {
2113 OPC_SwitchField, 7, 8, // 1920: switch Inst[14:7] {
2114 0, 24, // 1923: case 0x0: {
2115 OPC_SwitchField, 28, 4, // 1925: switch Inst[31:28] {
2116 0, 8, // 1928: case 0x0: {
2117 OPC_CheckField, 15, 5, 0, // 1930: check Inst[19:15] == 0x0
2118 OPC_Decode, 134, 115, 13, // 1934: decode to FENCE using decoder 13
2119 // 1934: }
2120 8, 0, // 1938: case 0x8: {
2121 OPC_CheckField, 15, 13, 224, 12, // 1940: check Inst[27:15] == 0x660
2122 OPC_Decode, 136, 115, 14, // 1945: decode to FENCE_TSO using decoder 14
2123 // 1945: }
2124 // 1945: } // switch Inst[31:28]
2125 // 1945: }
2126 32, 8, // 1949: case 0x20: {
2127 OPC_CheckField, 15, 17, 0, // 1951: check Inst[31:15] == 0x0
2128 OPC_Decode, 135, 115, 14, // 1955: decode to FENCE_I using decoder 14
2129 // 1955: }
2130 64, 0, // 1959: case 0x40: {
2131 OPC_SwitchField, 20, 12, // 1961: switch Inst[31:20] {
2132 0, 6, // 1964: case 0x0: {
2133 OPC_CheckPredicate, 33, // 1966: check predicate 33
2134 OPC_Decode, 243, 110, 15, // 1968: decode to CBO_INVAL using decoder 15
2135 // 1968: }
2136 1, 6, // 1972: case 0x1: {
2137 OPC_CheckPredicate, 33, // 1974: check predicate 33
2138 OPC_Decode, 241, 110, 15, // 1976: decode to CBO_CLEAN using decoder 15
2139 // 1976: }
2140 2, 6, // 1980: case 0x2: {
2141 OPC_CheckPredicate, 33, // 1982: check predicate 33
2142 OPC_Decode, 242, 110, 15, // 1984: decode to CBO_FLUSH using decoder 15
2143 // 1984: }
2144 4, 0, // 1988: case 0x4: {
2145 OPC_CheckPredicate, 34, // 1990: check predicate 34
2146 OPC_Decode, 244, 110, 15, // 1992: decode to CBO_ZERO using decoder 15
2147 // 1992: }
2148 // 1992: } // switch Inst[31:20]
2149 // 1992: }
2150 // 1992: } // switch Inst[14:7]
2151 // 1992: }
2152 19, 149, 3, // 1996: case 0x13: {
2153 OPC_SwitchField, 12, 3, // 1999: switch Inst[14:12] {
2154 0, 4, // 2002: case 0x0: {
2155 OPC_Decode, 206, 107, 0, // 2004: decode to ADDI using decoder 0
2156 // 2004: }
2157 1, 217, 1, // 2008: case 0x1: {
2158 OPC_SwitchField, 26, 6, // 2011: switch Inst[31:26] {
2159 0, 4, // 2014: case 0x0: {
2160 OPC_Decode, 215, 124, 16, // 2016: decode to SLLI using decoder 16
2161 // 2016: }
2162 2, 11, // 2020: case 0x2: {
2163 OPC_CheckPredicate, 35, // 2022: check predicate 35
2164 OPC_CheckField, 20, 6, 15, // 2024: check Inst[25:20] == 0xf
2165 OPC_Decode, 191, 132, 1, 17, // 2028: decode to ZIP_RV32 using decoder 17
2166 // 2028: }
2167 4, 83, // 2033: case 0x4: {
2168 OPC_SwitchField, 20, 6, // 2035: switch Inst[25:20] {
2169 0, 6, // 2038: case 0x0: {
2170 OPC_CheckPredicate, 36, // 2040: check predicate 36
2171 OPC_Decode, 194, 124, 17, // 2042: decode to SHA256SUM0 using decoder 17
2172 // 2042: }
2173 1, 6, // 2046: case 0x1: {
2174 OPC_CheckPredicate, 36, // 2048: check predicate 36
2175 OPC_Decode, 195, 124, 17, // 2050: decode to SHA256SUM1 using decoder 17
2176 // 2050: }
2177 2, 6, // 2054: case 0x2: {
2178 OPC_CheckPredicate, 36, // 2056: check predicate 36
2179 OPC_Decode, 192, 124, 17, // 2058: decode to SHA256SIG0 using decoder 17
2180 // 2058: }
2181 3, 6, // 2062: case 0x3: {
2182 OPC_CheckPredicate, 36, // 2064: check predicate 36
2183 OPC_Decode, 193, 124, 17, // 2066: decode to SHA256SIG1 using decoder 17
2184 // 2066: }
2185 4, 6, // 2070: case 0x4: {
2186 OPC_CheckPredicate, 37, // 2072: check predicate 37
2187 OPC_Decode, 202, 124, 17, // 2074: decode to SHA512SUM0 using decoder 17
2188 // 2074: }
2189 5, 6, // 2078: case 0x5: {
2190 OPC_CheckPredicate, 37, // 2080: check predicate 37
2191 OPC_Decode, 204, 124, 17, // 2082: decode to SHA512SUM1 using decoder 17
2192 // 2082: }
2193 6, 6, // 2086: case 0x6: {
2194 OPC_CheckPredicate, 37, // 2088: check predicate 37
2195 OPC_Decode, 196, 124, 17, // 2090: decode to SHA512SIG0 using decoder 17
2196 // 2090: }
2197 7, 6, // 2094: case 0x7: {
2198 OPC_CheckPredicate, 37, // 2096: check predicate 37
2199 OPC_Decode, 199, 124, 17, // 2098: decode to SHA512SIG1 using decoder 17
2200 // 2098: }
2201 8, 6, // 2102: case 0x8: {
2202 OPC_CheckPredicate, 38, // 2104: check predicate 38
2203 OPC_Decode, 224, 124, 17, // 2106: decode to SM3P0 using decoder 17
2204 // 2106: }
2205 9, 0, // 2110: case 0x9: {
2206 OPC_CheckPredicate, 38, // 2112: check predicate 38
2207 OPC_Decode, 225, 124, 17, // 2114: decode to SM3P1 using decoder 17
2208 // 2114: }
2209 // 2114: } // switch Inst[25:20]
2210 // 2114: }
2211 10, 6, // 2118: case 0xa: {
2212 OPC_CheckPredicate, 39, // 2120: check predicate 39
2213 OPC_Decode, 240, 110, 16, // 2122: decode to BSETI using decoder 16
2214 // 2122: }
2215 12, 23, // 2126: case 0xc: {
2216 OPC_SwitchField, 24, 2, // 2128: switch Inst[25:24] {
2217 0, 10, // 2131: case 0x0: {
2218 OPC_CheckPredicate, 40, // 2133: check predicate 40
2219 OPC_CheckField, 20, 4, 0, // 2135: check Inst[23:20] == 0x0
2220 OPC_Decode, 218, 107, 17, // 2139: decode to AES64IM using decoder 17
2221 // 2139: }
2222 1, 0, // 2143: case 0x1: {
2223 OPC_CheckPredicate, 41, // 2145: check predicate 41
2224 OPC_Decode, 219, 107, 18, // 2147: decode to AES64KS1I using decoder 18
2225 // 2147: }
2226 // 2147: } // switch Inst[25:24]
2227 // 2147: }
2228 18, 6, // 2151: case 0x12: {
2229 OPC_CheckPredicate, 39, // 2153: check predicate 39
2230 OPC_Decode, 225, 110, 16, // 2155: decode to BCLRI using decoder 16
2231 // 2155: }
2232 24, 59, // 2159: case 0x18: {
2233 OPC_SwitchField, 20, 6, // 2161: switch Inst[25:20] {
2234 0, 6, // 2164: case 0x0: {
2235 OPC_CheckPredicate, 42, // 2166: check predicate 42
2236 OPC_Decode, 250, 110, 17, // 2168: decode to CLZ using decoder 17
2237 // 2168: }
2238 1, 6, // 2172: case 0x1: {
2239 OPC_CheckPredicate, 42, // 2174: check predicate 42
2240 OPC_Decode, 140, 111, 17, // 2176: decode to CTZ using decoder 17
2241 // 2176: }
2242 2, 6, // 2180: case 0x2: {
2243 OPC_CheckPredicate, 42, // 2182: check predicate 42
2244 OPC_Decode, 132, 111, 17, // 2184: decode to CPOP using decoder 17
2245 // 2184: }
2246 3, 6, // 2188: case 0x3: {
2247 OPC_CheckPredicate, 43, // 2190: check predicate 43
2248 OPC_Decode, 248, 110, 17, // 2192: decode to CLS using decoder 17
2249 // 2192: }
2250 4, 6, // 2196: case 0x4: {
2251 OPC_CheckPredicate, 42, // 2198: check predicate 42
2252 OPC_Decode, 239, 123, 17, // 2200: decode to SEXT_B using decoder 17
2253 // 2200: }
2254 5, 6, // 2204: case 0x5: {
2255 OPC_CheckPredicate, 42, // 2206: check predicate 42
2256 OPC_Decode, 240, 123, 17, // 2208: decode to SEXT_H using decoder 17
2257 // 2208: }
2258 7, 0, // 2212: case 0x7: {
2259 OPC_CheckPredicate, 43, // 2214: check predicate 43
2260 OPC_Decode, 202, 107, 17, // 2216: decode to ABS using decoder 17
2261 // 2216: }
2262 // 2216: } // switch Inst[25:20]
2263 // 2216: }
2264 26, 0, // 2220: case 0x1a: {
2265 OPC_CheckPredicate, 39, // 2222: check predicate 39
2266 OPC_Decode, 233, 110, 16, // 2224: decode to BINVI using decoder 16
2267 // 2224: }
2268 // 2224: } // switch Inst[31:26]
2269 // 2224: }
2270 2, 4, // 2228: case 0x2: {
2271 OPC_Decode, 220, 124, 0, // 2230: decode to SLTI using decoder 0
2272 // 2230: }
2273 3, 4, // 2234: case 0x3: {
2274 OPC_Decode, 221, 124, 0, // 2236: decode to SLTIU using decoder 0
2275 // 2236: }
2276 4, 5, // 2240: case 0x4: {
2277 OPC_Decode, 160, 132, 1, 0, // 2242: decode to XORI using decoder 0
2278 // 2242: }
2279 5, 108, // 2247: case 0x5: {
2280 OPC_SwitchField, 26, 6, // 2249: switch Inst[31:26] {
2281 0, 4, // 2252: case 0x0: {
2282 OPC_Decode, 252, 124, 16, // 2254: decode to SRLI using decoder 16
2283 // 2254: }
2284 2, 10, // 2258: case 0x2: {
2285 OPC_CheckPredicate, 35, // 2260: check predicate 35
2286 OPC_CheckField, 20, 6, 15, // 2262: check Inst[25:20] == 0xf
2287 OPC_Decode, 140, 126, 17, // 2266: decode to UNZIP_RV32 using decoder 17
2288 // 2266: }
2289 10, 10, // 2270: case 0xa: {
2290 OPC_CheckPredicate, 42, // 2272: check predicate 42
2291 OPC_CheckField, 20, 6, 7, // 2274: check Inst[25:20] == 0x7
2292 OPC_Decode, 208, 118, 17, // 2278: decode to ORC_B using decoder 17
2293 // 2278: }
2294 16, 4, // 2282: case 0x10: {
2295 OPC_Decode, 245, 124, 16, // 2284: decode to SRAI using decoder 16
2296 // 2284: }
2297 18, 6, // 2288: case 0x12: {
2298 OPC_CheckPredicate, 39, // 2290: check predicate 39
2299 OPC_Decode, 229, 110, 16, // 2292: decode to BEXTI using decoder 16
2300 // 2292: }
2301 24, 6, // 2296: case 0x18: {
2302 OPC_CheckPredicate, 44, // 2298: check predicate 44
2303 OPC_Decode, 214, 123, 16, // 2300: decode to RORI using decoder 16
2304 // 2300: }
2305 26, 0, // 2304: case 0x1a: {
2306 OPC_SwitchField, 20, 6, // 2306: switch Inst[25:20] {
2307 7, 6, // 2309: case 0x7: {
2308 OPC_CheckPredicate, 45, // 2311: check predicate 45
2309 OPC_Decode, 238, 110, 17, // 2313: decode to BREV8 using decoder 17
2310 // 2313: }
2311 24, 6, // 2317: case 0x18: {
2312 OPC_CheckPredicate, 46, // 2319: check predicate 46
2313 OPC_Decode, 207, 123, 17, // 2321: decode to REV8_RV32 using decoder 17
2314 // 2321: }
2315 31, 6, // 2325: case 0x1f: {
2316 OPC_CheckPredicate, 47, // 2327: check predicate 47
2317 OPC_Decode, 209, 123, 17, // 2329: decode to REV_RV32 using decoder 17
2318 // 2329: }
2319 48, 6, // 2333: case 0x30: {
2320 OPC_CheckPredicate, 48, // 2335: check predicate 48
2321 OPC_Decode, 206, 123, 17, // 2337: decode to REV16_RV64 using decoder 17
2322 // 2337: }
2323 56, 6, // 2341: case 0x38: {
2324 OPC_CheckPredicate, 49, // 2343: check predicate 49
2325 OPC_Decode, 208, 123, 17, // 2345: decode to REV8_RV64 using decoder 17
2326 // 2345: }
2327 63, 0, // 2349: case 0x3f: {
2328 OPC_CheckPredicate, 48, // 2351: check predicate 48
2329 OPC_Decode, 210, 123, 17, // 2353: decode to REV_RV64 using decoder 17
2330 // 2353: }
2331 // 2353: } // switch Inst[25:20]
2332 // 2353: }
2333 // 2353: } // switch Inst[31:26]
2334 // 2353: }
2335 6, 39, // 2357: case 0x6: {
2336 OPC_Scope, 33, // 2359: try {
2337 OPC_SwitchField, 20, 5, // 2361: switch Inst[24:20] {
2338 0, 8, // 2364: case 0x0: {
2339 OPC_CheckField, 7, 5, 0, // 2366: check Inst[11:7] == 0x0
2340 OPC_Decode, 132, 121, 19, // 2370: decode to PREFETCH_I using decoder 19
2341 // 2370: }
2342 1, 8, // 2374: case 0x1: {
2343 OPC_CheckField, 7, 5, 0, // 2376: check Inst[11:7] == 0x0
2344 OPC_Decode, 133, 121, 19, // 2380: decode to PREFETCH_R using decoder 19
2345 // 2380: }
2346 3, 0, // 2384: case 0x3: {
2347 OPC_CheckField, 7, 5, 0, // 2386: check Inst[11:7] == 0x0
2348 OPC_Decode, 134, 121, 19, // 2390: decode to PREFETCH_W using decoder 19
2349 // 2390: }
2350 // 2390: } // switch Inst[24:20]
2351 // 2390: } else try {
2352 OPC_Decode, 209, 118, 0, // 2394: decode to ORI using decoder 0
2353 // 2394: }
2354 // 2394: }
2355 7, 0, // 2398: case 0x7: {
2356 OPC_Decode, 219, 110, 0, // 2400: decode to ANDI using decoder 0
2357 // 2400: }
2358 // 2400: } // switch Inst[14:12]
2359 // 2400: }
2360 23, 4, // 2404: case 0x17: {
2361 OPC_Decode, 223, 110, 20, // 2406: decode to AUIPC using decoder 20
2362 // 2406: }
2363 27, 195, 35, // 2410: case 0x1b: {
2364 OPC_SwitchField, 12, 3, // 2413: switch Inst[14:12] {
2365 0, 6, // 2416: case 0x0: {
2366 OPC_CheckPredicate, 22, // 2418: check predicate 22
2367 OPC_Decode, 207, 107, 0, // 2420: decode to ADDIW using decoder 0
2368 // 2420: }
2369 1, 68, // 2424: case 0x1: {
2370 OPC_SwitchField, 26, 6, // 2426: switch Inst[31:26] {
2371 0, 10, // 2429: case 0x0: {
2372 OPC_CheckPredicate, 22, // 2431: check predicate 22
2373 OPC_CheckField, 25, 1, 0, // 2433: check Inst[25] == 0x0
2374 OPC_Decode, 216, 124, 21, // 2437: decode to SLLIW using decoder 21
2375 // 2437: }
2376 2, 6, // 2441: case 0x2: {
2377 OPC_CheckPredicate, 50, // 2443: check predicate 50
2378 OPC_Decode, 217, 124, 16, // 2445: decode to SLLI_UW using decoder 16
2379 // 2445: }
2380 24, 0, // 2449: case 0x18: {
2381 OPC_SwitchField, 20, 6, // 2451: switch Inst[25:20] {
2382 0, 6, // 2454: case 0x0: {
2383 OPC_CheckPredicate, 51, // 2456: check predicate 51
2384 OPC_Decode, 251, 110, 17, // 2458: decode to CLZW using decoder 17
2385 // 2458: }
2386 1, 6, // 2462: case 0x1: {
2387 OPC_CheckPredicate, 51, // 2464: check predicate 51
2388 OPC_Decode, 141, 111, 17, // 2466: decode to CTZW using decoder 17
2389 // 2466: }
2390 2, 6, // 2470: case 0x2: {
2391 OPC_CheckPredicate, 51, // 2472: check predicate 51
2392 OPC_Decode, 133, 111, 17, // 2474: decode to CPOPW using decoder 17
2393 // 2474: }
2394 3, 6, // 2478: case 0x3: {
2395 OPC_CheckPredicate, 48, // 2480: check predicate 48
2396 OPC_Decode, 249, 110, 17, // 2482: decode to CLSW using decoder 17
2397 // 2482: }
2398 7, 0, // 2486: case 0x7: {
2399 OPC_CheckPredicate, 48, // 2488: check predicate 48
2400 OPC_Decode, 203, 107, 17, // 2490: decode to ABSW using decoder 17
2401 // 2490: }
2402 // 2490: } // switch Inst[25:20]
2403 // 2490: }
2404 // 2490: } // switch Inst[31:26]
2405 // 2490: }
2406 2, 209, 10, // 2494: case 0x2: {
2407 OPC_SwitchField, 26, 6, // 2497: switch Inst[31:26] {
2408 0, 50, // 2500: case 0x0: {
2409 OPC_SwitchField, 7, 1, // 2502: switch Inst[7] {
2410 0, 23, // 2505: case 0x0: {
2411 OPC_SwitchField, 25, 1, // 2507: switch Inst[25] {
2412 0, 10, // 2510: case 0x0: {
2413 OPC_CheckPredicate, 47, // 2512: check predicate 47
2414 OPC_CheckField, 24, 1, 1, // 2514: check Inst[24] == 0x1
2415 OPC_Decode, 153, 122, 22, // 2518: decode to PWSLLI_B using decoder 22
2416 // 2518: }
2417 1, 0, // 2522: case 0x1: {
2418 OPC_CheckPredicate, 47, // 2524: check predicate 47
2419 OPC_Decode, 154, 122, 23, // 2526: decode to PWSLLI_H using decoder 23
2420 // 2526: }
2421 // 2526: } // switch Inst[25]
2422 // 2526: }
2423 1, 0, // 2530: case 0x1: {
2424 OPC_SwitchField, 25, 1, // 2532: switch Inst[25] {
2425 0, 6, // 2535: case 0x0: {
2426 OPC_CheckPredicate, 47, // 2537: check predicate 47
2427 OPC_Decode, 139, 122, 24, // 2539: decode to PWADD_H using decoder 24
2428 // 2539: }
2429 1, 0, // 2543: case 0x1: {
2430 OPC_CheckPredicate, 47, // 2545: check predicate 47
2431 OPC_Decode, 135, 132, 1, 24, // 2547: decode to WADD using decoder 24
2432 // 2547: }
2433 // 2547: } // switch Inst[25]
2434 // 2547: }
2435 // 2547: } // switch Inst[7]
2436 // 2547: }
2437 1, 33, // 2552: case 0x1: {
2438 OPC_SwitchField, 7, 1, // 2554: switch Inst[7] {
2439 0, 7, // 2557: case 0x0: {
2440 OPC_CheckPredicate, 47, // 2559: check predicate 47
2441 OPC_Decode, 151, 132, 1, 25, // 2561: decode to WSLLI using decoder 25
2442 // 2561: }
2443 1, 0, // 2566: case 0x1: {
2444 OPC_SwitchField, 25, 1, // 2568: switch Inst[25] {
2445 0, 6, // 2571: case 0x0: {
2446 OPC_CheckPredicate, 47, // 2573: check predicate 47
2447 OPC_Decode, 138, 122, 24, // 2575: decode to PWADD_B using decoder 24
2448 // 2575: }
2449 1, 0, // 2579: case 0x1: {
2450 OPC_CheckPredicate, 47, // 2581: check predicate 47
2451 OPC_Decode, 181, 119, 24, // 2583: decode to PM2WADD_H using decoder 24
2452 // 2583: }
2453 // 2583: } // switch Inst[25]
2454 // 2583: }
2455 // 2583: } // switch Inst[7]
2456 // 2583: }
2457 2, 46, // 2587: case 0x2: {
2458 OPC_SwitchField, 7, 1, // 2589: switch Inst[7] {
2459 0, 19, // 2592: case 0x0: {
2460 OPC_SwitchField, 25, 1, // 2594: switch Inst[25] {
2461 0, 6, // 2597: case 0x0: {
2462 OPC_CheckPredicate, 47, // 2599: check predicate 47
2463 OPC_Decode, 155, 122, 24, // 2601: decode to PWSLL_BS using decoder 24
2464 // 2601: }
2465 1, 0, // 2605: case 0x1: {
2466 OPC_CheckPredicate, 47, // 2607: check predicate 47
2467 OPC_Decode, 156, 122, 24, // 2609: decode to PWSLL_HS using decoder 24
2468 // 2609: }
2469 // 2609: } // switch Inst[25]
2470 // 2609: }
2471 1, 0, // 2613: case 0x1: {
2472 OPC_SwitchField, 25, 1, // 2615: switch Inst[25] {
2473 0, 6, // 2618: case 0x0: {
2474 OPC_CheckPredicate, 47, // 2620: check predicate 47
2475 OPC_Decode, 135, 122, 26, // 2622: decode to PWADDA_H using decoder 26
2476 // 2622: }
2477 1, 0, // 2626: case 0x1: {
2478 OPC_CheckPredicate, 47, // 2628: check predicate 47
2479 OPC_Decode, 136, 132, 1, 26, // 2630: decode to WADDA using decoder 26
2480 // 2630: }
2481 // 2630: } // switch Inst[25]
2482 // 2630: }
2483 // 2630: } // switch Inst[7]
2484 // 2630: }
2485 3, 37, // 2635: case 0x3: {
2486 OPC_SwitchField, 7, 1, // 2637: switch Inst[7] {
2487 0, 11, // 2640: case 0x0: {
2488 OPC_CheckPredicate, 47, // 2642: check predicate 47
2489 OPC_CheckField, 25, 1, 1, // 2644: check Inst[25] == 0x1
2490 OPC_Decode, 150, 132, 1, 24, // 2648: decode to WSLL using decoder 24
2491 // 2648: }
2492 1, 0, // 2653: case 0x1: {
2493 OPC_SwitchField, 25, 1, // 2655: switch Inst[25] {
2494 0, 6, // 2658: case 0x0: {
2495 OPC_CheckPredicate, 47, // 2660: check predicate 47
2496 OPC_Decode, 134, 122, 26, // 2662: decode to PWADDA_B using decoder 26
2497 // 2662: }
2498 1, 0, // 2666: case 0x1: {
2499 OPC_CheckPredicate, 47, // 2668: check predicate 47
2500 OPC_Decode, 177, 119, 26, // 2670: decode to PM2WADDA_H using decoder 26
2501 // 2670: }
2502 // 2670: } // switch Inst[25]
2503 // 2670: }
2504 // 2670: } // switch Inst[7]
2505 // 2670: }
2506 4, 28, // 2674: case 0x4: {
2507 OPC_SwitchField, 25, 1, // 2676: switch Inst[25] {
2508 0, 10, // 2679: case 0x0: {
2509 OPC_CheckPredicate, 47, // 2681: check predicate 47
2510 OPC_CheckField, 7, 1, 1, // 2683: check Inst[7] == 0x1
2511 OPC_Decode, 137, 122, 24, // 2687: decode to PWADDU_H using decoder 24
2512 // 2687: }
2513 1, 0, // 2691: case 0x1: {
2514 OPC_CheckPredicate, 47, // 2693: check predicate 47
2515 OPC_CheckField, 7, 1, 1, // 2695: check Inst[7] == 0x1
2516 OPC_Decode, 138, 132, 1, 24, // 2699: decode to WADDU using decoder 24
2517 // 2699: }
2518 // 2699: } // switch Inst[25]
2519 // 2699: }
2520 5, 27, // 2704: case 0x5: {
2521 OPC_SwitchField, 25, 1, // 2706: switch Inst[25] {
2522 0, 10, // 2709: case 0x0: {
2523 OPC_CheckPredicate, 47, // 2711: check predicate 47
2524 OPC_CheckField, 7, 1, 1, // 2713: check Inst[7] == 0x1
2525 OPC_Decode, 136, 122, 24, // 2717: decode to PWADDU_B using decoder 24
2526 // 2717: }
2527 1, 0, // 2721: case 0x1: {
2528 OPC_CheckPredicate, 47, // 2723: check predicate 47
2529 OPC_CheckField, 7, 1, 1, // 2725: check Inst[7] == 0x1
2530 OPC_Decode, 182, 119, 24, // 2729: decode to PM2WADD_HX using decoder 24
2531 // 2729: }
2532 // 2729: } // switch Inst[25]
2533 // 2729: }
2534 6, 28, // 2733: case 0x6: {
2535 OPC_SwitchField, 25, 1, // 2735: switch Inst[25] {
2536 0, 10, // 2738: case 0x0: {
2537 OPC_CheckPredicate, 47, // 2740: check predicate 47
2538 OPC_CheckField, 7, 1, 1, // 2742: check Inst[7] == 0x1
2539 OPC_Decode, 133, 122, 26, // 2746: decode to PWADDAU_H using decoder 26
2540 // 2746: }
2541 1, 0, // 2750: case 0x1: {
2542 OPC_CheckPredicate, 47, // 2752: check predicate 47
2543 OPC_CheckField, 7, 1, 1, // 2754: check Inst[7] == 0x1
2544 OPC_Decode, 137, 132, 1, 26, // 2758: decode to WADDAU using decoder 26
2545 // 2758: }
2546 // 2758: } // switch Inst[25]
2547 // 2758: }
2548 7, 27, // 2763: case 0x7: {
2549 OPC_SwitchField, 25, 1, // 2765: switch Inst[25] {
2550 0, 10, // 2768: case 0x0: {
2551 OPC_CheckPredicate, 47, // 2770: check predicate 47
2552 OPC_CheckField, 7, 1, 1, // 2772: check Inst[7] == 0x1
2553 OPC_Decode, 132, 122, 26, // 2776: decode to PWADDAU_B using decoder 26
2554 // 2776: }
2555 1, 0, // 2780: case 0x1: {
2556 OPC_CheckPredicate, 47, // 2782: check predicate 47
2557 OPC_CheckField, 7, 1, 1, // 2784: check Inst[7] == 0x1
2558 OPC_Decode, 178, 119, 26, // 2788: decode to PM2WADDA_HX using decoder 26
2559 // 2788: }
2560 // 2788: } // switch Inst[25]
2561 // 2788: }
2562 8, 28, // 2792: case 0x8: {
2563 OPC_SwitchField, 25, 1, // 2794: switch Inst[25] {
2564 0, 10, // 2797: case 0x0: {
2565 OPC_CheckPredicate, 47, // 2799: check predicate 47
2566 OPC_CheckField, 7, 1, 1, // 2801: check Inst[7] == 0x1
2567 OPC_Decode, 148, 122, 24, // 2805: decode to PWMUL_H using decoder 24
2568 // 2805: }
2569 1, 0, // 2809: case 0x1: {
2570 OPC_CheckPredicate, 47, // 2811: check predicate 47
2571 OPC_CheckField, 7, 1, 1, // 2813: check Inst[7] == 0x1
2572 OPC_Decode, 143, 132, 1, 24, // 2817: decode to WMUL using decoder 24
2573 // 2817: }
2574 // 2817: } // switch Inst[25]
2575 // 2817: }
2576 9, 27, // 2822: case 0x9: {
2577 OPC_SwitchField, 25, 1, // 2824: switch Inst[25] {
2578 0, 10, // 2827: case 0x0: {
2579 OPC_CheckPredicate, 47, // 2829: check predicate 47
2580 OPC_CheckField, 7, 1, 1, // 2831: check Inst[7] == 0x1
2581 OPC_Decode, 147, 122, 24, // 2835: decode to PWMUL_B using decoder 24
2582 // 2835: }
2583 1, 0, // 2839: case 0x1: {
2584 OPC_CheckPredicate, 47, // 2841: check predicate 47
2585 OPC_CheckField, 7, 1, 1, // 2843: check Inst[7] == 0x1
2586 OPC_Decode, 180, 119, 24, // 2847: decode to PM2WADDU_H using decoder 24
2587 // 2847: }
2588 // 2847: } // switch Inst[25]
2589 // 2847: }
2590 10, 28, // 2851: case 0xa: {
2591 OPC_SwitchField, 25, 1, // 2853: switch Inst[25] {
2592 0, 10, // 2856: case 0x0: {
2593 OPC_CheckPredicate, 47, // 2858: check predicate 47
2594 OPC_CheckField, 7, 1, 1, // 2860: check Inst[7] == 0x1
2595 OPC_Decode, 142, 122, 26, // 2864: decode to PWMACC_H using decoder 26
2596 // 2864: }
2597 1, 0, // 2868: case 0x1: {
2598 OPC_CheckPredicate, 47, // 2870: check predicate 47
2599 OPC_CheckField, 7, 1, 1, // 2872: check Inst[7] == 0x1
2600 OPC_Decode, 140, 132, 1, 26, // 2876: decode to WMACC using decoder 26
2601 // 2876: }
2602 // 2876: } // switch Inst[25]
2603 // 2876: }
2604 11, 14, // 2881: case 0xb: {
2605 OPC_CheckPredicate, 47, // 2883: check predicate 47
2606 OPC_CheckField, 25, 1, 1, // 2885: check Inst[25] == 0x1
2607 OPC_CheckField, 7, 1, 1, // 2889: check Inst[7] == 0x1
2608 OPC_Decode, 176, 119, 26, // 2893: decode to PM2WADDAU_H using decoder 26
2609 // 2893: }
2610 12, 37, // 2897: case 0xc: {
2611 OPC_SwitchField, 7, 1, // 2899: switch Inst[7] {
2612 0, 10, // 2902: case 0x0: {
2613 OPC_CheckPredicate, 47, // 2904: check predicate 47
2614 OPC_CheckField, 25, 1, 0, // 2906: check Inst[25] == 0x0
2615 OPC_Decode, 143, 119, 27, // 2910: decode to PLI_DH using decoder 27
2616 // 2910: }
2617 1, 0, // 2914: case 0x1: {
2618 OPC_SwitchField, 25, 1, // 2916: switch Inst[25] {
2619 0, 6, // 2919: case 0x0: {
2620 OPC_CheckPredicate, 47, // 2921: check predicate 47
2621 OPC_Decode, 146, 122, 24, // 2923: decode to PWMULU_H using decoder 24
2622 // 2923: }
2623 1, 0, // 2927: case 0x1: {
2624 OPC_CheckPredicate, 47, // 2929: check predicate 47
2625 OPC_Decode, 145, 132, 1, 24, // 2931: decode to WMULU using decoder 24
2626 // 2931: }
2627 // 2931: } // switch Inst[25]
2628 // 2931: }
2629 // 2931: } // switch Inst[7]
2630 // 2931: }
2631 13, 31, // 2936: case 0xd: {
2632 OPC_SwitchField, 7, 1, // 2938: switch Inst[7] {
2633 0, 14, // 2941: case 0x0: {
2634 OPC_CheckPredicate, 47, // 2943: check predicate 47
2635 OPC_CheckField, 24, 2, 0, // 2945: check Inst[25:24] == 0x0
2636 OPC_CheckField, 15, 1, 0, // 2949: check Inst[15] == 0x0
2637 OPC_Decode, 142, 119, 28, // 2953: decode to PLI_DB using decoder 28
2638 // 2953: }
2639 1, 0, // 2957: case 0x1: {
2640 OPC_CheckPredicate, 47, // 2959: check predicate 47
2641 OPC_CheckField, 25, 1, 0, // 2961: check Inst[25] == 0x0
2642 OPC_Decode, 145, 122, 24, // 2965: decode to PWMULU_B using decoder 24
2643 // 2965: }
2644 // 2965: } // switch Inst[7]
2645 // 2965: }
2646 14, 28, // 2969: case 0xe: {
2647 OPC_SwitchField, 25, 1, // 2971: switch Inst[25] {
2648 0, 10, // 2974: case 0x0: {
2649 OPC_CheckPredicate, 47, // 2976: check predicate 47
2650 OPC_CheckField, 7, 1, 1, // 2978: check Inst[7] == 0x1
2651 OPC_Decode, 141, 122, 26, // 2982: decode to PWMACCU_H using decoder 26
2652 // 2982: }
2653 1, 0, // 2986: case 0x1: {
2654 OPC_CheckPredicate, 47, // 2988: check predicate 47
2655 OPC_CheckField, 7, 1, 1, // 2990: check Inst[7] == 0x1
2656 OPC_Decode, 142, 132, 1, 26, // 2994: decode to WMACCU using decoder 26
2657 // 2994: }
2658 // 2994: } // switch Inst[25]
2659 // 2994: }
2660 16, 50, // 2999: case 0x10: {
2661 OPC_SwitchField, 7, 1, // 3001: switch Inst[7] {
2662 0, 23, // 3004: case 0x0: {
2663 OPC_SwitchField, 25, 1, // 3006: switch Inst[25] {
2664 0, 10, // 3009: case 0x0: {
2665 OPC_CheckPredicate, 47, // 3011: check predicate 47
2666 OPC_CheckField, 24, 1, 1, // 3013: check Inst[24] == 0x1
2667 OPC_Decode, 149, 122, 22, // 3017: decode to PWSLAI_B using decoder 22
2668 // 3017: }
2669 1, 0, // 3021: case 0x1: {
2670 OPC_CheckPredicate, 47, // 3023: check predicate 47
2671 OPC_Decode, 150, 122, 23, // 3025: decode to PWSLAI_H using decoder 23
2672 // 3025: }
2673 // 3025: } // switch Inst[25]
2674 // 3025: }
2675 1, 0, // 3029: case 0x1: {
2676 OPC_SwitchField, 25, 1, // 3031: switch Inst[25] {
2677 0, 6, // 3034: case 0x0: {
2678 OPC_CheckPredicate, 47, // 3036: check predicate 47
2679 OPC_Decode, 164, 122, 24, // 3038: decode to PWSUB_H using decoder 24
2680 // 3038: }
2681 1, 0, // 3042: case 0x1: {
2682 OPC_CheckPredicate, 47, // 3044: check predicate 47
2683 OPC_Decode, 152, 132, 1, 24, // 3046: decode to WSUB using decoder 24
2684 // 3046: }
2685 // 3046: } // switch Inst[25]
2686 // 3046: }
2687 // 3046: } // switch Inst[7]
2688 // 3046: }
2689 17, 33, // 3051: case 0x11: {
2690 OPC_SwitchField, 7, 1, // 3053: switch Inst[7] {
2691 0, 7, // 3056: case 0x0: {
2692 OPC_CheckPredicate, 47, // 3058: check predicate 47
2693 OPC_Decode, 149, 132, 1, 25, // 3060: decode to WSLAI using decoder 25
2694 // 3060: }
2695 1, 0, // 3065: case 0x1: {
2696 OPC_SwitchField, 25, 1, // 3067: switch Inst[25] {
2697 0, 6, // 3070: case 0x0: {
2698 OPC_CheckPredicate, 47, // 3072: check predicate 47
2699 OPC_Decode, 163, 122, 24, // 3074: decode to PWSUB_B using decoder 24
2700 // 3074: }
2701 1, 0, // 3078: case 0x1: {
2702 OPC_CheckPredicate, 47, // 3080: check predicate 47
2703 OPC_Decode, 185, 119, 24, // 3082: decode to PM2WSUB_H using decoder 24
2704 // 3082: }
2705 // 3082: } // switch Inst[25]
2706 // 3082: }
2707 // 3082: } // switch Inst[7]
2708 // 3082: }
2709 18, 46, // 3086: case 0x12: {
2710 OPC_SwitchField, 7, 1, // 3088: switch Inst[7] {
2711 0, 19, // 3091: case 0x0: {
2712 OPC_SwitchField, 25, 1, // 3093: switch Inst[25] {
2713 0, 6, // 3096: case 0x0: {
2714 OPC_CheckPredicate, 47, // 3098: check predicate 47
2715 OPC_Decode, 151, 122, 24, // 3100: decode to PWSLA_BS using decoder 24
2716 // 3100: }
2717 1, 0, // 3104: case 0x1: {
2718 OPC_CheckPredicate, 47, // 3106: check predicate 47
2719 OPC_Decode, 152, 122, 24, // 3108: decode to PWSLA_HS using decoder 24
2720 // 3108: }
2721 // 3108: } // switch Inst[25]
2722 // 3108: }
2723 1, 0, // 3112: case 0x1: {
2724 OPC_SwitchField, 25, 1, // 3114: switch Inst[25] {
2725 0, 6, // 3117: case 0x0: {
2726 OPC_CheckPredicate, 47, // 3119: check predicate 47
2727 OPC_Decode, 160, 122, 26, // 3121: decode to PWSUBA_H using decoder 26
2728 // 3121: }
2729 1, 0, // 3125: case 0x1: {
2730 OPC_CheckPredicate, 47, // 3127: check predicate 47
2731 OPC_Decode, 153, 132, 1, 26, // 3129: decode to WSUBA using decoder 26
2732 // 3129: }
2733 // 3129: } // switch Inst[25]
2734 // 3129: }
2735 // 3129: } // switch Inst[7]
2736 // 3129: }
2737 19, 37, // 3134: case 0x13: {
2738 OPC_SwitchField, 7, 1, // 3136: switch Inst[7] {
2739 0, 11, // 3139: case 0x0: {
2740 OPC_CheckPredicate, 47, // 3141: check predicate 47
2741 OPC_CheckField, 25, 1, 1, // 3143: check Inst[25] == 0x1
2742 OPC_Decode, 148, 132, 1, 24, // 3147: decode to WSLA using decoder 24
2743 // 3147: }
2744 1, 0, // 3152: case 0x1: {
2745 OPC_SwitchField, 25, 1, // 3154: switch Inst[25] {
2746 0, 6, // 3157: case 0x0: {
2747 OPC_CheckPredicate, 47, // 3159: check predicate 47
2748 OPC_Decode, 159, 122, 26, // 3161: decode to PWSUBA_B using decoder 26
2749 // 3161: }
2750 1, 0, // 3165: case 0x1: {
2751 OPC_CheckPredicate, 47, // 3167: check predicate 47
2752 OPC_Decode, 183, 119, 26, // 3169: decode to PM2WSUBA_H using decoder 26
2753 // 3169: }
2754 // 3169: } // switch Inst[25]
2755 // 3169: }
2756 // 3169: } // switch Inst[7]
2757 // 3169: }
2758 20, 28, // 3173: case 0x14: {
2759 OPC_SwitchField, 25, 1, // 3175: switch Inst[25] {
2760 0, 10, // 3178: case 0x0: {
2761 OPC_CheckPredicate, 47, // 3180: check predicate 47
2762 OPC_CheckField, 7, 1, 1, // 3182: check Inst[7] == 0x1
2763 OPC_Decode, 162, 122, 24, // 3186: decode to PWSUBU_H using decoder 24
2764 // 3186: }
2765 1, 0, // 3190: case 0x1: {
2766 OPC_CheckPredicate, 47, // 3192: check predicate 47
2767 OPC_CheckField, 7, 1, 1, // 3194: check Inst[7] == 0x1
2768 OPC_Decode, 155, 132, 1, 24, // 3198: decode to WSUBU using decoder 24
2769 // 3198: }
2770 // 3198: } // switch Inst[25]
2771 // 3198: }
2772 21, 27, // 3203: case 0x15: {
2773 OPC_SwitchField, 25, 1, // 3205: switch Inst[25] {
2774 0, 10, // 3208: case 0x0: {
2775 OPC_CheckPredicate, 47, // 3210: check predicate 47
2776 OPC_CheckField, 7, 1, 1, // 3212: check Inst[7] == 0x1
2777 OPC_Decode, 161, 122, 24, // 3216: decode to PWSUBU_B using decoder 24
2778 // 3216: }
2779 1, 0, // 3220: case 0x1: {
2780 OPC_CheckPredicate, 47, // 3222: check predicate 47
2781 OPC_CheckField, 7, 1, 1, // 3224: check Inst[7] == 0x1
2782 OPC_Decode, 186, 119, 24, // 3228: decode to PM2WSUB_HX using decoder 24
2783 // 3228: }
2784 // 3228: } // switch Inst[25]
2785 // 3228: }
2786 22, 28, // 3232: case 0x16: {
2787 OPC_SwitchField, 25, 1, // 3234: switch Inst[25] {
2788 0, 10, // 3237: case 0x0: {
2789 OPC_CheckPredicate, 47, // 3239: check predicate 47
2790 OPC_CheckField, 7, 1, 1, // 3241: check Inst[7] == 0x1
2791 OPC_Decode, 158, 122, 26, // 3245: decode to PWSUBAU_H using decoder 26
2792 // 3245: }
2793 1, 0, // 3249: case 0x1: {
2794 OPC_CheckPredicate, 47, // 3251: check predicate 47
2795 OPC_CheckField, 7, 1, 1, // 3253: check Inst[7] == 0x1
2796 OPC_Decode, 154, 132, 1, 26, // 3257: decode to WSUBAU using decoder 26
2797 // 3257: }
2798 // 3257: } // switch Inst[25]
2799 // 3257: }
2800 23, 27, // 3262: case 0x17: {
2801 OPC_SwitchField, 25, 1, // 3264: switch Inst[25] {
2802 0, 10, // 3267: case 0x0: {
2803 OPC_CheckPredicate, 47, // 3269: check predicate 47
2804 OPC_CheckField, 7, 1, 1, // 3271: check Inst[7] == 0x1
2805 OPC_Decode, 157, 122, 26, // 3275: decode to PWSUBAU_B using decoder 26
2806 // 3275: }
2807 1, 0, // 3279: case 0x1: {
2808 OPC_CheckPredicate, 47, // 3281: check predicate 47
2809 OPC_CheckField, 7, 1, 1, // 3283: check Inst[7] == 0x1
2810 OPC_Decode, 184, 119, 26, // 3287: decode to PM2WSUBA_HX using decoder 26
2811 // 3287: }
2812 // 3287: } // switch Inst[25]
2813 // 3287: }
2814 24, 28, // 3291: case 0x18: {
2815 OPC_SwitchField, 25, 1, // 3293: switch Inst[25] {
2816 0, 10, // 3296: case 0x0: {
2817 OPC_CheckPredicate, 47, // 3298: check predicate 47
2818 OPC_CheckField, 7, 1, 1, // 3300: check Inst[7] == 0x1
2819 OPC_Decode, 144, 122, 24, // 3304: decode to PWMULSU_H using decoder 24
2820 // 3304: }
2821 1, 0, // 3308: case 0x1: {
2822 OPC_CheckPredicate, 47, // 3310: check predicate 47
2823 OPC_CheckField, 7, 1, 1, // 3312: check Inst[7] == 0x1
2824 OPC_Decode, 144, 132, 1, 24, // 3316: decode to WMULSU using decoder 24
2825 // 3316: }
2826 // 3316: } // switch Inst[25]
2827 // 3316: }
2828 25, 27, // 3321: case 0x19: {
2829 OPC_SwitchField, 25, 1, // 3323: switch Inst[25] {
2830 0, 10, // 3326: case 0x0: {
2831 OPC_CheckPredicate, 47, // 3328: check predicate 47
2832 OPC_CheckField, 7, 1, 1, // 3330: check Inst[7] == 0x1
2833 OPC_Decode, 143, 122, 24, // 3334: decode to PWMULSU_B using decoder 24
2834 // 3334: }
2835 1, 0, // 3338: case 0x1: {
2836 OPC_CheckPredicate, 47, // 3340: check predicate 47
2837 OPC_CheckField, 7, 1, 1, // 3342: check Inst[7] == 0x1
2838 OPC_Decode, 179, 119, 24, // 3346: decode to PM2WADDSU_H using decoder 24
2839 // 3346: }
2840 // 3346: } // switch Inst[25]
2841 // 3346: }
2842 26, 28, // 3350: case 0x1a: {
2843 OPC_SwitchField, 25, 1, // 3352: switch Inst[25] {
2844 0, 10, // 3355: case 0x0: {
2845 OPC_CheckPredicate, 47, // 3357: check predicate 47
2846 OPC_CheckField, 7, 1, 1, // 3359: check Inst[7] == 0x1
2847 OPC_Decode, 140, 122, 26, // 3363: decode to PWMACCSU_H using decoder 26
2848 // 3363: }
2849 1, 0, // 3367: case 0x1: {
2850 OPC_CheckPredicate, 47, // 3369: check predicate 47
2851 OPC_CheckField, 7, 1, 1, // 3371: check Inst[7] == 0x1
2852 OPC_Decode, 141, 132, 1, 26, // 3375: decode to WMACCSU using decoder 26
2853 // 3375: }
2854 // 3375: } // switch Inst[25]
2855 // 3375: }
2856 27, 14, // 3380: case 0x1b: {
2857 OPC_CheckPredicate, 47, // 3382: check predicate 47
2858 OPC_CheckField, 25, 1, 1, // 3384: check Inst[25] == 0x1
2859 OPC_CheckField, 7, 1, 1, // 3388: check Inst[7] == 0x1
2860 OPC_Decode, 175, 119, 26, // 3392: decode to PM2WADDASU_H using decoder 26
2861 // 3392: }
2862 28, 14, // 3396: case 0x1c: {
2863 OPC_CheckPredicate, 47, // 3398: check predicate 47
2864 OPC_CheckField, 25, 1, 0, // 3400: check Inst[25] == 0x0
2865 OPC_CheckField, 7, 1, 0, // 3404: check Inst[7] == 0x0
2866 OPC_Decode, 146, 119, 29, // 3408: decode to PLUI_DH using decoder 29
2867 // 3408: }
2868 30, 47, // 3412: case 0x1e: {
2869 OPC_SwitchField, 7, 1, // 3414: switch Inst[7] {
2870 0, 21, // 3417: case 0x0: {
2871 OPC_SwitchField, 25, 1, // 3419: switch Inst[25] {
2872 0, 7, // 3422: case 0x0: {
2873 OPC_CheckPredicate, 47, // 3424: check predicate 47
2874 OPC_Decode, 157, 132, 1, 24, // 3426: decode to WZIP8P using decoder 24
2875 // 3426: }
2876 1, 0, // 3431: case 0x1: {
2877 OPC_CheckPredicate, 47, // 3433: check predicate 47
2878 OPC_Decode, 156, 132, 1, 24, // 3435: decode to WZIP16P using decoder 24
2879 // 3435: }
2880 // 3435: } // switch Inst[25]
2881 // 3435: }
2882 1, 0, // 3440: case 0x1: {
2883 OPC_SwitchField, 25, 1, // 3442: switch Inst[25] {
2884 0, 6, // 3445: case 0x0: {
2885 OPC_CheckPredicate, 47, // 3447: check predicate 47
2886 OPC_Decode, 138, 120, 26, // 3449: decode to PMQWACC_H using decoder 26
2887 // 3449: }
2888 1, 0, // 3453: case 0x1: {
2889 OPC_CheckPredicate, 47, // 3455: check predicate 47
2890 OPC_Decode, 237, 117, 26, // 3457: decode to MQWACC using decoder 26
2891 // 3457: }
2892 // 3457: } // switch Inst[25]
2893 // 3457: }
2894 // 3457: } // switch Inst[7]
2895 // 3457: }
2896 31, 27, // 3461: case 0x1f: {
2897 OPC_SwitchField, 25, 1, // 3463: switch Inst[25] {
2898 0, 10, // 3466: case 0x0: {
2899 OPC_CheckPredicate, 47, // 3468: check predicate 47
2900 OPC_CheckField, 7, 1, 1, // 3470: check Inst[7] == 0x1
2901 OPC_Decode, 137, 120, 26, // 3474: decode to PMQRWACC_H using decoder 26
2902 // 3474: }
2903 1, 0, // 3478: case 0x1: {
2904 OPC_CheckPredicate, 47, // 3480: check predicate 47
2905 OPC_CheckField, 7, 1, 1, // 3482: check Inst[7] == 0x1
2906 OPC_Decode, 236, 117, 26, // 3486: decode to MQRWACC using decoder 26
2907 // 3486: }
2908 // 3486: } // switch Inst[25]
2909 // 3486: }
2910 32, 36, // 3490: case 0x20: {
2911 OPC_SwitchField, 25, 1, // 3492: switch Inst[25] {
2912 0, 23, // 3495: case 0x0: {
2913 OPC_SwitchField, 24, 1, // 3497: switch Inst[24] {
2914 0, 10, // 3500: case 0x0: {
2915 OPC_CheckPredicate, 43, // 3502: check predicate 43
2916 OPC_CheckField, 23, 1, 1, // 3504: check Inst[23] == 0x1
2917 OPC_Decode, 171, 121, 30, // 3508: decode to PSLLI_B using decoder 30
2918 // 3508: }
2919 1, 0, // 3512: case 0x1: {
2920 OPC_CheckPredicate, 43, // 3514: check predicate 43
2921 OPC_Decode, 175, 121, 18, // 3516: decode to PSLLI_H using decoder 18
2922 // 3516: }
2923 // 3516: } // switch Inst[24]
2924 // 3516: }
2925 1, 0, // 3520: case 0x1: {
2926 OPC_CheckPredicate, 48, // 3522: check predicate 48
2927 OPC_Decode, 176, 121, 21, // 3524: decode to PSLLI_W using decoder 21
2928 // 3524: }
2929 // 3524: } // switch Inst[25]
2930 // 3524: }
2931 34, 19, // 3528: case 0x22: {
2932 OPC_SwitchField, 25, 1, // 3530: switch Inst[25] {
2933 0, 6, // 3533: case 0x0: {
2934 OPC_CheckPredicate, 43, // 3535: check predicate 43
2935 OPC_Decode, 181, 121, 31, // 3537: decode to PSLL_HS using decoder 31
2936 // 3537: }
2937 1, 0, // 3541: case 0x1: {
2938 OPC_CheckPredicate, 48, // 3543: check predicate 48
2939 OPC_Decode, 182, 121, 31, // 3545: decode to PSLL_WS using decoder 31
2940 // 3545: }
2941 // 3545: } // switch Inst[25]
2942 // 3545: }
2943 35, 10, // 3549: case 0x23: {
2944 OPC_CheckPredicate, 43, // 3551: check predicate 43
2945 OPC_CheckField, 25, 1, 0, // 3553: check Inst[25] == 0x0
2946 OPC_Decode, 177, 121, 31, // 3557: decode to PSLL_BS using decoder 31
2947 // 3557: }
2948 38, 19, // 3561: case 0x26: {
2949 OPC_SwitchField, 25, 1, // 3563: switch Inst[25] {
2950 0, 6, // 3566: case 0x0: {
2951 OPC_CheckPredicate, 43, // 3568: check predicate 43
2952 OPC_Decode, 248, 118, 31, // 3570: decode to PADD_HS using decoder 31
2953 // 3570: }
2954 1, 0, // 3574: case 0x1: {
2955 OPC_CheckPredicate, 48, // 3576: check predicate 48
2956 OPC_Decode, 250, 118, 31, // 3578: decode to PADD_WS using decoder 31
2957 // 3578: }
2958 // 3578: } // switch Inst[25]
2959 // 3578: }
2960 39, 10, // 3582: case 0x27: {
2961 OPC_CheckPredicate, 43, // 3584: check predicate 43
2962 OPC_CheckField, 25, 1, 0, // 3586: check Inst[25] == 0x0
2963 OPC_Decode, 240, 118, 31, // 3590: decode to PADD_BS using decoder 31
2964 // 3590: }
2965 42, 19, // 3594: case 0x2a: {
2966 OPC_SwitchField, 25, 1, // 3596: switch Inst[25] {
2967 0, 6, // 3599: case 0x0: {
2968 OPC_CheckPredicate, 43, // 3601: check predicate 43
2969 OPC_Decode, 232, 121, 31, // 3603: decode to PSSHL_HS using decoder 31
2970 // 3603: }
2971 1, 0, // 3607: case 0x1: {
2972 OPC_CheckPredicate, 48, // 3609: check predicate 48
2973 OPC_Decode, 233, 121, 31, // 3611: decode to PSSHL_WS using decoder 31
2974 // 3611: }
2975 // 3611: } // switch Inst[25]
2976 // 3611: }
2977 43, 10, // 3615: case 0x2b: {
2978 OPC_CheckPredicate, 48, // 3617: check predicate 48
2979 OPC_CheckField, 25, 1, 1, // 3619: check Inst[25] == 0x1
2980 OPC_Decode, 207, 124, 31, // 3623: decode to SHL using decoder 31
2981 // 3623: }
2982 44, 19, // 3627: case 0x2c: {
2983 OPC_SwitchField, 25, 1, // 3629: switch Inst[25] {
2984 0, 6, // 3632: case 0x0: {
2985 OPC_CheckPredicate, 43, // 3634: check predicate 43
2986 OPC_Decode, 144, 119, 32, // 3636: decode to PLI_H using decoder 32
2987 // 3636: }
2988 1, 0, // 3640: case 0x1: {
2989 OPC_CheckPredicate, 48, // 3642: check predicate 48
2990 OPC_Decode, 145, 119, 32, // 3644: decode to PLI_W using decoder 32
2991 // 3644: }
2992 // 3644: } // switch Inst[25]
2993 // 3644: }
2994 45, 14, // 3648: case 0x2d: {
2995 OPC_CheckPredicate, 43, // 3650: check predicate 43
2996 OPC_CheckField, 24, 2, 0, // 3652: check Inst[25:24] == 0x0
2997 OPC_CheckField, 15, 1, 0, // 3656: check Inst[15] == 0x0
2998 OPC_Decode, 141, 119, 33, // 3660: decode to PLI_B using decoder 33
2999 // 3660: }
3000 46, 19, // 3664: case 0x2e: {
3001 OPC_SwitchField, 25, 1, // 3666: switch Inst[25] {
3002 0, 6, // 3669: case 0x0: {
3003 OPC_CheckPredicate, 43, // 3671: check predicate 43
3004 OPC_Decode, 228, 121, 31, // 3673: decode to PSSHLR_HS using decoder 31
3005 // 3673: }
3006 1, 0, // 3677: case 0x1: {
3007 OPC_CheckPredicate, 48, // 3679: check predicate 48
3008 OPC_Decode, 229, 121, 31, // 3681: decode to PSSHLR_WS using decoder 31
3009 // 3681: }
3010 // 3681: } // switch Inst[25]
3011 // 3681: }
3012 47, 10, // 3685: case 0x2f: {
3013 OPC_CheckPredicate, 48, // 3687: check predicate 48
3014 OPC_CheckField, 25, 1, 1, // 3689: check Inst[25] == 0x1
3015 OPC_Decode, 208, 124, 31, // 3693: decode to SHLR using decoder 31
3016 // 3693: }
3017 52, 23, // 3697: case 0x34: {
3018 OPC_SwitchField, 25, 1, // 3699: switch Inst[25] {
3019 0, 10, // 3702: case 0x0: {
3020 OPC_CheckPredicate, 43, // 3704: check predicate 43
3021 OPC_CheckField, 24, 1, 1, // 3706: check Inst[24] == 0x1
3022 OPC_Decode, 236, 121, 18, // 3710: decode to PSSLAI_H using decoder 18
3023 // 3710: }
3024 1, 0, // 3714: case 0x1: {
3025 OPC_CheckPredicate, 48, // 3716: check predicate 48
3026 OPC_Decode, 237, 121, 21, // 3718: decode to PSSLAI_W using decoder 21
3027 // 3718: }
3028 // 3718: } // switch Inst[25]
3029 // 3718: }
3030 56, 35, // 3722: case 0x38: {
3031 OPC_SwitchField, 20, 6, // 3724: switch Inst[25:20] {
3032 4, 6, // 3727: case 0x4: {
3033 OPC_CheckPredicate, 43, // 3729: check predicate 43
3034 OPC_Decode, 164, 121, 17, // 3731: decode to PSEXT_H_B using decoder 17
3035 // 3731: }
3036 7, 6, // 3735: case 0x7: {
3037 OPC_CheckPredicate, 43, // 3737: check predicate 43
3038 OPC_Decode, 138, 121, 17, // 3739: decode to PSABS_H using decoder 17
3039 // 3739: }
3040 36, 6, // 3743: case 0x24: {
3041 OPC_CheckPredicate, 48, // 3745: check predicate 48
3042 OPC_Decode, 165, 121, 17, // 3747: decode to PSEXT_W_B using decoder 17
3043 // 3747: }
3044 37, 0, // 3751: case 0x25: {
3045 OPC_CheckPredicate, 48, // 3753: check predicate 48
3046 OPC_Decode, 166, 121, 17, // 3755: decode to PSEXT_W_H using decoder 17
3047 // 3755: }
3048 // 3755: } // switch Inst[25:20]
3049 // 3755: }
3050 57, 10, // 3759: case 0x39: {
3051 OPC_CheckPredicate, 43, // 3761: check predicate 43
3052 OPC_CheckField, 20, 6, 7, // 3763: check Inst[25:20] == 0x7
3053 OPC_Decode, 135, 121, 17, // 3767: decode to PSABS_B using decoder 17
3054 // 3767: }
3055 58, 19, // 3771: case 0x3a: {
3056 OPC_SwitchField, 25, 1, // 3773: switch Inst[25] {
3057 0, 6, // 3776: case 0x0: {
3058 OPC_CheckPredicate, 43, // 3778: check predicate 43
3059 OPC_Decode, 224, 121, 31, // 3780: decode to PSSHA_HS using decoder 31
3060 // 3780: }
3061 1, 0, // 3784: case 0x1: {
3062 OPC_CheckPredicate, 48, // 3786: check predicate 48
3063 OPC_Decode, 225, 121, 31, // 3788: decode to PSSHA_WS using decoder 31
3064 // 3788: }
3065 // 3788: } // switch Inst[25]
3066 // 3788: }
3067 59, 10, // 3792: case 0x3b: {
3068 OPC_CheckPredicate, 48, // 3794: check predicate 48
3069 OPC_CheckField, 25, 1, 1, // 3796: check Inst[25] == 0x1
3070 OPC_Decode, 191, 124, 31, // 3800: decode to SHA using decoder 31
3071 // 3800: }
3072 60, 19, // 3804: case 0x3c: {
3073 OPC_SwitchField, 25, 1, // 3806: switch Inst[25] {
3074 0, 6, // 3809: case 0x0: {
3075 OPC_CheckPredicate, 43, // 3811: check predicate 43
3076 OPC_Decode, 147, 119, 34, // 3813: decode to PLUI_H using decoder 34
3077 // 3813: }
3078 1, 0, // 3817: case 0x1: {
3079 OPC_CheckPredicate, 48, // 3819: check predicate 48
3080 OPC_Decode, 148, 119, 34, // 3821: decode to PLUI_W using decoder 34
3081 // 3821: }
3082 // 3821: } // switch Inst[25]
3083 // 3821: }
3084 62, 19, // 3825: case 0x3e: {
3085 OPC_SwitchField, 25, 1, // 3827: switch Inst[25] {
3086 0, 6, // 3830: case 0x0: {
3087 OPC_CheckPredicate, 43, // 3832: check predicate 43
3088 OPC_Decode, 220, 121, 31, // 3834: decode to PSSHAR_HS using decoder 31
3089 // 3834: }
3090 1, 0, // 3838: case 0x1: {
3091 OPC_CheckPredicate, 48, // 3840: check predicate 48
3092 OPC_Decode, 221, 121, 31, // 3842: decode to PSSHAR_WS using decoder 31
3093 // 3842: }
3094 // 3842: } // switch Inst[25]
3095 // 3842: }
3096 63, 0, // 3846: case 0x3f: {
3097 OPC_CheckPredicate, 48, // 3848: check predicate 48
3098 OPC_CheckField, 25, 1, 1, // 3850: check Inst[25] == 0x1
3099 OPC_Decode, 206, 124, 31, // 3854: decode to SHAR using decoder 31
3100 // 3854: }
3101 // 3854: } // switch Inst[31:26]
3102 // 3854: }
3103 4, 226, 7, // 3858: case 0x4: {
3104 OPC_SwitchField, 26, 6, // 3861: switch Inst[31:26] {
3105 0, 31, // 3864: case 0x0: {
3106 OPC_SwitchField, 25, 1, // 3866: switch Inst[25] {
3107 0, 14, // 3869: case 0x0: {
3108 OPC_CheckPredicate, 47, // 3871: check predicate 47
3109 OPC_CheckField, 24, 1, 1, // 3873: check Inst[24] == 0x1
3110 OPC_CheckField, 15, 1, 1, // 3877: check Inst[15] == 0x1
3111 OPC_Decode, 227, 120, 35, // 3881: decode to PNSRLI_B using decoder 35
3112 // 3881: }
3113 1, 0, // 3885: case 0x1: {
3114 OPC_CheckPredicate, 47, // 3887: check predicate 47
3115 OPC_CheckField, 15, 1, 1, // 3889: check Inst[15] == 0x1
3116 OPC_Decode, 228, 120, 36, // 3893: decode to PNSRLI_H using decoder 36
3117 // 3893: }
3118 // 3893: } // switch Inst[25]
3119 // 3893: }
3120 1, 10, // 3897: case 0x1: {
3121 OPC_CheckPredicate, 47, // 3899: check predicate 47
3122 OPC_CheckField, 15, 1, 1, // 3901: check Inst[15] == 0x1
3123 OPC_Decode, 206, 118, 37, // 3905: decode to NSRLI using decoder 37
3124 // 3905: }
3125 2, 27, // 3909: case 0x2: {
3126 OPC_SwitchField, 25, 1, // 3911: switch Inst[25] {
3127 0, 10, // 3914: case 0x0: {
3128 OPC_CheckPredicate, 47, // 3916: check predicate 47
3129 OPC_CheckField, 15, 1, 1, // 3918: check Inst[15] == 0x1
3130 OPC_Decode, 229, 120, 38, // 3922: decode to PNSRL_BS using decoder 38
3131 // 3922: }
3132 1, 0, // 3926: case 0x1: {
3133 OPC_CheckPredicate, 47, // 3928: check predicate 47
3134 OPC_CheckField, 15, 1, 1, // 3930: check Inst[15] == 0x1
3135 OPC_Decode, 230, 120, 38, // 3934: decode to PNSRL_HS using decoder 38
3136 // 3934: }
3137 // 3934: } // switch Inst[25]
3138 // 3934: }
3139 3, 14, // 3938: case 0x3: {
3140 OPC_CheckPredicate, 47, // 3940: check predicate 47
3141 OPC_CheckField, 25, 1, 1, // 3942: check Inst[25] == 0x1
3142 OPC_CheckField, 15, 1, 1, // 3946: check Inst[15] == 0x1
3143 OPC_Decode, 205, 118, 38, // 3950: decode to NSRL using decoder 38
3144 // 3950: }
3145 6, 14, // 3954: case 0x6: {
3146 OPC_CheckPredicate, 47, // 3956: check predicate 47
3147 OPC_CheckField, 25, 1, 0, // 3958: check Inst[25] == 0x0
3148 OPC_CheckField, 15, 1, 0, // 3962: check Inst[15] == 0x0
3149 OPC_Decode, 129, 121, 38, // 3966: decode to PREDSUM_DHS using decoder 38
3150 // 3966: }
3151 7, 14, // 3970: case 0x7: {
3152 OPC_CheckPredicate, 47, // 3972: check predicate 47
3153 OPC_CheckField, 25, 1, 0, // 3974: check Inst[25] == 0x0
3154 OPC_CheckField, 15, 1, 0, // 3978: check Inst[15] == 0x0
3155 OPC_Decode, 128, 121, 38, // 3982: decode to PREDSUM_DBS using decoder 38
3156 // 3982: }
3157 8, 31, // 3986: case 0x8: {
3158 OPC_SwitchField, 25, 1, // 3988: switch Inst[25] {
3159 0, 14, // 3991: case 0x0: {
3160 OPC_CheckPredicate, 47, // 3993: check predicate 47
3161 OPC_CheckField, 24, 1, 1, // 3995: check Inst[24] == 0x1
3162 OPC_CheckField, 15, 1, 1, // 3999: check Inst[15] == 0x1
3163 OPC_Decode, 197, 120, 35, // 4003: decode to PNCLIPIU_B using decoder 35
3164 // 4003: }
3165 1, 0, // 4007: case 0x1: {
3166 OPC_CheckPredicate, 47, // 4009: check predicate 47
3167 OPC_CheckField, 15, 1, 1, // 4011: check Inst[15] == 0x1
3168 OPC_Decode, 198, 120, 36, // 4015: decode to PNCLIPIU_H using decoder 36
3169 // 4015: }
3170 // 4015: } // switch Inst[25]
3171 // 4015: }
3172 9, 10, // 4019: case 0x9: {
3173 OPC_CheckPredicate, 47, // 4021: check predicate 47
3174 OPC_CheckField, 15, 1, 1, // 4023: check Inst[15] == 0x1
3175 OPC_Decode, 148, 118, 37, // 4027: decode to NCLIPIU using decoder 37
3176 // 4027: }
3177 10, 27, // 4031: case 0xa: {
3178 OPC_SwitchField, 25, 1, // 4033: switch Inst[25] {
3179 0, 10, // 4036: case 0x0: {
3180 OPC_CheckPredicate, 47, // 4038: check predicate 47
3181 OPC_CheckField, 15, 1, 1, // 4040: check Inst[15] == 0x1
3182 OPC_Decode, 215, 120, 38, // 4044: decode to PNCLIPU_BS using decoder 38
3183 // 4044: }
3184 1, 0, // 4048: case 0x1: {
3185 OPC_CheckPredicate, 47, // 4050: check predicate 47
3186 OPC_CheckField, 15, 1, 1, // 4052: check Inst[15] == 0x1
3187 OPC_Decode, 216, 120, 38, // 4056: decode to PNCLIPU_HS using decoder 38
3188 // 4056: }
3189 // 4056: } // switch Inst[25]
3190 // 4056: }
3191 11, 14, // 4060: case 0xb: {
3192 OPC_CheckPredicate, 47, // 4062: check predicate 47
3193 OPC_CheckField, 25, 1, 1, // 4064: check Inst[25] == 0x1
3194 OPC_CheckField, 15, 1, 1, // 4068: check Inst[15] == 0x1
3195 OPC_Decode, 153, 118, 38, // 4072: decode to NCLIPU using decoder 38
3196 // 4072: }
3197 12, 31, // 4076: case 0xc: {
3198 OPC_SwitchField, 25, 1, // 4078: switch Inst[25] {
3199 0, 14, // 4081: case 0x0: {
3200 OPC_CheckPredicate, 47, // 4083: check predicate 47
3201 OPC_CheckField, 24, 1, 1, // 4085: check Inst[24] == 0x1
3202 OPC_CheckField, 15, 1, 1, // 4089: check Inst[15] == 0x1
3203 OPC_Decode, 204, 120, 35, // 4093: decode to PNCLIPRIU_B using decoder 35
3204 // 4093: }
3205 1, 0, // 4097: case 0x1: {
3206 OPC_CheckPredicate, 47, // 4099: check predicate 47
3207 OPC_CheckField, 15, 1, 1, // 4101: check Inst[15] == 0x1
3208 OPC_Decode, 205, 120, 36, // 4105: decode to PNCLIPRIU_H using decoder 36
3209 // 4105: }
3210 // 4105: } // switch Inst[25]
3211 // 4105: }
3212 13, 10, // 4109: case 0xd: {
3213 OPC_CheckPredicate, 47, // 4111: check predicate 47
3214 OPC_CheckField, 15, 1, 1, // 4113: check Inst[15] == 0x1
3215 OPC_Decode, 151, 118, 37, // 4117: decode to NCLIPRIU using decoder 37
3216 // 4117: }
3217 14, 36, // 4121: case 0xe: {
3218 OPC_SwitchField, 15, 1, // 4123: switch Inst[15] {
3219 0, 10, // 4126: case 0x0: {
3220 OPC_CheckPredicate, 47, // 4128: check predicate 47
3221 OPC_CheckField, 25, 1, 0, // 4130: check Inst[25] == 0x0
3222 OPC_Decode, 252, 120, 38, // 4134: decode to PREDSUMU_DHS using decoder 38
3223 // 4134: }
3224 1, 0, // 4138: case 0x1: {
3225 OPC_SwitchField, 25, 1, // 4140: switch Inst[25] {
3226 0, 6, // 4143: case 0x0: {
3227 OPC_CheckPredicate, 47, // 4145: check predicate 47
3228 OPC_Decode, 208, 120, 38, // 4147: decode to PNCLIPRU_BS using decoder 38
3229 // 4147: }
3230 1, 0, // 4151: case 0x1: {
3231 OPC_CheckPredicate, 47, // 4153: check predicate 47
3232 OPC_Decode, 209, 120, 38, // 4155: decode to PNCLIPRU_HS using decoder 38
3233 // 4155: }
3234 // 4155: } // switch Inst[25]
3235 // 4155: }
3236 // 4155: } // switch Inst[15]
3237 // 4155: }
3238 15, 27, // 4159: case 0xf: {
3239 OPC_SwitchField, 15, 1, // 4161: switch Inst[15] {
3240 0, 10, // 4164: case 0x0: {
3241 OPC_CheckPredicate, 47, // 4166: check predicate 47
3242 OPC_CheckField, 25, 1, 0, // 4168: check Inst[25] == 0x0
3243 OPC_Decode, 251, 120, 38, // 4172: decode to PREDSUMU_DBS using decoder 38
3244 // 4172: }
3245 1, 0, // 4176: case 0x1: {
3246 OPC_CheckPredicate, 47, // 4178: check predicate 47
3247 OPC_CheckField, 25, 1, 1, // 4180: check Inst[25] == 0x1
3248 OPC_Decode, 152, 118, 38, // 4184: decode to NCLIPRU using decoder 38
3249 // 4184: }
3250 // 4184: } // switch Inst[15]
3251 // 4184: }
3252 16, 31, // 4188: case 0x10: {
3253 OPC_SwitchField, 25, 1, // 4190: switch Inst[25] {
3254 0, 14, // 4193: case 0x0: {
3255 OPC_CheckPredicate, 47, // 4195: check predicate 47
3256 OPC_CheckField, 24, 1, 1, // 4197: check Inst[24] == 0x1
3257 OPC_CheckField, 15, 1, 1, // 4201: check Inst[15] == 0x1
3258 OPC_Decode, 219, 120, 35, // 4205: decode to PNSRAI_B using decoder 35
3259 // 4205: }
3260 1, 0, // 4209: case 0x1: {
3261 OPC_CheckPredicate, 47, // 4211: check predicate 47
3262 OPC_CheckField, 15, 1, 1, // 4213: check Inst[15] == 0x1
3263 OPC_Decode, 220, 120, 36, // 4217: decode to PNSRAI_H using decoder 36
3264 // 4217: }
3265 // 4217: } // switch Inst[25]
3266 // 4217: }
3267 17, 10, // 4221: case 0x11: {
3268 OPC_CheckPredicate, 47, // 4223: check predicate 47
3269 OPC_CheckField, 15, 1, 1, // 4225: check Inst[15] == 0x1
3270 OPC_Decode, 202, 118, 37, // 4229: decode to NSRAI using decoder 37
3271 // 4229: }
3272 18, 27, // 4233: case 0x12: {
3273 OPC_SwitchField, 25, 1, // 4235: switch Inst[25] {
3274 0, 10, // 4238: case 0x0: {
3275 OPC_CheckPredicate, 47, // 4240: check predicate 47
3276 OPC_CheckField, 15, 1, 1, // 4242: check Inst[15] == 0x1
3277 OPC_Decode, 225, 120, 38, // 4246: decode to PNSRA_BS using decoder 38
3278 // 4246: }
3279 1, 0, // 4250: case 0x1: {
3280 OPC_CheckPredicate, 47, // 4252: check predicate 47
3281 OPC_CheckField, 15, 1, 1, // 4254: check Inst[15] == 0x1
3282 OPC_Decode, 226, 120, 38, // 4258: decode to PNSRA_HS using decoder 38
3283 // 4258: }
3284 // 4258: } // switch Inst[25]
3285 // 4258: }
3286 19, 14, // 4262: case 0x13: {
3287 OPC_CheckPredicate, 47, // 4264: check predicate 47
3288 OPC_CheckField, 25, 1, 1, // 4266: check Inst[25] == 0x1
3289 OPC_CheckField, 15, 1, 1, // 4270: check Inst[15] == 0x1
3290 OPC_Decode, 201, 118, 38, // 4274: decode to NSRA using decoder 38
3291 // 4274: }
3292 20, 31, // 4278: case 0x14: {
3293 OPC_SwitchField, 25, 1, // 4280: switch Inst[25] {
3294 0, 14, // 4283: case 0x0: {
3295 OPC_CheckPredicate, 47, // 4285: check predicate 47
3296 OPC_CheckField, 24, 1, 1, // 4287: check Inst[24] == 0x1
3297 OPC_CheckField, 15, 1, 1, // 4291: check Inst[15] == 0x1
3298 OPC_Decode, 221, 120, 35, // 4295: decode to PNSRARI_B using decoder 35
3299 // 4295: }
3300 1, 0, // 4299: case 0x1: {
3301 OPC_CheckPredicate, 47, // 4301: check predicate 47
3302 OPC_CheckField, 15, 1, 1, // 4303: check Inst[15] == 0x1
3303 OPC_Decode, 222, 120, 36, // 4307: decode to PNSRARI_H using decoder 36
3304 // 4307: }
3305 // 4307: } // switch Inst[25]
3306 // 4307: }
3307 21, 10, // 4311: case 0x15: {
3308 OPC_CheckPredicate, 47, // 4313: check predicate 47
3309 OPC_CheckField, 15, 1, 1, // 4315: check Inst[15] == 0x1
3310 OPC_Decode, 204, 118, 37, // 4319: decode to NSRARI using decoder 37
3311 // 4319: }
3312 22, 27, // 4323: case 0x16: {
3313 OPC_SwitchField, 25, 1, // 4325: switch Inst[25] {
3314 0, 10, // 4328: case 0x0: {
3315 OPC_CheckPredicate, 47, // 4330: check predicate 47
3316 OPC_CheckField, 15, 1, 1, // 4332: check Inst[15] == 0x1
3317 OPC_Decode, 223, 120, 38, // 4336: decode to PNSRAR_BS using decoder 38
3318 // 4336: }
3319 1, 0, // 4340: case 0x1: {
3320 OPC_CheckPredicate, 47, // 4342: check predicate 47
3321 OPC_CheckField, 15, 1, 1, // 4344: check Inst[15] == 0x1
3322 OPC_Decode, 224, 120, 38, // 4348: decode to PNSRAR_HS using decoder 38
3323 // 4348: }
3324 // 4348: } // switch Inst[25]
3325 // 4348: }
3326 23, 14, // 4352: case 0x17: {
3327 OPC_CheckPredicate, 47, // 4354: check predicate 47
3328 OPC_CheckField, 25, 1, 1, // 4356: check Inst[25] == 0x1
3329 OPC_CheckField, 15, 1, 1, // 4360: check Inst[15] == 0x1
3330 OPC_Decode, 203, 118, 38, // 4364: decode to NSRAR using decoder 38
3331 // 4364: }
3332 24, 31, // 4368: case 0x18: {
3333 OPC_SwitchField, 25, 1, // 4370: switch Inst[25] {
3334 0, 14, // 4373: case 0x0: {
3335 OPC_CheckPredicate, 47, // 4375: check predicate 47
3336 OPC_CheckField, 24, 1, 1, // 4377: check Inst[24] == 0x1
3337 OPC_CheckField, 15, 1, 1, // 4381: check Inst[15] == 0x1
3338 OPC_Decode, 199, 120, 35, // 4385: decode to PNCLIPI_B using decoder 35
3339 // 4385: }
3340 1, 0, // 4389: case 0x1: {
3341 OPC_CheckPredicate, 47, // 4391: check predicate 47
3342 OPC_CheckField, 15, 1, 1, // 4393: check Inst[15] == 0x1
3343 OPC_Decode, 200, 120, 36, // 4397: decode to PNCLIPI_H using decoder 36
3344 // 4397: }
3345 // 4397: } // switch Inst[25]
3346 // 4397: }
3347 25, 10, // 4401: case 0x19: {
3348 OPC_CheckPredicate, 47, // 4403: check predicate 47
3349 OPC_CheckField, 15, 1, 1, // 4405: check Inst[15] == 0x1
3350 OPC_Decode, 147, 118, 37, // 4409: decode to NCLIPI using decoder 37
3351 // 4409: }
3352 26, 27, // 4413: case 0x1a: {
3353 OPC_SwitchField, 25, 1, // 4415: switch Inst[25] {
3354 0, 10, // 4418: case 0x0: {
3355 OPC_CheckPredicate, 47, // 4420: check predicate 47
3356 OPC_CheckField, 15, 1, 1, // 4422: check Inst[15] == 0x1
3357 OPC_Decode, 217, 120, 38, // 4426: decode to PNCLIP_BS using decoder 38
3358 // 4426: }
3359 1, 0, // 4430: case 0x1: {
3360 OPC_CheckPredicate, 47, // 4432: check predicate 47
3361 OPC_CheckField, 15, 1, 1, // 4434: check Inst[15] == 0x1
3362 OPC_Decode, 218, 120, 38, // 4438: decode to PNCLIP_HS using decoder 38
3363 // 4438: }
3364 // 4438: } // switch Inst[25]
3365 // 4438: }
3366 27, 14, // 4442: case 0x1b: {
3367 OPC_CheckPredicate, 47, // 4444: check predicate 47
3368 OPC_CheckField, 25, 1, 1, // 4446: check Inst[25] == 0x1
3369 OPC_CheckField, 15, 1, 1, // 4450: check Inst[15] == 0x1
3370 OPC_Decode, 146, 118, 38, // 4454: decode to NCLIP using decoder 38
3371 // 4454: }
3372 28, 31, // 4458: case 0x1c: {
3373 OPC_SwitchField, 25, 1, // 4460: switch Inst[25] {
3374 0, 14, // 4463: case 0x0: {
3375 OPC_CheckPredicate, 47, // 4465: check predicate 47
3376 OPC_CheckField, 24, 1, 1, // 4467: check Inst[24] == 0x1
3377 OPC_CheckField, 15, 1, 1, // 4471: check Inst[15] == 0x1
3378 OPC_Decode, 206, 120, 35, // 4475: decode to PNCLIPRI_B using decoder 35
3379 // 4475: }
3380 1, 0, // 4479: case 0x1: {
3381 OPC_CheckPredicate, 47, // 4481: check predicate 47
3382 OPC_CheckField, 15, 1, 1, // 4483: check Inst[15] == 0x1
3383 OPC_Decode, 207, 120, 36, // 4487: decode to PNCLIPRI_H using decoder 36
3384 // 4487: }
3385 // 4487: } // switch Inst[25]
3386 // 4487: }
3387 29, 10, // 4491: case 0x1d: {
3388 OPC_CheckPredicate, 47, // 4493: check predicate 47
3389 OPC_CheckField, 15, 1, 1, // 4495: check Inst[15] == 0x1
3390 OPC_Decode, 150, 118, 37, // 4499: decode to NCLIPRI using decoder 37
3391 // 4499: }
3392 30, 27, // 4503: case 0x1e: {
3393 OPC_SwitchField, 25, 1, // 4505: switch Inst[25] {
3394 0, 10, // 4508: case 0x0: {
3395 OPC_CheckPredicate, 47, // 4510: check predicate 47
3396 OPC_CheckField, 15, 1, 1, // 4512: check Inst[15] == 0x1
3397 OPC_Decode, 210, 120, 38, // 4516: decode to PNCLIPR_BS using decoder 38
3398 // 4516: }
3399 1, 0, // 4520: case 0x1: {
3400 OPC_CheckPredicate, 47, // 4522: check predicate 47
3401 OPC_CheckField, 15, 1, 1, // 4524: check Inst[15] == 0x1
3402 OPC_Decode, 211, 120, 38, // 4528: decode to PNCLIPR_HS using decoder 38
3403 // 4528: }
3404 // 4528: } // switch Inst[25]
3405 // 4528: }
3406 31, 14, // 4532: case 0x1f: {
3407 OPC_CheckPredicate, 47, // 4534: check predicate 47
3408 OPC_CheckField, 25, 1, 1, // 4536: check Inst[25] == 0x1
3409 OPC_CheckField, 15, 1, 1, // 4540: check Inst[15] == 0x1
3410 OPC_Decode, 149, 118, 38, // 4544: decode to NCLIPR using decoder 38
3411 // 4544: }
3412 32, 36, // 4548: case 0x20: {
3413 OPC_SwitchField, 25, 1, // 4550: switch Inst[25] {
3414 0, 23, // 4553: case 0x0: {
3415 OPC_SwitchField, 24, 1, // 4555: switch Inst[24] {
3416 0, 10, // 4558: case 0x0: {
3417 OPC_CheckPredicate, 43, // 4560: check predicate 43
3418 OPC_CheckField, 23, 1, 1, // 4562: check Inst[23] == 0x1
3419 OPC_Decode, 199, 121, 30, // 4566: decode to PSRLI_B using decoder 30
3420 // 4566: }
3421 1, 0, // 4570: case 0x1: {
3422 OPC_CheckPredicate, 43, // 4572: check predicate 43
3423 OPC_Decode, 203, 121, 18, // 4574: decode to PSRLI_H using decoder 18
3424 // 4574: }
3425 // 4574: } // switch Inst[24]
3426 // 4574: }
3427 1, 0, // 4578: case 0x1: {
3428 OPC_CheckPredicate, 48, // 4580: check predicate 48
3429 OPC_Decode, 204, 121, 21, // 4582: decode to PSRLI_W using decoder 21
3430 // 4582: }
3431 // 4582: } // switch Inst[25]
3432 // 4582: }
3433 34, 19, // 4586: case 0x22: {
3434 OPC_SwitchField, 25, 1, // 4588: switch Inst[25] {
3435 0, 6, // 4591: case 0x0: {
3436 OPC_CheckPredicate, 43, // 4593: check predicate 43
3437 OPC_Decode, 209, 121, 31, // 4595: decode to PSRL_HS using decoder 31
3438 // 4595: }
3439 1, 0, // 4599: case 0x1: {
3440 OPC_CheckPredicate, 48, // 4601: check predicate 48
3441 OPC_Decode, 210, 121, 31, // 4603: decode to PSRL_WS using decoder 31
3442 // 4603: }
3443 // 4603: } // switch Inst[25]
3444 // 4603: }
3445 35, 10, // 4607: case 0x23: {
3446 OPC_CheckPredicate, 43, // 4609: check predicate 43
3447 OPC_CheckField, 25, 1, 0, // 4611: check Inst[25] == 0x0
3448 OPC_Decode, 205, 121, 31, // 4615: decode to PSRL_BS using decoder 31
3449 // 4615: }
3450 38, 19, // 4619: case 0x26: {
3451 OPC_SwitchField, 25, 1, // 4621: switch Inst[25] {
3452 0, 6, // 4624: case 0x0: {
3453 OPC_CheckPredicate, 43, // 4626: check predicate 43
3454 OPC_Decode, 130, 121, 31, // 4628: decode to PREDSUM_HS using decoder 31
3455 // 4628: }
3456 1, 0, // 4632: case 0x1: {
3457 OPC_CheckPredicate, 48, // 4634: check predicate 48
3458 OPC_Decode, 131, 121, 31, // 4636: decode to PREDSUM_WS using decoder 31
3459 // 4636: }
3460 // 4636: } // switch Inst[25]
3461 // 4636: }
3462 39, 10, // 4640: case 0x27: {
3463 OPC_CheckPredicate, 43, // 4642: check predicate 43
3464 OPC_CheckField, 25, 1, 0, // 4644: check Inst[25] == 0x0
3465 OPC_Decode, 255, 120, 31, // 4648: decode to PREDSUM_BS using decoder 31
3466 // 4648: }
3467 40, 23, // 4652: case 0x28: {
3468 OPC_SwitchField, 25, 1, // 4654: switch Inst[25] {
3469 0, 10, // 4657: case 0x0: {
3470 OPC_CheckPredicate, 43, // 4659: check predicate 43
3471 OPC_CheckField, 24, 1, 1, // 4661: check Inst[24] == 0x1
3472 OPC_Decode, 130, 122, 18, // 4665: decode to PUSATI_H using decoder 18
3473 // 4665: }
3474 1, 0, // 4669: case 0x1: {
3475 OPC_CheckPredicate, 48, // 4671: check predicate 48
3476 OPC_Decode, 131, 122, 21, // 4673: decode to PUSATI_W using decoder 21
3477 // 4673: }
3478 // 4673: } // switch Inst[25]
3479 // 4673: }
3480 41, 6, // 4677: case 0x29: {
3481 OPC_CheckPredicate, 48, // 4679: check predicate 48
3482 OPC_Decode, 142, 126, 39, // 4681: decode to USATI_RV64 using decoder 39
3483 // 4681: }
3484 46, 19, // 4685: case 0x2e: {
3485 OPC_SwitchField, 25, 1, // 4687: switch Inst[25] {
3486 0, 6, // 4690: case 0x0: {
3487 OPC_CheckPredicate, 43, // 4692: check predicate 43
3488 OPC_Decode, 253, 120, 31, // 4694: decode to PREDSUMU_HS using decoder 31
3489 // 4694: }
3490 1, 0, // 4698: case 0x1: {
3491 OPC_CheckPredicate, 48, // 4700: check predicate 48
3492 OPC_Decode, 254, 120, 31, // 4702: decode to PREDSUMU_WS using decoder 31
3493 // 4702: }
3494 // 4702: } // switch Inst[25]
3495 // 4702: }
3496 47, 10, // 4706: case 0x2f: {
3497 OPC_CheckPredicate, 43, // 4708: check predicate 43
3498 OPC_CheckField, 25, 1, 0, // 4710: check Inst[25] == 0x0
3499 OPC_Decode, 250, 120, 31, // 4714: decode to PREDSUMU_BS using decoder 31
3500 // 4714: }
3501 48, 36, // 4718: case 0x30: {
3502 OPC_SwitchField, 25, 1, // 4720: switch Inst[25] {
3503 0, 23, // 4723: case 0x0: {
3504 OPC_SwitchField, 24, 1, // 4725: switch Inst[24] {
3505 0, 10, // 4728: case 0x0: {
3506 OPC_CheckPredicate, 43, // 4730: check predicate 43
3507 OPC_CheckField, 23, 1, 1, // 4732: check Inst[23] == 0x1
3508 OPC_Decode, 183, 121, 30, // 4736: decode to PSRAI_B using decoder 30
3509 // 4736: }
3510 1, 0, // 4740: case 0x1: {
3511 OPC_CheckPredicate, 43, // 4742: check predicate 43
3512 OPC_Decode, 187, 121, 18, // 4744: decode to PSRAI_H using decoder 18
3513 // 4744: }
3514 // 4744: } // switch Inst[24]
3515 // 4744: }
3516 1, 0, // 4748: case 0x1: {
3517 OPC_CheckPredicate, 48, // 4750: check predicate 48
3518 OPC_Decode, 188, 121, 21, // 4752: decode to PSRAI_W using decoder 21
3519 // 4752: }
3520 // 4752: } // switch Inst[25]
3521 // 4752: }
3522 50, 19, // 4756: case 0x32: {
3523 OPC_SwitchField, 25, 1, // 4758: switch Inst[25] {
3524 0, 6, // 4761: case 0x0: {
3525 OPC_CheckPredicate, 43, // 4763: check predicate 43
3526 OPC_Decode, 197, 121, 31, // 4765: decode to PSRA_HS using decoder 31
3527 // 4765: }
3528 1, 0, // 4769: case 0x1: {
3529 OPC_CheckPredicate, 48, // 4771: check predicate 48
3530 OPC_Decode, 198, 121, 31, // 4773: decode to PSRA_WS using decoder 31
3531 // 4773: }
3532 // 4773: } // switch Inst[25]
3533 // 4773: }
3534 51, 10, // 4777: case 0x33: {
3535 OPC_CheckPredicate, 43, // 4779: check predicate 43
3536 OPC_CheckField, 25, 1, 0, // 4781: check Inst[25] == 0x0
3537 OPC_Decode, 193, 121, 31, // 4785: decode to PSRA_BS using decoder 31
3538 // 4785: }
3539 52, 23, // 4789: case 0x34: {
3540 OPC_SwitchField, 25, 1, // 4791: switch Inst[25] {
3541 0, 10, // 4794: case 0x0: {
3542 OPC_CheckPredicate, 43, // 4796: check predicate 43
3543 OPC_CheckField, 24, 1, 1, // 4798: check Inst[24] == 0x1
3544 OPC_Decode, 191, 121, 18, // 4802: decode to PSRARI_H using decoder 18
3545 // 4802: }
3546 1, 0, // 4806: case 0x1: {
3547 OPC_CheckPredicate, 48, // 4808: check predicate 48
3548 OPC_Decode, 192, 121, 21, // 4810: decode to PSRARI_W using decoder 21
3549 // 4810: }
3550 // 4810: } // switch Inst[25]
3551 // 4810: }
3552 53, 6, // 4814: case 0x35: {
3553 OPC_CheckPredicate, 48, // 4816: check predicate 48
3554 OPC_Decode, 248, 124, 39, // 4818: decode to SRARI_RV64 using decoder 39
3555 // 4818: }
3556 56, 23, // 4822: case 0x38: {
3557 OPC_SwitchField, 25, 1, // 4824: switch Inst[25] {
3558 0, 10, // 4827: case 0x0: {
3559 OPC_CheckPredicate, 43, // 4829: check predicate 43
3560 OPC_CheckField, 24, 1, 1, // 4831: check Inst[24] == 0x1
3561 OPC_Decode, 156, 121, 40, // 4835: decode to PSATI_H using decoder 40
3562 // 4835: }
3563 1, 0, // 4839: case 0x1: {
3564 OPC_CheckPredicate, 48, // 4841: check predicate 48
3565 OPC_Decode, 157, 121, 41, // 4843: decode to PSATI_W using decoder 41
3566 // 4843: }
3567 // 4843: } // switch Inst[25]
3568 // 4843: }
3569 57, 0, // 4847: case 0x39: {
3570 OPC_CheckPredicate, 48, // 4849: check predicate 48
3571 OPC_Decode, 220, 123, 42, // 4851: decode to SATI_RV64 using decoder 42
3572 // 4851: }
3573 // 4851: } // switch Inst[31:26]
3574 // 4851: }
3575 5, 27, // 4855: case 0x5: {
3576 OPC_SwitchField, 25, 7, // 4857: switch Inst[31:25] {
3577 0, 6, // 4860: case 0x0: {
3578 OPC_CheckPredicate, 22, // 4862: check predicate 22
3579 OPC_Decode, 253, 124, 21, // 4864: decode to SRLIW using decoder 21
3580 // 4864: }
3581 32, 6, // 4868: case 0x20: {
3582 OPC_CheckPredicate, 22, // 4870: check predicate 22
3583 OPC_Decode, 246, 124, 21, // 4872: decode to SRAIW using decoder 21
3584 // 4872: }
3585 48, 0, // 4876: case 0x30: {
3586 OPC_CheckPredicate, 49, // 4878: check predicate 49
3587 OPC_Decode, 215, 123, 21, // 4880: decode to RORIW using decoder 21
3588 // 4880: }
3589 // 4880: } // switch Inst[31:25]
3590 // 4880: }
3591 6, 0, // 4884: case 0x6: {
3592 OPC_SwitchField, 25, 7, // 4886: switch Inst[31:25] {
3593 0, 69, // 4889: case 0x0: {
3594 OPC_SwitchField, 15, 1, // 4891: switch Inst[15] {
3595 0, 31, // 4894: case 0x0: {
3596 OPC_SwitchField, 24, 1, // 4896: switch Inst[24] {
3597 0, 14, // 4899: case 0x0: {
3598 OPC_CheckPredicate, 47, // 4901: check predicate 47
3599 OPC_CheckField, 23, 1, 1, // 4903: check Inst[23] == 0x1
3600 OPC_CheckField, 7, 1, 0, // 4907: check Inst[7] == 0x0
3601 OPC_Decode, 172, 121, 43, // 4911: decode to PSLLI_DB using decoder 43
3602 // 4911: }
3603 1, 0, // 4915: case 0x1: {
3604 OPC_CheckPredicate, 47, // 4917: check predicate 47
3605 OPC_CheckField, 7, 1, 0, // 4919: check Inst[7] == 0x0
3606 OPC_Decode, 173, 121, 44, // 4923: decode to PSLLI_DH using decoder 44
3607 // 4923: }
3608 // 4923: } // switch Inst[24]
3609 // 4923: }
3610 1, 0, // 4927: case 0x1: {
3611 OPC_SwitchField, 24, 1, // 4929: switch Inst[24] {
3612 0, 14, // 4932: case 0x0: {
3613 OPC_CheckPredicate, 47, // 4934: check predicate 47
3614 OPC_CheckField, 23, 1, 1, // 4936: check Inst[23] == 0x1
3615 OPC_CheckField, 7, 1, 0, // 4940: check Inst[7] == 0x0
3616 OPC_Decode, 200, 121, 43, // 4944: decode to PSRLI_DB using decoder 43
3617 // 4944: }
3618 1, 0, // 4948: case 0x1: {
3619 OPC_CheckPredicate, 47, // 4950: check predicate 47
3620 OPC_CheckField, 7, 1, 0, // 4952: check Inst[7] == 0x0
3621 OPC_Decode, 201, 121, 44, // 4956: decode to PSRLI_DH using decoder 44
3622 // 4956: }
3623 // 4956: } // switch Inst[24]
3624 // 4956: }
3625 // 4956: } // switch Inst[15]
3626 // 4956: }
3627 1, 27, // 4960: case 0x1: {
3628 OPC_SwitchField, 15, 1, // 4962: switch Inst[15] {
3629 0, 10, // 4965: case 0x0: {
3630 OPC_CheckPredicate, 47, // 4967: check predicate 47
3631 OPC_CheckField, 7, 1, 0, // 4969: check Inst[7] == 0x0
3632 OPC_Decode, 174, 121, 45, // 4973: decode to PSLLI_DW using decoder 45
3633 // 4973: }
3634 1, 0, // 4977: case 0x1: {
3635 OPC_CheckPredicate, 47, // 4979: check predicate 47
3636 OPC_CheckField, 7, 1, 0, // 4981: check Inst[7] == 0x0
3637 OPC_Decode, 202, 121, 45, // 4985: decode to PSRLI_DW using decoder 45
3638 // 4985: }
3639 // 4985: } // switch Inst[15]
3640 // 4985: }
3641 4, 27, // 4989: case 0x4: {
3642 OPC_SwitchField, 15, 1, // 4991: switch Inst[15] {
3643 0, 10, // 4994: case 0x0: {
3644 OPC_CheckPredicate, 47, // 4996: check predicate 47
3645 OPC_CheckField, 7, 1, 0, // 4998: check Inst[7] == 0x0
3646 OPC_Decode, 179, 121, 46, // 5002: decode to PSLL_DHS using decoder 46
3647 // 5002: }
3648 1, 0, // 5006: case 0x1: {
3649 OPC_CheckPredicate, 47, // 5008: check predicate 47
3650 OPC_CheckField, 7, 1, 0, // 5010: check Inst[7] == 0x0
3651 OPC_Decode, 207, 121, 46, // 5014: decode to PSRL_DHS using decoder 46
3652 // 5014: }
3653 // 5014: } // switch Inst[15]
3654 // 5014: }
3655 5, 27, // 5018: case 0x5: {
3656 OPC_SwitchField, 15, 1, // 5020: switch Inst[15] {
3657 0, 10, // 5023: case 0x0: {
3658 OPC_CheckPredicate, 47, // 5025: check predicate 47
3659 OPC_CheckField, 7, 1, 0, // 5027: check Inst[7] == 0x0
3660 OPC_Decode, 180, 121, 46, // 5031: decode to PSLL_DWS using decoder 46
3661 // 5031: }
3662 1, 0, // 5035: case 0x1: {
3663 OPC_CheckPredicate, 47, // 5037: check predicate 47
3664 OPC_CheckField, 7, 1, 0, // 5039: check Inst[7] == 0x0
3665 OPC_Decode, 208, 121, 46, // 5043: decode to PSRL_DWS using decoder 46
3666 // 5043: }
3667 // 5043: } // switch Inst[15]
3668 // 5043: }
3669 6, 27, // 5047: case 0x6: {
3670 OPC_SwitchField, 15, 1, // 5049: switch Inst[15] {
3671 0, 10, // 5052: case 0x0: {
3672 OPC_CheckPredicate, 47, // 5054: check predicate 47
3673 OPC_CheckField, 7, 1, 0, // 5056: check Inst[7] == 0x0
3674 OPC_Decode, 178, 121, 46, // 5060: decode to PSLL_DBS using decoder 46
3675 // 5060: }
3676 1, 0, // 5064: case 0x1: {
3677 OPC_CheckPredicate, 47, // 5066: check predicate 47
3678 OPC_CheckField, 7, 1, 0, // 5068: check Inst[7] == 0x0
3679 OPC_Decode, 206, 121, 46, // 5072: decode to PSRL_DBS using decoder 46
3680 // 5072: }
3681 // 5072: } // switch Inst[15]
3682 // 5072: }
3683 12, 14, // 5076: case 0xc: {
3684 OPC_CheckPredicate, 47, // 5078: check predicate 47
3685 OPC_CheckField, 15, 1, 0, // 5080: check Inst[15] == 0x0
3686 OPC_CheckField, 7, 1, 0, // 5084: check Inst[7] == 0x0
3687 OPC_Decode, 244, 118, 46, // 5088: decode to PADD_DHS using decoder 46
3688 // 5088: }
3689 13, 14, // 5092: case 0xd: {
3690 OPC_CheckPredicate, 47, // 5094: check predicate 47
3691 OPC_CheckField, 15, 1, 0, // 5096: check Inst[15] == 0x0
3692 OPC_CheckField, 7, 1, 0, // 5100: check Inst[7] == 0x0
3693 OPC_Decode, 246, 118, 46, // 5104: decode to PADD_DWS using decoder 46
3694 // 5104: }
3695 14, 14, // 5108: case 0xe: {
3696 OPC_CheckPredicate, 47, // 5110: check predicate 47
3697 OPC_CheckField, 15, 1, 0, // 5112: check Inst[15] == 0x0
3698 OPC_CheckField, 7, 1, 0, // 5116: check Inst[7] == 0x0
3699 OPC_Decode, 242, 118, 46, // 5120: decode to PADD_DBS using decoder 46
3700 // 5120: }
3701 16, 18, // 5124: case 0x10: {
3702 OPC_CheckPredicate, 47, // 5126: check predicate 47
3703 OPC_CheckField, 24, 1, 1, // 5128: check Inst[24] == 0x1
3704 OPC_CheckField, 15, 1, 1, // 5132: check Inst[15] == 0x1
3705 OPC_CheckField, 7, 1, 0, // 5136: check Inst[7] == 0x0
3706 OPC_Decode, 128, 122, 44, // 5140: decode to PUSATI_DH using decoder 44
3707 // 5140: }
3708 17, 14, // 5144: case 0x11: {
3709 OPC_CheckPredicate, 47, // 5146: check predicate 47
3710 OPC_CheckField, 15, 1, 1, // 5148: check Inst[15] == 0x1
3711 OPC_CheckField, 7, 1, 0, // 5152: check Inst[7] == 0x0
3712 OPC_Decode, 129, 122, 45, // 5156: decode to PUSATI_DW using decoder 45
3713 // 5156: }
3714 20, 14, // 5160: case 0x14: {
3715 OPC_CheckPredicate, 47, // 5162: check predicate 47
3716 OPC_CheckField, 15, 1, 0, // 5164: check Inst[15] == 0x0
3717 OPC_CheckField, 7, 1, 0, // 5168: check Inst[7] == 0x0
3718 OPC_Decode, 230, 121, 46, // 5172: decode to PSSHL_DHS using decoder 46
3719 // 5172: }
3720 21, 14, // 5176: case 0x15: {
3721 OPC_CheckPredicate, 47, // 5178: check predicate 47
3722 OPC_CheckField, 15, 1, 0, // 5180: check Inst[15] == 0x0
3723 OPC_CheckField, 7, 1, 0, // 5184: check Inst[7] == 0x0
3724 OPC_Decode, 231, 121, 46, // 5188: decode to PSSHL_DWS using decoder 46
3725 // 5188: }
3726 28, 14, // 5192: case 0x1c: {
3727 OPC_CheckPredicate, 47, // 5194: check predicate 47
3728 OPC_CheckField, 15, 1, 0, // 5196: check Inst[15] == 0x0
3729 OPC_CheckField, 7, 1, 0, // 5200: check Inst[7] == 0x0
3730 OPC_Decode, 226, 121, 46, // 5204: decode to PSSHLR_DHS using decoder 46
3731 // 5204: }
3732 29, 14, // 5208: case 0x1d: {
3733 OPC_CheckPredicate, 47, // 5210: check predicate 47
3734 OPC_CheckField, 15, 1, 0, // 5212: check Inst[15] == 0x0
3735 OPC_CheckField, 7, 1, 0, // 5216: check Inst[7] == 0x0
3736 OPC_Decode, 227, 121, 46, // 5220: decode to PSSHLR_DWS using decoder 46
3737 // 5220: }
3738 32, 39, // 5224: case 0x20: {
3739 OPC_SwitchField, 24, 1, // 5226: switch Inst[24] {
3740 0, 18, // 5229: case 0x0: {
3741 OPC_CheckPredicate, 47, // 5231: check predicate 47
3742 OPC_CheckField, 23, 1, 1, // 5233: check Inst[23] == 0x1
3743 OPC_CheckField, 15, 1, 1, // 5237: check Inst[15] == 0x1
3744 OPC_CheckField, 7, 1, 0, // 5241: check Inst[7] == 0x0
3745 OPC_Decode, 184, 121, 43, // 5245: decode to PSRAI_DB using decoder 43
3746 // 5245: }
3747 1, 0, // 5249: case 0x1: {
3748 OPC_CheckPredicate, 47, // 5251: check predicate 47
3749 OPC_CheckField, 15, 1, 1, // 5253: check Inst[15] == 0x1
3750 OPC_CheckField, 7, 1, 0, // 5257: check Inst[7] == 0x0
3751 OPC_Decode, 185, 121, 44, // 5261: decode to PSRAI_DH using decoder 44
3752 // 5261: }
3753 // 5261: } // switch Inst[24]
3754 // 5261: }
3755 33, 14, // 5265: case 0x21: {
3756 OPC_CheckPredicate, 47, // 5267: check predicate 47
3757 OPC_CheckField, 15, 1, 1, // 5269: check Inst[15] == 0x1
3758 OPC_CheckField, 7, 1, 0, // 5273: check Inst[7] == 0x0
3759 OPC_Decode, 186, 121, 45, // 5277: decode to PSRAI_DW using decoder 45
3760 // 5277: }
3761 36, 14, // 5281: case 0x24: {
3762 OPC_CheckPredicate, 47, // 5283: check predicate 47
3763 OPC_CheckField, 15, 1, 1, // 5285: check Inst[15] == 0x1
3764 OPC_CheckField, 7, 1, 0, // 5289: check Inst[7] == 0x0
3765 OPC_Decode, 195, 121, 46, // 5293: decode to PSRA_DHS using decoder 46
3766 // 5293: }
3767 37, 14, // 5297: case 0x25: {
3768 OPC_CheckPredicate, 47, // 5299: check predicate 47
3769 OPC_CheckField, 15, 1, 1, // 5301: check Inst[15] == 0x1
3770 OPC_CheckField, 7, 1, 0, // 5305: check Inst[7] == 0x0
3771 OPC_Decode, 196, 121, 46, // 5309: decode to PSRA_DWS using decoder 46
3772 // 5309: }
3773 38, 14, // 5313: case 0x26: {
3774 OPC_CheckPredicate, 47, // 5315: check predicate 47
3775 OPC_CheckField, 15, 1, 1, // 5317: check Inst[15] == 0x1
3776 OPC_CheckField, 7, 1, 0, // 5321: check Inst[7] == 0x0
3777 OPC_Decode, 194, 121, 46, // 5325: decode to PSRA_DBS using decoder 46
3778 // 5325: }
3779 40, 35, // 5329: case 0x28: {
3780 OPC_SwitchField, 15, 1, // 5331: switch Inst[15] {
3781 0, 14, // 5334: case 0x0: {
3782 OPC_CheckPredicate, 47, // 5336: check predicate 47
3783 OPC_CheckField, 24, 1, 1, // 5338: check Inst[24] == 0x1
3784 OPC_CheckField, 7, 1, 0, // 5342: check Inst[7] == 0x0
3785 OPC_Decode, 234, 121, 44, // 5346: decode to PSSLAI_DH using decoder 44
3786 // 5346: }
3787 1, 0, // 5350: case 0x1: {
3788 OPC_CheckPredicate, 47, // 5352: check predicate 47
3789 OPC_CheckField, 24, 1, 1, // 5354: check Inst[24] == 0x1
3790 OPC_CheckField, 7, 1, 0, // 5358: check Inst[7] == 0x0
3791 OPC_Decode, 189, 121, 44, // 5362: decode to PSRARI_DH using decoder 44
3792 // 5362: }
3793 // 5362: } // switch Inst[15]
3794 // 5362: }
3795 41, 27, // 5366: case 0x29: {
3796 OPC_SwitchField, 15, 1, // 5368: switch Inst[15] {
3797 0, 10, // 5371: case 0x0: {
3798 OPC_CheckPredicate, 47, // 5373: check predicate 47
3799 OPC_CheckField, 7, 1, 0, // 5375: check Inst[7] == 0x0
3800 OPC_Decode, 235, 121, 45, // 5379: decode to PSSLAI_DW using decoder 45
3801 // 5379: }
3802 1, 0, // 5383: case 0x1: {
3803 OPC_CheckPredicate, 47, // 5385: check predicate 47
3804 OPC_CheckField, 7, 1, 0, // 5387: check Inst[7] == 0x0
3805 OPC_Decode, 190, 121, 45, // 5391: decode to PSRARI_DW using decoder 45
3806 // 5391: }
3807 // 5391: } // switch Inst[15]
3808 // 5391: }
3809 48, 48, // 5395: case 0x30: {
3810 OPC_SwitchField, 15, 1, // 5397: switch Inst[15] {
3811 0, 27, // 5400: case 0x0: {
3812 OPC_SwitchField, 20, 5, // 5402: switch Inst[24:20] {
3813 4, 10, // 5405: case 0x4: {
3814 OPC_CheckPredicate, 47, // 5407: check predicate 47
3815 OPC_CheckField, 7, 1, 0, // 5409: check Inst[7] == 0x0
3816 OPC_Decode, 161, 121, 47, // 5413: decode to PSEXT_DH_B using decoder 47
3817 // 5413: }
3818 7, 0, // 5417: case 0x7: {
3819 OPC_CheckPredicate, 47, // 5419: check predicate 47
3820 OPC_CheckField, 7, 1, 0, // 5421: check Inst[7] == 0x0
3821 OPC_Decode, 137, 121, 47, // 5425: decode to PSABS_DH using decoder 47
3822 // 5425: }
3823 // 5425: } // switch Inst[24:20]
3824 // 5425: }
3825 1, 0, // 5429: case 0x1: {
3826 OPC_CheckPredicate, 47, // 5431: check predicate 47
3827 OPC_CheckField, 24, 1, 1, // 5433: check Inst[24] == 0x1
3828 OPC_CheckField, 7, 1, 0, // 5437: check Inst[7] == 0x0
3829 OPC_Decode, 154, 121, 48, // 5441: decode to PSATI_DH using decoder 48
3830 // 5441: }
3831 // 5441: } // switch Inst[15]
3832 // 5441: }
3833 49, 44, // 5445: case 0x31: {
3834 OPC_SwitchField, 15, 1, // 5447: switch Inst[15] {
3835 0, 27, // 5450: case 0x0: {
3836 OPC_SwitchField, 20, 5, // 5452: switch Inst[24:20] {
3837 4, 10, // 5455: case 0x4: {
3838 OPC_CheckPredicate, 47, // 5457: check predicate 47
3839 OPC_CheckField, 7, 1, 0, // 5459: check Inst[7] == 0x0
3840 OPC_Decode, 162, 121, 47, // 5463: decode to PSEXT_DW_B using decoder 47
3841 // 5463: }
3842 5, 0, // 5467: case 0x5: {
3843 OPC_CheckPredicate, 47, // 5469: check predicate 47
3844 OPC_CheckField, 7, 1, 0, // 5471: check Inst[7] == 0x0
3845 OPC_Decode, 163, 121, 47, // 5475: decode to PSEXT_DW_H using decoder 47
3846 // 5475: }
3847 // 5475: } // switch Inst[24:20]
3848 // 5475: }
3849 1, 0, // 5479: case 0x1: {
3850 OPC_CheckPredicate, 47, // 5481: check predicate 47
3851 OPC_CheckField, 7, 1, 0, // 5483: check Inst[7] == 0x0
3852 OPC_Decode, 155, 121, 49, // 5487: decode to PSATI_DW using decoder 49
3853 // 5487: }
3854 // 5487: } // switch Inst[15]
3855 // 5487: }
3856 50, 18, // 5491: case 0x32: {
3857 OPC_CheckPredicate, 47, // 5493: check predicate 47
3858 OPC_CheckField, 20, 5, 7, // 5495: check Inst[24:20] == 0x7
3859 OPC_CheckField, 15, 1, 0, // 5499: check Inst[15] == 0x0
3860 OPC_CheckField, 7, 1, 0, // 5503: check Inst[7] == 0x0
3861 OPC_Decode, 136, 121, 47, // 5507: decode to PSABS_DB using decoder 47
3862 // 5507: }
3863 52, 14, // 5511: case 0x34: {
3864 OPC_CheckPredicate, 47, // 5513: check predicate 47
3865 OPC_CheckField, 15, 1, 0, // 5515: check Inst[15] == 0x0
3866 OPC_CheckField, 7, 1, 0, // 5519: check Inst[7] == 0x0
3867 OPC_Decode, 222, 121, 46, // 5523: decode to PSSHA_DHS using decoder 46
3868 // 5523: }
3869 53, 14, // 5527: case 0x35: {
3870 OPC_CheckPredicate, 47, // 5529: check predicate 47
3871 OPC_CheckField, 15, 1, 0, // 5531: check Inst[15] == 0x0
3872 OPC_CheckField, 7, 1, 0, // 5535: check Inst[7] == 0x0
3873 OPC_Decode, 223, 121, 46, // 5539: decode to PSSHA_DWS using decoder 46
3874 // 5539: }
3875 60, 14, // 5543: case 0x3c: {
3876 OPC_CheckPredicate, 47, // 5545: check predicate 47
3877 OPC_CheckField, 15, 1, 0, // 5547: check Inst[15] == 0x0
3878 OPC_CheckField, 7, 1, 0, // 5551: check Inst[7] == 0x0
3879 OPC_Decode, 218, 121, 46, // 5555: decode to PSSHAR_DHS using decoder 46
3880 // 5555: }
3881 61, 14, // 5559: case 0x3d: {
3882 OPC_CheckPredicate, 47, // 5561: check predicate 47
3883 OPC_CheckField, 15, 1, 0, // 5563: check Inst[15] == 0x0
3884 OPC_CheckField, 7, 1, 0, // 5567: check Inst[7] == 0x0
3885 OPC_Decode, 219, 121, 46, // 5571: decode to PSSHAR_DWS using decoder 46
3886 // 5571: }
3887 64, 48, // 5575: case 0x40: {
3888 OPC_SwitchField, 15, 1, // 5577: switch Inst[15] {
3889 0, 14, // 5580: case 0x0: {
3890 OPC_CheckPredicate, 47, // 5582: check predicate 47
3891 OPC_CheckField, 20, 1, 0, // 5584: check Inst[20] == 0x0
3892 OPC_CheckField, 7, 1, 0, // 5588: check Inst[7] == 0x0
3893 OPC_Decode, 243, 118, 50, // 5592: decode to PADD_DH using decoder 50
3894 // 5592: }
3895 1, 0, // 5596: case 0x1: {
3896 OPC_SwitchField, 20, 1, // 5598: switch Inst[20] {
3897 0, 10, // 5601: case 0x0: {
3898 OPC_CheckPredicate, 47, // 5603: check predicate 47
3899 OPC_CheckField, 7, 1, 0, // 5605: check Inst[7] == 0x0
3900 OPC_Decode, 237, 120, 50, // 5609: decode to PPAIRE_DB using decoder 50
3901 // 5609: }
3902 1, 0, // 5613: case 0x1: {
3903 OPC_CheckPredicate, 47, // 5615: check predicate 47
3904 OPC_CheckField, 7, 1, 0, // 5617: check Inst[7] == 0x0
3905 OPC_Decode, 138, 119, 50, // 5621: decode to PAS_DHX using decoder 50
3906 // 5621: }
3907 // 5621: } // switch Inst[20]
3908 // 5621: }
3909 // 5621: } // switch Inst[15]
3910 // 5621: }
3911 65, 35, // 5625: case 0x41: {
3912 OPC_SwitchField, 15, 1, // 5627: switch Inst[15] {
3913 0, 14, // 5630: case 0x0: {
3914 OPC_CheckPredicate, 47, // 5632: check predicate 47
3915 OPC_CheckField, 20, 1, 0, // 5634: check Inst[20] == 0x0
3916 OPC_CheckField, 7, 1, 0, // 5638: check Inst[7] == 0x0
3917 OPC_Decode, 245, 118, 50, // 5642: decode to PADD_DW using decoder 50
3918 // 5642: }
3919 1, 0, // 5646: case 0x1: {
3920 OPC_CheckPredicate, 47, // 5648: check predicate 47
3921 OPC_CheckField, 20, 1, 0, // 5650: check Inst[20] == 0x0
3922 OPC_CheckField, 7, 1, 0, // 5654: check Inst[7] == 0x0
3923 OPC_Decode, 238, 120, 50, // 5658: decode to PPAIRE_DH using decoder 50
3924 // 5658: }
3925 // 5658: } // switch Inst[15]
3926 // 5658: }
3927 66, 35, // 5662: case 0x42: {
3928 OPC_SwitchField, 15, 1, // 5664: switch Inst[15] {
3929 0, 14, // 5667: case 0x0: {
3930 OPC_CheckPredicate, 47, // 5669: check predicate 47
3931 OPC_CheckField, 20, 1, 0, // 5671: check Inst[20] == 0x0
3932 OPC_CheckField, 7, 1, 0, // 5675: check Inst[7] == 0x0
3933 OPC_Decode, 241, 118, 50, // 5679: decode to PADD_DB using decoder 50
3934 // 5679: }
3935 1, 0, // 5683: case 0x1: {
3936 OPC_CheckPredicate, 47, // 5685: check predicate 47
3937 OPC_CheckField, 20, 1, 1, // 5687: check Inst[20] == 0x1
3938 OPC_CheckField, 7, 1, 0, // 5691: check Inst[7] == 0x0
3939 OPC_Decode, 158, 121, 50, // 5695: decode to PSA_DHX using decoder 50
3940 // 5695: }
3941 // 5695: } // switch Inst[15]
3942 // 5695: }
3943 67, 18, // 5699: case 0x43: {
3944 OPC_CheckPredicate, 47, // 5701: check predicate 47
3945 OPC_CheckField, 20, 1, 0, // 5703: check Inst[20] == 0x0
3946 OPC_CheckField, 15, 1, 0, // 5707: check Inst[15] == 0x0
3947 OPC_CheckField, 7, 1, 0, // 5711: check Inst[7] == 0x0
3948 OPC_Decode, 205, 107, 50, // 5715: decode to ADDD using decoder 50
3949 // 5715: }
3950 72, 48, // 5719: case 0x48: {
3951 OPC_SwitchField, 15, 1, // 5721: switch Inst[15] {
3952 0, 14, // 5724: case 0x0: {
3953 OPC_CheckPredicate, 47, // 5726: check predicate 47
3954 OPC_CheckField, 20, 1, 0, // 5728: check Inst[20] == 0x0
3955 OPC_CheckField, 7, 1, 0, // 5732: check Inst[7] == 0x0
3956 OPC_Decode, 147, 121, 50, // 5736: decode to PSADD_DH using decoder 50
3957 // 5736: }
3958 1, 0, // 5740: case 0x1: {
3959 OPC_SwitchField, 20, 1, // 5742: switch Inst[20] {
3960 0, 10, // 5745: case 0x0: {
3961 OPC_CheckPredicate, 47, // 5747: check predicate 47
3962 OPC_CheckField, 7, 1, 0, // 5749: check Inst[7] == 0x0
3963 OPC_Decode, 232, 120, 50, // 5753: decode to PPAIREO_DB using decoder 50
3964 // 5753: }
3965 1, 0, // 5757: case 0x1: {
3966 OPC_CheckPredicate, 47, // 5759: check predicate 47
3967 OPC_CheckField, 7, 1, 0, // 5761: check Inst[7] == 0x0
3968 OPC_Decode, 151, 121, 50, // 5765: decode to PSAS_DHX using decoder 50
3969 // 5765: }
3970 // 5765: } // switch Inst[20]
3971 // 5765: }
3972 // 5765: } // switch Inst[15]
3973 // 5765: }
3974 73, 35, // 5769: case 0x49: {
3975 OPC_SwitchField, 15, 1, // 5771: switch Inst[15] {
3976 0, 14, // 5774: case 0x0: {
3977 OPC_CheckPredicate, 47, // 5776: check predicate 47
3978 OPC_CheckField, 20, 1, 0, // 5778: check Inst[20] == 0x0
3979 OPC_CheckField, 7, 1, 0, // 5782: check Inst[7] == 0x0
3980 OPC_Decode, 148, 121, 50, // 5786: decode to PSADD_DW using decoder 50
3981 // 5786: }
3982 1, 0, // 5790: case 0x1: {
3983 OPC_CheckPredicate, 47, // 5792: check predicate 47
3984 OPC_CheckField, 20, 1, 0, // 5794: check Inst[20] == 0x0
3985 OPC_CheckField, 7, 1, 0, // 5798: check Inst[7] == 0x0
3986 OPC_Decode, 233, 120, 50, // 5802: decode to PPAIREO_DH using decoder 50
3987 // 5802: }
3988 // 5802: } // switch Inst[15]
3989 // 5802: }
3990 74, 35, // 5806: case 0x4a: {
3991 OPC_SwitchField, 15, 1, // 5808: switch Inst[15] {
3992 0, 14, // 5811: case 0x0: {
3993 OPC_CheckPredicate, 47, // 5813: check predicate 47
3994 OPC_CheckField, 20, 1, 0, // 5815: check Inst[20] == 0x0
3995 OPC_CheckField, 7, 1, 0, // 5819: check Inst[7] == 0x0
3996 OPC_Decode, 146, 121, 50, // 5823: decode to PSADD_DB using decoder 50
3997 // 5823: }
3998 1, 0, // 5827: case 0x1: {
3999 OPC_CheckPredicate, 47, // 5829: check predicate 47
4000 OPC_CheckField, 20, 1, 1, // 5831: check Inst[20] == 0x1
4001 OPC_CheckField, 7, 1, 0, // 5835: check Inst[7] == 0x0
4002 OPC_Decode, 211, 121, 50, // 5839: decode to PSSA_DHX using decoder 50
4003 // 5839: }
4004 // 5839: } // switch Inst[15]
4005 // 5839: }
4006 76, 35, // 5843: case 0x4c: {
4007 OPC_SwitchField, 15, 1, // 5845: switch Inst[15] {
4008 0, 14, // 5848: case 0x0: {
4009 OPC_CheckPredicate, 47, // 5850: check predicate 47
4010 OPC_CheckField, 20, 1, 0, // 5852: check Inst[20] == 0x0
4011 OPC_CheckField, 7, 1, 0, // 5856: check Inst[7] == 0x0
4012 OPC_Decode, 219, 118, 50, // 5860: decode to PAADD_DH using decoder 50
4013 // 5860: }
4014 1, 0, // 5864: case 0x1: {
4015 OPC_CheckPredicate, 47, // 5866: check predicate 47
4016 OPC_CheckField, 20, 1, 1, // 5868: check Inst[20] == 0x1
4017 OPC_CheckField, 7, 1, 0, // 5872: check Inst[7] == 0x0
4018 OPC_Decode, 223, 118, 50, // 5876: decode to PAAS_DHX using decoder 50
4019 // 5876: }
4020 // 5876: } // switch Inst[15]
4021 // 5876: }
4022 77, 18, // 5880: case 0x4d: {
4023 OPC_CheckPredicate, 47, // 5882: check predicate 47
4024 OPC_CheckField, 20, 1, 0, // 5884: check Inst[20] == 0x0
4025 OPC_CheckField, 15, 1, 0, // 5888: check Inst[15] == 0x0
4026 OPC_CheckField, 7, 1, 0, // 5892: check Inst[7] == 0x0
4027 OPC_Decode, 220, 118, 50, // 5896: decode to PAADD_DW using decoder 50
4028 // 5896: }
4029 78, 35, // 5900: case 0x4e: {
4030 OPC_SwitchField, 15, 1, // 5902: switch Inst[15] {
4031 0, 14, // 5905: case 0x0: {
4032 OPC_CheckPredicate, 47, // 5907: check predicate 47
4033 OPC_CheckField, 20, 1, 0, // 5909: check Inst[20] == 0x0
4034 OPC_CheckField, 7, 1, 0, // 5913: check Inst[7] == 0x0
4035 OPC_Decode, 218, 118, 50, // 5917: decode to PAADD_DB using decoder 50
4036 // 5917: }
4037 1, 0, // 5921: case 0x1: {
4038 OPC_CheckPredicate, 47, // 5923: check predicate 47
4039 OPC_CheckField, 20, 1, 1, // 5925: check Inst[20] == 0x1
4040 OPC_CheckField, 7, 1, 0, // 5929: check Inst[7] == 0x0
4041 OPC_Decode, 251, 118, 50, // 5933: decode to PASA_DHX using decoder 50
4042 // 5933: }
4043 // 5933: } // switch Inst[15]
4044 // 5933: }
4045 80, 35, // 5937: case 0x50: {
4046 OPC_SwitchField, 15, 1, // 5939: switch Inst[15] {
4047 0, 14, // 5942: case 0x0: {
4048 OPC_CheckPredicate, 47, // 5944: check predicate 47
4049 OPC_CheckField, 20, 1, 1, // 5946: check Inst[20] == 0x1
4050 OPC_CheckField, 7, 1, 0, // 5950: check Inst[7] == 0x0
4051 OPC_Decode, 167, 121, 50, // 5954: decode to PSH1ADD_DH using decoder 50
4052 // 5954: }
4053 1, 0, // 5958: case 0x1: {
4054 OPC_CheckPredicate, 47, // 5960: check predicate 47
4055 OPC_CheckField, 20, 1, 0, // 5962: check Inst[20] == 0x0
4056 OPC_CheckField, 7, 1, 0, // 5966: check Inst[7] == 0x0
4057 OPC_Decode, 241, 120, 50, // 5970: decode to PPAIROE_DB using decoder 50
4058 // 5970: }
4059 // 5970: } // switch Inst[15]
4060 // 5970: }
4061 81, 35, // 5974: case 0x51: {
4062 OPC_SwitchField, 15, 1, // 5976: switch Inst[15] {
4063 0, 14, // 5979: case 0x0: {
4064 OPC_CheckPredicate, 47, // 5981: check predicate 47
4065 OPC_CheckField, 20, 1, 1, // 5983: check Inst[20] == 0x1
4066 OPC_CheckField, 7, 1, 0, // 5987: check Inst[7] == 0x0
4067 OPC_Decode, 168, 121, 50, // 5991: decode to PSH1ADD_DW using decoder 50
4068 // 5991: }
4069 1, 0, // 5995: case 0x1: {
4070 OPC_CheckPredicate, 47, // 5997: check predicate 47
4071 OPC_CheckField, 20, 1, 0, // 5999: check Inst[20] == 0x0
4072 OPC_CheckField, 7, 1, 0, // 6003: check Inst[7] == 0x0
4073 OPC_Decode, 242, 120, 50, // 6007: decode to PPAIROE_DH using decoder 50
4074 // 6007: }
4075 // 6007: } // switch Inst[15]
4076 // 6007: }
4077 88, 48, // 6011: case 0x58: {
4078 OPC_SwitchField, 15, 1, // 6013: switch Inst[15] {
4079 0, 27, // 6016: case 0x0: {
4080 OPC_SwitchField, 20, 1, // 6018: switch Inst[20] {
4081 0, 10, // 6021: case 0x0: {
4082 OPC_CheckPredicate, 47, // 6023: check predicate 47
4083 OPC_CheckField, 7, 1, 0, // 6025: check Inst[7] == 0x0
4084 OPC_Decode, 141, 121, 50, // 6029: decode to PSADDU_DH using decoder 50
4085 // 6029: }
4086 1, 0, // 6033: case 0x1: {
4087 OPC_CheckPredicate, 47, // 6035: check predicate 47
4088 OPC_CheckField, 7, 1, 0, // 6037: check Inst[7] == 0x0
4089 OPC_Decode, 214, 121, 50, // 6041: decode to PSSH1SADD_DH using decoder 50
4090 // 6041: }
4091 // 6041: } // switch Inst[20]
4092 // 6041: }
4093 1, 0, // 6045: case 0x1: {
4094 OPC_CheckPredicate, 47, // 6047: check predicate 47
4095 OPC_CheckField, 20, 1, 0, // 6049: check Inst[20] == 0x0
4096 OPC_CheckField, 7, 1, 0, // 6053: check Inst[7] == 0x0
4097 OPC_Decode, 246, 120, 50, // 6057: decode to PPAIRO_DB using decoder 50
4098 // 6057: }
4099 // 6057: } // switch Inst[15]
4100 // 6057: }
4101 89, 48, // 6061: case 0x59: {
4102 OPC_SwitchField, 15, 1, // 6063: switch Inst[15] {
4103 0, 27, // 6066: case 0x0: {
4104 OPC_SwitchField, 20, 1, // 6068: switch Inst[20] {
4105 0, 10, // 6071: case 0x0: {
4106 OPC_CheckPredicate, 47, // 6073: check predicate 47
4107 OPC_CheckField, 7, 1, 0, // 6075: check Inst[7] == 0x0
4108 OPC_Decode, 142, 121, 50, // 6079: decode to PSADDU_DW using decoder 50
4109 // 6079: }
4110 1, 0, // 6083: case 0x1: {
4111 OPC_CheckPredicate, 47, // 6085: check predicate 47
4112 OPC_CheckField, 7, 1, 0, // 6087: check Inst[7] == 0x0
4113 OPC_Decode, 215, 121, 50, // 6091: decode to PSSH1SADD_DW using decoder 50
4114 // 6091: }
4115 // 6091: } // switch Inst[20]
4116 // 6091: }
4117 1, 0, // 6095: case 0x1: {
4118 OPC_CheckPredicate, 47, // 6097: check predicate 47
4119 OPC_CheckField, 20, 1, 0, // 6099: check Inst[20] == 0x0
4120 OPC_CheckField, 7, 1, 0, // 6103: check Inst[7] == 0x0
4121 OPC_Decode, 247, 120, 50, // 6107: decode to PPAIRO_DH using decoder 50
4122 // 6107: }
4123 // 6107: } // switch Inst[15]
4124 // 6107: }
4125 90, 18, // 6111: case 0x5a: {
4126 OPC_CheckPredicate, 47, // 6113: check predicate 47
4127 OPC_CheckField, 20, 1, 0, // 6115: check Inst[20] == 0x0
4128 OPC_CheckField, 15, 1, 0, // 6119: check Inst[15] == 0x0
4129 OPC_CheckField, 7, 1, 0, // 6123: check Inst[7] == 0x0
4130 OPC_Decode, 140, 121, 50, // 6127: decode to PSADDU_DB using decoder 50
4131 // 6127: }
4132 92, 18, // 6131: case 0x5c: {
4133 OPC_CheckPredicate, 47, // 6133: check predicate 47
4134 OPC_CheckField, 20, 1, 0, // 6135: check Inst[20] == 0x0
4135 OPC_CheckField, 15, 1, 0, // 6139: check Inst[15] == 0x0
4136 OPC_CheckField, 7, 1, 0, // 6143: check Inst[7] == 0x0
4137 OPC_Decode, 213, 118, 50, // 6147: decode to PAADDU_DH using decoder 50
4138 // 6147: }
4139 93, 18, // 6151: case 0x5d: {
4140 OPC_CheckPredicate, 47, // 6153: check predicate 47
4141 OPC_CheckField, 20, 1, 0, // 6155: check Inst[20] == 0x0
4142 OPC_CheckField, 15, 1, 0, // 6159: check Inst[15] == 0x0
4143 OPC_CheckField, 7, 1, 0, // 6163: check Inst[7] == 0x0
4144 OPC_Decode, 214, 118, 50, // 6167: decode to PAADDU_DW using decoder 50
4145 // 6167: }
4146 94, 18, // 6171: case 0x5e: {
4147 OPC_CheckPredicate, 47, // 6173: check predicate 47
4148 OPC_CheckField, 20, 1, 0, // 6175: check Inst[20] == 0x0
4149 OPC_CheckField, 15, 1, 0, // 6179: check Inst[15] == 0x0
4150 OPC_CheckField, 7, 1, 0, // 6183: check Inst[7] == 0x0
4151 OPC_Decode, 212, 118, 50, // 6187: decode to PAADDU_DB using decoder 50
4152 // 6187: }
4153 96, 35, // 6191: case 0x60: {
4154 OPC_SwitchField, 15, 1, // 6193: switch Inst[15] {
4155 0, 14, // 6196: case 0x0: {
4156 OPC_CheckPredicate, 47, // 6198: check predicate 47
4157 OPC_CheckField, 20, 1, 0, // 6200: check Inst[20] == 0x0
4158 OPC_CheckField, 7, 1, 0, // 6204: check Inst[7] == 0x0
4159 OPC_Decode, 252, 121, 50, // 6208: decode to PSUB_DH using decoder 50
4160 // 6208: }
4161 1, 0, // 6212: case 0x1: {
4162 OPC_CheckPredicate, 47, // 6214: check predicate 47
4163 OPC_CheckField, 20, 1, 1, // 6216: check Inst[20] == 0x1
4164 OPC_CheckField, 7, 1, 0, // 6220: check Inst[7] == 0x0
4165 OPC_Decode, 141, 120, 50, // 6224: decode to PMSEQ_DH using decoder 50
4166 // 6224: }
4167 // 6224: } // switch Inst[15]
4168 // 6224: }
4169 97, 35, // 6228: case 0x61: {
4170 OPC_SwitchField, 15, 1, // 6230: switch Inst[15] {
4171 0, 14, // 6233: case 0x0: {
4172 OPC_CheckPredicate, 47, // 6235: check predicate 47
4173 OPC_CheckField, 20, 1, 0, // 6237: check Inst[20] == 0x0
4174 OPC_CheckField, 7, 1, 0, // 6241: check Inst[7] == 0x0
4175 OPC_Decode, 253, 121, 50, // 6245: decode to PSUB_DW using decoder 50
4176 // 6245: }
4177 1, 0, // 6249: case 0x1: {
4178 OPC_CheckPredicate, 47, // 6251: check predicate 47
4179 OPC_CheckField, 20, 1, 1, // 6253: check Inst[20] == 0x1
4180 OPC_CheckField, 7, 1, 0, // 6257: check Inst[7] == 0x0
4181 OPC_Decode, 142, 120, 50, // 6261: decode to PMSEQ_DW using decoder 50
4182 // 6261: }
4183 // 6261: } // switch Inst[15]
4184 // 6261: }
4185 98, 35, // 6265: case 0x62: {
4186 OPC_SwitchField, 15, 1, // 6267: switch Inst[15] {
4187 0, 14, // 6270: case 0x0: {
4188 OPC_CheckPredicate, 47, // 6272: check predicate 47
4189 OPC_CheckField, 20, 1, 0, // 6274: check Inst[20] == 0x0
4190 OPC_CheckField, 7, 1, 0, // 6278: check Inst[7] == 0x0
4191 OPC_Decode, 251, 121, 50, // 6282: decode to PSUB_DB using decoder 50
4192 // 6282: }
4193 1, 0, // 6286: case 0x1: {
4194 OPC_CheckPredicate, 47, // 6288: check predicate 47
4195 OPC_CheckField, 20, 1, 1, // 6290: check Inst[20] == 0x1
4196 OPC_CheckField, 7, 1, 0, // 6294: check Inst[7] == 0x0
4197 OPC_Decode, 140, 120, 50, // 6298: decode to PMSEQ_DB using decoder 50
4198 // 6298: }
4199 // 6298: } // switch Inst[15]
4200 // 6298: }
4201 99, 18, // 6302: case 0x63: {
4202 OPC_CheckPredicate, 47, // 6304: check predicate 47
4203 OPC_CheckField, 20, 1, 0, // 6306: check Inst[20] == 0x0
4204 OPC_CheckField, 15, 1, 0, // 6310: check Inst[15] == 0x0
4205 OPC_CheckField, 7, 1, 0, // 6314: check Inst[7] == 0x0
4206 OPC_Decode, 148, 125, 50, // 6318: decode to SUBD using decoder 50
4207 // 6318: }
4208 100, 18, // 6322: case 0x64: {
4209 OPC_CheckPredicate, 47, // 6324: check predicate 47
4210 OPC_CheckField, 20, 1, 0, // 6326: check Inst[20] == 0x0
4211 OPC_CheckField, 15, 1, 0, // 6330: check Inst[15] == 0x0
4212 OPC_CheckField, 7, 1, 0, // 6334: check Inst[7] == 0x0
4213 OPC_Decode, 234, 118, 50, // 6338: decode to PABD_DH using decoder 50
4214 // 6338: }
4215 102, 18, // 6342: case 0x66: {
4216 OPC_CheckPredicate, 47, // 6344: check predicate 47
4217 OPC_CheckField, 20, 1, 0, // 6346: check Inst[20] == 0x0
4218 OPC_CheckField, 15, 1, 0, // 6350: check Inst[15] == 0x0
4219 OPC_CheckField, 7, 1, 0, // 6354: check Inst[7] == 0x0
4220 OPC_Decode, 233, 118, 50, // 6358: decode to PABD_DB using decoder 50
4221 // 6358: }
4222 104, 35, // 6362: case 0x68: {
4223 OPC_SwitchField, 15, 1, // 6364: switch Inst[15] {
4224 0, 14, // 6367: case 0x0: {
4225 OPC_CheckPredicate, 47, // 6369: check predicate 47
4226 OPC_CheckField, 20, 1, 0, // 6371: check Inst[20] == 0x0
4227 OPC_CheckField, 7, 1, 0, // 6375: check Inst[7] == 0x0
4228 OPC_Decode, 246, 121, 50, // 6379: decode to PSSUB_DH using decoder 50
4229 // 6379: }
4230 1, 0, // 6383: case 0x1: {
4231 OPC_CheckPredicate, 47, // 6385: check predicate 47
4232 OPC_CheckField, 20, 1, 1, // 6387: check Inst[20] == 0x1
4233 OPC_CheckField, 7, 1, 0, // 6391: check Inst[7] == 0x0
4234 OPC_Decode, 153, 120, 50, // 6395: decode to PMSLT_DH using decoder 50
4235 // 6395: }
4236 // 6395: } // switch Inst[15]
4237 // 6395: }
4238 105, 35, // 6399: case 0x69: {
4239 OPC_SwitchField, 15, 1, // 6401: switch Inst[15] {
4240 0, 14, // 6404: case 0x0: {
4241 OPC_CheckPredicate, 47, // 6406: check predicate 47
4242 OPC_CheckField, 20, 1, 0, // 6408: check Inst[20] == 0x0
4243 OPC_CheckField, 7, 1, 0, // 6412: check Inst[7] == 0x0
4244 OPC_Decode, 247, 121, 50, // 6416: decode to PSSUB_DW using decoder 50
4245 // 6416: }
4246 1, 0, // 6420: case 0x1: {
4247 OPC_CheckPredicate, 47, // 6422: check predicate 47
4248 OPC_CheckField, 20, 1, 1, // 6424: check Inst[20] == 0x1
4249 OPC_CheckField, 7, 1, 0, // 6428: check Inst[7] == 0x0
4250 OPC_Decode, 154, 120, 50, // 6432: decode to PMSLT_DW using decoder 50
4251 // 6432: }
4252 // 6432: } // switch Inst[15]
4253 // 6432: }
4254 106, 35, // 6436: case 0x6a: {
4255 OPC_SwitchField, 15, 1, // 6438: switch Inst[15] {
4256 0, 14, // 6441: case 0x0: {
4257 OPC_CheckPredicate, 47, // 6443: check predicate 47
4258 OPC_CheckField, 20, 1, 0, // 6445: check Inst[20] == 0x0
4259 OPC_CheckField, 7, 1, 0, // 6449: check Inst[7] == 0x0
4260 OPC_Decode, 245, 121, 50, // 6453: decode to PSSUB_DB using decoder 50
4261 // 6453: }
4262 1, 0, // 6457: case 0x1: {
4263 OPC_CheckPredicate, 47, // 6459: check predicate 47
4264 OPC_CheckField, 20, 1, 1, // 6461: check Inst[20] == 0x1
4265 OPC_CheckField, 7, 1, 0, // 6465: check Inst[7] == 0x0
4266 OPC_Decode, 152, 120, 50, // 6469: decode to PMSLT_DB using decoder 50
4267 // 6469: }
4268 // 6469: } // switch Inst[15]
4269 // 6469: }
4270 108, 35, // 6473: case 0x6c: {
4271 OPC_SwitchField, 15, 1, // 6475: switch Inst[15] {
4272 0, 14, // 6478: case 0x0: {
4273 OPC_CheckPredicate, 47, // 6480: check predicate 47
4274 OPC_CheckField, 20, 1, 0, // 6482: check Inst[20] == 0x0
4275 OPC_CheckField, 7, 1, 0, // 6486: check Inst[7] == 0x0
4276 OPC_Decode, 134, 119, 50, // 6490: decode to PASUB_DH using decoder 50
4277 // 6490: }
4278 1, 0, // 6494: case 0x1: {
4279 OPC_CheckPredicate, 47, // 6496: check predicate 47
4280 OPC_CheckField, 20, 1, 1, // 6498: check Inst[20] == 0x1
4281 OPC_CheckField, 7, 1, 0, // 6502: check Inst[7] == 0x0
4282 OPC_Decode, 147, 120, 50, // 6506: decode to PMSLTU_DH using decoder 50
4283 // 6506: }
4284 // 6506: } // switch Inst[15]
4285 // 6506: }
4286 109, 35, // 6510: case 0x6d: {
4287 OPC_SwitchField, 15, 1, // 6512: switch Inst[15] {
4288 0, 14, // 6515: case 0x0: {
4289 OPC_CheckPredicate, 47, // 6517: check predicate 47
4290 OPC_CheckField, 20, 1, 0, // 6519: check Inst[20] == 0x0
4291 OPC_CheckField, 7, 1, 0, // 6523: check Inst[7] == 0x0
4292 OPC_Decode, 135, 119, 50, // 6527: decode to PASUB_DW using decoder 50
4293 // 6527: }
4294 1, 0, // 6531: case 0x1: {
4295 OPC_CheckPredicate, 47, // 6533: check predicate 47
4296 OPC_CheckField, 20, 1, 1, // 6535: check Inst[20] == 0x1
4297 OPC_CheckField, 7, 1, 0, // 6539: check Inst[7] == 0x0
4298 OPC_Decode, 148, 120, 50, // 6543: decode to PMSLTU_DW using decoder 50
4299 // 6543: }
4300 // 6543: } // switch Inst[15]
4301 // 6543: }
4302 110, 35, // 6547: case 0x6e: {
4303 OPC_SwitchField, 15, 1, // 6549: switch Inst[15] {
4304 0, 14, // 6552: case 0x0: {
4305 OPC_CheckPredicate, 47, // 6554: check predicate 47
4306 OPC_CheckField, 20, 1, 0, // 6556: check Inst[20] == 0x0
4307 OPC_CheckField, 7, 1, 0, // 6560: check Inst[7] == 0x0
4308 OPC_Decode, 133, 119, 50, // 6564: decode to PASUB_DB using decoder 50
4309 // 6564: }
4310 1, 0, // 6568: case 0x1: {
4311 OPC_CheckPredicate, 47, // 6570: check predicate 47
4312 OPC_CheckField, 20, 1, 1, // 6572: check Inst[20] == 0x1
4313 OPC_CheckField, 7, 1, 0, // 6576: check Inst[7] == 0x0
4314 OPC_Decode, 146, 120, 50, // 6580: decode to PMSLTU_DB using decoder 50
4315 // 6580: }
4316 // 6580: } // switch Inst[15]
4317 // 6580: }
4318 112, 18, // 6584: case 0x70: {
4319 OPC_CheckPredicate, 47, // 6586: check predicate 47
4320 OPC_CheckField, 20, 1, 1, // 6588: check Inst[20] == 0x1
4321 OPC_CheckField, 15, 1, 1, // 6592: check Inst[15] == 0x1
4322 OPC_CheckField, 7, 1, 0, // 6596: check Inst[7] == 0x0
4323 OPC_Decode, 247, 119, 50, // 6600: decode to PMIN_DH using decoder 50
4324 // 6600: }
4325 113, 18, // 6604: case 0x71: {
4326 OPC_CheckPredicate, 47, // 6606: check predicate 47
4327 OPC_CheckField, 20, 1, 1, // 6608: check Inst[20] == 0x1
4328 OPC_CheckField, 15, 1, 1, // 6612: check Inst[15] == 0x1
4329 OPC_CheckField, 7, 1, 0, // 6616: check Inst[7] == 0x0
4330 OPC_Decode, 248, 119, 50, // 6620: decode to PMIN_DW using decoder 50
4331 // 6620: }
4332 114, 18, // 6624: case 0x72: {
4333 OPC_CheckPredicate, 47, // 6626: check predicate 47
4334 OPC_CheckField, 20, 1, 1, // 6628: check Inst[20] == 0x1
4335 OPC_CheckField, 15, 1, 1, // 6632: check Inst[15] == 0x1
4336 OPC_CheckField, 7, 1, 0, // 6636: check Inst[7] == 0x0
4337 OPC_Decode, 246, 119, 50, // 6640: decode to PMIN_DB using decoder 50
4338 // 6640: }
4339 116, 35, // 6644: case 0x74: {
4340 OPC_SwitchField, 15, 1, // 6646: switch Inst[15] {
4341 0, 14, // 6649: case 0x0: {
4342 OPC_CheckPredicate, 47, // 6651: check predicate 47
4343 OPC_CheckField, 20, 1, 0, // 6653: check Inst[20] == 0x0
4344 OPC_CheckField, 7, 1, 0, // 6657: check Inst[7] == 0x0
4345 OPC_Decode, 230, 118, 50, // 6661: decode to PABDU_DH using decoder 50
4346 // 6661: }
4347 1, 0, // 6665: case 0x1: {
4348 OPC_CheckPredicate, 47, // 6667: check predicate 47
4349 OPC_CheckField, 20, 1, 1, // 6669: check Inst[20] == 0x1
4350 OPC_CheckField, 7, 1, 0, // 6673: check Inst[7] == 0x0
4351 OPC_Decode, 241, 119, 50, // 6677: decode to PMINU_DH using decoder 50
4352 // 6677: }
4353 // 6677: } // switch Inst[15]
4354 // 6677: }
4355 117, 18, // 6681: case 0x75: {
4356 OPC_CheckPredicate, 47, // 6683: check predicate 47
4357 OPC_CheckField, 20, 1, 1, // 6685: check Inst[20] == 0x1
4358 OPC_CheckField, 15, 1, 1, // 6689: check Inst[15] == 0x1
4359 OPC_CheckField, 7, 1, 0, // 6693: check Inst[7] == 0x0
4360 OPC_Decode, 242, 119, 50, // 6697: decode to PMINU_DW using decoder 50
4361 // 6697: }
4362 118, 35, // 6701: case 0x76: {
4363 OPC_SwitchField, 15, 1, // 6703: switch Inst[15] {
4364 0, 14, // 6706: case 0x0: {
4365 OPC_CheckPredicate, 47, // 6708: check predicate 47
4366 OPC_CheckField, 20, 1, 0, // 6710: check Inst[20] == 0x0
4367 OPC_CheckField, 7, 1, 0, // 6714: check Inst[7] == 0x0
4368 OPC_Decode, 229, 118, 50, // 6718: decode to PABDU_DB using decoder 50
4369 // 6718: }
4370 1, 0, // 6722: case 0x1: {
4371 OPC_CheckPredicate, 47, // 6724: check predicate 47
4372 OPC_CheckField, 20, 1, 1, // 6726: check Inst[20] == 0x1
4373 OPC_CheckField, 7, 1, 0, // 6730: check Inst[7] == 0x0
4374 OPC_Decode, 240, 119, 50, // 6734: decode to PMINU_DB using decoder 50
4375 // 6734: }
4376 // 6734: } // switch Inst[15]
4377 // 6734: }
4378 120, 35, // 6738: case 0x78: {
4379 OPC_SwitchField, 15, 1, // 6740: switch Inst[15] {
4380 0, 14, // 6743: case 0x0: {
4381 OPC_CheckPredicate, 47, // 6745: check predicate 47
4382 OPC_CheckField, 20, 1, 0, // 6747: check Inst[20] == 0x0
4383 OPC_CheckField, 7, 1, 0, // 6751: check Inst[7] == 0x0
4384 OPC_Decode, 240, 121, 50, // 6755: decode to PSSUBU_DH using decoder 50
4385 // 6755: }
4386 1, 0, // 6759: case 0x1: {
4387 OPC_CheckPredicate, 47, // 6761: check predicate 47
4388 OPC_CheckField, 20, 1, 1, // 6763: check Inst[20] == 0x1
4389 OPC_CheckField, 7, 1, 0, // 6767: check Inst[7] == 0x0
4390 OPC_Decode, 215, 119, 50, // 6771: decode to PMAX_DH using decoder 50
4391 // 6771: }
4392 // 6771: } // switch Inst[15]
4393 // 6771: }
4394 121, 35, // 6775: case 0x79: {
4395 OPC_SwitchField, 15, 1, // 6777: switch Inst[15] {
4396 0, 14, // 6780: case 0x0: {
4397 OPC_CheckPredicate, 47, // 6782: check predicate 47
4398 OPC_CheckField, 20, 1, 0, // 6784: check Inst[20] == 0x0
4399 OPC_CheckField, 7, 1, 0, // 6788: check Inst[7] == 0x0
4400 OPC_Decode, 241, 121, 50, // 6792: decode to PSSUBU_DW using decoder 50
4401 // 6792: }
4402 1, 0, // 6796: case 0x1: {
4403 OPC_CheckPredicate, 47, // 6798: check predicate 47
4404 OPC_CheckField, 20, 1, 1, // 6800: check Inst[20] == 0x1
4405 OPC_CheckField, 7, 1, 0, // 6804: check Inst[7] == 0x0
4406 OPC_Decode, 216, 119, 50, // 6808: decode to PMAX_DW using decoder 50
4407 // 6808: }
4408 // 6808: } // switch Inst[15]
4409 // 6808: }
4410 122, 35, // 6812: case 0x7a: {
4411 OPC_SwitchField, 15, 1, // 6814: switch Inst[15] {
4412 0, 14, // 6817: case 0x0: {
4413 OPC_CheckPredicate, 47, // 6819: check predicate 47
4414 OPC_CheckField, 20, 1, 0, // 6821: check Inst[20] == 0x0
4415 OPC_CheckField, 7, 1, 0, // 6825: check Inst[7] == 0x0
4416 OPC_Decode, 239, 121, 50, // 6829: decode to PSSUBU_DB using decoder 50
4417 // 6829: }
4418 1, 0, // 6833: case 0x1: {
4419 OPC_CheckPredicate, 47, // 6835: check predicate 47
4420 OPC_CheckField, 20, 1, 1, // 6837: check Inst[20] == 0x1
4421 OPC_CheckField, 7, 1, 0, // 6841: check Inst[7] == 0x0
4422 OPC_Decode, 214, 119, 50, // 6845: decode to PMAX_DB using decoder 50
4423 // 6845: }
4424 // 6845: } // switch Inst[15]
4425 // 6845: }
4426 124, 35, // 6849: case 0x7c: {
4427 OPC_SwitchField, 15, 1, // 6851: switch Inst[15] {
4428 0, 14, // 6854: case 0x0: {
4429 OPC_CheckPredicate, 47, // 6856: check predicate 47
4430 OPC_CheckField, 20, 1, 0, // 6858: check Inst[20] == 0x0
4431 OPC_CheckField, 7, 1, 0, // 6862: check Inst[7] == 0x0
4432 OPC_Decode, 128, 119, 50, // 6866: decode to PASUBU_DH using decoder 50
4433 // 6866: }
4434 1, 0, // 6870: case 0x1: {
4435 OPC_CheckPredicate, 47, // 6872: check predicate 47
4436 OPC_CheckField, 20, 1, 1, // 6874: check Inst[20] == 0x1
4437 OPC_CheckField, 7, 1, 0, // 6878: check Inst[7] == 0x0
4438 OPC_Decode, 209, 119, 50, // 6882: decode to PMAXU_DH using decoder 50
4439 // 6882: }
4440 // 6882: } // switch Inst[15]
4441 // 6882: }
4442 125, 35, // 6886: case 0x7d: {
4443 OPC_SwitchField, 15, 1, // 6888: switch Inst[15] {
4444 0, 14, // 6891: case 0x0: {
4445 OPC_CheckPredicate, 47, // 6893: check predicate 47
4446 OPC_CheckField, 20, 1, 0, // 6895: check Inst[20] == 0x0
4447 OPC_CheckField, 7, 1, 0, // 6899: check Inst[7] == 0x0
4448 OPC_Decode, 129, 119, 50, // 6903: decode to PASUBU_DW using decoder 50
4449 // 6903: }
4450 1, 0, // 6907: case 0x1: {
4451 OPC_CheckPredicate, 47, // 6909: check predicate 47
4452 OPC_CheckField, 20, 1, 1, // 6911: check Inst[20] == 0x1
4453 OPC_CheckField, 7, 1, 0, // 6915: check Inst[7] == 0x0
4454 OPC_Decode, 210, 119, 50, // 6919: decode to PMAXU_DW using decoder 50
4455 // 6919: }
4456 // 6919: } // switch Inst[15]
4457 // 6919: }
4458 126, 0, // 6923: case 0x7e: {
4459 OPC_SwitchField, 15, 1, // 6925: switch Inst[15] {
4460 0, 14, // 6928: case 0x0: {
4461 OPC_CheckPredicate, 47, // 6930: check predicate 47
4462 OPC_CheckField, 20, 1, 0, // 6932: check Inst[20] == 0x0
4463 OPC_CheckField, 7, 1, 0, // 6936: check Inst[7] == 0x0
4464 OPC_Decode, 255, 118, 50, // 6940: decode to PASUBU_DB using decoder 50
4465 // 6940: }
4466 1, 0, // 6944: case 0x1: {
4467 OPC_CheckPredicate, 47, // 6946: check predicate 47
4468 OPC_CheckField, 20, 1, 1, // 6948: check Inst[20] == 0x1
4469 OPC_CheckField, 7, 1, 0, // 6952: check Inst[7] == 0x0
4470 OPC_Decode, 208, 119, 50, // 6956: decode to PMAXU_DB using decoder 50
4471 // 6956: }
4472 // 6956: } // switch Inst[15]
4473 // 6956: }
4474 // 6956: } // switch Inst[31:25]
4475 // 6956: }
4476 // 6956: } // switch Inst[14:12]
4477 // 6956: }
4478 35, 29, // 6960: case 0x23: {
4479 OPC_SwitchField, 12, 3, // 6962: switch Inst[14:12] {
4480 0, 4, // 6965: case 0x0: {
4481 OPC_Decode, 221, 123, 51, // 6967: decode to SB using decoder 51
4482 // 6967: }
4483 1, 4, // 6971: case 0x1: {
4484 OPC_Decode, 184, 124, 51, // 6973: decode to SH using decoder 51
4485 // 6973: }
4486 2, 4, // 6977: case 0x2: {
4487 OPC_Decode, 150, 125, 51, // 6979: decode to SW using decoder 51
4488 // 6979: }
4489 3, 0, // 6983: case 0x3: {
4490 OPC_CheckPredicate, 22, // 6985: check predicate 22
4491 OPC_Decode, 235, 123, 51, // 6987: decode to SD using decoder 51
4492 // 6987: }
4493 // 6987: } // switch Inst[14:12]
4494 // 6987: }
4495 39, 165, 11, // 6991: case 0x27: {
4496 OPC_SwitchField, 12, 3, // 6994: switch Inst[14:12] {
4497 0, 136, 3, // 6997: case 0x0: {
4498 OPC_SwitchField, 26, 6, // 7000: switch Inst[31:26] {
4499 0, 38, // 7003: case 0x0: {
4500 OPC_SwitchField, 20, 5, // 7005: switch Inst[24:20] {
4501 0, 7, // 7008: case 0x0: {
4502 OPC_CheckPredicate, 23, // 7010: check predicate 23
4503 OPC_Decode, 173, 130, 1, 1, // 7012: decode to VSE8_V using decoder 1
4504 // 7012: }
4505 8, 11, // 7017: case 0x8: {
4506 OPC_CheckPredicate, 23, // 7019: check predicate 23
4507 OPC_CheckField, 25, 1, 1, // 7021: check Inst[25] == 0x1
4508 OPC_Decode, 158, 130, 1, 2, // 7025: decode to VS1R_V using decoder 2
4509 // 7025: }
4510 11, 0, // 7030: case 0xb: {
4511 OPC_CheckPredicate, 23, // 7032: check predicate 23
4512 OPC_CheckField, 25, 1, 1, // 7034: check Inst[25] == 0x1
4513 OPC_Decode, 199, 130, 1, 2, // 7038: decode to VSM_V using decoder 2
4514 // 7038: }
4515 // 7038: } // switch Inst[24:20]
4516 // 7038: }
4517 1, 7, // 7043: case 0x1: {
4518 OPC_CheckPredicate, 23, // 7045: check predicate 23
4519 OPC_Decode, 185, 131, 1, 3, // 7047: decode to VSUXEI8_V using decoder 3
4520 // 7047: }
4521 2, 7, // 7052: case 0x2: {
4522 OPC_CheckPredicate, 23, // 7054: check predicate 23
4523 OPC_Decode, 241, 130, 1, 4, // 7056: decode to VSSE8_V using decoder 4
4524 // 7056: }
4525 3, 7, // 7061: case 0x3: {
4526 OPC_CheckPredicate, 23, // 7063: check predicate 23
4527 OPC_Decode, 203, 130, 1, 3, // 7065: decode to VSOXEI8_V using decoder 3
4528 // 7065: }
4529 8, 25, // 7070: case 0x8: {
4530 OPC_SwitchField, 20, 5, // 7072: switch Inst[24:20] {
4531 0, 7, // 7075: case 0x0: {
4532 OPC_CheckPredicate, 23, // 7077: check predicate 23
4533 OPC_Decode, 245, 130, 1, 1, // 7079: decode to VSSEG2E8_V using decoder 1
4534 // 7079: }
4535 8, 0, // 7084: case 0x8: {
4536 OPC_CheckPredicate, 23, // 7086: check predicate 23
4537 OPC_CheckField, 25, 1, 1, // 7088: check Inst[25] == 0x1
4538 OPC_Decode, 159, 130, 1, 5, // 7092: decode to VS2R_V using decoder 5
4539 // 7092: }
4540 // 7092: } // switch Inst[24:20]
4541 // 7092: }
4542 9, 7, // 7097: case 0x9: {
4543 OPC_CheckPredicate, 23, // 7099: check predicate 23
4544 OPC_Decode, 189, 131, 1, 3, // 7101: decode to VSUXSEG2EI8_V using decoder 3
4545 // 7101: }
4546 10, 7, // 7106: case 0xa: {
4547 OPC_CheckPredicate, 23, // 7108: check predicate 23
4548 OPC_Decode, 151, 131, 1, 4, // 7110: decode to VSSSEG2E8_V using decoder 4
4549 // 7110: }
4550 11, 7, // 7115: case 0xb: {
4551 OPC_CheckPredicate, 23, // 7117: check predicate 23
4552 OPC_Decode, 207, 130, 1, 3, // 7119: decode to VSOXSEG2EI8_V using decoder 3
4553 // 7119: }
4554 16, 11, // 7124: case 0x10: {
4555 OPC_CheckPredicate, 23, // 7126: check predicate 23
4556 OPC_CheckField, 20, 5, 0, // 7128: check Inst[24:20] == 0x0
4557 OPC_Decode, 249, 130, 1, 1, // 7132: decode to VSSEG3E8_V using decoder 1
4558 // 7132: }
4559 17, 7, // 7137: case 0x11: {
4560 OPC_CheckPredicate, 23, // 7139: check predicate 23
4561 OPC_Decode, 193, 131, 1, 3, // 7141: decode to VSUXSEG3EI8_V using decoder 3
4562 // 7141: }
4563 18, 7, // 7146: case 0x12: {
4564 OPC_CheckPredicate, 23, // 7148: check predicate 23
4565 OPC_Decode, 155, 131, 1, 4, // 7150: decode to VSSSEG3E8_V using decoder 4
4566 // 7150: }
4567 19, 7, // 7155: case 0x13: {
4568 OPC_CheckPredicate, 23, // 7157: check predicate 23
4569 OPC_Decode, 211, 130, 1, 3, // 7159: decode to VSOXSEG3EI8_V using decoder 3
4570 // 7159: }
4571 24, 25, // 7164: case 0x18: {
4572 OPC_SwitchField, 20, 5, // 7166: switch Inst[24:20] {
4573 0, 7, // 7169: case 0x0: {
4574 OPC_CheckPredicate, 23, // 7171: check predicate 23
4575 OPC_Decode, 253, 130, 1, 1, // 7173: decode to VSSEG4E8_V using decoder 1
4576 // 7173: }
4577 8, 0, // 7178: case 0x8: {
4578 OPC_CheckPredicate, 23, // 7180: check predicate 23
4579 OPC_CheckField, 25, 1, 1, // 7182: check Inst[25] == 0x1
4580 OPC_Decode, 160, 130, 1, 6, // 7186: decode to VS4R_V using decoder 6
4581 // 7186: }
4582 // 7186: } // switch Inst[24:20]
4583 // 7186: }
4584 25, 7, // 7191: case 0x19: {
4585 OPC_CheckPredicate, 23, // 7193: check predicate 23
4586 OPC_Decode, 197, 131, 1, 3, // 7195: decode to VSUXSEG4EI8_V using decoder 3
4587 // 7195: }
4588 26, 7, // 7200: case 0x1a: {
4589 OPC_CheckPredicate, 23, // 7202: check predicate 23
4590 OPC_Decode, 159, 131, 1, 4, // 7204: decode to VSSSEG4E8_V using decoder 4
4591 // 7204: }
4592 27, 7, // 7209: case 0x1b: {
4593 OPC_CheckPredicate, 23, // 7211: check predicate 23
4594 OPC_Decode, 215, 130, 1, 3, // 7213: decode to VSOXSEG4EI8_V using decoder 3
4595 // 7213: }
4596 32, 11, // 7218: case 0x20: {
4597 OPC_CheckPredicate, 23, // 7220: check predicate 23
4598 OPC_CheckField, 20, 5, 0, // 7222: check Inst[24:20] == 0x0
4599 OPC_Decode, 129, 131, 1, 1, // 7226: decode to VSSEG5E8_V using decoder 1
4600 // 7226: }
4601 33, 7, // 7231: case 0x21: {
4602 OPC_CheckPredicate, 23, // 7233: check predicate 23
4603 OPC_Decode, 201, 131, 1, 3, // 7235: decode to VSUXSEG5EI8_V using decoder 3
4604 // 7235: }
4605 34, 7, // 7240: case 0x22: {
4606 OPC_CheckPredicate, 23, // 7242: check predicate 23
4607 OPC_Decode, 163, 131, 1, 4, // 7244: decode to VSSSEG5E8_V using decoder 4
4608 // 7244: }
4609 35, 7, // 7249: case 0x23: {
4610 OPC_CheckPredicate, 23, // 7251: check predicate 23
4611 OPC_Decode, 219, 130, 1, 3, // 7253: decode to VSOXSEG5EI8_V using decoder 3
4612 // 7253: }
4613 40, 11, // 7258: case 0x28: {
4614 OPC_CheckPredicate, 23, // 7260: check predicate 23
4615 OPC_CheckField, 20, 5, 0, // 7262: check Inst[24:20] == 0x0
4616 OPC_Decode, 133, 131, 1, 1, // 7266: decode to VSSEG6E8_V using decoder 1
4617 // 7266: }
4618 41, 7, // 7271: case 0x29: {
4619 OPC_CheckPredicate, 23, // 7273: check predicate 23
4620 OPC_Decode, 205, 131, 1, 3, // 7275: decode to VSUXSEG6EI8_V using decoder 3
4621 // 7275: }
4622 42, 7, // 7280: case 0x2a: {
4623 OPC_CheckPredicate, 23, // 7282: check predicate 23
4624 OPC_Decode, 167, 131, 1, 4, // 7284: decode to VSSSEG6E8_V using decoder 4
4625 // 7284: }
4626 43, 7, // 7289: case 0x2b: {
4627 OPC_CheckPredicate, 23, // 7291: check predicate 23
4628 OPC_Decode, 223, 130, 1, 3, // 7293: decode to VSOXSEG6EI8_V using decoder 3
4629 // 7293: }
4630 48, 11, // 7298: case 0x30: {
4631 OPC_CheckPredicate, 23, // 7300: check predicate 23
4632 OPC_CheckField, 20, 5, 0, // 7302: check Inst[24:20] == 0x0
4633 OPC_Decode, 137, 131, 1, 1, // 7306: decode to VSSEG7E8_V using decoder 1
4634 // 7306: }
4635 49, 7, // 7311: case 0x31: {
4636 OPC_CheckPredicate, 23, // 7313: check predicate 23
4637 OPC_Decode, 209, 131, 1, 3, // 7315: decode to VSUXSEG7EI8_V using decoder 3
4638 // 7315: }
4639 50, 7, // 7320: case 0x32: {
4640 OPC_CheckPredicate, 23, // 7322: check predicate 23
4641 OPC_Decode, 171, 131, 1, 4, // 7324: decode to VSSSEG7E8_V using decoder 4
4642 // 7324: }
4643 51, 7, // 7329: case 0x33: {
4644 OPC_CheckPredicate, 23, // 7331: check predicate 23
4645 OPC_Decode, 227, 130, 1, 3, // 7333: decode to VSOXSEG7EI8_V using decoder 3
4646 // 7333: }
4647 56, 25, // 7338: case 0x38: {
4648 OPC_SwitchField, 20, 5, // 7340: switch Inst[24:20] {
4649 0, 7, // 7343: case 0x0: {
4650 OPC_CheckPredicate, 23, // 7345: check predicate 23
4651 OPC_Decode, 141, 131, 1, 1, // 7347: decode to VSSEG8E8_V using decoder 1
4652 // 7347: }
4653 8, 0, // 7352: case 0x8: {
4654 OPC_CheckPredicate, 23, // 7354: check predicate 23
4655 OPC_CheckField, 25, 1, 1, // 7356: check Inst[25] == 0x1
4656 OPC_Decode, 161, 130, 1, 7, // 7360: decode to VS8R_V using decoder 7
4657 // 7360: }
4658 // 7360: } // switch Inst[24:20]
4659 // 7360: }
4660 57, 7, // 7365: case 0x39: {
4661 OPC_CheckPredicate, 23, // 7367: check predicate 23
4662 OPC_Decode, 213, 131, 1, 3, // 7369: decode to VSUXSEG8EI8_V using decoder 3
4663 // 7369: }
4664 58, 7, // 7374: case 0x3a: {
4665 OPC_CheckPredicate, 23, // 7376: check predicate 23
4666 OPC_Decode, 175, 131, 1, 4, // 7378: decode to VSSSEG8E8_V using decoder 4
4667 // 7378: }
4668 59, 0, // 7383: case 0x3b: {
4669 OPC_CheckPredicate, 23, // 7385: check predicate 23
4670 OPC_Decode, 231, 130, 1, 3, // 7387: decode to VSOXSEG8EI8_V using decoder 3
4671 // 7387: }
4672 // 7387: } // switch Inst[31:26]
4673 // 7387: }
4674 1, 6, // 7392: case 0x1: {
4675 OPC_CheckPredicate, 24, // 7394: check predicate 24
4676 OPC_Decode, 157, 116, 52, // 7396: decode to FSH using decoder 52
4677 // 7396: }
4678 2, 6, // 7400: case 0x2: {
4679 OPC_CheckPredicate, 25, // 7402: check predicate 25
4680 OPC_Decode, 175, 116, 53, // 7404: decode to FSW using decoder 53
4681 // 7404: }
4682 3, 6, // 7408: case 0x3: {
4683 OPC_CheckPredicate, 26, // 7410: check predicate 26
4684 OPC_Decode, 132, 116, 54, // 7412: decode to FSD using decoder 54
4685 // 7412: }
4686 4, 6, // 7416: case 0x4: {
4687 OPC_CheckPredicate, 27, // 7418: check predicate 27
4688 OPC_Decode, 158, 116, 55, // 7420: decode to FSQ using decoder 55
4689 // 7420: }
4690 5, 195, 2, // 7424: case 0x5: {
4691 OPC_SwitchField, 26, 6, // 7427: switch Inst[31:26] {
4692 0, 11, // 7430: case 0x0: {
4693 OPC_CheckPredicate, 23, // 7432: check predicate 23
4694 OPC_CheckField, 20, 5, 0, // 7434: check Inst[24:20] == 0x0
4695 OPC_Decode, 170, 130, 1, 1, // 7438: decode to VSE16_V using decoder 1
4696 // 7438: }
4697 1, 7, // 7443: case 0x1: {
4698 OPC_CheckPredicate, 23, // 7445: check predicate 23
4699 OPC_Decode, 182, 131, 1, 3, // 7447: decode to VSUXEI16_V using decoder 3
4700 // 7447: }
4701 2, 7, // 7452: case 0x2: {
4702 OPC_CheckPredicate, 23, // 7454: check predicate 23
4703 OPC_Decode, 238, 130, 1, 4, // 7456: decode to VSSE16_V using decoder 4
4704 // 7456: }
4705 3, 7, // 7461: case 0x3: {
4706 OPC_CheckPredicate, 23, // 7463: check predicate 23
4707 OPC_Decode, 200, 130, 1, 3, // 7465: decode to VSOXEI16_V using decoder 3
4708 // 7465: }
4709 8, 11, // 7470: case 0x8: {
4710 OPC_CheckPredicate, 23, // 7472: check predicate 23
4711 OPC_CheckField, 20, 5, 0, // 7474: check Inst[24:20] == 0x0
4712 OPC_Decode, 242, 130, 1, 1, // 7478: decode to VSSEG2E16_V using decoder 1
4713 // 7478: }
4714 9, 7, // 7483: case 0x9: {
4715 OPC_CheckPredicate, 23, // 7485: check predicate 23
4716 OPC_Decode, 186, 131, 1, 3, // 7487: decode to VSUXSEG2EI16_V using decoder 3
4717 // 7487: }
4718 10, 7, // 7492: case 0xa: {
4719 OPC_CheckPredicate, 23, // 7494: check predicate 23
4720 OPC_Decode, 148, 131, 1, 4, // 7496: decode to VSSSEG2E16_V using decoder 4
4721 // 7496: }
4722 11, 7, // 7501: case 0xb: {
4723 OPC_CheckPredicate, 23, // 7503: check predicate 23
4724 OPC_Decode, 204, 130, 1, 3, // 7505: decode to VSOXSEG2EI16_V using decoder 3
4725 // 7505: }
4726 16, 11, // 7510: case 0x10: {
4727 OPC_CheckPredicate, 23, // 7512: check predicate 23
4728 OPC_CheckField, 20, 5, 0, // 7514: check Inst[24:20] == 0x0
4729 OPC_Decode, 246, 130, 1, 1, // 7518: decode to VSSEG3E16_V using decoder 1
4730 // 7518: }
4731 17, 7, // 7523: case 0x11: {
4732 OPC_CheckPredicate, 23, // 7525: check predicate 23
4733 OPC_Decode, 190, 131, 1, 3, // 7527: decode to VSUXSEG3EI16_V using decoder 3
4734 // 7527: }
4735 18, 7, // 7532: case 0x12: {
4736 OPC_CheckPredicate, 23, // 7534: check predicate 23
4737 OPC_Decode, 152, 131, 1, 4, // 7536: decode to VSSSEG3E16_V using decoder 4
4738 // 7536: }
4739 19, 7, // 7541: case 0x13: {
4740 OPC_CheckPredicate, 23, // 7543: check predicate 23
4741 OPC_Decode, 208, 130, 1, 3, // 7545: decode to VSOXSEG3EI16_V using decoder 3
4742 // 7545: }
4743 24, 11, // 7550: case 0x18: {
4744 OPC_CheckPredicate, 23, // 7552: check predicate 23
4745 OPC_CheckField, 20, 5, 0, // 7554: check Inst[24:20] == 0x0
4746 OPC_Decode, 250, 130, 1, 1, // 7558: decode to VSSEG4E16_V using decoder 1
4747 // 7558: }
4748 25, 7, // 7563: case 0x19: {
4749 OPC_CheckPredicate, 23, // 7565: check predicate 23
4750 OPC_Decode, 194, 131, 1, 3, // 7567: decode to VSUXSEG4EI16_V using decoder 3
4751 // 7567: }
4752 26, 7, // 7572: case 0x1a: {
4753 OPC_CheckPredicate, 23, // 7574: check predicate 23
4754 OPC_Decode, 156, 131, 1, 4, // 7576: decode to VSSSEG4E16_V using decoder 4
4755 // 7576: }
4756 27, 7, // 7581: case 0x1b: {
4757 OPC_CheckPredicate, 23, // 7583: check predicate 23
4758 OPC_Decode, 212, 130, 1, 3, // 7585: decode to VSOXSEG4EI16_V using decoder 3
4759 // 7585: }
4760 32, 11, // 7590: case 0x20: {
4761 OPC_CheckPredicate, 23, // 7592: check predicate 23
4762 OPC_CheckField, 20, 5, 0, // 7594: check Inst[24:20] == 0x0
4763 OPC_Decode, 254, 130, 1, 1, // 7598: decode to VSSEG5E16_V using decoder 1
4764 // 7598: }
4765 33, 7, // 7603: case 0x21: {
4766 OPC_CheckPredicate, 23, // 7605: check predicate 23
4767 OPC_Decode, 198, 131, 1, 3, // 7607: decode to VSUXSEG5EI16_V using decoder 3
4768 // 7607: }
4769 34, 7, // 7612: case 0x22: {
4770 OPC_CheckPredicate, 23, // 7614: check predicate 23
4771 OPC_Decode, 160, 131, 1, 4, // 7616: decode to VSSSEG5E16_V using decoder 4
4772 // 7616: }
4773 35, 7, // 7621: case 0x23: {
4774 OPC_CheckPredicate, 23, // 7623: check predicate 23
4775 OPC_Decode, 216, 130, 1, 3, // 7625: decode to VSOXSEG5EI16_V using decoder 3
4776 // 7625: }
4777 40, 11, // 7630: case 0x28: {
4778 OPC_CheckPredicate, 23, // 7632: check predicate 23
4779 OPC_CheckField, 20, 5, 0, // 7634: check Inst[24:20] == 0x0
4780 OPC_Decode, 130, 131, 1, 1, // 7638: decode to VSSEG6E16_V using decoder 1
4781 // 7638: }
4782 41, 7, // 7643: case 0x29: {
4783 OPC_CheckPredicate, 23, // 7645: check predicate 23
4784 OPC_Decode, 202, 131, 1, 3, // 7647: decode to VSUXSEG6EI16_V using decoder 3
4785 // 7647: }
4786 42, 7, // 7652: case 0x2a: {
4787 OPC_CheckPredicate, 23, // 7654: check predicate 23
4788 OPC_Decode, 164, 131, 1, 4, // 7656: decode to VSSSEG6E16_V using decoder 4
4789 // 7656: }
4790 43, 7, // 7661: case 0x2b: {
4791 OPC_CheckPredicate, 23, // 7663: check predicate 23
4792 OPC_Decode, 220, 130, 1, 3, // 7665: decode to VSOXSEG6EI16_V using decoder 3
4793 // 7665: }
4794 48, 11, // 7670: case 0x30: {
4795 OPC_CheckPredicate, 23, // 7672: check predicate 23
4796 OPC_CheckField, 20, 5, 0, // 7674: check Inst[24:20] == 0x0
4797 OPC_Decode, 134, 131, 1, 1, // 7678: decode to VSSEG7E16_V using decoder 1
4798 // 7678: }
4799 49, 7, // 7683: case 0x31: {
4800 OPC_CheckPredicate, 23, // 7685: check predicate 23
4801 OPC_Decode, 206, 131, 1, 3, // 7687: decode to VSUXSEG7EI16_V using decoder 3
4802 // 7687: }
4803 50, 7, // 7692: case 0x32: {
4804 OPC_CheckPredicate, 23, // 7694: check predicate 23
4805 OPC_Decode, 168, 131, 1, 4, // 7696: decode to VSSSEG7E16_V using decoder 4
4806 // 7696: }
4807 51, 7, // 7701: case 0x33: {
4808 OPC_CheckPredicate, 23, // 7703: check predicate 23
4809 OPC_Decode, 224, 130, 1, 3, // 7705: decode to VSOXSEG7EI16_V using decoder 3
4810 // 7705: }
4811 56, 11, // 7710: case 0x38: {
4812 OPC_CheckPredicate, 23, // 7712: check predicate 23
4813 OPC_CheckField, 20, 5, 0, // 7714: check Inst[24:20] == 0x0
4814 OPC_Decode, 138, 131, 1, 1, // 7718: decode to VSSEG8E16_V using decoder 1
4815 // 7718: }
4816 57, 7, // 7723: case 0x39: {
4817 OPC_CheckPredicate, 23, // 7725: check predicate 23
4818 OPC_Decode, 210, 131, 1, 3, // 7727: decode to VSUXSEG8EI16_V using decoder 3
4819 // 7727: }
4820 58, 7, // 7732: case 0x3a: {
4821 OPC_CheckPredicate, 23, // 7734: check predicate 23
4822 OPC_Decode, 172, 131, 1, 4, // 7736: decode to VSSSEG8E16_V using decoder 4
4823 // 7736: }
4824 59, 0, // 7741: case 0x3b: {
4825 OPC_CheckPredicate, 23, // 7743: check predicate 23
4826 OPC_Decode, 228, 130, 1, 3, // 7745: decode to VSOXSEG8EI16_V using decoder 3
4827 // 7745: }
4828 // 7745: } // switch Inst[31:26]
4829 // 7745: }
4830 6, 195, 2, // 7750: case 0x6: {
4831 OPC_SwitchField, 26, 6, // 7753: switch Inst[31:26] {
4832 0, 11, // 7756: case 0x0: {
4833 OPC_CheckPredicate, 23, // 7758: check predicate 23
4834 OPC_CheckField, 20, 5, 0, // 7760: check Inst[24:20] == 0x0
4835 OPC_Decode, 171, 130, 1, 1, // 7764: decode to VSE32_V using decoder 1
4836 // 7764: }
4837 1, 7, // 7769: case 0x1: {
4838 OPC_CheckPredicate, 23, // 7771: check predicate 23
4839 OPC_Decode, 183, 131, 1, 3, // 7773: decode to VSUXEI32_V using decoder 3
4840 // 7773: }
4841 2, 7, // 7778: case 0x2: {
4842 OPC_CheckPredicate, 23, // 7780: check predicate 23
4843 OPC_Decode, 239, 130, 1, 4, // 7782: decode to VSSE32_V using decoder 4
4844 // 7782: }
4845 3, 7, // 7787: case 0x3: {
4846 OPC_CheckPredicate, 23, // 7789: check predicate 23
4847 OPC_Decode, 201, 130, 1, 3, // 7791: decode to VSOXEI32_V using decoder 3
4848 // 7791: }
4849 8, 11, // 7796: case 0x8: {
4850 OPC_CheckPredicate, 23, // 7798: check predicate 23
4851 OPC_CheckField, 20, 5, 0, // 7800: check Inst[24:20] == 0x0
4852 OPC_Decode, 243, 130, 1, 1, // 7804: decode to VSSEG2E32_V using decoder 1
4853 // 7804: }
4854 9, 7, // 7809: case 0x9: {
4855 OPC_CheckPredicate, 23, // 7811: check predicate 23
4856 OPC_Decode, 187, 131, 1, 3, // 7813: decode to VSUXSEG2EI32_V using decoder 3
4857 // 7813: }
4858 10, 7, // 7818: case 0xa: {
4859 OPC_CheckPredicate, 23, // 7820: check predicate 23
4860 OPC_Decode, 149, 131, 1, 4, // 7822: decode to VSSSEG2E32_V using decoder 4
4861 // 7822: }
4862 11, 7, // 7827: case 0xb: {
4863 OPC_CheckPredicate, 23, // 7829: check predicate 23
4864 OPC_Decode, 205, 130, 1, 3, // 7831: decode to VSOXSEG2EI32_V using decoder 3
4865 // 7831: }
4866 16, 11, // 7836: case 0x10: {
4867 OPC_CheckPredicate, 23, // 7838: check predicate 23
4868 OPC_CheckField, 20, 5, 0, // 7840: check Inst[24:20] == 0x0
4869 OPC_Decode, 247, 130, 1, 1, // 7844: decode to VSSEG3E32_V using decoder 1
4870 // 7844: }
4871 17, 7, // 7849: case 0x11: {
4872 OPC_CheckPredicate, 23, // 7851: check predicate 23
4873 OPC_Decode, 191, 131, 1, 3, // 7853: decode to VSUXSEG3EI32_V using decoder 3
4874 // 7853: }
4875 18, 7, // 7858: case 0x12: {
4876 OPC_CheckPredicate, 23, // 7860: check predicate 23
4877 OPC_Decode, 153, 131, 1, 4, // 7862: decode to VSSSEG3E32_V using decoder 4
4878 // 7862: }
4879 19, 7, // 7867: case 0x13: {
4880 OPC_CheckPredicate, 23, // 7869: check predicate 23
4881 OPC_Decode, 209, 130, 1, 3, // 7871: decode to VSOXSEG3EI32_V using decoder 3
4882 // 7871: }
4883 24, 11, // 7876: case 0x18: {
4884 OPC_CheckPredicate, 23, // 7878: check predicate 23
4885 OPC_CheckField, 20, 5, 0, // 7880: check Inst[24:20] == 0x0
4886 OPC_Decode, 251, 130, 1, 1, // 7884: decode to VSSEG4E32_V using decoder 1
4887 // 7884: }
4888 25, 7, // 7889: case 0x19: {
4889 OPC_CheckPredicate, 23, // 7891: check predicate 23
4890 OPC_Decode, 195, 131, 1, 3, // 7893: decode to VSUXSEG4EI32_V using decoder 3
4891 // 7893: }
4892 26, 7, // 7898: case 0x1a: {
4893 OPC_CheckPredicate, 23, // 7900: check predicate 23
4894 OPC_Decode, 157, 131, 1, 4, // 7902: decode to VSSSEG4E32_V using decoder 4
4895 // 7902: }
4896 27, 7, // 7907: case 0x1b: {
4897 OPC_CheckPredicate, 23, // 7909: check predicate 23
4898 OPC_Decode, 213, 130, 1, 3, // 7911: decode to VSOXSEG4EI32_V using decoder 3
4899 // 7911: }
4900 32, 11, // 7916: case 0x20: {
4901 OPC_CheckPredicate, 23, // 7918: check predicate 23
4902 OPC_CheckField, 20, 5, 0, // 7920: check Inst[24:20] == 0x0
4903 OPC_Decode, 255, 130, 1, 1, // 7924: decode to VSSEG5E32_V using decoder 1
4904 // 7924: }
4905 33, 7, // 7929: case 0x21: {
4906 OPC_CheckPredicate, 23, // 7931: check predicate 23
4907 OPC_Decode, 199, 131, 1, 3, // 7933: decode to VSUXSEG5EI32_V using decoder 3
4908 // 7933: }
4909 34, 7, // 7938: case 0x22: {
4910 OPC_CheckPredicate, 23, // 7940: check predicate 23
4911 OPC_Decode, 161, 131, 1, 4, // 7942: decode to VSSSEG5E32_V using decoder 4
4912 // 7942: }
4913 35, 7, // 7947: case 0x23: {
4914 OPC_CheckPredicate, 23, // 7949: check predicate 23
4915 OPC_Decode, 217, 130, 1, 3, // 7951: decode to VSOXSEG5EI32_V using decoder 3
4916 // 7951: }
4917 40, 11, // 7956: case 0x28: {
4918 OPC_CheckPredicate, 23, // 7958: check predicate 23
4919 OPC_CheckField, 20, 5, 0, // 7960: check Inst[24:20] == 0x0
4920 OPC_Decode, 131, 131, 1, 1, // 7964: decode to VSSEG6E32_V using decoder 1
4921 // 7964: }
4922 41, 7, // 7969: case 0x29: {
4923 OPC_CheckPredicate, 23, // 7971: check predicate 23
4924 OPC_Decode, 203, 131, 1, 3, // 7973: decode to VSUXSEG6EI32_V using decoder 3
4925 // 7973: }
4926 42, 7, // 7978: case 0x2a: {
4927 OPC_CheckPredicate, 23, // 7980: check predicate 23
4928 OPC_Decode, 165, 131, 1, 4, // 7982: decode to VSSSEG6E32_V using decoder 4
4929 // 7982: }
4930 43, 7, // 7987: case 0x2b: {
4931 OPC_CheckPredicate, 23, // 7989: check predicate 23
4932 OPC_Decode, 221, 130, 1, 3, // 7991: decode to VSOXSEG6EI32_V using decoder 3
4933 // 7991: }
4934 48, 11, // 7996: case 0x30: {
4935 OPC_CheckPredicate, 23, // 7998: check predicate 23
4936 OPC_CheckField, 20, 5, 0, // 8000: check Inst[24:20] == 0x0
4937 OPC_Decode, 135, 131, 1, 1, // 8004: decode to VSSEG7E32_V using decoder 1
4938 // 8004: }
4939 49, 7, // 8009: case 0x31: {
4940 OPC_CheckPredicate, 23, // 8011: check predicate 23
4941 OPC_Decode, 207, 131, 1, 3, // 8013: decode to VSUXSEG7EI32_V using decoder 3
4942 // 8013: }
4943 50, 7, // 8018: case 0x32: {
4944 OPC_CheckPredicate, 23, // 8020: check predicate 23
4945 OPC_Decode, 169, 131, 1, 4, // 8022: decode to VSSSEG7E32_V using decoder 4
4946 // 8022: }
4947 51, 7, // 8027: case 0x33: {
4948 OPC_CheckPredicate, 23, // 8029: check predicate 23
4949 OPC_Decode, 225, 130, 1, 3, // 8031: decode to VSOXSEG7EI32_V using decoder 3
4950 // 8031: }
4951 56, 11, // 8036: case 0x38: {
4952 OPC_CheckPredicate, 23, // 8038: check predicate 23
4953 OPC_CheckField, 20, 5, 0, // 8040: check Inst[24:20] == 0x0
4954 OPC_Decode, 139, 131, 1, 1, // 8044: decode to VSSEG8E32_V using decoder 1
4955 // 8044: }
4956 57, 7, // 8049: case 0x39: {
4957 OPC_CheckPredicate, 23, // 8051: check predicate 23
4958 OPC_Decode, 211, 131, 1, 3, // 8053: decode to VSUXSEG8EI32_V using decoder 3
4959 // 8053: }
4960 58, 7, // 8058: case 0x3a: {
4961 OPC_CheckPredicate, 23, // 8060: check predicate 23
4962 OPC_Decode, 173, 131, 1, 4, // 8062: decode to VSSSEG8E32_V using decoder 4
4963 // 8062: }
4964 59, 0, // 8067: case 0x3b: {
4965 OPC_CheckPredicate, 23, // 8069: check predicate 23
4966 OPC_Decode, 229, 130, 1, 3, // 8071: decode to VSOXSEG8EI32_V using decoder 3
4967 // 8071: }
4968 // 8071: } // switch Inst[31:26]
4969 // 8071: }
4970 7, 0, // 8076: case 0x7: {
4971 OPC_SwitchField, 26, 3, // 8078: switch Inst[28:26] {
4972 0, 107, // 8081: case 0x0: {
4973 OPC_SwitchField, 29, 3, // 8083: switch Inst[31:29] {
4974 0, 11, // 8086: case 0x0: {
4975 OPC_CheckPredicate, 28, // 8088: check predicate 28
4976 OPC_CheckField, 20, 5, 0, // 8090: check Inst[24:20] == 0x0
4977 OPC_Decode, 172, 130, 1, 1, // 8094: decode to VSE64_V using decoder 1
4978 // 8094: }
4979 1, 11, // 8099: case 0x1: {
4980 OPC_CheckPredicate, 28, // 8101: check predicate 28
4981 OPC_CheckField, 20, 5, 0, // 8103: check Inst[24:20] == 0x0
4982 OPC_Decode, 244, 130, 1, 1, // 8107: decode to VSSEG2E64_V using decoder 1
4983 // 8107: }
4984 2, 11, // 8112: case 0x2: {
4985 OPC_CheckPredicate, 28, // 8114: check predicate 28
4986 OPC_CheckField, 20, 5, 0, // 8116: check Inst[24:20] == 0x0
4987 OPC_Decode, 248, 130, 1, 1, // 8120: decode to VSSEG3E64_V using decoder 1
4988 // 8120: }
4989 3, 11, // 8125: case 0x3: {
4990 OPC_CheckPredicate, 28, // 8127: check predicate 28
4991 OPC_CheckField, 20, 5, 0, // 8129: check Inst[24:20] == 0x0
4992 OPC_Decode, 252, 130, 1, 1, // 8133: decode to VSSEG4E64_V using decoder 1
4993 // 8133: }
4994 4, 11, // 8138: case 0x4: {
4995 OPC_CheckPredicate, 28, // 8140: check predicate 28
4996 OPC_CheckField, 20, 5, 0, // 8142: check Inst[24:20] == 0x0
4997 OPC_Decode, 128, 131, 1, 1, // 8146: decode to VSSEG5E64_V using decoder 1
4998 // 8146: }
4999 5, 11, // 8151: case 0x5: {
5000 OPC_CheckPredicate, 28, // 8153: check predicate 28
5001 OPC_CheckField, 20, 5, 0, // 8155: check Inst[24:20] == 0x0
5002 OPC_Decode, 132, 131, 1, 1, // 8159: decode to VSSEG6E64_V using decoder 1
5003 // 8159: }
5004 6, 11, // 8164: case 0x6: {
5005 OPC_CheckPredicate, 28, // 8166: check predicate 28
5006 OPC_CheckField, 20, 5, 0, // 8168: check Inst[24:20] == 0x0
5007 OPC_Decode, 136, 131, 1, 1, // 8172: decode to VSSEG7E64_V using decoder 1
5008 // 8172: }
5009 7, 0, // 8177: case 0x7: {
5010 OPC_CheckPredicate, 28, // 8179: check predicate 28
5011 OPC_CheckField, 20, 5, 0, // 8181: check Inst[24:20] == 0x0
5012 OPC_Decode, 140, 131, 1, 1, // 8185: decode to VSSEG8E64_V using decoder 1
5013 // 8185: }
5014 // 8185: } // switch Inst[31:29]
5015 // 8185: }
5016 1, 75, // 8190: case 0x1: {
5017 OPC_SwitchField, 29, 3, // 8192: switch Inst[31:29] {
5018 0, 7, // 8195: case 0x0: {
5019 OPC_CheckPredicate, 29, // 8197: check predicate 29
5020 OPC_Decode, 184, 131, 1, 3, // 8199: decode to VSUXEI64_V using decoder 3
5021 // 8199: }
5022 1, 7, // 8204: case 0x1: {
5023 OPC_CheckPredicate, 30, // 8206: check predicate 30
5024 OPC_Decode, 188, 131, 1, 3, // 8208: decode to VSUXSEG2EI64_V using decoder 3
5025 // 8208: }
5026 2, 7, // 8213: case 0x2: {
5027 OPC_CheckPredicate, 30, // 8215: check predicate 30
5028 OPC_Decode, 192, 131, 1, 3, // 8217: decode to VSUXSEG3EI64_V using decoder 3
5029 // 8217: }
5030 3, 7, // 8222: case 0x3: {
5031 OPC_CheckPredicate, 30, // 8224: check predicate 30
5032 OPC_Decode, 196, 131, 1, 3, // 8226: decode to VSUXSEG4EI64_V using decoder 3
5033 // 8226: }
5034 4, 7, // 8231: case 0x4: {
5035 OPC_CheckPredicate, 30, // 8233: check predicate 30
5036 OPC_Decode, 200, 131, 1, 3, // 8235: decode to VSUXSEG5EI64_V using decoder 3
5037 // 8235: }
5038 5, 7, // 8240: case 0x5: {
5039 OPC_CheckPredicate, 30, // 8242: check predicate 30
5040 OPC_Decode, 204, 131, 1, 3, // 8244: decode to VSUXSEG6EI64_V using decoder 3
5041 // 8244: }
5042 6, 7, // 8249: case 0x6: {
5043 OPC_CheckPredicate, 30, // 8251: check predicate 30
5044 OPC_Decode, 208, 131, 1, 3, // 8253: decode to VSUXSEG7EI64_V using decoder 3
5045 // 8253: }
5046 7, 0, // 8258: case 0x7: {
5047 OPC_CheckPredicate, 30, // 8260: check predicate 30
5048 OPC_Decode, 212, 131, 1, 3, // 8262: decode to VSUXSEG8EI64_V using decoder 3
5049 // 8262: }
5050 // 8262: } // switch Inst[31:29]
5051 // 8262: }
5052 2, 75, // 8267: case 0x2: {
5053 OPC_SwitchField, 29, 3, // 8269: switch Inst[31:29] {
5054 0, 7, // 8272: case 0x0: {
5055 OPC_CheckPredicate, 28, // 8274: check predicate 28
5056 OPC_Decode, 240, 130, 1, 4, // 8276: decode to VSSE64_V using decoder 4
5057 // 8276: }
5058 1, 7, // 8281: case 0x1: {
5059 OPC_CheckPredicate, 28, // 8283: check predicate 28
5060 OPC_Decode, 150, 131, 1, 4, // 8285: decode to VSSSEG2E64_V using decoder 4
5061 // 8285: }
5062 2, 7, // 8290: case 0x2: {
5063 OPC_CheckPredicate, 28, // 8292: check predicate 28
5064 OPC_Decode, 154, 131, 1, 4, // 8294: decode to VSSSEG3E64_V using decoder 4
5065 // 8294: }
5066 3, 7, // 8299: case 0x3: {
5067 OPC_CheckPredicate, 28, // 8301: check predicate 28
5068 OPC_Decode, 158, 131, 1, 4, // 8303: decode to VSSSEG4E64_V using decoder 4
5069 // 8303: }
5070 4, 7, // 8308: case 0x4: {
5071 OPC_CheckPredicate, 28, // 8310: check predicate 28
5072 OPC_Decode, 162, 131, 1, 4, // 8312: decode to VSSSEG5E64_V using decoder 4
5073 // 8312: }
5074 5, 7, // 8317: case 0x5: {
5075 OPC_CheckPredicate, 28, // 8319: check predicate 28
5076 OPC_Decode, 166, 131, 1, 4, // 8321: decode to VSSSEG6E64_V using decoder 4
5077 // 8321: }
5078 6, 7, // 8326: case 0x6: {
5079 OPC_CheckPredicate, 28, // 8328: check predicate 28
5080 OPC_Decode, 170, 131, 1, 4, // 8330: decode to VSSSEG7E64_V using decoder 4
5081 // 8330: }
5082 7, 0, // 8335: case 0x7: {
5083 OPC_CheckPredicate, 28, // 8337: check predicate 28
5084 OPC_Decode, 174, 131, 1, 4, // 8339: decode to VSSSEG8E64_V using decoder 4
5085 // 8339: }
5086 // 8339: } // switch Inst[31:29]
5087 // 8339: }
5088 3, 75, // 8344: case 0x3: {
5089 OPC_SwitchField, 29, 3, // 8346: switch Inst[31:29] {
5090 0, 7, // 8349: case 0x0: {
5091 OPC_CheckPredicate, 29, // 8351: check predicate 29
5092 OPC_Decode, 202, 130, 1, 3, // 8353: decode to VSOXEI64_V using decoder 3
5093 // 8353: }
5094 1, 7, // 8358: case 0x1: {
5095 OPC_CheckPredicate, 30, // 8360: check predicate 30
5096 OPC_Decode, 206, 130, 1, 3, // 8362: decode to VSOXSEG2EI64_V using decoder 3
5097 // 8362: }
5098 2, 7, // 8367: case 0x2: {
5099 OPC_CheckPredicate, 30, // 8369: check predicate 30
5100 OPC_Decode, 210, 130, 1, 3, // 8371: decode to VSOXSEG3EI64_V using decoder 3
5101 // 8371: }
5102 3, 7, // 8376: case 0x3: {
5103 OPC_CheckPredicate, 30, // 8378: check predicate 30
5104 OPC_Decode, 214, 130, 1, 3, // 8380: decode to VSOXSEG4EI64_V using decoder 3
5105 // 8380: }
5106 4, 7, // 8385: case 0x4: {
5107 OPC_CheckPredicate, 30, // 8387: check predicate 30
5108 OPC_Decode, 218, 130, 1, 3, // 8389: decode to VSOXSEG5EI64_V using decoder 3
5109 // 8389: }
5110 5, 7, // 8394: case 0x5: {
5111 OPC_CheckPredicate, 30, // 8396: check predicate 30
5112 OPC_Decode, 222, 130, 1, 3, // 8398: decode to VSOXSEG6EI64_V using decoder 3
5113 // 8398: }
5114 6, 7, // 8403: case 0x6: {
5115 OPC_CheckPredicate, 30, // 8405: check predicate 30
5116 OPC_Decode, 226, 130, 1, 3, // 8407: decode to VSOXSEG7EI64_V using decoder 3
5117 // 8407: }
5118 7, 0, // 8412: case 0x7: {
5119 OPC_CheckPredicate, 30, // 8414: check predicate 30
5120 OPC_Decode, 230, 130, 1, 3, // 8416: decode to VSOXSEG8EI64_V using decoder 3
5121 // 8416: }
5122 // 8416: } // switch Inst[31:29]
5123 // 8416: }
5124 4, 7, // 8421: case 0x4: {
5125 OPC_CheckPredicate, 31, // 8423: check predicate 31
5126 OPC_Decode, 209, 129, 1, 12, // 8425: decode to VMTS_V using decoder 12
5127 // 8425: }
5128 5, 0, // 8430: case 0x5: {
5129 OPC_CheckPredicate, 32, // 8432: check predicate 32
5130 OPC_Decode, 211, 129, 1, 12, // 8434: decode to VMTTS_V using decoder 12
5131 // 8434: }
5132 // 8434: } // switch Inst[28:26]
5133 // 8434: }
5134 // 8434: } // switch Inst[14:12]
5135 // 8434: }
5136 47, 226, 16, // 8439: case 0x2f: {
5137 OPC_SwitchField, 25, 7, // 8442: switch Inst[31:25] {
5138 0, 35, // 8445: case 0x0: {
5139 OPC_SwitchField, 12, 3, // 8447: switch Inst[14:12] {
5140 0, 6, // 8450: case 0x0: {
5141 OPC_CheckPredicate, 52, // 8452: check predicate 52
5142 OPC_Decode, 178, 109, 56, // 8454: decode to AMOADD_B using decoder 56
5143 // 8454: }
5144 1, 6, // 8458: case 0x1: {
5145 OPC_CheckPredicate, 52, // 8460: check predicate 52
5146 OPC_Decode, 186, 109, 56, // 8462: decode to AMOADD_H using decoder 56
5147 // 8462: }
5148 2, 6, // 8466: case 0x2: {
5149 OPC_CheckPredicate, 53, // 8468: check predicate 53
5150 OPC_Decode, 190, 109, 56, // 8470: decode to AMOADD_W using decoder 56
5151 // 8470: }
5152 3, 0, // 8474: case 0x3: {
5153 OPC_CheckPredicate, 54, // 8476: check predicate 54
5154 OPC_Decode, 182, 109, 56, // 8478: decode to AMOADD_D using decoder 56
5155 // 8478: }
5156 // 8478: } // switch Inst[14:12]
5157 // 8478: }
5158 1, 35, // 8482: case 0x1: {
5159 OPC_SwitchField, 12, 3, // 8484: switch Inst[14:12] {
5160 0, 6, // 8487: case 0x0: {
5161 OPC_CheckPredicate, 52, // 8489: check predicate 52
5162 OPC_Decode, 181, 109, 56, // 8491: decode to AMOADD_B_RL using decoder 56
5163 // 8491: }
5164 1, 6, // 8495: case 0x1: {
5165 OPC_CheckPredicate, 52, // 8497: check predicate 52
5166 OPC_Decode, 189, 109, 56, // 8499: decode to AMOADD_H_RL using decoder 56
5167 // 8499: }
5168 2, 6, // 8503: case 0x2: {
5169 OPC_CheckPredicate, 53, // 8505: check predicate 53
5170 OPC_Decode, 193, 109, 56, // 8507: decode to AMOADD_W_RL using decoder 56
5171 // 8507: }
5172 3, 0, // 8511: case 0x3: {
5173 OPC_CheckPredicate, 54, // 8513: check predicate 54
5174 OPC_Decode, 185, 109, 56, // 8515: decode to AMOADD_D_RL using decoder 56
5175 // 8515: }
5176 // 8515: } // switch Inst[14:12]
5177 // 8515: }
5178 2, 35, // 8519: case 0x2: {
5179 OPC_SwitchField, 12, 3, // 8521: switch Inst[14:12] {
5180 0, 6, // 8524: case 0x0: {
5181 OPC_CheckPredicate, 52, // 8526: check predicate 52
5182 OPC_Decode, 179, 109, 56, // 8528: decode to AMOADD_B_AQ using decoder 56
5183 // 8528: }
5184 1, 6, // 8532: case 0x1: {
5185 OPC_CheckPredicate, 52, // 8534: check predicate 52
5186 OPC_Decode, 187, 109, 56, // 8536: decode to AMOADD_H_AQ using decoder 56
5187 // 8536: }
5188 2, 6, // 8540: case 0x2: {
5189 OPC_CheckPredicate, 53, // 8542: check predicate 53
5190 OPC_Decode, 191, 109, 56, // 8544: decode to AMOADD_W_AQ using decoder 56
5191 // 8544: }
5192 3, 0, // 8548: case 0x3: {
5193 OPC_CheckPredicate, 54, // 8550: check predicate 54
5194 OPC_Decode, 183, 109, 56, // 8552: decode to AMOADD_D_AQ using decoder 56
5195 // 8552: }
5196 // 8552: } // switch Inst[14:12]
5197 // 8552: }
5198 3, 35, // 8556: case 0x3: {
5199 OPC_SwitchField, 12, 3, // 8558: switch Inst[14:12] {
5200 0, 6, // 8561: case 0x0: {
5201 OPC_CheckPredicate, 52, // 8563: check predicate 52
5202 OPC_Decode, 180, 109, 56, // 8565: decode to AMOADD_B_AQRL using decoder 56
5203 // 8565: }
5204 1, 6, // 8569: case 0x1: {
5205 OPC_CheckPredicate, 52, // 8571: check predicate 52
5206 OPC_Decode, 188, 109, 56, // 8573: decode to AMOADD_H_AQRL using decoder 56
5207 // 8573: }
5208 2, 6, // 8577: case 0x2: {
5209 OPC_CheckPredicate, 53, // 8579: check predicate 53
5210 OPC_Decode, 192, 109, 56, // 8581: decode to AMOADD_W_AQRL using decoder 56
5211 // 8581: }
5212 3, 0, // 8585: case 0x3: {
5213 OPC_CheckPredicate, 54, // 8587: check predicate 54
5214 OPC_Decode, 184, 109, 56, // 8589: decode to AMOADD_D_AQRL using decoder 56
5215 // 8589: }
5216 // 8589: } // switch Inst[14:12]
5217 // 8589: }
5218 4, 35, // 8593: case 0x4: {
5219 OPC_SwitchField, 12, 3, // 8595: switch Inst[14:12] {
5220 0, 6, // 8598: case 0x0: {
5221 OPC_CheckPredicate, 52, // 8600: check predicate 52
5222 OPC_Decode, 186, 110, 56, // 8602: decode to AMOSWAP_B using decoder 56
5223 // 8602: }
5224 1, 6, // 8606: case 0x1: {
5225 OPC_CheckPredicate, 52, // 8608: check predicate 52
5226 OPC_Decode, 194, 110, 56, // 8610: decode to AMOSWAP_H using decoder 56
5227 // 8610: }
5228 2, 6, // 8614: case 0x2: {
5229 OPC_CheckPredicate, 53, // 8616: check predicate 53
5230 OPC_Decode, 198, 110, 56, // 8618: decode to AMOSWAP_W using decoder 56
5231 // 8618: }
5232 3, 0, // 8622: case 0x3: {
5233 OPC_CheckPredicate, 54, // 8624: check predicate 54
5234 OPC_Decode, 190, 110, 56, // 8626: decode to AMOSWAP_D using decoder 56
5235 // 8626: }
5236 // 8626: } // switch Inst[14:12]
5237 // 8626: }
5238 5, 35, // 8630: case 0x5: {
5239 OPC_SwitchField, 12, 3, // 8632: switch Inst[14:12] {
5240 0, 6, // 8635: case 0x0: {
5241 OPC_CheckPredicate, 52, // 8637: check predicate 52
5242 OPC_Decode, 189, 110, 56, // 8639: decode to AMOSWAP_B_RL using decoder 56
5243 // 8639: }
5244 1, 6, // 8643: case 0x1: {
5245 OPC_CheckPredicate, 52, // 8645: check predicate 52
5246 OPC_Decode, 197, 110, 56, // 8647: decode to AMOSWAP_H_RL using decoder 56
5247 // 8647: }
5248 2, 6, // 8651: case 0x2: {
5249 OPC_CheckPredicate, 53, // 8653: check predicate 53
5250 OPC_Decode, 201, 110, 56, // 8655: decode to AMOSWAP_W_RL using decoder 56
5251 // 8655: }
5252 3, 0, // 8659: case 0x3: {
5253 OPC_CheckPredicate, 54, // 8661: check predicate 54
5254 OPC_Decode, 193, 110, 56, // 8663: decode to AMOSWAP_D_RL using decoder 56
5255 // 8663: }
5256 // 8663: } // switch Inst[14:12]
5257 // 8663: }
5258 6, 35, // 8667: case 0x6: {
5259 OPC_SwitchField, 12, 3, // 8669: switch Inst[14:12] {
5260 0, 6, // 8672: case 0x0: {
5261 OPC_CheckPredicate, 52, // 8674: check predicate 52
5262 OPC_Decode, 187, 110, 56, // 8676: decode to AMOSWAP_B_AQ using decoder 56
5263 // 8676: }
5264 1, 6, // 8680: case 0x1: {
5265 OPC_CheckPredicate, 52, // 8682: check predicate 52
5266 OPC_Decode, 195, 110, 56, // 8684: decode to AMOSWAP_H_AQ using decoder 56
5267 // 8684: }
5268 2, 6, // 8688: case 0x2: {
5269 OPC_CheckPredicate, 53, // 8690: check predicate 53
5270 OPC_Decode, 199, 110, 56, // 8692: decode to AMOSWAP_W_AQ using decoder 56
5271 // 8692: }
5272 3, 0, // 8696: case 0x3: {
5273 OPC_CheckPredicate, 54, // 8698: check predicate 54
5274 OPC_Decode, 191, 110, 56, // 8700: decode to AMOSWAP_D_AQ using decoder 56
5275 // 8700: }
5276 // 8700: } // switch Inst[14:12]
5277 // 8700: }
5278 7, 35, // 8704: case 0x7: {
5279 OPC_SwitchField, 12, 3, // 8706: switch Inst[14:12] {
5280 0, 6, // 8709: case 0x0: {
5281 OPC_CheckPredicate, 52, // 8711: check predicate 52
5282 OPC_Decode, 188, 110, 56, // 8713: decode to AMOSWAP_B_AQRL using decoder 56
5283 // 8713: }
5284 1, 6, // 8717: case 0x1: {
5285 OPC_CheckPredicate, 52, // 8719: check predicate 52
5286 OPC_Decode, 196, 110, 56, // 8721: decode to AMOSWAP_H_AQRL using decoder 56
5287 // 8721: }
5288 2, 6, // 8725: case 0x2: {
5289 OPC_CheckPredicate, 53, // 8727: check predicate 53
5290 OPC_Decode, 200, 110, 56, // 8729: decode to AMOSWAP_W_AQRL using decoder 56
5291 // 8729: }
5292 3, 0, // 8733: case 0x3: {
5293 OPC_CheckPredicate, 54, // 8735: check predicate 54
5294 OPC_Decode, 192, 110, 56, // 8737: decode to AMOSWAP_D_AQRL using decoder 56
5295 // 8737: }
5296 // 8737: } // switch Inst[14:12]
5297 // 8737: }
5298 8, 27, // 8741: case 0x8: {
5299 OPC_SwitchField, 12, 3, // 8743: switch Inst[14:12] {
5300 2, 10, // 8746: case 0x2: {
5301 OPC_CheckPredicate, 55, // 8748: check predicate 55
5302 OPC_CheckField, 20, 5, 0, // 8750: check Inst[24:20] == 0x0
5303 OPC_Decode, 239, 116, 17, // 8754: decode to LR_W using decoder 17
5304 // 8754: }
5305 3, 0, // 8758: case 0x3: {
5306 OPC_CheckPredicate, 56, // 8760: check predicate 56
5307 OPC_CheckField, 20, 5, 0, // 8762: check Inst[24:20] == 0x0
5308 OPC_Decode, 235, 116, 17, // 8766: decode to LR_D using decoder 17
5309 // 8766: }
5310 // 8766: } // switch Inst[14:12]
5311 // 8766: }
5312 9, 27, // 8770: case 0x9: {
5313 OPC_SwitchField, 12, 3, // 8772: switch Inst[14:12] {
5314 2, 10, // 8775: case 0x2: {
5315 OPC_CheckPredicate, 55, // 8777: check predicate 55
5316 OPC_CheckField, 20, 5, 0, // 8779: check Inst[24:20] == 0x0
5317 OPC_Decode, 242, 116, 17, // 8783: decode to LR_W_RL using decoder 17
5318 // 8783: }
5319 3, 0, // 8787: case 0x3: {
5320 OPC_CheckPredicate, 56, // 8789: check predicate 56
5321 OPC_CheckField, 20, 5, 0, // 8791: check Inst[24:20] == 0x0
5322 OPC_Decode, 238, 116, 17, // 8795: decode to LR_D_RL using decoder 17
5323 // 8795: }
5324 // 8795: } // switch Inst[14:12]
5325 // 8795: }
5326 10, 27, // 8799: case 0xa: {
5327 OPC_SwitchField, 12, 3, // 8801: switch Inst[14:12] {
5328 2, 10, // 8804: case 0x2: {
5329 OPC_CheckPredicate, 55, // 8806: check predicate 55
5330 OPC_CheckField, 20, 5, 0, // 8808: check Inst[24:20] == 0x0
5331 OPC_Decode, 240, 116, 17, // 8812: decode to LR_W_AQ using decoder 17
5332 // 8812: }
5333 3, 0, // 8816: case 0x3: {
5334 OPC_CheckPredicate, 56, // 8818: check predicate 56
5335 OPC_CheckField, 20, 5, 0, // 8820: check Inst[24:20] == 0x0
5336 OPC_Decode, 236, 116, 17, // 8824: decode to LR_D_AQ using decoder 17
5337 // 8824: }
5338 // 8824: } // switch Inst[14:12]
5339 // 8824: }
5340 11, 27, // 8828: case 0xb: {
5341 OPC_SwitchField, 12, 3, // 8830: switch Inst[14:12] {
5342 2, 10, // 8833: case 0x2: {
5343 OPC_CheckPredicate, 55, // 8835: check predicate 55
5344 OPC_CheckField, 20, 5, 0, // 8837: check Inst[24:20] == 0x0
5345 OPC_Decode, 241, 116, 17, // 8841: decode to LR_W_AQRL using decoder 17
5346 // 8841: }
5347 3, 0, // 8845: case 0x3: {
5348 OPC_CheckPredicate, 56, // 8847: check predicate 56
5349 OPC_CheckField, 20, 5, 0, // 8849: check Inst[24:20] == 0x0
5350 OPC_Decode, 237, 116, 17, // 8853: decode to LR_D_AQRL using decoder 17
5351 // 8853: }
5352 // 8853: } // switch Inst[14:12]
5353 // 8853: }
5354 12, 19, // 8857: case 0xc: {
5355 OPC_SwitchField, 12, 3, // 8859: switch Inst[14:12] {
5356 2, 6, // 8862: case 0x2: {
5357 OPC_CheckPredicate, 55, // 8864: check predicate 55
5358 OPC_Decode, 231, 123, 56, // 8866: decode to SC_W using decoder 56
5359 // 8866: }
5360 3, 0, // 8870: case 0x3: {
5361 OPC_CheckPredicate, 56, // 8872: check predicate 56
5362 OPC_Decode, 227, 123, 56, // 8874: decode to SC_D using decoder 56
5363 // 8874: }
5364 // 8874: } // switch Inst[14:12]
5365 // 8874: }
5366 13, 19, // 8878: case 0xd: {
5367 OPC_SwitchField, 12, 3, // 8880: switch Inst[14:12] {
5368 2, 6, // 8883: case 0x2: {
5369 OPC_CheckPredicate, 55, // 8885: check predicate 55
5370 OPC_Decode, 234, 123, 56, // 8887: decode to SC_W_RL using decoder 56
5371 // 8887: }
5372 3, 0, // 8891: case 0x3: {
5373 OPC_CheckPredicate, 56, // 8893: check predicate 56
5374 OPC_Decode, 230, 123, 56, // 8895: decode to SC_D_RL using decoder 56
5375 // 8895: }
5376 // 8895: } // switch Inst[14:12]
5377 // 8895: }
5378 14, 19, // 8899: case 0xe: {
5379 OPC_SwitchField, 12, 3, // 8901: switch Inst[14:12] {
5380 2, 6, // 8904: case 0x2: {
5381 OPC_CheckPredicate, 55, // 8906: check predicate 55
5382 OPC_Decode, 232, 123, 56, // 8908: decode to SC_W_AQ using decoder 56
5383 // 8908: }
5384 3, 0, // 8912: case 0x3: {
5385 OPC_CheckPredicate, 56, // 8914: check predicate 56
5386 OPC_Decode, 228, 123, 56, // 8916: decode to SC_D_AQ using decoder 56
5387 // 8916: }
5388 // 8916: } // switch Inst[14:12]
5389 // 8916: }
5390 15, 19, // 8920: case 0xf: {
5391 OPC_SwitchField, 12, 3, // 8922: switch Inst[14:12] {
5392 2, 6, // 8925: case 0x2: {
5393 OPC_CheckPredicate, 55, // 8927: check predicate 55
5394 OPC_Decode, 233, 123, 56, // 8929: decode to SC_W_AQRL using decoder 56
5395 // 8929: }
5396 3, 0, // 8933: case 0x3: {
5397 OPC_CheckPredicate, 56, // 8935: check predicate 56
5398 OPC_Decode, 229, 123, 56, // 8937: decode to SC_D_AQRL using decoder 56
5399 // 8937: }
5400 // 8937: } // switch Inst[14:12]
5401 // 8937: }
5402 16, 35, // 8941: case 0x10: {
5403 OPC_SwitchField, 12, 3, // 8943: switch Inst[14:12] {
5404 0, 6, // 8946: case 0x0: {
5405 OPC_CheckPredicate, 52, // 8948: check predicate 52
5406 OPC_Decode, 202, 110, 56, // 8950: decode to AMOXOR_B using decoder 56
5407 // 8950: }
5408 1, 6, // 8954: case 0x1: {
5409 OPC_CheckPredicate, 52, // 8956: check predicate 52
5410 OPC_Decode, 210, 110, 56, // 8958: decode to AMOXOR_H using decoder 56
5411 // 8958: }
5412 2, 6, // 8962: case 0x2: {
5413 OPC_CheckPredicate, 53, // 8964: check predicate 53
5414 OPC_Decode, 214, 110, 56, // 8966: decode to AMOXOR_W using decoder 56
5415 // 8966: }
5416 3, 0, // 8970: case 0x3: {
5417 OPC_CheckPredicate, 54, // 8972: check predicate 54
5418 OPC_Decode, 206, 110, 56, // 8974: decode to AMOXOR_D using decoder 56
5419 // 8974: }
5420 // 8974: } // switch Inst[14:12]
5421 // 8974: }
5422 17, 35, // 8978: case 0x11: {
5423 OPC_SwitchField, 12, 3, // 8980: switch Inst[14:12] {
5424 0, 6, // 8983: case 0x0: {
5425 OPC_CheckPredicate, 52, // 8985: check predicate 52
5426 OPC_Decode, 205, 110, 56, // 8987: decode to AMOXOR_B_RL using decoder 56
5427 // 8987: }
5428 1, 6, // 8991: case 0x1: {
5429 OPC_CheckPredicate, 52, // 8993: check predicate 52
5430 OPC_Decode, 213, 110, 56, // 8995: decode to AMOXOR_H_RL using decoder 56
5431 // 8995: }
5432 2, 6, // 8999: case 0x2: {
5433 OPC_CheckPredicate, 53, // 9001: check predicate 53
5434 OPC_Decode, 217, 110, 56, // 9003: decode to AMOXOR_W_RL using decoder 56
5435 // 9003: }
5436 3, 0, // 9007: case 0x3: {
5437 OPC_CheckPredicate, 54, // 9009: check predicate 54
5438 OPC_Decode, 209, 110, 56, // 9011: decode to AMOXOR_D_RL using decoder 56
5439 // 9011: }
5440 // 9011: } // switch Inst[14:12]
5441 // 9011: }
5442 18, 35, // 9015: case 0x12: {
5443 OPC_SwitchField, 12, 3, // 9017: switch Inst[14:12] {
5444 0, 6, // 9020: case 0x0: {
5445 OPC_CheckPredicate, 52, // 9022: check predicate 52
5446 OPC_Decode, 203, 110, 56, // 9024: decode to AMOXOR_B_AQ using decoder 56
5447 // 9024: }
5448 1, 6, // 9028: case 0x1: {
5449 OPC_CheckPredicate, 52, // 9030: check predicate 52
5450 OPC_Decode, 211, 110, 56, // 9032: decode to AMOXOR_H_AQ using decoder 56
5451 // 9032: }
5452 2, 6, // 9036: case 0x2: {
5453 OPC_CheckPredicate, 53, // 9038: check predicate 53
5454 OPC_Decode, 215, 110, 56, // 9040: decode to AMOXOR_W_AQ using decoder 56
5455 // 9040: }
5456 3, 0, // 9044: case 0x3: {
5457 OPC_CheckPredicate, 54, // 9046: check predicate 54
5458 OPC_Decode, 207, 110, 56, // 9048: decode to AMOXOR_D_AQ using decoder 56
5459 // 9048: }
5460 // 9048: } // switch Inst[14:12]
5461 // 9048: }
5462 19, 35, // 9052: case 0x13: {
5463 OPC_SwitchField, 12, 3, // 9054: switch Inst[14:12] {
5464 0, 6, // 9057: case 0x0: {
5465 OPC_CheckPredicate, 52, // 9059: check predicate 52
5466 OPC_Decode, 204, 110, 56, // 9061: decode to AMOXOR_B_AQRL using decoder 56
5467 // 9061: }
5468 1, 6, // 9065: case 0x1: {
5469 OPC_CheckPredicate, 52, // 9067: check predicate 52
5470 OPC_Decode, 212, 110, 56, // 9069: decode to AMOXOR_H_AQRL using decoder 56
5471 // 9069: }
5472 2, 6, // 9073: case 0x2: {
5473 OPC_CheckPredicate, 53, // 9075: check predicate 53
5474 OPC_Decode, 216, 110, 56, // 9077: decode to AMOXOR_W_AQRL using decoder 56
5475 // 9077: }
5476 3, 0, // 9081: case 0x3: {
5477 OPC_CheckPredicate, 54, // 9083: check predicate 54
5478 OPC_Decode, 208, 110, 56, // 9085: decode to AMOXOR_D_AQRL using decoder 56
5479 // 9085: }
5480 // 9085: } // switch Inst[14:12]
5481 // 9085: }
5482 20, 43, // 9089: case 0x14: {
5483 OPC_SwitchField, 12, 3, // 9091: switch Inst[14:12] {
5484 0, 6, // 9094: case 0x0: {
5485 OPC_CheckPredicate, 57, // 9096: check predicate 57
5486 OPC_Decode, 210, 109, 57, // 9098: decode to AMOCAS_B using decoder 57
5487 // 9098: }
5488 1, 6, // 9102: case 0x1: {
5489 OPC_CheckPredicate, 57, // 9104: check predicate 57
5490 OPC_Decode, 222, 109, 57, // 9106: decode to AMOCAS_H using decoder 57
5491 // 9106: }
5492 2, 6, // 9110: case 0x2: {
5493 OPC_CheckPredicate, 58, // 9112: check predicate 58
5494 OPC_Decode, 230, 109, 57, // 9114: decode to AMOCAS_W using decoder 57
5495 // 9114: }
5496 3, 6, // 9118: case 0x3: {
5497 OPC_CheckPredicate, 59, // 9120: check predicate 59
5498 OPC_Decode, 218, 109, 57, // 9122: decode to AMOCAS_D_RV64 using decoder 57
5499 // 9122: }
5500 4, 0, // 9126: case 0x4: {
5501 OPC_CheckPredicate, 59, // 9128: check predicate 59
5502 OPC_Decode, 226, 109, 58, // 9130: decode to AMOCAS_Q using decoder 58
5503 // 9130: }
5504 // 9130: } // switch Inst[14:12]
5505 // 9130: }
5506 21, 43, // 9134: case 0x15: {
5507 OPC_SwitchField, 12, 3, // 9136: switch Inst[14:12] {
5508 0, 6, // 9139: case 0x0: {
5509 OPC_CheckPredicate, 57, // 9141: check predicate 57
5510 OPC_Decode, 213, 109, 57, // 9143: decode to AMOCAS_B_RL using decoder 57
5511 // 9143: }
5512 1, 6, // 9147: case 0x1: {
5513 OPC_CheckPredicate, 57, // 9149: check predicate 57
5514 OPC_Decode, 225, 109, 57, // 9151: decode to AMOCAS_H_RL using decoder 57
5515 // 9151: }
5516 2, 6, // 9155: case 0x2: {
5517 OPC_CheckPredicate, 58, // 9157: check predicate 58
5518 OPC_Decode, 233, 109, 57, // 9159: decode to AMOCAS_W_RL using decoder 57
5519 // 9159: }
5520 3, 6, // 9163: case 0x3: {
5521 OPC_CheckPredicate, 59, // 9165: check predicate 59
5522 OPC_Decode, 221, 109, 57, // 9167: decode to AMOCAS_D_RV64_RL using decoder 57
5523 // 9167: }
5524 4, 0, // 9171: case 0x4: {
5525 OPC_CheckPredicate, 59, // 9173: check predicate 59
5526 OPC_Decode, 229, 109, 58, // 9175: decode to AMOCAS_Q_RL using decoder 58
5527 // 9175: }
5528 // 9175: } // switch Inst[14:12]
5529 // 9175: }
5530 22, 43, // 9179: case 0x16: {
5531 OPC_SwitchField, 12, 3, // 9181: switch Inst[14:12] {
5532 0, 6, // 9184: case 0x0: {
5533 OPC_CheckPredicate, 57, // 9186: check predicate 57
5534 OPC_Decode, 211, 109, 57, // 9188: decode to AMOCAS_B_AQ using decoder 57
5535 // 9188: }
5536 1, 6, // 9192: case 0x1: {
5537 OPC_CheckPredicate, 57, // 9194: check predicate 57
5538 OPC_Decode, 223, 109, 57, // 9196: decode to AMOCAS_H_AQ using decoder 57
5539 // 9196: }
5540 2, 6, // 9200: case 0x2: {
5541 OPC_CheckPredicate, 58, // 9202: check predicate 58
5542 OPC_Decode, 231, 109, 57, // 9204: decode to AMOCAS_W_AQ using decoder 57
5543 // 9204: }
5544 3, 6, // 9208: case 0x3: {
5545 OPC_CheckPredicate, 59, // 9210: check predicate 59
5546 OPC_Decode, 219, 109, 57, // 9212: decode to AMOCAS_D_RV64_AQ using decoder 57
5547 // 9212: }
5548 4, 0, // 9216: case 0x4: {
5549 OPC_CheckPredicate, 59, // 9218: check predicate 59
5550 OPC_Decode, 227, 109, 58, // 9220: decode to AMOCAS_Q_AQ using decoder 58
5551 // 9220: }
5552 // 9220: } // switch Inst[14:12]
5553 // 9220: }
5554 23, 43, // 9224: case 0x17: {
5555 OPC_SwitchField, 12, 3, // 9226: switch Inst[14:12] {
5556 0, 6, // 9229: case 0x0: {
5557 OPC_CheckPredicate, 57, // 9231: check predicate 57
5558 OPC_Decode, 212, 109, 57, // 9233: decode to AMOCAS_B_AQRL using decoder 57
5559 // 9233: }
5560 1, 6, // 9237: case 0x1: {
5561 OPC_CheckPredicate, 57, // 9239: check predicate 57
5562 OPC_Decode, 224, 109, 57, // 9241: decode to AMOCAS_H_AQRL using decoder 57
5563 // 9241: }
5564 2, 6, // 9245: case 0x2: {
5565 OPC_CheckPredicate, 58, // 9247: check predicate 58
5566 OPC_Decode, 232, 109, 57, // 9249: decode to AMOCAS_W_AQRL using decoder 57
5567 // 9249: }
5568 3, 6, // 9253: case 0x3: {
5569 OPC_CheckPredicate, 59, // 9255: check predicate 59
5570 OPC_Decode, 220, 109, 57, // 9257: decode to AMOCAS_D_RV64_AQRL using decoder 57
5571 // 9257: }
5572 4, 0, // 9261: case 0x4: {
5573 OPC_CheckPredicate, 59, // 9263: check predicate 59
5574 OPC_Decode, 228, 109, 58, // 9265: decode to AMOCAS_Q_AQRL using decoder 58
5575 // 9265: }
5576 // 9265: } // switch Inst[14:12]
5577 // 9265: }
5578 26, 51, // 9269: case 0x1a: {
5579 OPC_SwitchField, 12, 3, // 9271: switch Inst[14:12] {
5580 0, 10, // 9274: case 0x0: {
5581 OPC_CheckPredicate, 60, // 9276: check predicate 60
5582 OPC_CheckField, 20, 5, 0, // 9278: check Inst[24:20] == 0x0
5583 OPC_Decode, 224, 116, 17, // 9282: decode to LB_AQ using decoder 17
5584 // 9282: }
5585 1, 10, // 9286: case 0x1: {
5586 OPC_CheckPredicate, 60, // 9288: check predicate 60
5587 OPC_CheckField, 20, 5, 0, // 9290: check Inst[24:20] == 0x0
5588 OPC_Decode, 232, 116, 17, // 9294: decode to LH_AQ using decoder 17
5589 // 9294: }
5590 2, 10, // 9298: case 0x2: {
5591 OPC_CheckPredicate, 60, // 9300: check predicate 60
5592 OPC_CheckField, 20, 5, 0, // 9302: check Inst[24:20] == 0x0
5593 OPC_Decode, 246, 116, 17, // 9306: decode to LW_AQ using decoder 17
5594 // 9306: }
5595 3, 0, // 9310: case 0x3: {
5596 OPC_CheckPredicate, 61, // 9312: check predicate 61
5597 OPC_CheckField, 20, 5, 0, // 9314: check Inst[24:20] == 0x0
5598 OPC_Decode, 227, 116, 17, // 9318: decode to LD_AQ using decoder 17
5599 // 9318: }
5600 // 9318: } // switch Inst[14:12]
5601 // 9318: }
5602 27, 51, // 9322: case 0x1b: {
5603 OPC_SwitchField, 12, 3, // 9324: switch Inst[14:12] {
5604 0, 10, // 9327: case 0x0: {
5605 OPC_CheckPredicate, 60, // 9329: check predicate 60
5606 OPC_CheckField, 20, 5, 0, // 9331: check Inst[24:20] == 0x0
5607 OPC_Decode, 225, 116, 17, // 9335: decode to LB_AQRL using decoder 17
5608 // 9335: }
5609 1, 10, // 9339: case 0x1: {
5610 OPC_CheckPredicate, 60, // 9341: check predicate 60
5611 OPC_CheckField, 20, 5, 0, // 9343: check Inst[24:20] == 0x0
5612 OPC_Decode, 233, 116, 17, // 9347: decode to LH_AQRL using decoder 17
5613 // 9347: }
5614 2, 10, // 9351: case 0x2: {
5615 OPC_CheckPredicate, 60, // 9353: check predicate 60
5616 OPC_CheckField, 20, 5, 0, // 9355: check Inst[24:20] == 0x0
5617 OPC_Decode, 247, 116, 17, // 9359: decode to LW_AQRL using decoder 17
5618 // 9359: }
5619 3, 0, // 9363: case 0x3: {
5620 OPC_CheckPredicate, 61, // 9365: check predicate 61
5621 OPC_CheckField, 20, 5, 0, // 9367: check Inst[24:20] == 0x0
5622 OPC_Decode, 228, 116, 17, // 9371: decode to LD_AQRL using decoder 17
5623 // 9371: }
5624 // 9371: } // switch Inst[14:12]
5625 // 9371: }
5626 29, 35, // 9375: case 0x1d: {
5627 OPC_SwitchField, 7, 8, // 9377: switch Inst[14:7] {
5628 0, 6, // 9380: case 0x0: {
5629 OPC_CheckPredicate, 60, // 9382: check predicate 60
5630 OPC_Decode, 223, 123, 59, // 9384: decode to SB_RL using decoder 59
5631 // 9384: }
5632 32, 6, // 9388: case 0x20: {
5633 OPC_CheckPredicate, 60, // 9390: check predicate 60
5634 OPC_Decode, 211, 124, 59, // 9392: decode to SH_RL using decoder 59
5635 // 9392: }
5636 64, 6, // 9396: case 0x40: {
5637 OPC_CheckPredicate, 60, // 9398: check predicate 60
5638 OPC_Decode, 153, 125, 59, // 9400: decode to SW_RL using decoder 59
5639 // 9400: }
5640 96, 0, // 9404: case 0x60: {
5641 OPC_CheckPredicate, 61, // 9406: check predicate 61
5642 OPC_Decode, 237, 123, 59, // 9408: decode to SD_RL using decoder 59
5643 // 9408: }
5644 // 9408: } // switch Inst[14:7]
5645 // 9408: }
5646 31, 35, // 9412: case 0x1f: {
5647 OPC_SwitchField, 7, 8, // 9414: switch Inst[14:7] {
5648 0, 6, // 9417: case 0x0: {
5649 OPC_CheckPredicate, 60, // 9419: check predicate 60
5650 OPC_Decode, 222, 123, 59, // 9421: decode to SB_AQRL using decoder 59
5651 // 9421: }
5652 32, 6, // 9425: case 0x20: {
5653 OPC_CheckPredicate, 60, // 9427: check predicate 60
5654 OPC_Decode, 209, 124, 59, // 9429: decode to SH_AQRL using decoder 59
5655 // 9429: }
5656 64, 6, // 9433: case 0x40: {
5657 OPC_CheckPredicate, 60, // 9435: check predicate 60
5658 OPC_Decode, 151, 125, 59, // 9437: decode to SW_AQRL using decoder 59
5659 // 9437: }
5660 96, 0, // 9441: case 0x60: {
5661 OPC_CheckPredicate, 61, // 9443: check predicate 61
5662 OPC_Decode, 236, 123, 59, // 9445: decode to SD_AQRL using decoder 59
5663 // 9445: }
5664 // 9445: } // switch Inst[14:7]
5665 // 9445: }
5666 32, 35, // 9449: case 0x20: {
5667 OPC_SwitchField, 12, 3, // 9451: switch Inst[14:12] {
5668 0, 6, // 9454: case 0x0: {
5669 OPC_CheckPredicate, 52, // 9456: check predicate 52
5670 OPC_Decode, 170, 110, 56, // 9458: decode to AMOOR_B using decoder 56
5671 // 9458: }
5672 1, 6, // 9462: case 0x1: {
5673 OPC_CheckPredicate, 52, // 9464: check predicate 52
5674 OPC_Decode, 178, 110, 56, // 9466: decode to AMOOR_H using decoder 56
5675 // 9466: }
5676 2, 6, // 9470: case 0x2: {
5677 OPC_CheckPredicate, 53, // 9472: check predicate 53
5678 OPC_Decode, 182, 110, 56, // 9474: decode to AMOOR_W using decoder 56
5679 // 9474: }
5680 3, 0, // 9478: case 0x3: {
5681 OPC_CheckPredicate, 54, // 9480: check predicate 54
5682 OPC_Decode, 174, 110, 56, // 9482: decode to AMOOR_D using decoder 56
5683 // 9482: }
5684 // 9482: } // switch Inst[14:12]
5685 // 9482: }
5686 33, 35, // 9486: case 0x21: {
5687 OPC_SwitchField, 12, 3, // 9488: switch Inst[14:12] {
5688 0, 6, // 9491: case 0x0: {
5689 OPC_CheckPredicate, 52, // 9493: check predicate 52
5690 OPC_Decode, 173, 110, 56, // 9495: decode to AMOOR_B_RL using decoder 56
5691 // 9495: }
5692 1, 6, // 9499: case 0x1: {
5693 OPC_CheckPredicate, 52, // 9501: check predicate 52
5694 OPC_Decode, 181, 110, 56, // 9503: decode to AMOOR_H_RL using decoder 56
5695 // 9503: }
5696 2, 6, // 9507: case 0x2: {
5697 OPC_CheckPredicate, 53, // 9509: check predicate 53
5698 OPC_Decode, 185, 110, 56, // 9511: decode to AMOOR_W_RL using decoder 56
5699 // 9511: }
5700 3, 0, // 9515: case 0x3: {
5701 OPC_CheckPredicate, 54, // 9517: check predicate 54
5702 OPC_Decode, 177, 110, 56, // 9519: decode to AMOOR_D_RL using decoder 56
5703 // 9519: }
5704 // 9519: } // switch Inst[14:12]
5705 // 9519: }
5706 34, 35, // 9523: case 0x22: {
5707 OPC_SwitchField, 12, 3, // 9525: switch Inst[14:12] {
5708 0, 6, // 9528: case 0x0: {
5709 OPC_CheckPredicate, 52, // 9530: check predicate 52
5710 OPC_Decode, 171, 110, 56, // 9532: decode to AMOOR_B_AQ using decoder 56
5711 // 9532: }
5712 1, 6, // 9536: case 0x1: {
5713 OPC_CheckPredicate, 52, // 9538: check predicate 52
5714 OPC_Decode, 179, 110, 56, // 9540: decode to AMOOR_H_AQ using decoder 56
5715 // 9540: }
5716 2, 6, // 9544: case 0x2: {
5717 OPC_CheckPredicate, 53, // 9546: check predicate 53
5718 OPC_Decode, 183, 110, 56, // 9548: decode to AMOOR_W_AQ using decoder 56
5719 // 9548: }
5720 3, 0, // 9552: case 0x3: {
5721 OPC_CheckPredicate, 54, // 9554: check predicate 54
5722 OPC_Decode, 175, 110, 56, // 9556: decode to AMOOR_D_AQ using decoder 56
5723 // 9556: }
5724 // 9556: } // switch Inst[14:12]
5725 // 9556: }
5726 35, 35, // 9560: case 0x23: {
5727 OPC_SwitchField, 12, 3, // 9562: switch Inst[14:12] {
5728 0, 6, // 9565: case 0x0: {
5729 OPC_CheckPredicate, 52, // 9567: check predicate 52
5730 OPC_Decode, 172, 110, 56, // 9569: decode to AMOOR_B_AQRL using decoder 56
5731 // 9569: }
5732 1, 6, // 9573: case 0x1: {
5733 OPC_CheckPredicate, 52, // 9575: check predicate 52
5734 OPC_Decode, 180, 110, 56, // 9577: decode to AMOOR_H_AQRL using decoder 56
5735 // 9577: }
5736 2, 6, // 9581: case 0x2: {
5737 OPC_CheckPredicate, 53, // 9583: check predicate 53
5738 OPC_Decode, 184, 110, 56, // 9585: decode to AMOOR_W_AQRL using decoder 56
5739 // 9585: }
5740 3, 0, // 9589: case 0x3: {
5741 OPC_CheckPredicate, 54, // 9591: check predicate 54
5742 OPC_Decode, 176, 110, 56, // 9593: decode to AMOOR_D_AQRL using decoder 56
5743 // 9593: }
5744 // 9593: } // switch Inst[14:12]
5745 // 9593: }
5746 36, 19, // 9597: case 0x24: {
5747 OPC_SwitchField, 12, 3, // 9599: switch Inst[14:12] {
5748 2, 6, // 9602: case 0x2: {
5749 OPC_CheckPredicate, 62, // 9604: check predicate 62
5750 OPC_Decode, 132, 125, 56, // 9606: decode to SSAMOSWAP_W using decoder 56
5751 // 9606: }
5752 3, 0, // 9610: case 0x3: {
5753 OPC_CheckPredicate, 63, // 9612: check predicate 63
5754 OPC_Decode, 128, 125, 56, // 9614: decode to SSAMOSWAP_D using decoder 56
5755 // 9614: }
5756 // 9614: } // switch Inst[14:12]
5757 // 9614: }
5758 37, 19, // 9618: case 0x25: {
5759 OPC_SwitchField, 12, 3, // 9620: switch Inst[14:12] {
5760 2, 6, // 9623: case 0x2: {
5761 OPC_CheckPredicate, 62, // 9625: check predicate 62
5762 OPC_Decode, 135, 125, 56, // 9627: decode to SSAMOSWAP_W_RL using decoder 56
5763 // 9627: }
5764 3, 0, // 9631: case 0x3: {
5765 OPC_CheckPredicate, 63, // 9633: check predicate 63
5766 OPC_Decode, 131, 125, 56, // 9635: decode to SSAMOSWAP_D_RL using decoder 56
5767 // 9635: }
5768 // 9635: } // switch Inst[14:12]
5769 // 9635: }
5770 38, 19, // 9639: case 0x26: {
5771 OPC_SwitchField, 12, 3, // 9641: switch Inst[14:12] {
5772 2, 6, // 9644: case 0x2: {
5773 OPC_CheckPredicate, 62, // 9646: check predicate 62
5774 OPC_Decode, 133, 125, 56, // 9648: decode to SSAMOSWAP_W_AQ using decoder 56
5775 // 9648: }
5776 3, 0, // 9652: case 0x3: {
5777 OPC_CheckPredicate, 63, // 9654: check predicate 63
5778 OPC_Decode, 129, 125, 56, // 9656: decode to SSAMOSWAP_D_AQ using decoder 56
5779 // 9656: }
5780 // 9656: } // switch Inst[14:12]
5781 // 9656: }
5782 39, 19, // 9660: case 0x27: {
5783 OPC_SwitchField, 12, 3, // 9662: switch Inst[14:12] {
5784 2, 6, // 9665: case 0x2: {
5785 OPC_CheckPredicate, 62, // 9667: check predicate 62
5786 OPC_Decode, 134, 125, 56, // 9669: decode to SSAMOSWAP_W_AQRL using decoder 56
5787 // 9669: }
5788 3, 0, // 9673: case 0x3: {
5789 OPC_CheckPredicate, 63, // 9675: check predicate 63
5790 OPC_Decode, 130, 125, 56, // 9677: decode to SSAMOSWAP_D_AQRL using decoder 56
5791 // 9677: }
5792 // 9677: } // switch Inst[14:12]
5793 // 9677: }
5794 48, 35, // 9681: case 0x30: {
5795 OPC_SwitchField, 12, 3, // 9683: switch Inst[14:12] {
5796 0, 6, // 9686: case 0x0: {
5797 OPC_CheckPredicate, 52, // 9688: check predicate 52
5798 OPC_Decode, 194, 109, 56, // 9690: decode to AMOAND_B using decoder 56
5799 // 9690: }
5800 1, 6, // 9694: case 0x1: {
5801 OPC_CheckPredicate, 52, // 9696: check predicate 52
5802 OPC_Decode, 202, 109, 56, // 9698: decode to AMOAND_H using decoder 56
5803 // 9698: }
5804 2, 6, // 9702: case 0x2: {
5805 OPC_CheckPredicate, 53, // 9704: check predicate 53
5806 OPC_Decode, 206, 109, 56, // 9706: decode to AMOAND_W using decoder 56
5807 // 9706: }
5808 3, 0, // 9710: case 0x3: {
5809 OPC_CheckPredicate, 54, // 9712: check predicate 54
5810 OPC_Decode, 198, 109, 56, // 9714: decode to AMOAND_D using decoder 56
5811 // 9714: }
5812 // 9714: } // switch Inst[14:12]
5813 // 9714: }
5814 49, 35, // 9718: case 0x31: {
5815 OPC_SwitchField, 12, 3, // 9720: switch Inst[14:12] {
5816 0, 6, // 9723: case 0x0: {
5817 OPC_CheckPredicate, 52, // 9725: check predicate 52
5818 OPC_Decode, 197, 109, 56, // 9727: decode to AMOAND_B_RL using decoder 56
5819 // 9727: }
5820 1, 6, // 9731: case 0x1: {
5821 OPC_CheckPredicate, 52, // 9733: check predicate 52
5822 OPC_Decode, 205, 109, 56, // 9735: decode to AMOAND_H_RL using decoder 56
5823 // 9735: }
5824 2, 6, // 9739: case 0x2: {
5825 OPC_CheckPredicate, 53, // 9741: check predicate 53
5826 OPC_Decode, 209, 109, 56, // 9743: decode to AMOAND_W_RL using decoder 56
5827 // 9743: }
5828 3, 0, // 9747: case 0x3: {
5829 OPC_CheckPredicate, 54, // 9749: check predicate 54
5830 OPC_Decode, 201, 109, 56, // 9751: decode to AMOAND_D_RL using decoder 56
5831 // 9751: }
5832 // 9751: } // switch Inst[14:12]
5833 // 9751: }
5834 50, 35, // 9755: case 0x32: {
5835 OPC_SwitchField, 12, 3, // 9757: switch Inst[14:12] {
5836 0, 6, // 9760: case 0x0: {
5837 OPC_CheckPredicate, 52, // 9762: check predicate 52
5838 OPC_Decode, 195, 109, 56, // 9764: decode to AMOAND_B_AQ using decoder 56
5839 // 9764: }
5840 1, 6, // 9768: case 0x1: {
5841 OPC_CheckPredicate, 52, // 9770: check predicate 52
5842 OPC_Decode, 203, 109, 56, // 9772: decode to AMOAND_H_AQ using decoder 56
5843 // 9772: }
5844 2, 6, // 9776: case 0x2: {
5845 OPC_CheckPredicate, 53, // 9778: check predicate 53
5846 OPC_Decode, 207, 109, 56, // 9780: decode to AMOAND_W_AQ using decoder 56
5847 // 9780: }
5848 3, 0, // 9784: case 0x3: {
5849 OPC_CheckPredicate, 54, // 9786: check predicate 54
5850 OPC_Decode, 199, 109, 56, // 9788: decode to AMOAND_D_AQ using decoder 56
5851 // 9788: }
5852 // 9788: } // switch Inst[14:12]
5853 // 9788: }
5854 51, 35, // 9792: case 0x33: {
5855 OPC_SwitchField, 12, 3, // 9794: switch Inst[14:12] {
5856 0, 6, // 9797: case 0x0: {
5857 OPC_CheckPredicate, 52, // 9799: check predicate 52
5858 OPC_Decode, 196, 109, 56, // 9801: decode to AMOAND_B_AQRL using decoder 56
5859 // 9801: }
5860 1, 6, // 9805: case 0x1: {
5861 OPC_CheckPredicate, 52, // 9807: check predicate 52
5862 OPC_Decode, 204, 109, 56, // 9809: decode to AMOAND_H_AQRL using decoder 56
5863 // 9809: }
5864 2, 6, // 9813: case 0x2: {
5865 OPC_CheckPredicate, 53, // 9815: check predicate 53
5866 OPC_Decode, 208, 109, 56, // 9817: decode to AMOAND_W_AQRL using decoder 56
5867 // 9817: }
5868 3, 0, // 9821: case 0x3: {
5869 OPC_CheckPredicate, 54, // 9823: check predicate 54
5870 OPC_Decode, 200, 109, 56, // 9825: decode to AMOAND_D_AQRL using decoder 56
5871 // 9825: }
5872 // 9825: } // switch Inst[14:12]
5873 // 9825: }
5874 64, 35, // 9829: case 0x40: {
5875 OPC_SwitchField, 12, 3, // 9831: switch Inst[14:12] {
5876 0, 6, // 9834: case 0x0: {
5877 OPC_CheckPredicate, 52, // 9836: check predicate 52
5878 OPC_Decode, 154, 110, 56, // 9838: decode to AMOMIN_B using decoder 56
5879 // 9838: }
5880 1, 6, // 9842: case 0x1: {
5881 OPC_CheckPredicate, 52, // 9844: check predicate 52
5882 OPC_Decode, 162, 110, 56, // 9846: decode to AMOMIN_H using decoder 56
5883 // 9846: }
5884 2, 6, // 9850: case 0x2: {
5885 OPC_CheckPredicate, 53, // 9852: check predicate 53
5886 OPC_Decode, 166, 110, 56, // 9854: decode to AMOMIN_W using decoder 56
5887 // 9854: }
5888 3, 0, // 9858: case 0x3: {
5889 OPC_CheckPredicate, 54, // 9860: check predicate 54
5890 OPC_Decode, 158, 110, 56, // 9862: decode to AMOMIN_D using decoder 56
5891 // 9862: }
5892 // 9862: } // switch Inst[14:12]
5893 // 9862: }
5894 65, 35, // 9866: case 0x41: {
5895 OPC_SwitchField, 12, 3, // 9868: switch Inst[14:12] {
5896 0, 6, // 9871: case 0x0: {
5897 OPC_CheckPredicate, 52, // 9873: check predicate 52
5898 OPC_Decode, 157, 110, 56, // 9875: decode to AMOMIN_B_RL using decoder 56
5899 // 9875: }
5900 1, 6, // 9879: case 0x1: {
5901 OPC_CheckPredicate, 52, // 9881: check predicate 52
5902 OPC_Decode, 165, 110, 56, // 9883: decode to AMOMIN_H_RL using decoder 56
5903 // 9883: }
5904 2, 6, // 9887: case 0x2: {
5905 OPC_CheckPredicate, 53, // 9889: check predicate 53
5906 OPC_Decode, 169, 110, 56, // 9891: decode to AMOMIN_W_RL using decoder 56
5907 // 9891: }
5908 3, 0, // 9895: case 0x3: {
5909 OPC_CheckPredicate, 54, // 9897: check predicate 54
5910 OPC_Decode, 161, 110, 56, // 9899: decode to AMOMIN_D_RL using decoder 56
5911 // 9899: }
5912 // 9899: } // switch Inst[14:12]
5913 // 9899: }
5914 66, 35, // 9903: case 0x42: {
5915 OPC_SwitchField, 12, 3, // 9905: switch Inst[14:12] {
5916 0, 6, // 9908: case 0x0: {
5917 OPC_CheckPredicate, 52, // 9910: check predicate 52
5918 OPC_Decode, 155, 110, 56, // 9912: decode to AMOMIN_B_AQ using decoder 56
5919 // 9912: }
5920 1, 6, // 9916: case 0x1: {
5921 OPC_CheckPredicate, 52, // 9918: check predicate 52
5922 OPC_Decode, 163, 110, 56, // 9920: decode to AMOMIN_H_AQ using decoder 56
5923 // 9920: }
5924 2, 6, // 9924: case 0x2: {
5925 OPC_CheckPredicate, 53, // 9926: check predicate 53
5926 OPC_Decode, 167, 110, 56, // 9928: decode to AMOMIN_W_AQ using decoder 56
5927 // 9928: }
5928 3, 0, // 9932: case 0x3: {
5929 OPC_CheckPredicate, 54, // 9934: check predicate 54
5930 OPC_Decode, 159, 110, 56, // 9936: decode to AMOMIN_D_AQ using decoder 56
5931 // 9936: }
5932 // 9936: } // switch Inst[14:12]
5933 // 9936: }
5934 67, 35, // 9940: case 0x43: {
5935 OPC_SwitchField, 12, 3, // 9942: switch Inst[14:12] {
5936 0, 6, // 9945: case 0x0: {
5937 OPC_CheckPredicate, 52, // 9947: check predicate 52
5938 OPC_Decode, 156, 110, 56, // 9949: decode to AMOMIN_B_AQRL using decoder 56
5939 // 9949: }
5940 1, 6, // 9953: case 0x1: {
5941 OPC_CheckPredicate, 52, // 9955: check predicate 52
5942 OPC_Decode, 164, 110, 56, // 9957: decode to AMOMIN_H_AQRL using decoder 56
5943 // 9957: }
5944 2, 6, // 9961: case 0x2: {
5945 OPC_CheckPredicate, 53, // 9963: check predicate 53
5946 OPC_Decode, 168, 110, 56, // 9965: decode to AMOMIN_W_AQRL using decoder 56
5947 // 9965: }
5948 3, 0, // 9969: case 0x3: {
5949 OPC_CheckPredicate, 54, // 9971: check predicate 54
5950 OPC_Decode, 160, 110, 56, // 9973: decode to AMOMIN_D_AQRL using decoder 56
5951 // 9973: }
5952 // 9973: } // switch Inst[14:12]
5953 // 9973: }
5954 72, 43, // 9977: case 0x48: {
5955 OPC_SwitchField, 12, 3, // 9979: switch Inst[14:12] {
5956 1, 6, // 9982: case 0x1: {
5957 OPC_CheckPredicate, 64, // 9984: check predicate 64
5958 OPC_Decode, 250, 116, 56, // 9986: decode to LXH using decoder 56
5959 // 9986: }
5960 2, 6, // 9990: case 0x2: {
5961 OPC_CheckPredicate, 64, // 9992: check predicate 64
5962 OPC_Decode, 138, 117, 56, // 9994: decode to LXW using decoder 56
5963 // 9994: }
5964 3, 6, // 9998: case 0x3: {
5965 OPC_CheckPredicate, 65, // 10000: check predicate 65
5966 OPC_Decode, 249, 116, 56, // 10002: decode to LXD using decoder 56
5967 // 10002: }
5968 5, 6, // 10006: case 0x5: {
5969 OPC_CheckPredicate, 64, // 10008: check predicate 64
5970 OPC_Decode, 251, 116, 56, // 10010: decode to LXHU using decoder 56
5971 // 10010: }
5972 6, 0, // 10014: case 0x6: {
5973 OPC_CheckPredicate, 65, // 10016: check predicate 65
5974 OPC_Decode, 139, 117, 56, // 10018: decode to LXWU using decoder 56
5975 // 10018: }
5976 // 10018: } // switch Inst[14:12]
5977 // 10018: }
5978 80, 35, // 10022: case 0x50: {
5979 OPC_SwitchField, 12, 3, // 10024: switch Inst[14:12] {
5980 0, 6, // 10027: case 0x0: {
5981 OPC_CheckPredicate, 52, // 10029: check predicate 52
5982 OPC_Decode, 250, 109, 56, // 10031: decode to AMOMAX_B using decoder 56
5983 // 10031: }
5984 1, 6, // 10035: case 0x1: {
5985 OPC_CheckPredicate, 52, // 10037: check predicate 52
5986 OPC_Decode, 130, 110, 56, // 10039: decode to AMOMAX_H using decoder 56
5987 // 10039: }
5988 2, 6, // 10043: case 0x2: {
5989 OPC_CheckPredicate, 53, // 10045: check predicate 53
5990 OPC_Decode, 134, 110, 56, // 10047: decode to AMOMAX_W using decoder 56
5991 // 10047: }
5992 3, 0, // 10051: case 0x3: {
5993 OPC_CheckPredicate, 54, // 10053: check predicate 54
5994 OPC_Decode, 254, 109, 56, // 10055: decode to AMOMAX_D using decoder 56
5995 // 10055: }
5996 // 10055: } // switch Inst[14:12]
5997 // 10055: }
5998 81, 35, // 10059: case 0x51: {
5999 OPC_SwitchField, 12, 3, // 10061: switch Inst[14:12] {
6000 0, 6, // 10064: case 0x0: {
6001 OPC_CheckPredicate, 52, // 10066: check predicate 52
6002 OPC_Decode, 253, 109, 56, // 10068: decode to AMOMAX_B_RL using decoder 56
6003 // 10068: }
6004 1, 6, // 10072: case 0x1: {
6005 OPC_CheckPredicate, 52, // 10074: check predicate 52
6006 OPC_Decode, 133, 110, 56, // 10076: decode to AMOMAX_H_RL using decoder 56
6007 // 10076: }
6008 2, 6, // 10080: case 0x2: {
6009 OPC_CheckPredicate, 53, // 10082: check predicate 53
6010 OPC_Decode, 137, 110, 56, // 10084: decode to AMOMAX_W_RL using decoder 56
6011 // 10084: }
6012 3, 0, // 10088: case 0x3: {
6013 OPC_CheckPredicate, 54, // 10090: check predicate 54
6014 OPC_Decode, 129, 110, 56, // 10092: decode to AMOMAX_D_RL using decoder 56
6015 // 10092: }
6016 // 10092: } // switch Inst[14:12]
6017 // 10092: }
6018 82, 35, // 10096: case 0x52: {
6019 OPC_SwitchField, 12, 3, // 10098: switch Inst[14:12] {
6020 0, 6, // 10101: case 0x0: {
6021 OPC_CheckPredicate, 52, // 10103: check predicate 52
6022 OPC_Decode, 251, 109, 56, // 10105: decode to AMOMAX_B_AQ using decoder 56
6023 // 10105: }
6024 1, 6, // 10109: case 0x1: {
6025 OPC_CheckPredicate, 52, // 10111: check predicate 52
6026 OPC_Decode, 131, 110, 56, // 10113: decode to AMOMAX_H_AQ using decoder 56
6027 // 10113: }
6028 2, 6, // 10117: case 0x2: {
6029 OPC_CheckPredicate, 53, // 10119: check predicate 53
6030 OPC_Decode, 135, 110, 56, // 10121: decode to AMOMAX_W_AQ using decoder 56
6031 // 10121: }
6032 3, 0, // 10125: case 0x3: {
6033 OPC_CheckPredicate, 54, // 10127: check predicate 54
6034 OPC_Decode, 255, 109, 56, // 10129: decode to AMOMAX_D_AQ using decoder 56
6035 // 10129: }
6036 // 10129: } // switch Inst[14:12]
6037 // 10129: }
6038 83, 35, // 10133: case 0x53: {
6039 OPC_SwitchField, 12, 3, // 10135: switch Inst[14:12] {
6040 0, 6, // 10138: case 0x0: {
6041 OPC_CheckPredicate, 52, // 10140: check predicate 52
6042 OPC_Decode, 252, 109, 56, // 10142: decode to AMOMAX_B_AQRL using decoder 56
6043 // 10142: }
6044 1, 6, // 10146: case 0x1: {
6045 OPC_CheckPredicate, 52, // 10148: check predicate 52
6046 OPC_Decode, 132, 110, 56, // 10150: decode to AMOMAX_H_AQRL using decoder 56
6047 // 10150: }
6048 2, 6, // 10154: case 0x2: {
6049 OPC_CheckPredicate, 53, // 10156: check predicate 53
6050 OPC_Decode, 136, 110, 56, // 10158: decode to AMOMAX_W_AQRL using decoder 56
6051 // 10158: }
6052 3, 0, // 10162: case 0x3: {
6053 OPC_CheckPredicate, 54, // 10164: check predicate 54
6054 OPC_Decode, 128, 110, 56, // 10166: decode to AMOMAX_D_AQRL using decoder 56
6055 // 10166: }
6056 // 10166: } // switch Inst[14:12]
6057 // 10166: }
6058 96, 35, // 10170: case 0x60: {
6059 OPC_SwitchField, 12, 3, // 10172: switch Inst[14:12] {
6060 0, 6, // 10175: case 0x0: {
6061 OPC_CheckPredicate, 52, // 10177: check predicate 52
6062 OPC_Decode, 138, 110, 56, // 10179: decode to AMOMINU_B using decoder 56
6063 // 10179: }
6064 1, 6, // 10183: case 0x1: {
6065 OPC_CheckPredicate, 52, // 10185: check predicate 52
6066 OPC_Decode, 146, 110, 56, // 10187: decode to AMOMINU_H using decoder 56
6067 // 10187: }
6068 2, 6, // 10191: case 0x2: {
6069 OPC_CheckPredicate, 53, // 10193: check predicate 53
6070 OPC_Decode, 150, 110, 56, // 10195: decode to AMOMINU_W using decoder 56
6071 // 10195: }
6072 3, 0, // 10199: case 0x3: {
6073 OPC_CheckPredicate, 54, // 10201: check predicate 54
6074 OPC_Decode, 142, 110, 56, // 10203: decode to AMOMINU_D using decoder 56
6075 // 10203: }
6076 // 10203: } // switch Inst[14:12]
6077 // 10203: }
6078 97, 35, // 10207: case 0x61: {
6079 OPC_SwitchField, 12, 3, // 10209: switch Inst[14:12] {
6080 0, 6, // 10212: case 0x0: {
6081 OPC_CheckPredicate, 52, // 10214: check predicate 52
6082 OPC_Decode, 141, 110, 56, // 10216: decode to AMOMINU_B_RL using decoder 56
6083 // 10216: }
6084 1, 6, // 10220: case 0x1: {
6085 OPC_CheckPredicate, 52, // 10222: check predicate 52
6086 OPC_Decode, 149, 110, 56, // 10224: decode to AMOMINU_H_RL using decoder 56
6087 // 10224: }
6088 2, 6, // 10228: case 0x2: {
6089 OPC_CheckPredicate, 53, // 10230: check predicate 53
6090 OPC_Decode, 153, 110, 56, // 10232: decode to AMOMINU_W_RL using decoder 56
6091 // 10232: }
6092 3, 0, // 10236: case 0x3: {
6093 OPC_CheckPredicate, 54, // 10238: check predicate 54
6094 OPC_Decode, 145, 110, 56, // 10240: decode to AMOMINU_D_RL using decoder 56
6095 // 10240: }
6096 // 10240: } // switch Inst[14:12]
6097 // 10240: }
6098 98, 35, // 10244: case 0x62: {
6099 OPC_SwitchField, 12, 3, // 10246: switch Inst[14:12] {
6100 0, 6, // 10249: case 0x0: {
6101 OPC_CheckPredicate, 52, // 10251: check predicate 52
6102 OPC_Decode, 139, 110, 56, // 10253: decode to AMOMINU_B_AQ using decoder 56
6103 // 10253: }
6104 1, 6, // 10257: case 0x1: {
6105 OPC_CheckPredicate, 52, // 10259: check predicate 52
6106 OPC_Decode, 147, 110, 56, // 10261: decode to AMOMINU_H_AQ using decoder 56
6107 // 10261: }
6108 2, 6, // 10265: case 0x2: {
6109 OPC_CheckPredicate, 53, // 10267: check predicate 53
6110 OPC_Decode, 151, 110, 56, // 10269: decode to AMOMINU_W_AQ using decoder 56
6111 // 10269: }
6112 3, 0, // 10273: case 0x3: {
6113 OPC_CheckPredicate, 54, // 10275: check predicate 54
6114 OPC_Decode, 143, 110, 56, // 10277: decode to AMOMINU_D_AQ using decoder 56
6115 // 10277: }
6116 // 10277: } // switch Inst[14:12]
6117 // 10277: }
6118 99, 35, // 10281: case 0x63: {
6119 OPC_SwitchField, 12, 3, // 10283: switch Inst[14:12] {
6120 0, 6, // 10286: case 0x0: {
6121 OPC_CheckPredicate, 52, // 10288: check predicate 52
6122 OPC_Decode, 140, 110, 56, // 10290: decode to AMOMINU_B_AQRL using decoder 56
6123 // 10290: }
6124 1, 6, // 10294: case 0x1: {
6125 OPC_CheckPredicate, 52, // 10296: check predicate 52
6126 OPC_Decode, 148, 110, 56, // 10298: decode to AMOMINU_H_AQRL using decoder 56
6127 // 10298: }
6128 2, 6, // 10302: case 0x2: {
6129 OPC_CheckPredicate, 53, // 10304: check predicate 53
6130 OPC_Decode, 152, 110, 56, // 10306: decode to AMOMINU_W_AQRL using decoder 56
6131 // 10306: }
6132 3, 0, // 10310: case 0x3: {
6133 OPC_CheckPredicate, 54, // 10312: check predicate 54
6134 OPC_Decode, 144, 110, 56, // 10314: decode to AMOMINU_D_AQRL using decoder 56
6135 // 10314: }
6136 // 10314: } // switch Inst[14:12]
6137 // 10314: }
6138 104, 59, // 10318: case 0x68: {
6139 OPC_SwitchField, 12, 3, // 10320: switch Inst[14:12] {
6140 0, 6, // 10323: case 0x0: {
6141 OPC_CheckPredicate, 64, // 10325: check predicate 64
6142 OPC_Decode, 252, 116, 56, // 10327: decode to LXSB using decoder 56
6143 // 10327: }
6144 1, 6, // 10331: case 0x1: {
6145 OPC_CheckPredicate, 64, // 10333: check predicate 64
6146 OPC_Decode, 255, 116, 56, // 10335: decode to LXSH using decoder 56
6147 // 10335: }
6148 2, 6, // 10339: case 0x2: {
6149 OPC_CheckPredicate, 64, // 10341: check predicate 64
6150 OPC_Decode, 136, 117, 56, // 10343: decode to LXSW using decoder 56
6151 // 10343: }
6152 3, 6, // 10347: case 0x3: {
6153 OPC_CheckPredicate, 65, // 10349: check predicate 65
6154 OPC_Decode, 254, 116, 56, // 10351: decode to LXSD using decoder 56
6155 // 10351: }
6156 4, 6, // 10355: case 0x4: {
6157 OPC_CheckPredicate, 64, // 10357: check predicate 64
6158 OPC_Decode, 253, 116, 56, // 10359: decode to LXSBU using decoder 56
6159 // 10359: }
6160 5, 6, // 10363: case 0x5: {
6161 OPC_CheckPredicate, 64, // 10365: check predicate 64
6162 OPC_Decode, 128, 117, 56, // 10367: decode to LXSHU using decoder 56
6163 // 10367: }
6164 6, 0, // 10371: case 0x6: {
6165 OPC_CheckPredicate, 65, // 10373: check predicate 65
6166 OPC_Decode, 137, 117, 56, // 10375: decode to LXSWU using decoder 56
6167 // 10375: }
6168 // 10375: } // switch Inst[14:12]
6169 // 10375: }
6170 112, 35, // 10379: case 0x70: {
6171 OPC_SwitchField, 12, 3, // 10381: switch Inst[14:12] {
6172 0, 6, // 10384: case 0x0: {
6173 OPC_CheckPredicate, 52, // 10386: check predicate 52
6174 OPC_Decode, 234, 109, 56, // 10388: decode to AMOMAXU_B using decoder 56
6175 // 10388: }
6176 1, 6, // 10392: case 0x1: {
6177 OPC_CheckPredicate, 52, // 10394: check predicate 52
6178 OPC_Decode, 242, 109, 56, // 10396: decode to AMOMAXU_H using decoder 56
6179 // 10396: }
6180 2, 6, // 10400: case 0x2: {
6181 OPC_CheckPredicate, 53, // 10402: check predicate 53
6182 OPC_Decode, 246, 109, 56, // 10404: decode to AMOMAXU_W using decoder 56
6183 // 10404: }
6184 3, 0, // 10408: case 0x3: {
6185 OPC_CheckPredicate, 54, // 10410: check predicate 54
6186 OPC_Decode, 238, 109, 56, // 10412: decode to AMOMAXU_D using decoder 56
6187 // 10412: }
6188 // 10412: } // switch Inst[14:12]
6189 // 10412: }
6190 113, 35, // 10416: case 0x71: {
6191 OPC_SwitchField, 12, 3, // 10418: switch Inst[14:12] {
6192 0, 6, // 10421: case 0x0: {
6193 OPC_CheckPredicate, 52, // 10423: check predicate 52
6194 OPC_Decode, 237, 109, 56, // 10425: decode to AMOMAXU_B_RL using decoder 56
6195 // 10425: }
6196 1, 6, // 10429: case 0x1: {
6197 OPC_CheckPredicate, 52, // 10431: check predicate 52
6198 OPC_Decode, 245, 109, 56, // 10433: decode to AMOMAXU_H_RL using decoder 56
6199 // 10433: }
6200 2, 6, // 10437: case 0x2: {
6201 OPC_CheckPredicate, 53, // 10439: check predicate 53
6202 OPC_Decode, 249, 109, 56, // 10441: decode to AMOMAXU_W_RL using decoder 56
6203 // 10441: }
6204 3, 0, // 10445: case 0x3: {
6205 OPC_CheckPredicate, 54, // 10447: check predicate 54
6206 OPC_Decode, 241, 109, 56, // 10449: decode to AMOMAXU_D_RL using decoder 56
6207 // 10449: }
6208 // 10449: } // switch Inst[14:12]
6209 // 10449: }
6210 114, 35, // 10453: case 0x72: {
6211 OPC_SwitchField, 12, 3, // 10455: switch Inst[14:12] {
6212 0, 6, // 10458: case 0x0: {
6213 OPC_CheckPredicate, 52, // 10460: check predicate 52
6214 OPC_Decode, 235, 109, 56, // 10462: decode to AMOMAXU_B_AQ using decoder 56
6215 // 10462: }
6216 1, 6, // 10466: case 0x1: {
6217 OPC_CheckPredicate, 52, // 10468: check predicate 52
6218 OPC_Decode, 243, 109, 56, // 10470: decode to AMOMAXU_H_AQ using decoder 56
6219 // 10470: }
6220 2, 6, // 10474: case 0x2: {
6221 OPC_CheckPredicate, 53, // 10476: check predicate 53
6222 OPC_Decode, 247, 109, 56, // 10478: decode to AMOMAXU_W_AQ using decoder 56
6223 // 10478: }
6224 3, 0, // 10482: case 0x3: {
6225 OPC_CheckPredicate, 54, // 10484: check predicate 54
6226 OPC_Decode, 239, 109, 56, // 10486: decode to AMOMAXU_D_AQ using decoder 56
6227 // 10486: }
6228 // 10486: } // switch Inst[14:12]
6229 // 10486: }
6230 115, 35, // 10490: case 0x73: {
6231 OPC_SwitchField, 12, 3, // 10492: switch Inst[14:12] {
6232 0, 6, // 10495: case 0x0: {
6233 OPC_CheckPredicate, 52, // 10497: check predicate 52
6234 OPC_Decode, 236, 109, 56, // 10499: decode to AMOMAXU_B_AQRL using decoder 56
6235 // 10499: }
6236 1, 6, // 10503: case 0x1: {
6237 OPC_CheckPredicate, 52, // 10505: check predicate 52
6238 OPC_Decode, 244, 109, 56, // 10507: decode to AMOMAXU_H_AQRL using decoder 56
6239 // 10507: }
6240 2, 6, // 10511: case 0x2: {
6241 OPC_CheckPredicate, 53, // 10513: check predicate 53
6242 OPC_Decode, 248, 109, 56, // 10515: decode to AMOMAXU_W_AQRL using decoder 56
6243 // 10515: }
6244 3, 0, // 10519: case 0x3: {
6245 OPC_CheckPredicate, 54, // 10521: check predicate 54
6246 OPC_Decode, 240, 109, 56, // 10523: decode to AMOMAXU_D_AQRL using decoder 56
6247 // 10523: }
6248 // 10523: } // switch Inst[14:12]
6249 // 10523: }
6250 120, 0, // 10527: case 0x78: {
6251 OPC_SwitchField, 12, 3, // 10529: switch Inst[14:12] {
6252 0, 6, // 10532: case 0x0: {
6253 OPC_CheckPredicate, 65, // 10534: check predicate 65
6254 OPC_Decode, 129, 117, 56, // 10536: decode to LXSUWB using decoder 56
6255 // 10536: }
6256 1, 6, // 10540: case 0x1: {
6257 OPC_CheckPredicate, 65, // 10542: check predicate 65
6258 OPC_Decode, 132, 117, 56, // 10544: decode to LXSUWH using decoder 56
6259 // 10544: }
6260 2, 6, // 10548: case 0x2: {
6261 OPC_CheckPredicate, 65, // 10550: check predicate 65
6262 OPC_Decode, 134, 117, 56, // 10552: decode to LXSUWW using decoder 56
6263 // 10552: }
6264 3, 6, // 10556: case 0x3: {
6265 OPC_CheckPredicate, 65, // 10558: check predicate 65
6266 OPC_Decode, 131, 117, 56, // 10560: decode to LXSUWD using decoder 56
6267 // 10560: }
6268 4, 6, // 10564: case 0x4: {
6269 OPC_CheckPredicate, 65, // 10566: check predicate 65
6270 OPC_Decode, 130, 117, 56, // 10568: decode to LXSUWBU using decoder 56
6271 // 10568: }
6272 5, 6, // 10572: case 0x5: {
6273 OPC_CheckPredicate, 65, // 10574: check predicate 65
6274 OPC_Decode, 133, 117, 56, // 10576: decode to LXSUWHU using decoder 56
6275 // 10576: }
6276 6, 0, // 10580: case 0x6: {
6277 OPC_CheckPredicate, 65, // 10582: check predicate 65
6278 OPC_Decode, 135, 117, 56, // 10584: decode to LXSUWWU using decoder 56
6279 // 10584: }
6280 // 10584: } // switch Inst[14:12]
6281 // 10584: }
6282 // 10584: } // switch Inst[31:25]
6283 // 10584: }
6284 51, 138, 6, // 10588: case 0x33: {
6285 OPC_SwitchField, 25, 5, // 10591: switch Inst[29:25] {
6286 0, 126, // 10594: case 0x0: {
6287 OPC_SwitchField, 12, 3, // 10596: switch Inst[14:12] {
6288 0, 15, // 10599: case 0x0: {
6289 OPC_SwitchField, 30, 2, // 10601: switch Inst[31:30] {
6290 0, 4, // 10604: case 0x0: {
6291 OPC_Decode, 204, 107, 31, // 10606: decode to ADD using decoder 31
6292 // 10606: }
6293 1, 0, // 10610: case 0x1: {
6294 OPC_Decode, 147, 125, 31, // 10612: decode to SUB using decoder 31
6295 // 10612: }
6296 // 10612: } // switch Inst[31:30]
6297 // 10612: }
6298 1, 8, // 10616: case 0x1: {
6299 OPC_CheckField, 30, 2, 0, // 10618: check Inst[31:30] == 0x0
6300 OPC_Decode, 214, 124, 31, // 10622: decode to SLL using decoder 31
6301 // 10622: }
6302 2, 8, // 10626: case 0x2: {
6303 OPC_CheckField, 30, 2, 0, // 10628: check Inst[31:30] == 0x0
6304 OPC_Decode, 219, 124, 31, // 10632: decode to SLT using decoder 31
6305 // 10632: }
6306 3, 8, // 10636: case 0x3: {
6307 OPC_CheckField, 30, 2, 0, // 10638: check Inst[31:30] == 0x0
6308 OPC_Decode, 222, 124, 31, // 10642: decode to SLTU using decoder 31
6309 // 10642: }
6310 4, 19, // 10646: case 0x4: {
6311 OPC_SwitchField, 30, 2, // 10648: switch Inst[31:30] {
6312 0, 5, // 10651: case 0x0: {
6313 OPC_Decode, 159, 132, 1, 31, // 10653: decode to XOR using decoder 31
6314 // 10653: }
6315 1, 0, // 10658: case 0x1: {
6316 OPC_CheckPredicate, 44, // 10660: check predicate 44
6317 OPC_Decode, 158, 132, 1, 31, // 10662: decode to XNOR using decoder 31
6318 // 10662: }
6319 // 10662: } // switch Inst[31:30]
6320 // 10662: }
6321 5, 15, // 10667: case 0x5: {
6322 OPC_SwitchField, 30, 2, // 10669: switch Inst[31:30] {
6323 0, 4, // 10672: case 0x0: {
6324 OPC_Decode, 251, 124, 31, // 10674: decode to SRL using decoder 31
6325 // 10674: }
6326 1, 0, // 10678: case 0x1: {
6327 OPC_Decode, 244, 124, 31, // 10680: decode to SRA using decoder 31
6328 // 10680: }
6329 // 10680: } // switch Inst[31:30]
6330 // 10680: }
6331 6, 17, // 10684: case 0x6: {
6332 OPC_SwitchField, 30, 2, // 10686: switch Inst[31:30] {
6333 0, 4, // 10689: case 0x0: {
6334 OPC_Decode, 207, 118, 31, // 10691: decode to OR using decoder 31
6335 // 10691: }
6336 1, 0, // 10695: case 0x1: {
6337 OPC_CheckPredicate, 44, // 10697: check predicate 44
6338 OPC_Decode, 210, 118, 31, // 10699: decode to ORN using decoder 31
6339 // 10699: }
6340 // 10699: } // switch Inst[31:30]
6341 // 10699: }
6342 7, 0, // 10703: case 0x7: {
6343 OPC_SwitchField, 30, 2, // 10705: switch Inst[31:30] {
6344 0, 4, // 10708: case 0x0: {
6345 OPC_Decode, 218, 110, 31, // 10710: decode to AND using decoder 31
6346 // 10710: }
6347 1, 0, // 10714: case 0x1: {
6348 OPC_CheckPredicate, 44, // 10716: check predicate 44
6349 OPC_Decode, 220, 110, 31, // 10718: decode to ANDN using decoder 31
6350 // 10718: }
6351 // 10718: } // switch Inst[31:30]
6352 // 10718: }
6353 // 10718: } // switch Inst[14:12]
6354 // 10718: }
6355 1, 99, // 10722: case 0x1: {
6356 OPC_SwitchField, 12, 3, // 10724: switch Inst[14:12] {
6357 0, 10, // 10727: case 0x0: {
6358 OPC_CheckPredicate, 66, // 10729: check predicate 66
6359 OPC_CheckField, 30, 2, 0, // 10731: check Inst[31:30] == 0x0
6360 OPC_Decode, 242, 117, 31, // 10735: decode to MUL using decoder 31
6361 // 10735: }
6362 1, 10, // 10739: case 0x1: {
6363 OPC_CheckPredicate, 66, // 10741: check predicate 66
6364 OPC_CheckField, 30, 2, 0, // 10743: check Inst[31:30] == 0x0
6365 OPC_Decode, 243, 117, 31, // 10747: decode to MULH using decoder 31
6366 // 10747: }
6367 2, 10, // 10751: case 0x2: {
6368 OPC_CheckPredicate, 66, // 10753: check predicate 66
6369 OPC_CheckField, 30, 2, 0, // 10755: check Inst[31:30] == 0x0
6370 OPC_Decode, 247, 117, 31, // 10759: decode to MULHSU using decoder 31
6371 // 10759: }
6372 3, 10, // 10763: case 0x3: {
6373 OPC_CheckPredicate, 66, // 10765: check predicate 66
6374 OPC_CheckField, 30, 2, 0, // 10767: check Inst[31:30] == 0x0
6375 OPC_Decode, 250, 117, 31, // 10771: decode to MULHU using decoder 31
6376 // 10771: }
6377 4, 10, // 10775: case 0x4: {
6378 OPC_CheckPredicate, 67, // 10777: check predicate 67
6379 OPC_CheckField, 30, 2, 0, // 10779: check Inst[31:30] == 0x0
6380 OPC_Decode, 146, 114, 31, // 10783: decode to DIV using decoder 31
6381 // 10783: }
6382 5, 10, // 10787: case 0x5: {
6383 OPC_CheckPredicate, 67, // 10789: check predicate 67
6384 OPC_CheckField, 30, 2, 0, // 10791: check Inst[31:30] == 0x0
6385 OPC_Decode, 147, 114, 31, // 10795: decode to DIVU using decoder 31
6386 // 10795: }
6387 6, 10, // 10799: case 0x6: {
6388 OPC_CheckPredicate, 67, // 10801: check predicate 67
6389 OPC_CheckField, 30, 2, 0, // 10803: check Inst[31:30] == 0x0
6390 OPC_Decode, 202, 123, 31, // 10807: decode to REM using decoder 31
6391 // 10807: }
6392 7, 0, // 10811: case 0x7: {
6393 OPC_CheckPredicate, 67, // 10813: check predicate 67
6394 OPC_CheckField, 30, 2, 0, // 10815: check Inst[31:30] == 0x0
6395 OPC_Decode, 203, 123, 31, // 10819: decode to REMU using decoder 31
6396 // 10819: }
6397 // 10819: } // switch Inst[14:12]
6398 // 10819: }
6399 4, 64, // 10823: case 0x4: {
6400 OPC_SwitchField, 12, 3, // 10825: switch Inst[14:12] {
6401 1, 10, // 10828: case 0x1: {
6402 OPC_CheckPredicate, 39, // 10830: check predicate 39
6403 OPC_CheckField, 30, 2, 1, // 10832: check Inst[31:30] == 0x1
6404 OPC_Decode, 224, 110, 31, // 10836: decode to BCLR using decoder 31
6405 // 10836: }
6406 4, 23, // 10840: case 0x4: {
6407 OPC_CheckField, 30, 2, 0, // 10842: check Inst[31:30] == 0x0
6408 OPC_Scope, 11, // 10846: try {
6409 OPC_CheckField, 20, 5, 0, // 10848: check Inst[24:20] == 0x0
6410 OPC_CheckPredicate, 46, // 10852: check predicate 46
6411 OPC_Decode, 185, 132, 1, 17, // 10854: decode to ZEXT_H_RV32 using decoder 17
6412 // 10854: } else try {
6413 OPC_CheckPredicate, 68, // 10859: check predicate 68
6414 OPC_Decode, 236, 118, 31, // 10861: decode to PACK using decoder 31
6415 // 10861: }
6416 // 10861: }
6417 5, 10, // 10865: case 0x5: {
6418 OPC_CheckPredicate, 39, // 10867: check predicate 39
6419 OPC_CheckField, 30, 2, 1, // 10869: check Inst[31:30] == 0x1
6420 OPC_Decode, 228, 110, 31, // 10873: decode to BEXT using decoder 31
6421 // 10873: }
6422 7, 0, // 10877: case 0x7: {
6423 OPC_CheckPredicate, 45, // 10879: check predicate 45
6424 OPC_CheckField, 30, 2, 0, // 10881: check Inst[31:30] == 0x0
6425 OPC_Decode, 237, 118, 31, // 10885: decode to PACKH using decoder 31
6426 // 10885: }
6427 // 10885: } // switch Inst[14:12]
6428 // 10885: }
6429 5, 87, // 10889: case 0x5: {
6430 OPC_SwitchField, 12, 3, // 10891: switch Inst[14:12] {
6431 1, 10, // 10894: case 0x1: {
6432 OPC_CheckPredicate, 69, // 10896: check predicate 69
6433 OPC_CheckField, 30, 2, 0, // 10898: check Inst[31:30] == 0x0
6434 OPC_Decode, 245, 110, 31, // 10902: decode to CLMUL using decoder 31
6435 // 10902: }
6436 2, 10, // 10906: case 0x2: {
6437 OPC_CheckPredicate, 70, // 10908: check predicate 70
6438 OPC_CheckField, 30, 2, 0, // 10910: check Inst[31:30] == 0x0
6439 OPC_Decode, 247, 110, 31, // 10914: decode to CLMULR using decoder 31
6440 // 10914: }
6441 3, 10, // 10918: case 0x3: {
6442 OPC_CheckPredicate, 69, // 10920: check predicate 69
6443 OPC_CheckField, 30, 2, 0, // 10922: check Inst[31:30] == 0x0
6444 OPC_Decode, 246, 110, 31, // 10926: decode to CLMULH using decoder 31
6445 // 10926: }
6446 4, 10, // 10930: case 0x4: {
6447 OPC_CheckPredicate, 42, // 10932: check predicate 42
6448 OPC_CheckField, 30, 2, 0, // 10934: check Inst[31:30] == 0x0
6449 OPC_Decode, 171, 117, 31, // 10938: decode to MIN using decoder 31
6450 // 10938: }
6451 5, 10, // 10942: case 0x5: {
6452 OPC_CheckPredicate, 42, // 10944: check predicate 42
6453 OPC_CheckField, 30, 2, 0, // 10946: check Inst[31:30] == 0x0
6454 OPC_Decode, 172, 117, 31, // 10950: decode to MINU using decoder 31
6455 // 10950: }
6456 6, 10, // 10954: case 0x6: {
6457 OPC_CheckPredicate, 42, // 10956: check predicate 42
6458 OPC_CheckField, 30, 2, 0, // 10958: check Inst[31:30] == 0x0
6459 OPC_Decode, 156, 117, 31, // 10962: decode to MAX using decoder 31
6460 // 10962: }
6461 7, 0, // 10966: case 0x7: {
6462 OPC_CheckPredicate, 42, // 10968: check predicate 42
6463 OPC_CheckField, 30, 2, 0, // 10970: check Inst[31:30] == 0x0
6464 OPC_Decode, 157, 117, 31, // 10974: decode to MAXU using decoder 31
6465 // 10974: }
6466 // 10974: } // switch Inst[14:12]
6467 // 10974: }
6468 7, 27, // 10978: case 0x7: {
6469 OPC_SwitchField, 12, 3, // 10980: switch Inst[14:12] {
6470 5, 10, // 10983: case 0x5: {
6471 OPC_CheckPredicate, 71, // 10985: check predicate 71
6472 OPC_CheckField, 30, 2, 0, // 10987: check Inst[31:30] == 0x0
6473 OPC_Decode, 198, 113, 31, // 10991: decode to CZERO_EQZ using decoder 31
6474 // 10991: }
6475 7, 0, // 10995: case 0x7: {
6476 OPC_CheckPredicate, 71, // 10997: check predicate 71
6477 OPC_CheckField, 30, 2, 0, // 10999: check Inst[31:30] == 0x0
6478 OPC_Decode, 199, 113, 31, // 11003: decode to CZERO_NEZ using decoder 31
6479 // 11003: }
6480 // 11003: } // switch Inst[14:12]
6481 // 11003: }
6482 8, 14, // 11007: case 0x8: {
6483 OPC_CheckPredicate, 72, // 11009: check predicate 72
6484 OPC_CheckField, 30, 2, 1, // 11011: check Inst[31:30] == 0x1
6485 OPC_CheckField, 12, 3, 0, // 11015: check Inst[14:12] == 0x0
6486 OPC_Decode, 203, 124, 31, // 11019: decode to SHA512SUM0R using decoder 31
6487 // 11019: }
6488 9, 14, // 11023: case 0x9: {
6489 OPC_CheckPredicate, 72, // 11025: check predicate 72
6490 OPC_CheckField, 30, 2, 1, // 11027: check Inst[31:30] == 0x1
6491 OPC_CheckField, 12, 3, 0, // 11031: check Inst[14:12] == 0x0
6492 OPC_Decode, 205, 124, 31, // 11035: decode to SHA512SUM1R using decoder 31
6493 // 11035: }
6494 10, 14, // 11039: case 0xa: {
6495 OPC_CheckPredicate, 72, // 11041: check predicate 72
6496 OPC_CheckField, 30, 2, 1, // 11043: check Inst[31:30] == 0x1
6497 OPC_CheckField, 12, 3, 0, // 11047: check Inst[14:12] == 0x0
6498 OPC_Decode, 198, 124, 31, // 11051: decode to SHA512SIG0L using decoder 31
6499 // 11051: }
6500 11, 14, // 11055: case 0xb: {
6501 OPC_CheckPredicate, 72, // 11057: check predicate 72
6502 OPC_CheckField, 30, 2, 1, // 11059: check Inst[31:30] == 0x1
6503 OPC_CheckField, 12, 3, 0, // 11063: check Inst[14:12] == 0x0
6504 OPC_Decode, 201, 124, 31, // 11067: decode to SHA512SIG1L using decoder 31
6505 // 11067: }
6506 14, 14, // 11071: case 0xe: {
6507 OPC_CheckPredicate, 72, // 11073: check predicate 72
6508 OPC_CheckField, 30, 2, 1, // 11075: check Inst[31:30] == 0x1
6509 OPC_CheckField, 12, 3, 0, // 11079: check Inst[14:12] == 0x0
6510 OPC_Decode, 197, 124, 31, // 11083: decode to SHA512SIG0H using decoder 31
6511 // 11083: }
6512 15, 14, // 11087: case 0xf: {
6513 OPC_CheckPredicate, 72, // 11089: check predicate 72
6514 OPC_CheckField, 30, 2, 1, // 11091: check Inst[31:30] == 0x1
6515 OPC_CheckField, 12, 3, 0, // 11095: check Inst[14:12] == 0x0
6516 OPC_Decode, 200, 124, 31, // 11099: decode to SHA512SIG1H using decoder 31
6517 // 11099: }
6518 16, 63, // 11103: case 0x10: {
6519 OPC_SwitchField, 12, 3, // 11105: switch Inst[14:12] {
6520 1, 10, // 11108: case 0x1: {
6521 OPC_CheckPredicate, 44, // 11110: check predicate 44
6522 OPC_CheckField, 30, 2, 1, // 11112: check Inst[31:30] == 0x1
6523 OPC_Decode, 211, 123, 31, // 11116: decode to ROL using decoder 31
6524 // 11116: }
6525 2, 10, // 11120: case 0x2: {
6526 OPC_CheckPredicate, 73, // 11122: check predicate 73
6527 OPC_CheckField, 30, 2, 0, // 11124: check Inst[31:30] == 0x0
6528 OPC_Decode, 185, 124, 31, // 11128: decode to SH1ADD using decoder 31
6529 // 11128: }
6530 4, 10, // 11132: case 0x4: {
6531 OPC_CheckPredicate, 73, // 11134: check predicate 73
6532 OPC_CheckField, 30, 2, 0, // 11136: check Inst[31:30] == 0x0
6533 OPC_Decode, 187, 124, 31, // 11140: decode to SH2ADD using decoder 31
6534 // 11140: }
6535 5, 10, // 11144: case 0x5: {
6536 OPC_CheckPredicate, 44, // 11146: check predicate 44
6537 OPC_CheckField, 30, 2, 1, // 11148: check Inst[31:30] == 0x1
6538 OPC_Decode, 213, 123, 31, // 11152: decode to ROR using decoder 31
6539 // 11152: }
6540 6, 0, // 11156: case 0x6: {
6541 OPC_CheckPredicate, 73, // 11158: check predicate 73
6542 OPC_CheckField, 30, 2, 0, // 11160: check Inst[31:30] == 0x0
6543 OPC_Decode, 189, 124, 31, // 11164: decode to SH3ADD using decoder 31
6544 // 11164: }
6545 // 11164: } // switch Inst[14:12]
6546 // 11164: }
6547 17, 10, // 11168: case 0x11: {
6548 OPC_CheckPredicate, 74, // 11170: check predicate 74
6549 OPC_CheckField, 12, 3, 0, // 11172: check Inst[14:12] == 0x0
6550 OPC_Decode, 212, 107, 60, // 11176: decode to AES32ESI using decoder 60
6551 // 11176: }
6552 19, 10, // 11180: case 0x13: {
6553 OPC_CheckPredicate, 74, // 11182: check predicate 74
6554 OPC_CheckField, 12, 3, 0, // 11184: check Inst[14:12] == 0x0
6555 OPC_Decode, 213, 107, 60, // 11188: decode to AES32ESMI using decoder 60
6556 // 11188: }
6557 20, 50, // 11192: case 0x14: {
6558 OPC_SwitchField, 12, 3, // 11194: switch Inst[14:12] {
6559 1, 19, // 11197: case 0x1: {
6560 OPC_SwitchField, 30, 2, // 11199: switch Inst[31:30] {
6561 0, 6, // 11202: case 0x0: {
6562 OPC_CheckPredicate, 39, // 11204: check predicate 39
6563 OPC_Decode, 239, 110, 31, // 11206: decode to BSET using decoder 31
6564 // 11206: }
6565 1, 0, // 11210: case 0x1: {
6566 OPC_CheckPredicate, 39, // 11212: check predicate 39
6567 OPC_Decode, 232, 110, 31, // 11214: decode to BINV using decoder 31
6568 // 11214: }
6569 // 11214: } // switch Inst[31:30]
6570 // 11214: }
6571 2, 11, // 11218: case 0x2: {
6572 OPC_CheckPredicate, 75, // 11220: check predicate 75
6573 OPC_CheckField, 30, 2, 0, // 11222: check Inst[31:30] == 0x0
6574 OPC_Decode, 161, 132, 1, 31, // 11226: decode to XPERM4 using decoder 31
6575 // 11226: }
6576 4, 0, // 11231: case 0x4: {
6577 OPC_CheckPredicate, 75, // 11233: check predicate 75
6578 OPC_CheckField, 30, 2, 0, // 11235: check Inst[31:30] == 0x0
6579 OPC_Decode, 162, 132, 1, 31, // 11239: decode to XPERM8 using decoder 31
6580 // 11239: }
6581 // 11239: } // switch Inst[14:12]
6582 // 11239: }
6583 21, 10, // 11244: case 0x15: {
6584 OPC_CheckPredicate, 76, // 11246: check predicate 76
6585 OPC_CheckField, 12, 3, 0, // 11248: check Inst[14:12] == 0x0
6586 OPC_Decode, 210, 107, 60, // 11252: decode to AES32DSI using decoder 60
6587 // 11252: }
6588 23, 10, // 11256: case 0x17: {
6589 OPC_CheckPredicate, 76, // 11258: check predicate 76
6590 OPC_CheckField, 12, 3, 0, // 11260: check Inst[14:12] == 0x0
6591 OPC_Decode, 211, 107, 60, // 11264: decode to AES32DSMI using decoder 60
6592 // 11264: }
6593 24, 10, // 11268: case 0x18: {
6594 OPC_CheckPredicate, 77, // 11270: check predicate 77
6595 OPC_CheckField, 12, 3, 0, // 11272: check Inst[14:12] == 0x0
6596 OPC_Decode, 226, 124, 60, // 11276: decode to SM4ED using decoder 60
6597 // 11276: }
6598 25, 14, // 11280: case 0x19: {
6599 OPC_CheckPredicate, 78, // 11282: check predicate 78
6600 OPC_CheckField, 30, 2, 0, // 11284: check Inst[31:30] == 0x0
6601 OPC_CheckField, 12, 3, 0, // 11288: check Inst[14:12] == 0x0
6602 OPC_Decode, 216, 107, 31, // 11292: decode to AES64ES using decoder 31
6603 // 11292: }
6604 26, 10, // 11296: case 0x1a: {
6605 OPC_CheckPredicate, 77, // 11298: check predicate 77
6606 OPC_CheckField, 12, 3, 0, // 11300: check Inst[14:12] == 0x0
6607 OPC_Decode, 227, 124, 60, // 11304: decode to SM4KS using decoder 60
6608 // 11304: }
6609 27, 14, // 11308: case 0x1b: {
6610 OPC_CheckPredicate, 78, // 11310: check predicate 78
6611 OPC_CheckField, 30, 2, 0, // 11312: check Inst[31:30] == 0x0
6612 OPC_CheckField, 12, 3, 0, // 11316: check Inst[14:12] == 0x0
6613 OPC_Decode, 217, 107, 31, // 11320: decode to AES64ESM using decoder 31
6614 // 11320: }
6615 29, 14, // 11324: case 0x1d: {
6616 OPC_CheckPredicate, 40, // 11326: check predicate 40
6617 OPC_CheckField, 30, 2, 0, // 11328: check Inst[31:30] == 0x0
6618 OPC_CheckField, 12, 3, 0, // 11332: check Inst[14:12] == 0x0
6619 OPC_Decode, 214, 107, 31, // 11336: decode to AES64DS using decoder 31
6620 // 11336: }
6621 31, 0, // 11340: case 0x1f: {
6622 OPC_SwitchField, 30, 2, // 11342: switch Inst[31:30] {
6623 0, 10, // 11345: case 0x0: {
6624 OPC_CheckPredicate, 40, // 11347: check predicate 40
6625 OPC_CheckField, 12, 3, 0, // 11349: check Inst[14:12] == 0x0
6626 OPC_Decode, 215, 107, 31, // 11353: decode to AES64DSM using decoder 31
6627 // 11353: }
6628 1, 0, // 11357: case 0x1: {
6629 OPC_CheckPredicate, 41, // 11359: check predicate 41
6630 OPC_CheckField, 12, 3, 0, // 11361: check Inst[14:12] == 0x0
6631 OPC_Decode, 220, 107, 31, // 11365: decode to AES64KS2 using decoder 31
6632 // 11365: }
6633 // 11365: } // switch Inst[31:30]
6634 // 11365: }
6635 // 11365: } // switch Inst[29:25]
6636 // 11365: }
6637 55, 4, // 11369: case 0x37: {
6638 OPC_Decode, 243, 116, 20, // 11371: decode to LUI using decoder 20
6639 // 11371: }
6640 59, 155, 19, // 11375: case 0x3b: {
6641 OPC_SwitchField, 25, 7, // 11378: switch Inst[31:25] {
6642 0, 27, // 11381: case 0x0: {
6643 OPC_SwitchField, 12, 3, // 11383: switch Inst[14:12] {
6644 0, 6, // 11386: case 0x0: {
6645 OPC_CheckPredicate, 22, // 11388: check predicate 22
6646 OPC_Decode, 208, 107, 31, // 11390: decode to ADDW using decoder 31
6647 // 11390: }
6648 1, 6, // 11394: case 0x1: {
6649 OPC_CheckPredicate, 22, // 11396: check predicate 22
6650 OPC_Decode, 218, 124, 31, // 11398: decode to SLLW using decoder 31
6651 // 11398: }
6652 5, 0, // 11402: case 0x5: {
6653 OPC_CheckPredicate, 22, // 11404: check predicate 22
6654 OPC_Decode, 254, 124, 31, // 11406: decode to SRLW using decoder 31
6655 // 11406: }
6656 // 11406: } // switch Inst[14:12]
6657 // 11406: }
6658 1, 43, // 11410: case 0x1: {
6659 OPC_SwitchField, 12, 3, // 11412: switch Inst[14:12] {
6660 0, 6, // 11415: case 0x0: {
6661 OPC_CheckPredicate, 79, // 11417: check predicate 79
6662 OPC_Decode, 137, 118, 31, // 11419: decode to MULW using decoder 31
6663 // 11419: }
6664 4, 6, // 11423: case 0x4: {
6665 OPC_CheckPredicate, 80, // 11425: check predicate 80
6666 OPC_Decode, 149, 114, 31, // 11427: decode to DIVW using decoder 31
6667 // 11427: }
6668 5, 6, // 11431: case 0x5: {
6669 OPC_CheckPredicate, 80, // 11433: check predicate 80
6670 OPC_Decode, 148, 114, 31, // 11435: decode to DIVUW using decoder 31
6671 // 11435: }
6672 6, 6, // 11439: case 0x6: {
6673 OPC_CheckPredicate, 80, // 11441: check predicate 80
6674 OPC_Decode, 205, 123, 31, // 11443: decode to REMW using decoder 31
6675 // 11443: }
6676 7, 0, // 11447: case 0x7: {
6677 OPC_CheckPredicate, 80, // 11449: check predicate 80
6678 OPC_Decode, 204, 123, 31, // 11451: decode to REMUW using decoder 31
6679 // 11451: }
6680 // 11451: } // switch Inst[14:12]
6681 // 11451: }
6682 4, 32, // 11455: case 0x4: {
6683 OPC_SwitchField, 12, 3, // 11457: switch Inst[14:12] {
6684 0, 6, // 11460: case 0x0: {
6685 OPC_CheckPredicate, 50, // 11462: check predicate 50
6686 OPC_Decode, 209, 107, 31, // 11464: decode to ADD_UW using decoder 31
6687 // 11464: }
6688 4, 0, // 11468: case 0x4: {
6689 OPC_Scope, 11, // 11470: try {
6690 OPC_CheckField, 20, 5, 0, // 11472: check Inst[24:20] == 0x0
6691 OPC_CheckPredicate, 49, // 11476: check predicate 49
6692 OPC_Decode, 186, 132, 1, 17, // 11478: decode to ZEXT_H_RV64 using decoder 17
6693 // 11478: } else try {
6694 OPC_CheckPredicate, 81, // 11483: check predicate 81
6695 OPC_Decode, 238, 118, 31, // 11485: decode to PACKW using decoder 31
6696 // 11485: }
6697 // 11485: }
6698 // 11485: } // switch Inst[14:12]
6699 // 11485: }
6700 16, 27, // 11489: case 0x10: {
6701 OPC_SwitchField, 12, 3, // 11491: switch Inst[14:12] {
6702 2, 6, // 11494: case 0x2: {
6703 OPC_CheckPredicate, 50, // 11496: check predicate 50
6704 OPC_Decode, 186, 124, 31, // 11498: decode to SH1ADD_UW using decoder 31
6705 // 11498: }
6706 4, 6, // 11502: case 0x4: {
6707 OPC_CheckPredicate, 50, // 11504: check predicate 50
6708 OPC_Decode, 188, 124, 31, // 11506: decode to SH2ADD_UW using decoder 31
6709 // 11506: }
6710 6, 0, // 11510: case 0x6: {
6711 OPC_CheckPredicate, 50, // 11512: check predicate 50
6712 OPC_Decode, 190, 124, 31, // 11514: decode to SH3ADD_UW using decoder 31
6713 // 11514: }
6714 // 11514: } // switch Inst[14:12]
6715 // 11514: }
6716 32, 19, // 11518: case 0x20: {
6717 OPC_SwitchField, 12, 3, // 11520: switch Inst[14:12] {
6718 0, 6, // 11523: case 0x0: {
6719 OPC_CheckPredicate, 22, // 11525: check predicate 22
6720 OPC_Decode, 149, 125, 31, // 11527: decode to SUBW using decoder 31
6721 // 11527: }
6722 5, 0, // 11531: case 0x5: {
6723 OPC_CheckPredicate, 22, // 11533: check predicate 22
6724 OPC_Decode, 249, 124, 31, // 11535: decode to SRAW using decoder 31
6725 // 11535: }
6726 // 11535: } // switch Inst[14:12]
6727 // 11535: }
6728 48, 19, // 11539: case 0x30: {
6729 OPC_SwitchField, 12, 3, // 11541: switch Inst[14:12] {
6730 1, 6, // 11544: case 0x1: {
6731 OPC_CheckPredicate, 49, // 11546: check predicate 49
6732 OPC_Decode, 212, 123, 31, // 11548: decode to ROLW using decoder 31
6733 // 11548: }
6734 5, 0, // 11552: case 0x5: {
6735 OPC_CheckPredicate, 49, // 11554: check predicate 49
6736 OPC_Decode, 216, 123, 31, // 11556: decode to RORW using decoder 31
6737 // 11556: }
6738 // 11556: } // switch Inst[14:12]
6739 // 11556: }
6740 64, 59, // 11560: case 0x40: {
6741 OPC_SwitchField, 12, 3, // 11562: switch Inst[14:12] {
6742 0, 6, // 11565: case 0x0: {
6743 OPC_CheckPredicate, 43, // 11567: check predicate 43
6744 OPC_Decode, 247, 118, 31, // 11569: decode to PADD_H using decoder 31
6745 // 11569: }
6746 2, 6, // 11573: case 0x2: {
6747 OPC_CheckPredicate, 48, // 11575: check predicate 48
6748 OPC_Decode, 212, 120, 31, // 11577: decode to PNCLIPUP_B using decoder 31
6749 // 11577: }
6750 3, 6, // 11581: case 0x3: {
6751 OPC_CheckPredicate, 43, // 11583: check predicate 43
6752 OPC_Decode, 191, 120, 31, // 11585: decode to PMUL_H_B00 using decoder 31
6753 // 11585: }
6754 4, 6, // 11589: case 0x4: {
6755 OPC_CheckPredicate, 43, // 11591: check predicate 43
6756 OPC_Decode, 236, 120, 31, // 11593: decode to PPAIRE_B using decoder 31
6757 // 11593: }
6758 5, 6, // 11597: case 0x5: {
6759 OPC_CheckPredicate, 43, // 11599: check predicate 43
6760 OPC_Decode, 161, 119, 31, // 11601: decode to PM2ADD_H using decoder 31
6761 // 11601: }
6762 6, 6, // 11605: case 0x6: {
6763 OPC_CheckPredicate, 43, // 11607: check predicate 43
6764 OPC_Decode, 139, 119, 31, // 11609: decode to PAS_HX using decoder 31
6765 // 11609: }
6766 7, 0, // 11613: case 0x7: {
6767 OPC_CheckPredicate, 43, // 11615: check predicate 43
6768 OPC_Decode, 171, 120, 31, // 11617: decode to PMULH_H using decoder 31
6769 // 11617: }
6770 // 11617: } // switch Inst[14:12]
6771 // 11617: }
6772 65, 59, // 11621: case 0x41: {
6773 OPC_SwitchField, 12, 3, // 11623: switch Inst[14:12] {
6774 0, 6, // 11626: case 0x0: {
6775 OPC_CheckPredicate, 48, // 11628: check predicate 48
6776 OPC_Decode, 249, 118, 31, // 11630: decode to PADD_W using decoder 31
6777 // 11630: }
6778 2, 6, // 11634: case 0x2: {
6779 OPC_CheckPredicate, 48, // 11636: check predicate 48
6780 OPC_Decode, 213, 120, 31, // 11638: decode to PNCLIPUP_H using decoder 31
6781 // 11638: }
6782 3, 6, // 11642: case 0x3: {
6783 OPC_CheckPredicate, 48, // 11644: check predicate 48
6784 OPC_Decode, 194, 120, 31, // 11646: decode to PMUL_W_H00 using decoder 31
6785 // 11646: }
6786 4, 6, // 11650: case 0x4: {
6787 OPC_CheckPredicate, 48, // 11652: check predicate 48
6788 OPC_Decode, 239, 120, 31, // 11654: decode to PPAIRE_H using decoder 31
6789 // 11654: }
6790 5, 6, // 11658: case 0x5: {
6791 OPC_CheckPredicate, 48, // 11660: check predicate 48
6792 OPC_Decode, 163, 119, 31, // 11662: decode to PM2ADD_W using decoder 31
6793 // 11662: }
6794 6, 6, // 11666: case 0x6: {
6795 OPC_CheckPredicate, 48, // 11668: check predicate 48
6796 OPC_Decode, 140, 119, 31, // 11670: decode to PAS_WX using decoder 31
6797 // 11670: }
6798 7, 0, // 11674: case 0x7: {
6799 OPC_CheckPredicate, 48, // 11676: check predicate 48
6800 OPC_Decode, 174, 120, 31, // 11678: decode to PMULH_W using decoder 31
6801 // 11678: }
6802 // 11678: } // switch Inst[14:12]
6803 // 11678: }
6804 66, 35, // 11682: case 0x42: {
6805 OPC_SwitchField, 12, 3, // 11684: switch Inst[14:12] {
6806 0, 6, // 11687: case 0x0: {
6807 OPC_CheckPredicate, 43, // 11689: check predicate 43
6808 OPC_Decode, 239, 118, 31, // 11691: decode to PADD_B using decoder 31
6809 // 11691: }
6810 5, 6, // 11695: case 0x5: {
6811 OPC_CheckPredicate, 43, // 11697: check predicate 43
6812 OPC_Decode, 197, 119, 31, // 11699: decode to PM4ADD_B using decoder 31
6813 // 11699: }
6814 6, 6, // 11703: case 0x6: {
6815 OPC_CheckPredicate, 43, // 11705: check predicate 43
6816 OPC_Decode, 159, 121, 31, // 11707: decode to PSA_HX using decoder 31
6817 // 11707: }
6818 7, 0, // 11711: case 0x7: {
6819 OPC_CheckPredicate, 43, // 11713: check predicate 43
6820 OPC_Decode, 161, 120, 31, // 11715: decode to PMULHR_H using decoder 31
6821 // 11715: }
6822 // 11715: } // switch Inst[14:12]
6823 // 11715: }
6824 67, 43, // 11719: case 0x43: {
6825 OPC_SwitchField, 12, 3, // 11721: switch Inst[14:12] {
6826 2, 6, // 11724: case 0x2: {
6827 OPC_CheckPredicate, 48, // 11726: check predicate 48
6828 OPC_Decode, 214, 120, 31, // 11728: decode to PNCLIPUP_W using decoder 31
6829 // 11728: }
6830 3, 6, // 11732: case 0x3: {
6831 OPC_CheckPredicate, 48, // 11734: check predicate 48
6832 OPC_Decode, 141, 118, 31, // 11736: decode to MUL_W00 using decoder 31
6833 // 11736: }
6834 5, 6, // 11740: case 0x5: {
6835 OPC_CheckPredicate, 48, // 11742: check predicate 48
6836 OPC_Decode, 198, 119, 31, // 11744: decode to PM4ADD_H using decoder 31
6837 // 11744: }
6838 6, 6, // 11748: case 0x6: {
6839 OPC_CheckPredicate, 48, // 11750: check predicate 48
6840 OPC_Decode, 160, 121, 31, // 11752: decode to PSA_WX using decoder 31
6841 // 11752: }
6842 7, 0, // 11756: case 0x7: {
6843 OPC_CheckPredicate, 48, // 11758: check predicate 48
6844 OPC_Decode, 162, 120, 31, // 11760: decode to PMULHR_W using decoder 31
6845 // 11760: }
6846 // 11760: } // switch Inst[14:12]
6847 // 11760: }
6848 68, 19, // 11764: case 0x44: {
6849 OPC_SwitchField, 12, 3, // 11766: switch Inst[14:12] {
6850 5, 6, // 11769: case 0x5: {
6851 OPC_CheckPredicate, 43, // 11771: check predicate 43
6852 OPC_Decode, 153, 119, 61, // 11773: decode to PM2ADDA_H using decoder 61
6853 // 11773: }
6854 7, 0, // 11777: case 0x7: {
6855 OPC_CheckPredicate, 43, // 11779: check predicate 43
6856 OPC_Decode, 227, 119, 61, // 11781: decode to PMHACC_H using decoder 61
6857 // 11781: }
6858 // 11781: } // switch Inst[14:12]
6859 // 11781: }
6860 69, 27, // 11785: case 0x45: {
6861 OPC_SwitchField, 12, 3, // 11787: switch Inst[14:12] {
6862 3, 6, // 11790: case 0x3: {
6863 OPC_CheckPredicate, 48, // 11792: check predicate 48
6864 OPC_Decode, 204, 119, 61, // 11794: decode to PMACC_W_H00 using decoder 61
6865 // 11794: }
6866 5, 6, // 11798: case 0x5: {
6867 OPC_CheckPredicate, 48, // 11800: check predicate 48
6868 OPC_Decode, 155, 119, 61, // 11802: decode to PM2ADDA_W using decoder 61
6869 // 11802: }
6870 7, 0, // 11806: case 0x7: {
6871 OPC_CheckPredicate, 48, // 11808: check predicate 48
6872 OPC_Decode, 230, 119, 61, // 11810: decode to PMHACC_W using decoder 61
6873 // 11810: }
6874 // 11810: } // switch Inst[14:12]
6875 // 11810: }
6876 70, 19, // 11814: case 0x46: {
6877 OPC_SwitchField, 12, 3, // 11816: switch Inst[14:12] {
6878 5, 6, // 11819: case 0x5: {
6879 OPC_CheckPredicate, 43, // 11821: check predicate 43
6880 OPC_Decode, 191, 119, 61, // 11823: decode to PM4ADDA_B using decoder 61
6881 // 11823: }
6882 7, 0, // 11827: case 0x7: {
6883 OPC_CheckPredicate, 43, // 11829: check predicate 43
6884 OPC_Decode, 237, 119, 61, // 11831: decode to PMHRACC_H using decoder 61
6885 // 11831: }
6886 // 11831: } // switch Inst[14:12]
6887 // 11831: }
6888 71, 35, // 11835: case 0x47: {
6889 OPC_SwitchField, 12, 3, // 11837: switch Inst[14:12] {
6890 1, 6, // 11840: case 0x1: {
6891 OPC_CheckPredicate, 43, // 11842: check predicate 43
6892 OPC_Decode, 223, 124, 61, // 11844: decode to SLX using decoder 61
6893 // 11844: }
6894 3, 6, // 11848: case 0x3: {
6895 OPC_CheckPredicate, 48, // 11850: check predicate 48
6896 OPC_Decode, 153, 117, 61, // 11852: decode to MACC_W00 using decoder 61
6897 // 11852: }
6898 5, 6, // 11856: case 0x5: {
6899 OPC_CheckPredicate, 48, // 11858: check predicate 48
6900 OPC_Decode, 192, 119, 61, // 11860: decode to PM4ADDA_H using decoder 61
6901 // 11860: }
6902 7, 0, // 11864: case 0x7: {
6903 OPC_CheckPredicate, 48, // 11866: check predicate 48
6904 OPC_Decode, 238, 119, 61, // 11868: decode to PMHRACC_W using decoder 61
6905 // 11868: }
6906 // 11868: } // switch Inst[14:12]
6907 // 11868: }
6908 72, 59, // 11872: case 0x48: {
6909 OPC_SwitchField, 12, 3, // 11874: switch Inst[14:12] {
6910 0, 6, // 11877: case 0x0: {
6911 OPC_CheckPredicate, 43, // 11879: check predicate 43
6912 OPC_Decode, 149, 121, 31, // 11881: decode to PSADD_H using decoder 31
6913 // 11881: }
6914 1, 6, // 11885: case 0x1: {
6915 OPC_CheckPredicate, 43, // 11887: check predicate 43
6916 OPC_Decode, 192, 120, 31, // 11889: decode to PMUL_H_B01 using decoder 31
6917 // 11889: }
6918 3, 6, // 11893: case 0x3: {
6919 OPC_CheckPredicate, 43, // 11895: check predicate 43
6920 OPC_Decode, 193, 120, 31, // 11897: decode to PMUL_H_B11 using decoder 31
6921 // 11897: }
6922 4, 6, // 11901: case 0x4: {
6923 OPC_CheckPredicate, 43, // 11903: check predicate 43
6924 OPC_Decode, 231, 120, 31, // 11905: decode to PPAIREO_B using decoder 31
6925 // 11905: }
6926 5, 6, // 11909: case 0x5: {
6927 OPC_CheckPredicate, 43, // 11911: check predicate 43
6928 OPC_Decode, 162, 119, 31, // 11913: decode to PM2ADD_HX using decoder 31
6929 // 11913: }
6930 6, 6, // 11917: case 0x6: {
6931 OPC_CheckPredicate, 43, // 11919: check predicate 43
6932 OPC_Decode, 152, 121, 31, // 11921: decode to PSAS_HX using decoder 31
6933 // 11921: }
6934 7, 0, // 11925: case 0x7: {
6935 OPC_CheckPredicate, 43, // 11927: check predicate 43
6936 OPC_Decode, 169, 120, 31, // 11929: decode to PMULHU_H using decoder 31
6937 // 11929: }
6938 // 11929: } // switch Inst[14:12]
6939 // 11929: }
6940 73, 59, // 11933: case 0x49: {
6941 OPC_SwitchField, 12, 3, // 11935: switch Inst[14:12] {
6942 0, 6, // 11938: case 0x0: {
6943 OPC_CheckPredicate, 48, // 11940: check predicate 48
6944 OPC_Decode, 150, 121, 31, // 11942: decode to PSADD_W using decoder 31
6945 // 11942: }
6946 1, 6, // 11946: case 0x1: {
6947 OPC_CheckPredicate, 48, // 11948: check predicate 48
6948 OPC_Decode, 195, 120, 31, // 11950: decode to PMUL_W_H01 using decoder 31
6949 // 11950: }
6950 3, 6, // 11954: case 0x3: {
6951 OPC_CheckPredicate, 48, // 11956: check predicate 48
6952 OPC_Decode, 196, 120, 31, // 11958: decode to PMUL_W_H11 using decoder 31
6953 // 11958: }
6954 4, 6, // 11962: case 0x4: {
6955 OPC_CheckPredicate, 43, // 11964: check predicate 43
6956 OPC_Decode, 234, 120, 31, // 11966: decode to PPAIREO_H using decoder 31
6957 // 11966: }
6958 5, 6, // 11970: case 0x5: {
6959 OPC_CheckPredicate, 48, // 11972: check predicate 48
6960 OPC_Decode, 164, 119, 31, // 11974: decode to PM2ADD_WX using decoder 31
6961 // 11974: }
6962 6, 6, // 11978: case 0x6: {
6963 OPC_CheckPredicate, 48, // 11980: check predicate 48
6964 OPC_Decode, 153, 121, 31, // 11982: decode to PSAS_WX using decoder 31
6965 // 11982: }
6966 7, 0, // 11986: case 0x7: {
6967 OPC_CheckPredicate, 48, // 11988: check predicate 48
6968 OPC_Decode, 170, 120, 31, // 11990: decode to PMULHU_W using decoder 31
6969 // 11990: }
6970 // 11990: } // switch Inst[14:12]
6971 // 11990: }
6972 74, 27, // 11994: case 0x4a: {
6973 OPC_SwitchField, 12, 3, // 11996: switch Inst[14:12] {
6974 0, 6, // 11999: case 0x0: {
6975 OPC_CheckPredicate, 43, // 12001: check predicate 43
6976 OPC_Decode, 145, 121, 31, // 12003: decode to PSADD_B using decoder 31
6977 // 12003: }
6978 6, 6, // 12007: case 0x6: {
6979 OPC_CheckPredicate, 43, // 12009: check predicate 43
6980 OPC_Decode, 212, 121, 31, // 12011: decode to PSSA_HX using decoder 31
6981 // 12011: }
6982 7, 0, // 12015: case 0x7: {
6983 OPC_CheckPredicate, 43, // 12017: check predicate 43
6984 OPC_Decode, 159, 120, 31, // 12019: decode to PMULHRU_H using decoder 31
6985 // 12019: }
6986 // 12019: } // switch Inst[14:12]
6987 // 12019: }
6988 75, 43, // 12023: case 0x4b: {
6989 OPC_SwitchField, 12, 3, // 12025: switch Inst[14:12] {
6990 1, 6, // 12028: case 0x1: {
6991 OPC_CheckPredicate, 48, // 12030: check predicate 48
6992 OPC_Decode, 142, 118, 31, // 12032: decode to MUL_W01 using decoder 31
6993 // 12032: }
6994 3, 6, // 12036: case 0x3: {
6995 OPC_CheckPredicate, 48, // 12038: check predicate 48
6996 OPC_Decode, 143, 118, 31, // 12040: decode to MUL_W11 using decoder 31
6997 // 12040: }
6998 4, 6, // 12044: case 0x4: {
6999 OPC_CheckPredicate, 48, // 12046: check predicate 48
7000 OPC_Decode, 235, 120, 31, // 12048: decode to PPAIREO_W using decoder 31
7001 // 12048: }
7002 6, 6, // 12052: case 0x6: {
7003 OPC_CheckPredicate, 48, // 12054: check predicate 48
7004 OPC_Decode, 213, 121, 31, // 12056: decode to PSSA_WX using decoder 31
7005 // 12056: }
7006 7, 0, // 12060: case 0x7: {
7007 OPC_CheckPredicate, 48, // 12062: check predicate 48
7008 OPC_Decode, 160, 120, 31, // 12064: decode to PMULHRU_W using decoder 31
7009 // 12064: }
7010 // 12064: } // switch Inst[14:12]
7011 // 12064: }
7012 76, 35, // 12068: case 0x4c: {
7013 OPC_SwitchField, 12, 3, // 12070: switch Inst[14:12] {
7014 0, 6, // 12073: case 0x0: {
7015 OPC_CheckPredicate, 43, // 12075: check predicate 43
7016 OPC_Decode, 221, 118, 31, // 12077: decode to PAADD_H using decoder 31
7017 // 12077: }
7018 5, 6, // 12081: case 0x5: {
7019 OPC_CheckPredicate, 43, // 12083: check predicate 43
7020 OPC_Decode, 154, 119, 61, // 12085: decode to PM2ADDA_HX using decoder 61
7021 // 12085: }
7022 6, 6, // 12089: case 0x6: {
7023 OPC_CheckPredicate, 43, // 12091: check predicate 43
7024 OPC_Decode, 224, 118, 31, // 12093: decode to PAAS_HX using decoder 31
7025 // 12093: }
7026 7, 0, // 12097: case 0x7: {
7027 OPC_CheckPredicate, 43, // 12099: check predicate 43
7028 OPC_Decode, 225, 119, 61, // 12101: decode to PMHACCU_H using decoder 61
7029 // 12101: }
7030 // 12101: } // switch Inst[14:12]
7031 // 12101: }
7032 77, 51, // 12105: case 0x4d: {
7033 OPC_SwitchField, 12, 3, // 12107: switch Inst[14:12] {
7034 0, 6, // 12110: case 0x0: {
7035 OPC_CheckPredicate, 48, // 12112: check predicate 48
7036 OPC_Decode, 222, 118, 31, // 12114: decode to PAADD_W using decoder 31
7037 // 12114: }
7038 1, 6, // 12118: case 0x1: {
7039 OPC_CheckPredicate, 48, // 12120: check predicate 48
7040 OPC_Decode, 205, 119, 61, // 12122: decode to PMACC_W_H01 using decoder 61
7041 // 12122: }
7042 3, 6, // 12126: case 0x3: {
7043 OPC_CheckPredicate, 48, // 12128: check predicate 48
7044 OPC_Decode, 206, 119, 61, // 12130: decode to PMACC_W_H11 using decoder 61
7045 // 12130: }
7046 5, 6, // 12134: case 0x5: {
7047 OPC_CheckPredicate, 48, // 12136: check predicate 48
7048 OPC_Decode, 156, 119, 61, // 12138: decode to PM2ADDA_WX using decoder 61
7049 // 12138: }
7050 6, 6, // 12142: case 0x6: {
7051 OPC_CheckPredicate, 48, // 12144: check predicate 48
7052 OPC_Decode, 225, 118, 31, // 12146: decode to PAAS_WX using decoder 31
7053 // 12146: }
7054 7, 0, // 12150: case 0x7: {
7055 OPC_CheckPredicate, 48, // 12152: check predicate 48
7056 OPC_Decode, 226, 119, 61, // 12154: decode to PMHACCU_W using decoder 61
7057 // 12154: }
7058 // 12154: } // switch Inst[14:12]
7059 // 12154: }
7060 78, 27, // 12158: case 0x4e: {
7061 OPC_SwitchField, 12, 3, // 12160: switch Inst[14:12] {
7062 0, 6, // 12163: case 0x0: {
7063 OPC_CheckPredicate, 43, // 12165: check predicate 43
7064 OPC_Decode, 217, 118, 31, // 12167: decode to PAADD_B using decoder 31
7065 // 12167: }
7066 6, 6, // 12171: case 0x6: {
7067 OPC_CheckPredicate, 43, // 12173: check predicate 43
7068 OPC_Decode, 252, 118, 31, // 12175: decode to PASA_HX using decoder 31
7069 // 12175: }
7070 7, 0, // 12179: case 0x7: {
7071 OPC_CheckPredicate, 43, // 12181: check predicate 43
7072 OPC_Decode, 235, 119, 61, // 12183: decode to PMHRACCU_H using decoder 61
7073 // 12183: }
7074 // 12183: } // switch Inst[14:12]
7075 // 12183: }
7076 79, 35, // 12187: case 0x4f: {
7077 OPC_SwitchField, 12, 3, // 12189: switch Inst[14:12] {
7078 1, 6, // 12192: case 0x1: {
7079 OPC_CheckPredicate, 48, // 12194: check predicate 48
7080 OPC_Decode, 154, 117, 61, // 12196: decode to MACC_W01 using decoder 61
7081 // 12196: }
7082 3, 6, // 12200: case 0x3: {
7083 OPC_CheckPredicate, 48, // 12202: check predicate 48
7084 OPC_Decode, 155, 117, 61, // 12204: decode to MACC_W11 using decoder 61
7085 // 12204: }
7086 6, 6, // 12208: case 0x6: {
7087 OPC_CheckPredicate, 48, // 12210: check predicate 48
7088 OPC_Decode, 253, 118, 31, // 12212: decode to PASA_WX using decoder 31
7089 // 12212: }
7090 7, 0, // 12216: case 0x7: {
7091 OPC_CheckPredicate, 48, // 12218: check predicate 48
7092 OPC_Decode, 236, 119, 61, // 12220: decode to PMHRACCU_W using decoder 61
7093 // 12220: }
7094 // 12220: } // switch Inst[14:12]
7095 // 12220: }
7096 80, 43, // 12224: case 0x50: {
7097 OPC_SwitchField, 12, 3, // 12226: switch Inst[14:12] {
7098 2, 6, // 12229: case 0x2: {
7099 OPC_CheckPredicate, 43, // 12231: check predicate 43
7100 OPC_Decode, 169, 121, 31, // 12233: decode to PSH1ADD_H using decoder 31
7101 // 12233: }
7102 3, 6, // 12237: case 0x3: {
7103 OPC_CheckPredicate, 43, // 12239: check predicate 43
7104 OPC_Decode, 185, 120, 31, // 12241: decode to PMULU_H_B00 using decoder 31
7105 // 12241: }
7106 4, 6, // 12245: case 0x4: {
7107 OPC_CheckPredicate, 43, // 12247: check predicate 43
7108 OPC_Decode, 240, 120, 31, // 12249: decode to PPAIROE_B using decoder 31
7109 // 12249: }
7110 5, 6, // 12253: case 0x5: {
7111 OPC_CheckPredicate, 43, // 12255: check predicate 43
7112 OPC_Decode, 159, 119, 31, // 12257: decode to PM2ADDU_H using decoder 31
7113 // 12257: }
7114 7, 0, // 12261: case 0x7: {
7115 OPC_CheckPredicate, 43, // 12263: check predicate 43
7116 OPC_Decode, 172, 120, 31, // 12265: decode to PMULH_H_B0 using decoder 31
7117 // 12265: }
7118 // 12265: } // switch Inst[14:12]
7119 // 12265: }
7120 81, 43, // 12269: case 0x51: {
7121 OPC_SwitchField, 12, 3, // 12271: switch Inst[14:12] {
7122 2, 6, // 12274: case 0x2: {
7123 OPC_CheckPredicate, 48, // 12276: check predicate 48
7124 OPC_Decode, 170, 121, 31, // 12278: decode to PSH1ADD_W using decoder 31
7125 // 12278: }
7126 3, 6, // 12282: case 0x3: {
7127 OPC_CheckPredicate, 48, // 12284: check predicate 48
7128 OPC_Decode, 188, 120, 31, // 12286: decode to PMULU_W_H00 using decoder 31
7129 // 12286: }
7130 4, 6, // 12290: case 0x4: {
7131 OPC_CheckPredicate, 43, // 12292: check predicate 43
7132 OPC_Decode, 243, 120, 31, // 12294: decode to PPAIROE_H using decoder 31
7133 // 12294: }
7134 5, 6, // 12298: case 0x5: {
7135 OPC_CheckPredicate, 48, // 12300: check predicate 48
7136 OPC_Decode, 160, 119, 31, // 12302: decode to PM2ADDU_W using decoder 31
7137 // 12302: }
7138 7, 0, // 12306: case 0x7: {
7139 OPC_CheckPredicate, 48, // 12308: check predicate 48
7140 OPC_Decode, 175, 120, 31, // 12310: decode to PMULH_W_H0 using decoder 31
7141 // 12310: }
7142 // 12310: } // switch Inst[14:12]
7143 // 12310: }
7144 82, 19, // 12314: case 0x52: {
7145 OPC_SwitchField, 12, 3, // 12316: switch Inst[14:12] {
7146 5, 6, // 12319: case 0x5: {
7147 OPC_CheckPredicate, 43, // 12321: check predicate 43
7148 OPC_Decode, 195, 119, 31, // 12323: decode to PM4ADDU_B using decoder 31
7149 // 12323: }
7150 7, 0, // 12327: case 0x7: {
7151 OPC_CheckPredicate, 43, // 12329: check predicate 43
7152 OPC_Decode, 164, 120, 31, // 12331: decode to PMULHSU_H_B0 using decoder 31
7153 // 12331: }
7154 // 12331: } // switch Inst[14:12]
7155 // 12331: }
7156 83, 35, // 12335: case 0x53: {
7157 OPC_SwitchField, 12, 3, // 12337: switch Inst[14:12] {
7158 3, 6, // 12340: case 0x3: {
7159 OPC_CheckPredicate, 48, // 12342: check predicate 48
7160 OPC_Decode, 134, 118, 31, // 12344: decode to MULU_W00 using decoder 31
7161 // 12344: }
7162 4, 6, // 12348: case 0x4: {
7163 OPC_CheckPredicate, 48, // 12350: check predicate 48
7164 OPC_Decode, 244, 120, 31, // 12352: decode to PPAIROE_W using decoder 31
7165 // 12352: }
7166 5, 6, // 12356: case 0x5: {
7167 OPC_CheckPredicate, 48, // 12358: check predicate 48
7168 OPC_Decode, 196, 119, 31, // 12360: decode to PM4ADDU_H using decoder 31
7169 // 12360: }
7170 7, 0, // 12364: case 0x7: {
7171 OPC_CheckPredicate, 48, // 12366: check predicate 48
7172 OPC_Decode, 167, 120, 31, // 12368: decode to PMULHSU_W_H0 using decoder 31
7173 // 12368: }
7174 // 12368: } // switch Inst[14:12]
7175 // 12368: }
7176 84, 27, // 12372: case 0x54: {
7177 OPC_SwitchField, 12, 3, // 12374: switch Inst[14:12] {
7178 1, 6, // 12377: case 0x1: {
7179 OPC_CheckPredicate, 43, // 12379: check predicate 43
7180 OPC_Decode, 144, 118, 61, // 12381: decode to MVM using decoder 61
7181 // 12381: }
7182 5, 6, // 12385: case 0x5: {
7183 OPC_CheckPredicate, 43, // 12387: check predicate 43
7184 OPC_Decode, 151, 119, 61, // 12389: decode to PM2ADDAU_H using decoder 61
7185 // 12389: }
7186 7, 0, // 12393: case 0x7: {
7187 OPC_CheckPredicate, 43, // 12395: check predicate 43
7188 OPC_Decode, 228, 119, 61, // 12397: decode to PMHACC_H_B0 using decoder 61
7189 // 12397: }
7190 // 12397: } // switch Inst[14:12]
7191 // 12397: }
7192 85, 35, // 12401: case 0x55: {
7193 OPC_SwitchField, 12, 3, // 12403: switch Inst[14:12] {
7194 1, 6, // 12406: case 0x1: {
7195 OPC_CheckPredicate, 43, // 12408: check predicate 43
7196 OPC_Decode, 145, 118, 61, // 12410: decode to MVMN using decoder 61
7197 // 12410: }
7198 3, 6, // 12414: case 0x3: {
7199 OPC_CheckPredicate, 48, // 12416: check predicate 48
7200 OPC_Decode, 201, 119, 61, // 12418: decode to PMACCU_W_H00 using decoder 61
7201 // 12418: }
7202 5, 6, // 12422: case 0x5: {
7203 OPC_CheckPredicate, 48, // 12424: check predicate 48
7204 OPC_Decode, 152, 119, 61, // 12426: decode to PM2ADDAU_W using decoder 61
7205 // 12426: }
7206 7, 0, // 12430: case 0x7: {
7207 OPC_CheckPredicate, 48, // 12432: check predicate 48
7208 OPC_Decode, 231, 119, 61, // 12434: decode to PMHACC_W_H0 using decoder 61
7209 // 12434: }
7210 // 12434: } // switch Inst[14:12]
7211 // 12434: }
7212 86, 27, // 12438: case 0x56: {
7213 OPC_SwitchField, 12, 3, // 12440: switch Inst[14:12] {
7214 1, 6, // 12443: case 0x1: {
7215 OPC_CheckPredicate, 43, // 12445: check predicate 43
7216 OPC_Decode, 160, 117, 61, // 12447: decode to MERGE using decoder 61
7217 // 12447: }
7218 5, 6, // 12451: case 0x5: {
7219 OPC_CheckPredicate, 43, // 12453: check predicate 43
7220 OPC_Decode, 189, 119, 61, // 12455: decode to PM4ADDAU_B using decoder 61
7221 // 12455: }
7222 7, 0, // 12459: case 0x7: {
7223 OPC_CheckPredicate, 43, // 12461: check predicate 43
7224 OPC_Decode, 220, 119, 61, // 12463: decode to PMHACCSU_H_B0 using decoder 61
7225 // 12463: }
7226 // 12463: } // switch Inst[14:12]
7227 // 12463: }
7228 87, 35, // 12467: case 0x57: {
7229 OPC_SwitchField, 12, 3, // 12469: switch Inst[14:12] {
7230 1, 6, // 12472: case 0x1: {
7231 OPC_CheckPredicate, 43, // 12474: check predicate 43
7232 OPC_Decode, 255, 124, 61, // 12476: decode to SRX using decoder 61
7233 // 12476: }
7234 3, 6, // 12480: case 0x3: {
7235 OPC_CheckPredicate, 48, // 12482: check predicate 48
7236 OPC_Decode, 147, 117, 61, // 12484: decode to MACCU_W00 using decoder 61
7237 // 12484: }
7238 5, 6, // 12488: case 0x5: {
7239 OPC_CheckPredicate, 48, // 12490: check predicate 48
7240 OPC_Decode, 190, 119, 61, // 12492: decode to PM4ADDAU_H using decoder 61
7241 // 12492: }
7242 7, 0, // 12496: case 0x7: {
7243 OPC_CheckPredicate, 48, // 12498: check predicate 48
7244 OPC_Decode, 223, 119, 61, // 12500: decode to PMHACCSU_W_H0 using decoder 61
7245 // 12500: }
7246 // 12500: } // switch Inst[14:12]
7247 // 12500: }
7248 88, 59, // 12504: case 0x58: {
7249 OPC_SwitchField, 12, 3, // 12506: switch Inst[14:12] {
7250 0, 6, // 12509: case 0x0: {
7251 OPC_CheckPredicate, 43, // 12511: check predicate 43
7252 OPC_Decode, 143, 121, 31, // 12513: decode to PSADDU_H using decoder 31
7253 // 12513: }
7254 1, 6, // 12517: case 0x1: {
7255 OPC_CheckPredicate, 43, // 12519: check predicate 43
7256 OPC_Decode, 186, 120, 31, // 12521: decode to PMULU_H_B01 using decoder 31
7257 // 12521: }
7258 2, 6, // 12525: case 0x2: {
7259 OPC_CheckPredicate, 43, // 12527: check predicate 43
7260 OPC_Decode, 216, 121, 31, // 12529: decode to PSSH1SADD_H using decoder 31
7261 // 12529: }
7262 3, 6, // 12533: case 0x3: {
7263 OPC_CheckPredicate, 43, // 12535: check predicate 43
7264 OPC_Decode, 187, 120, 31, // 12537: decode to PMULU_H_B11 using decoder 31
7265 // 12537: }
7266 4, 6, // 12541: case 0x4: {
7267 OPC_CheckPredicate, 43, // 12543: check predicate 43
7268 OPC_Decode, 245, 120, 31, // 12545: decode to PPAIRO_B using decoder 31
7269 // 12545: }
7270 5, 6, // 12549: case 0x5: {
7271 OPC_CheckPredicate, 43, // 12551: check predicate 43
7272 OPC_Decode, 253, 119, 31, // 12553: decode to PMQ2ADD_H using decoder 31
7273 // 12553: }
7274 7, 0, // 12557: case 0x7: {
7275 OPC_CheckPredicate, 43, // 12559: check predicate 43
7276 OPC_Decode, 173, 120, 31, // 12561: decode to PMULH_H_B1 using decoder 31
7277 // 12561: }
7278 // 12561: } // switch Inst[14:12]
7279 // 12561: }
7280 89, 59, // 12565: case 0x59: {
7281 OPC_SwitchField, 12, 3, // 12567: switch Inst[14:12] {
7282 0, 6, // 12570: case 0x0: {
7283 OPC_CheckPredicate, 48, // 12572: check predicate 48
7284 OPC_Decode, 144, 121, 31, // 12574: decode to PSADDU_W using decoder 31
7285 // 12574: }
7286 1, 6, // 12578: case 0x1: {
7287 OPC_CheckPredicate, 48, // 12580: check predicate 48
7288 OPC_Decode, 189, 120, 31, // 12582: decode to PMULU_W_H01 using decoder 31
7289 // 12582: }
7290 2, 6, // 12586: case 0x2: {
7291 OPC_CheckPredicate, 48, // 12588: check predicate 48
7292 OPC_Decode, 217, 121, 31, // 12590: decode to PSSH1SADD_W using decoder 31
7293 // 12590: }
7294 3, 6, // 12594: case 0x3: {
7295 OPC_CheckPredicate, 48, // 12596: check predicate 48
7296 OPC_Decode, 190, 120, 31, // 12598: decode to PMULU_W_H11 using decoder 31
7297 // 12598: }
7298 4, 6, // 12602: case 0x4: {
7299 OPC_CheckPredicate, 43, // 12604: check predicate 43
7300 OPC_Decode, 248, 120, 31, // 12606: decode to PPAIRO_H using decoder 31
7301 // 12606: }
7302 5, 6, // 12610: case 0x5: {
7303 OPC_CheckPredicate, 48, // 12612: check predicate 48
7304 OPC_Decode, 254, 119, 31, // 12614: decode to PMQ2ADD_W using decoder 31
7305 // 12614: }
7306 7, 0, // 12618: case 0x7: {
7307 OPC_CheckPredicate, 48, // 12620: check predicate 48
7308 OPC_Decode, 176, 120, 31, // 12622: decode to PMULH_W_H1 using decoder 31
7309 // 12622: }
7310 // 12622: } // switch Inst[14:12]
7311 // 12622: }
7312 90, 35, // 12626: case 0x5a: {
7313 OPC_SwitchField, 12, 3, // 12628: switch Inst[14:12] {
7314 0, 6, // 12631: case 0x0: {
7315 OPC_CheckPredicate, 43, // 12633: check predicate 43
7316 OPC_Decode, 139, 121, 31, // 12635: decode to PSADDU_B using decoder 31
7317 // 12635: }
7318 1, 6, // 12639: case 0x1: {
7319 OPC_CheckPredicate, 43, // 12641: check predicate 43
7320 OPC_Decode, 227, 118, 31, // 12643: decode to PABDSUMU_B using decoder 31
7321 // 12643: }
7322 5, 6, // 12647: case 0x5: {
7323 OPC_CheckPredicate, 43, // 12649: check predicate 43
7324 OPC_Decode, 132, 120, 31, // 12651: decode to PMQR2ADD_H using decoder 31
7325 // 12651: }
7326 7, 0, // 12655: case 0x7: {
7327 OPC_CheckPredicate, 43, // 12657: check predicate 43
7328 OPC_Decode, 165, 120, 31, // 12659: decode to PMULHSU_H_B1 using decoder 31
7329 // 12659: }
7330 // 12659: } // switch Inst[14:12]
7331 // 12659: }
7332 91, 43, // 12663: case 0x5b: {
7333 OPC_SwitchField, 12, 3, // 12665: switch Inst[14:12] {
7334 1, 6, // 12668: case 0x1: {
7335 OPC_CheckPredicate, 48, // 12670: check predicate 48
7336 OPC_Decode, 135, 118, 31, // 12672: decode to MULU_W01 using decoder 31
7337 // 12672: }
7338 3, 6, // 12676: case 0x3: {
7339 OPC_CheckPredicate, 48, // 12678: check predicate 48
7340 OPC_Decode, 136, 118, 31, // 12680: decode to MULU_W11 using decoder 31
7341 // 12680: }
7342 4, 6, // 12684: case 0x4: {
7343 OPC_CheckPredicate, 48, // 12686: check predicate 48
7344 OPC_Decode, 249, 120, 31, // 12688: decode to PPAIRO_W using decoder 31
7345 // 12688: }
7346 5, 6, // 12692: case 0x5: {
7347 OPC_CheckPredicate, 48, // 12694: check predicate 48
7348 OPC_Decode, 133, 120, 31, // 12696: decode to PMQR2ADD_W using decoder 31
7349 // 12696: }
7350 7, 0, // 12700: case 0x7: {
7351 OPC_CheckPredicate, 48, // 12702: check predicate 48
7352 OPC_Decode, 168, 120, 31, // 12704: decode to PMULHSU_W_H1 using decoder 31
7353 // 12704: }
7354 // 12704: } // switch Inst[14:12]
7355 // 12704: }
7356 92, 27, // 12708: case 0x5c: {
7357 OPC_SwitchField, 12, 3, // 12710: switch Inst[14:12] {
7358 0, 6, // 12713: case 0x0: {
7359 OPC_CheckPredicate, 43, // 12715: check predicate 43
7360 OPC_Decode, 215, 118, 31, // 12717: decode to PAADDU_H using decoder 31
7361 // 12717: }
7362 5, 6, // 12721: case 0x5: {
7363 OPC_CheckPredicate, 43, // 12723: check predicate 43
7364 OPC_Decode, 251, 119, 61, // 12725: decode to PMQ2ADDA_H using decoder 61
7365 // 12725: }
7366 7, 0, // 12729: case 0x7: {
7367 OPC_CheckPredicate, 43, // 12731: check predicate 43
7368 OPC_Decode, 229, 119, 61, // 12733: decode to PMHACC_H_B1 using decoder 61
7369 // 12733: }
7370 // 12733: } // switch Inst[14:12]
7371 // 12733: }
7372 93, 43, // 12737: case 0x5d: {
7373 OPC_SwitchField, 12, 3, // 12739: switch Inst[14:12] {
7374 0, 6, // 12742: case 0x0: {
7375 OPC_CheckPredicate, 48, // 12744: check predicate 48
7376 OPC_Decode, 216, 118, 31, // 12746: decode to PAADDU_W using decoder 31
7377 // 12746: }
7378 1, 6, // 12750: case 0x1: {
7379 OPC_CheckPredicate, 48, // 12752: check predicate 48
7380 OPC_Decode, 202, 119, 61, // 12754: decode to PMACCU_W_H01 using decoder 61
7381 // 12754: }
7382 3, 6, // 12758: case 0x3: {
7383 OPC_CheckPredicate, 48, // 12760: check predicate 48
7384 OPC_Decode, 203, 119, 61, // 12762: decode to PMACCU_W_H11 using decoder 61
7385 // 12762: }
7386 5, 6, // 12766: case 0x5: {
7387 OPC_CheckPredicate, 48, // 12768: check predicate 48
7388 OPC_Decode, 252, 119, 61, // 12770: decode to PMQ2ADDA_W using decoder 61
7389 // 12770: }
7390 7, 0, // 12774: case 0x7: {
7391 OPC_CheckPredicate, 48, // 12776: check predicate 48
7392 OPC_Decode, 232, 119, 61, // 12778: decode to PMHACC_W_H1 using decoder 61
7393 // 12778: }
7394 // 12778: } // switch Inst[14:12]
7395 // 12778: }
7396 94, 35, // 12782: case 0x5e: {
7397 OPC_SwitchField, 12, 3, // 12784: switch Inst[14:12] {
7398 0, 6, // 12787: case 0x0: {
7399 OPC_CheckPredicate, 43, // 12789: check predicate 43
7400 OPC_Decode, 211, 118, 31, // 12791: decode to PAADDU_B using decoder 31
7401 // 12791: }
7402 1, 6, // 12795: case 0x1: {
7403 OPC_CheckPredicate, 43, // 12797: check predicate 43
7404 OPC_Decode, 226, 118, 61, // 12799: decode to PABDSUMAU_B using decoder 61
7405 // 12799: }
7406 5, 6, // 12803: case 0x5: {
7407 OPC_CheckPredicate, 43, // 12805: check predicate 43
7408 OPC_Decode, 130, 120, 61, // 12807: decode to PMQR2ADDA_H using decoder 61
7409 // 12807: }
7410 7, 0, // 12811: case 0x7: {
7411 OPC_CheckPredicate, 43, // 12813: check predicate 43
7412 OPC_Decode, 221, 119, 61, // 12815: decode to PMHACCSU_H_B1 using decoder 61
7413 // 12815: }
7414 // 12815: } // switch Inst[14:12]
7415 // 12815: }
7416 95, 35, // 12819: case 0x5f: {
7417 OPC_SwitchField, 12, 3, // 12821: switch Inst[14:12] {
7418 1, 6, // 12824: case 0x1: {
7419 OPC_CheckPredicate, 48, // 12826: check predicate 48
7420 OPC_Decode, 148, 117, 61, // 12828: decode to MACCU_W01 using decoder 61
7421 // 12828: }
7422 3, 6, // 12832: case 0x3: {
7423 OPC_CheckPredicate, 48, // 12834: check predicate 48
7424 OPC_Decode, 149, 117, 61, // 12836: decode to MACCU_W11 using decoder 61
7425 // 12836: }
7426 5, 6, // 12840: case 0x5: {
7427 OPC_CheckPredicate, 48, // 12842: check predicate 48
7428 OPC_Decode, 131, 120, 61, // 12844: decode to PMQR2ADDA_W using decoder 61
7429 // 12844: }
7430 7, 0, // 12848: case 0x7: {
7431 OPC_CheckPredicate, 48, // 12850: check predicate 48
7432 OPC_Decode, 224, 119, 61, // 12852: decode to PMHACCSU_W_H1 using decoder 61
7433 // 12852: }
7434 // 12852: } // switch Inst[14:12]
7435 // 12852: }
7436 96, 43, // 12856: case 0x60: {
7437 OPC_SwitchField, 12, 3, // 12858: switch Inst[14:12] {
7438 0, 6, // 12861: case 0x0: {
7439 OPC_CheckPredicate, 43, // 12863: check predicate 43
7440 OPC_Decode, 254, 121, 31, // 12865: decode to PSUB_H using decoder 31
7441 // 12865: }
7442 2, 6, // 12869: case 0x2: {
7443 OPC_CheckPredicate, 48, // 12871: check predicate 48
7444 OPC_Decode, 201, 120, 31, // 12873: decode to PNCLIPP_B using decoder 31
7445 // 12873: }
7446 5, 6, // 12877: case 0x5: {
7447 OPC_CheckPredicate, 43, // 12879: check predicate 43
7448 OPC_Decode, 171, 119, 31, // 12881: decode to PM2SUB_H using decoder 31
7449 // 12881: }
7450 6, 6, // 12885: case 0x6: {
7451 OPC_CheckPredicate, 43, // 12887: check predicate 43
7452 OPC_Decode, 143, 120, 31, // 12889: decode to PMSEQ_H using decoder 31
7453 // 12889: }
7454 7, 0, // 12893: case 0x7: {
7455 OPC_CheckPredicate, 43, // 12895: check predicate 43
7456 OPC_Decode, 163, 120, 31, // 12897: decode to PMULHSU_H using decoder 31
7457 // 12897: }
7458 // 12897: } // switch Inst[14:12]
7459 // 12897: }
7460 97, 43, // 12901: case 0x61: {
7461 OPC_SwitchField, 12, 3, // 12903: switch Inst[14:12] {
7462 0, 6, // 12906: case 0x0: {
7463 OPC_CheckPredicate, 48, // 12908: check predicate 48
7464 OPC_Decode, 255, 121, 31, // 12910: decode to PSUB_W using decoder 31
7465 // 12910: }
7466 2, 6, // 12914: case 0x2: {
7467 OPC_CheckPredicate, 48, // 12916: check predicate 48
7468 OPC_Decode, 202, 120, 31, // 12918: decode to PNCLIPP_H using decoder 31
7469 // 12918: }
7470 5, 6, // 12922: case 0x5: {
7471 OPC_CheckPredicate, 48, // 12924: check predicate 48
7472 OPC_Decode, 173, 119, 31, // 12926: decode to PM2SUB_W using decoder 31
7473 // 12926: }
7474 6, 6, // 12930: case 0x6: {
7475 OPC_CheckPredicate, 48, // 12932: check predicate 48
7476 OPC_Decode, 144, 120, 31, // 12934: decode to PMSEQ_W using decoder 31
7477 // 12934: }
7478 7, 0, // 12938: case 0x7: {
7479 OPC_CheckPredicate, 48, // 12940: check predicate 48
7480 OPC_Decode, 166, 120, 31, // 12942: decode to PMULHSU_W using decoder 31
7481 // 12942: }
7482 // 12942: } // switch Inst[14:12]
7483 // 12942: }
7484 98, 35, // 12946: case 0x62: {
7485 OPC_SwitchField, 12, 3, // 12948: switch Inst[14:12] {
7486 0, 6, // 12951: case 0x0: {
7487 OPC_CheckPredicate, 43, // 12953: check predicate 43
7488 OPC_Decode, 250, 121, 31, // 12955: decode to PSUB_B using decoder 31
7489 // 12955: }
7490 5, 6, // 12959: case 0x5: {
7491 OPC_CheckPredicate, 43, // 12961: check predicate 43
7492 OPC_Decode, 165, 119, 31, // 12963: decode to PM2SADD_H using decoder 31
7493 // 12963: }
7494 6, 6, // 12967: case 0x6: {
7495 OPC_CheckPredicate, 43, // 12969: check predicate 43
7496 OPC_Decode, 139, 120, 31, // 12971: decode to PMSEQ_B using decoder 31
7497 // 12971: }
7498 7, 0, // 12975: case 0x7: {
7499 OPC_CheckPredicate, 43, // 12977: check predicate 43
7500 OPC_Decode, 157, 120, 31, // 12979: decode to PMULHRSU_H using decoder 31
7501 // 12979: }
7502 // 12979: } // switch Inst[14:12]
7503 // 12979: }
7504 99, 19, // 12983: case 0x63: {
7505 OPC_SwitchField, 12, 3, // 12985: switch Inst[14:12] {
7506 2, 6, // 12988: case 0x2: {
7507 OPC_CheckPredicate, 48, // 12990: check predicate 48
7508 OPC_Decode, 203, 120, 31, // 12992: decode to PNCLIPP_W using decoder 31
7509 // 12992: }
7510 7, 0, // 12996: case 0x7: {
7511 OPC_CheckPredicate, 48, // 12998: check predicate 48
7512 OPC_Decode, 158, 120, 31, // 13000: decode to PMULHRSU_W using decoder 31
7513 // 13000: }
7514 // 13000: } // switch Inst[14:12]
7515 // 13000: }
7516 100, 27, // 13004: case 0x64: {
7517 OPC_SwitchField, 12, 3, // 13006: switch Inst[14:12] {
7518 0, 6, // 13009: case 0x0: {
7519 OPC_CheckPredicate, 43, // 13011: check predicate 43
7520 OPC_Decode, 235, 118, 31, // 13013: decode to PABD_H using decoder 31
7521 // 13013: }
7522 5, 6, // 13017: case 0x5: {
7523 OPC_CheckPredicate, 43, // 13019: check predicate 43
7524 OPC_Decode, 167, 119, 61, // 13021: decode to PM2SUBA_H using decoder 61
7525 // 13021: }
7526 7, 0, // 13025: case 0x7: {
7527 OPC_CheckPredicate, 43, // 13027: check predicate 43
7528 OPC_Decode, 219, 119, 61, // 13029: decode to PMHACCSU_H using decoder 61
7529 // 13029: }
7530 // 13029: } // switch Inst[14:12]
7531 // 13029: }
7532 101, 19, // 13033: case 0x65: {
7533 OPC_SwitchField, 12, 3, // 13035: switch Inst[14:12] {
7534 5, 6, // 13038: case 0x5: {
7535 OPC_CheckPredicate, 48, // 13040: check predicate 48
7536 OPC_Decode, 169, 119, 61, // 13042: decode to PM2SUBA_W using decoder 61
7537 // 13042: }
7538 7, 0, // 13046: case 0x7: {
7539 OPC_CheckPredicate, 48, // 13048: check predicate 48
7540 OPC_Decode, 222, 119, 61, // 13050: decode to PMHACCSU_W using decoder 61
7541 // 13050: }
7542 // 13050: } // switch Inst[14:12]
7543 // 13050: }
7544 102, 19, // 13054: case 0x66: {
7545 OPC_SwitchField, 12, 3, // 13056: switch Inst[14:12] {
7546 0, 6, // 13059: case 0x0: {
7547 OPC_CheckPredicate, 43, // 13061: check predicate 43
7548 OPC_Decode, 232, 118, 31, // 13063: decode to PABD_B using decoder 31
7549 // 13063: }
7550 7, 0, // 13067: case 0x7: {
7551 OPC_CheckPredicate, 43, // 13069: check predicate 43
7552 OPC_Decode, 233, 119, 61, // 13071: decode to PMHRACCSU_H using decoder 61
7553 // 13071: }
7554 // 13071: } // switch Inst[14:12]
7555 // 13071: }
7556 103, 10, // 13075: case 0x67: {
7557 OPC_CheckPredicate, 48, // 13077: check predicate 48
7558 OPC_CheckField, 12, 3, 7, // 13079: check Inst[14:12] == 0x7
7559 OPC_Decode, 234, 119, 61, // 13083: decode to PMHRACCSU_W using decoder 61
7560 // 13083: }
7561 104, 35, // 13087: case 0x68: {
7562 OPC_SwitchField, 12, 3, // 13089: switch Inst[14:12] {
7563 0, 6, // 13092: case 0x0: {
7564 OPC_CheckPredicate, 43, // 13094: check predicate 43
7565 OPC_Decode, 248, 121, 31, // 13096: decode to PSSUB_H using decoder 31
7566 // 13096: }
7567 5, 6, // 13100: case 0x5: {
7568 OPC_CheckPredicate, 43, // 13102: check predicate 43
7569 OPC_Decode, 172, 119, 31, // 13104: decode to PM2SUB_HX using decoder 31
7570 // 13104: }
7571 6, 6, // 13108: case 0x6: {
7572 OPC_CheckPredicate, 43, // 13110: check predicate 43
7573 OPC_Decode, 155, 120, 31, // 13112: decode to PMSLT_H using decoder 31
7574 // 13112: }
7575 7, 0, // 13116: case 0x7: {
7576 OPC_CheckPredicate, 43, // 13118: check predicate 43
7577 OPC_Decode, 179, 120, 31, // 13120: decode to PMULQ_H using decoder 31
7578 // 13120: }
7579 // 13120: } // switch Inst[14:12]
7580 // 13120: }
7581 105, 35, // 13124: case 0x69: {
7582 OPC_SwitchField, 12, 3, // 13126: switch Inst[14:12] {
7583 0, 6, // 13129: case 0x0: {
7584 OPC_CheckPredicate, 48, // 13131: check predicate 48
7585 OPC_Decode, 249, 121, 31, // 13133: decode to PSSUB_W using decoder 31
7586 // 13133: }
7587 5, 6, // 13137: case 0x5: {
7588 OPC_CheckPredicate, 48, // 13139: check predicate 48
7589 OPC_Decode, 174, 119, 31, // 13141: decode to PM2SUB_WX using decoder 31
7590 // 13141: }
7591 6, 6, // 13145: case 0x6: {
7592 OPC_CheckPredicate, 48, // 13147: check predicate 48
7593 OPC_Decode, 156, 120, 31, // 13149: decode to PMSLT_W using decoder 31
7594 // 13149: }
7595 7, 0, // 13153: case 0x7: {
7596 OPC_CheckPredicate, 48, // 13155: check predicate 48
7597 OPC_Decode, 180, 120, 31, // 13157: decode to PMULQ_W using decoder 31
7598 // 13157: }
7599 // 13157: } // switch Inst[14:12]
7600 // 13157: }
7601 106, 35, // 13161: case 0x6a: {
7602 OPC_SwitchField, 12, 3, // 13163: switch Inst[14:12] {
7603 0, 6, // 13166: case 0x0: {
7604 OPC_CheckPredicate, 43, // 13168: check predicate 43
7605 OPC_Decode, 244, 121, 31, // 13170: decode to PSSUB_B using decoder 31
7606 // 13170: }
7607 5, 6, // 13174: case 0x5: {
7608 OPC_CheckPredicate, 43, // 13176: check predicate 43
7609 OPC_Decode, 166, 119, 31, // 13178: decode to PM2SADD_HX using decoder 31
7610 // 13178: }
7611 6, 6, // 13182: case 0x6: {
7612 OPC_CheckPredicate, 43, // 13184: check predicate 43
7613 OPC_Decode, 151, 120, 31, // 13186: decode to PMSLT_B using decoder 31
7614 // 13186: }
7615 7, 0, // 13190: case 0x7: {
7616 OPC_CheckPredicate, 43, // 13192: check predicate 43
7617 OPC_Decode, 177, 120, 31, // 13194: decode to PMULQR_H using decoder 31
7618 // 13194: }
7619 // 13194: } // switch Inst[14:12]
7620 // 13194: }
7621 107, 10, // 13198: case 0x6b: {
7622 OPC_CheckPredicate, 48, // 13200: check predicate 48
7623 OPC_CheckField, 12, 3, 7, // 13202: check Inst[14:12] == 0x7
7624 OPC_Decode, 178, 120, 31, // 13206: decode to PMULQR_W using decoder 31
7625 // 13206: }
7626 108, 27, // 13210: case 0x6c: {
7627 OPC_SwitchField, 12, 3, // 13212: switch Inst[14:12] {
7628 0, 6, // 13215: case 0x0: {
7629 OPC_CheckPredicate, 43, // 13217: check predicate 43
7630 OPC_Decode, 136, 119, 31, // 13219: decode to PASUB_H using decoder 31
7631 // 13219: }
7632 5, 6, // 13223: case 0x5: {
7633 OPC_CheckPredicate, 43, // 13225: check predicate 43
7634 OPC_Decode, 168, 119, 61, // 13227: decode to PM2SUBA_HX using decoder 61
7635 // 13227: }
7636 6, 0, // 13231: case 0x6: {
7637 OPC_CheckPredicate, 43, // 13233: check predicate 43
7638 OPC_Decode, 149, 120, 31, // 13235: decode to PMSLTU_H using decoder 31
7639 // 13235: }
7640 // 13235: } // switch Inst[14:12]
7641 // 13235: }
7642 109, 27, // 13239: case 0x6d: {
7643 OPC_SwitchField, 12, 3, // 13241: switch Inst[14:12] {
7644 0, 6, // 13244: case 0x0: {
7645 OPC_CheckPredicate, 48, // 13246: check predicate 48
7646 OPC_Decode, 137, 119, 31, // 13248: decode to PASUB_W using decoder 31
7647 // 13248: }
7648 5, 6, // 13252: case 0x5: {
7649 OPC_CheckPredicate, 48, // 13254: check predicate 48
7650 OPC_Decode, 170, 119, 61, // 13256: decode to PM2SUBA_WX using decoder 61
7651 // 13256: }
7652 6, 0, // 13260: case 0x6: {
7653 OPC_CheckPredicate, 48, // 13262: check predicate 48
7654 OPC_Decode, 150, 120, 31, // 13264: decode to PMSLTU_W using decoder 31
7655 // 13264: }
7656 // 13264: } // switch Inst[14:12]
7657 // 13264: }
7658 110, 19, // 13268: case 0x6e: {
7659 OPC_SwitchField, 12, 3, // 13270: switch Inst[14:12] {
7660 0, 6, // 13273: case 0x0: {
7661 OPC_CheckPredicate, 43, // 13275: check predicate 43
7662 OPC_Decode, 132, 119, 31, // 13277: decode to PASUB_B using decoder 31
7663 // 13277: }
7664 6, 0, // 13281: case 0x6: {
7665 OPC_CheckPredicate, 43, // 13283: check predicate 43
7666 OPC_Decode, 145, 120, 31, // 13285: decode to PMSLTU_B using decoder 31
7667 // 13285: }
7668 // 13285: } // switch Inst[14:12]
7669 // 13285: }
7670 112, 35, // 13289: case 0x70: {
7671 OPC_SwitchField, 12, 3, // 13291: switch Inst[14:12] {
7672 2, 6, // 13294: case 0x2: {
7673 OPC_CheckPredicate, 48, // 13296: check predicate 48
7674 OPC_Decode, 139, 126, 31, // 13298: decode to UNZIP8P using decoder 31
7675 // 13298: }
7676 3, 6, // 13302: case 0x3: {
7677 OPC_CheckPredicate, 43, // 13304: check predicate 43
7678 OPC_Decode, 181, 120, 31, // 13306: decode to PMULSU_H_B00 using decoder 31
7679 // 13306: }
7680 5, 6, // 13310: case 0x5: {
7681 OPC_CheckPredicate, 43, // 13312: check predicate 43
7682 OPC_Decode, 157, 119, 31, // 13314: decode to PM2ADDSU_H using decoder 31
7683 // 13314: }
7684 6, 0, // 13318: case 0x6: {
7685 OPC_CheckPredicate, 43, // 13320: check predicate 43
7686 OPC_Decode, 249, 119, 31, // 13322: decode to PMIN_H using decoder 31
7687 // 13322: }
7688 // 13322: } // switch Inst[14:12]
7689 // 13322: }
7690 113, 35, // 13326: case 0x71: {
7691 OPC_SwitchField, 12, 3, // 13328: switch Inst[14:12] {
7692 2, 6, // 13331: case 0x2: {
7693 OPC_CheckPredicate, 48, // 13333: check predicate 48
7694 OPC_Decode, 137, 126, 31, // 13335: decode to UNZIP16P using decoder 31
7695 // 13335: }
7696 3, 6, // 13339: case 0x3: {
7697 OPC_CheckPredicate, 48, // 13341: check predicate 48
7698 OPC_Decode, 183, 120, 31, // 13343: decode to PMULSU_W_H00 using decoder 31
7699 // 13343: }
7700 5, 6, // 13347: case 0x5: {
7701 OPC_CheckPredicate, 48, // 13349: check predicate 48
7702 OPC_Decode, 158, 119, 31, // 13351: decode to PM2ADDSU_W using decoder 31
7703 // 13351: }
7704 6, 0, // 13355: case 0x6: {
7705 OPC_CheckPredicate, 48, // 13357: check predicate 48
7706 OPC_Decode, 250, 119, 31, // 13359: decode to PMIN_W using decoder 31
7707 // 13359: }
7708 // 13359: } // switch Inst[14:12]
7709 // 13359: }
7710 114, 27, // 13363: case 0x72: {
7711 OPC_SwitchField, 12, 3, // 13365: switch Inst[14:12] {
7712 2, 6, // 13368: case 0x2: {
7713 OPC_CheckPredicate, 48, // 13370: check predicate 48
7714 OPC_Decode, 138, 126, 31, // 13372: decode to UNZIP8HP using decoder 31
7715 // 13372: }
7716 5, 6, // 13376: case 0x5: {
7717 OPC_CheckPredicate, 43, // 13378: check predicate 43
7718 OPC_Decode, 193, 119, 31, // 13380: decode to PM4ADDSU_B using decoder 31
7719 // 13380: }
7720 6, 0, // 13384: case 0x6: {
7721 OPC_CheckPredicate, 43, // 13386: check predicate 43
7722 OPC_Decode, 245, 119, 31, // 13388: decode to PMIN_B using decoder 31
7723 // 13388: }
7724 // 13388: } // switch Inst[14:12]
7725 // 13388: }
7726 115, 27, // 13392: case 0x73: {
7727 OPC_SwitchField, 12, 3, // 13394: switch Inst[14:12] {
7728 2, 6, // 13397: case 0x2: {
7729 OPC_CheckPredicate, 48, // 13399: check predicate 48
7730 OPC_Decode, 136, 126, 31, // 13401: decode to UNZIP16HP using decoder 31
7731 // 13401: }
7732 3, 6, // 13405: case 0x3: {
7733 OPC_CheckPredicate, 48, // 13407: check predicate 48
7734 OPC_Decode, 129, 118, 31, // 13409: decode to MULSU_W00 using decoder 31
7735 // 13409: }
7736 5, 0, // 13413: case 0x5: {
7737 OPC_CheckPredicate, 48, // 13415: check predicate 48
7738 OPC_Decode, 194, 119, 31, // 13417: decode to PM4ADDSU_H using decoder 31
7739 // 13417: }
7740 // 13417: } // switch Inst[14:12]
7741 // 13417: }
7742 116, 35, // 13421: case 0x74: {
7743 OPC_SwitchField, 12, 3, // 13423: switch Inst[14:12] {
7744 0, 6, // 13426: case 0x0: {
7745 OPC_CheckPredicate, 43, // 13428: check predicate 43
7746 OPC_Decode, 231, 118, 31, // 13430: decode to PABDU_H using decoder 31
7747 // 13430: }
7748 5, 6, // 13434: case 0x5: {
7749 OPC_CheckPredicate, 43, // 13436: check predicate 43
7750 OPC_Decode, 149, 119, 61, // 13438: decode to PM2ADDASU_H using decoder 61
7751 // 13438: }
7752 6, 6, // 13442: case 0x6: {
7753 OPC_CheckPredicate, 43, // 13444: check predicate 43
7754 OPC_Decode, 243, 119, 31, // 13446: decode to PMINU_H using decoder 31
7755 // 13446: }
7756 7, 0, // 13450: case 0x7: {
7757 OPC_CheckPredicate, 48, // 13452: check predicate 48
7758 OPC_Decode, 255, 119, 61, // 13454: decode to PMQACC_W_H00 using decoder 61
7759 // 13454: }
7760 // 13454: } // switch Inst[14:12]
7761 // 13454: }
7762 117, 35, // 13458: case 0x75: {
7763 OPC_SwitchField, 12, 3, // 13460: switch Inst[14:12] {
7764 3, 6, // 13463: case 0x3: {
7765 OPC_CheckPredicate, 48, // 13465: check predicate 48
7766 OPC_Decode, 199, 119, 61, // 13467: decode to PMACCSU_W_H00 using decoder 61
7767 // 13467: }
7768 5, 6, // 13471: case 0x5: {
7769 OPC_CheckPredicate, 48, // 13473: check predicate 48
7770 OPC_Decode, 150, 119, 61, // 13475: decode to PM2ADDASU_W using decoder 61
7771 // 13475: }
7772 6, 6, // 13479: case 0x6: {
7773 OPC_CheckPredicate, 48, // 13481: check predicate 48
7774 OPC_Decode, 244, 119, 31, // 13483: decode to PMINU_W using decoder 31
7775 // 13483: }
7776 7, 0, // 13487: case 0x7: {
7777 OPC_CheckPredicate, 48, // 13489: check predicate 48
7778 OPC_Decode, 227, 117, 61, // 13491: decode to MQACC_W00 using decoder 61
7779 // 13491: }
7780 // 13491: } // switch Inst[14:12]
7781 // 13491: }
7782 118, 35, // 13495: case 0x76: {
7783 OPC_SwitchField, 12, 3, // 13497: switch Inst[14:12] {
7784 0, 6, // 13500: case 0x0: {
7785 OPC_CheckPredicate, 43, // 13502: check predicate 43
7786 OPC_Decode, 228, 118, 31, // 13504: decode to PABDU_B using decoder 31
7787 // 13504: }
7788 5, 6, // 13508: case 0x5: {
7789 OPC_CheckPredicate, 43, // 13510: check predicate 43
7790 OPC_Decode, 187, 119, 61, // 13512: decode to PM4ADDASU_B using decoder 61
7791 // 13512: }
7792 6, 6, // 13516: case 0x6: {
7793 OPC_CheckPredicate, 43, // 13518: check predicate 43
7794 OPC_Decode, 239, 119, 31, // 13520: decode to PMINU_B using decoder 31
7795 // 13520: }
7796 7, 0, // 13524: case 0x7: {
7797 OPC_CheckPredicate, 48, // 13526: check predicate 48
7798 OPC_Decode, 134, 120, 61, // 13528: decode to PMQRACC_W_H00 using decoder 61
7799 // 13528: }
7800 // 13528: } // switch Inst[14:12]
7801 // 13528: }
7802 119, 27, // 13532: case 0x77: {
7803 OPC_SwitchField, 12, 3, // 13534: switch Inst[14:12] {
7804 3, 6, // 13537: case 0x3: {
7805 OPC_CheckPredicate, 48, // 13539: check predicate 48
7806 OPC_Decode, 142, 117, 61, // 13541: decode to MACCSU_W00 using decoder 61
7807 // 13541: }
7808 5, 6, // 13545: case 0x5: {
7809 OPC_CheckPredicate, 48, // 13547: check predicate 48
7810 OPC_Decode, 188, 119, 61, // 13549: decode to PM4ADDASU_H using decoder 61
7811 // 13549: }
7812 7, 0, // 13553: case 0x7: {
7813 OPC_CheckPredicate, 48, // 13555: check predicate 48
7814 OPC_Decode, 233, 117, 61, // 13557: decode to MQRACC_W00 using decoder 61
7815 // 13557: }
7816 // 13557: } // switch Inst[14:12]
7817 // 13557: }
7818 120, 36, // 13561: case 0x78: {
7819 OPC_SwitchField, 12, 3, // 13563: switch Inst[14:12] {
7820 0, 6, // 13566: case 0x0: {
7821 OPC_CheckPredicate, 43, // 13568: check predicate 43
7822 OPC_Decode, 242, 121, 31, // 13570: decode to PSSUBU_H using decoder 31
7823 // 13570: }
7824 2, 7, // 13574: case 0x2: {
7825 OPC_CheckPredicate, 48, // 13576: check predicate 48
7826 OPC_Decode, 190, 132, 1, 31, // 13578: decode to ZIP8P using decoder 31
7827 // 13578: }
7828 3, 6, // 13583: case 0x3: {
7829 OPC_CheckPredicate, 43, // 13585: check predicate 43
7830 OPC_Decode, 182, 120, 31, // 13587: decode to PMULSU_H_B11 using decoder 31
7831 // 13587: }
7832 6, 0, // 13591: case 0x6: {
7833 OPC_CheckPredicate, 43, // 13593: check predicate 43
7834 OPC_Decode, 217, 119, 31, // 13595: decode to PMAX_H using decoder 31
7835 // 13595: }
7836 // 13595: } // switch Inst[14:12]
7837 // 13595: }
7838 121, 36, // 13599: case 0x79: {
7839 OPC_SwitchField, 12, 3, // 13601: switch Inst[14:12] {
7840 0, 6, // 13604: case 0x0: {
7841 OPC_CheckPredicate, 48, // 13606: check predicate 48
7842 OPC_Decode, 243, 121, 31, // 13608: decode to PSSUBU_W using decoder 31
7843 // 13608: }
7844 2, 7, // 13612: case 0x2: {
7845 OPC_CheckPredicate, 48, // 13614: check predicate 48
7846 OPC_Decode, 188, 132, 1, 31, // 13616: decode to ZIP16P using decoder 31
7847 // 13616: }
7848 3, 6, // 13621: case 0x3: {
7849 OPC_CheckPredicate, 48, // 13623: check predicate 48
7850 OPC_Decode, 184, 120, 31, // 13625: decode to PMULSU_W_H11 using decoder 31
7851 // 13625: }
7852 6, 0, // 13629: case 0x6: {
7853 OPC_CheckPredicate, 48, // 13631: check predicate 48
7854 OPC_Decode, 218, 119, 31, // 13633: decode to PMAX_W using decoder 31
7855 // 13633: }
7856 // 13633: } // switch Inst[14:12]
7857 // 13633: }
7858 122, 28, // 13637: case 0x7a: {
7859 OPC_SwitchField, 12, 3, // 13639: switch Inst[14:12] {
7860 0, 6, // 13642: case 0x0: {
7861 OPC_CheckPredicate, 43, // 13644: check predicate 43
7862 OPC_Decode, 238, 121, 31, // 13646: decode to PSSUBU_B using decoder 31
7863 // 13646: }
7864 2, 7, // 13650: case 0x2: {
7865 OPC_CheckPredicate, 48, // 13652: check predicate 48
7866 OPC_Decode, 189, 132, 1, 31, // 13654: decode to ZIP8HP using decoder 31
7867 // 13654: }
7868 6, 0, // 13659: case 0x6: {
7869 OPC_CheckPredicate, 43, // 13661: check predicate 43
7870 OPC_Decode, 213, 119, 31, // 13663: decode to PMAX_B using decoder 31
7871 // 13663: }
7872 // 13663: } // switch Inst[14:12]
7873 // 13663: }
7874 123, 20, // 13667: case 0x7b: {
7875 OPC_SwitchField, 12, 3, // 13669: switch Inst[14:12] {
7876 2, 7, // 13672: case 0x2: {
7877 OPC_CheckPredicate, 48, // 13674: check predicate 48
7878 OPC_Decode, 187, 132, 1, 31, // 13676: decode to ZIP16HP using decoder 31
7879 // 13676: }
7880 3, 0, // 13681: case 0x3: {
7881 OPC_CheckPredicate, 48, // 13683: check predicate 48
7882 OPC_Decode, 130, 118, 31, // 13685: decode to MULSU_W11 using decoder 31
7883 // 13685: }
7884 // 13685: } // switch Inst[14:12]
7885 // 13685: }
7886 124, 35, // 13689: case 0x7c: {
7887 OPC_SwitchField, 12, 3, // 13691: switch Inst[14:12] {
7888 0, 6, // 13694: case 0x0: {
7889 OPC_CheckPredicate, 43, // 13696: check predicate 43
7890 OPC_Decode, 130, 119, 31, // 13698: decode to PASUBU_H using decoder 31
7891 // 13698: }
7892 5, 6, // 13702: case 0x5: {
7893 OPC_CheckPredicate, 48, // 13704: check predicate 48
7894 OPC_Decode, 128, 120, 61, // 13706: decode to PMQACC_W_H01 using decoder 61
7895 // 13706: }
7896 6, 6, // 13710: case 0x6: {
7897 OPC_CheckPredicate, 43, // 13712: check predicate 43
7898 OPC_Decode, 211, 119, 31, // 13714: decode to PMAXU_H using decoder 31
7899 // 13714: }
7900 7, 0, // 13718: case 0x7: {
7901 OPC_CheckPredicate, 48, // 13720: check predicate 48
7902 OPC_Decode, 129, 120, 61, // 13722: decode to PMQACC_W_H11 using decoder 61
7903 // 13722: }
7904 // 13722: } // switch Inst[14:12]
7905 // 13722: }
7906 125, 43, // 13726: case 0x7d: {
7907 OPC_SwitchField, 12, 3, // 13728: switch Inst[14:12] {
7908 0, 6, // 13731: case 0x0: {
7909 OPC_CheckPredicate, 48, // 13733: check predicate 48
7910 OPC_Decode, 131, 119, 31, // 13735: decode to PASUBU_W using decoder 31
7911 // 13735: }
7912 3, 6, // 13739: case 0x3: {
7913 OPC_CheckPredicate, 48, // 13741: check predicate 48
7914 OPC_Decode, 200, 119, 61, // 13743: decode to PMACCSU_W_H11 using decoder 61
7915 // 13743: }
7916 5, 6, // 13747: case 0x5: {
7917 OPC_CheckPredicate, 48, // 13749: check predicate 48
7918 OPC_Decode, 228, 117, 61, // 13751: decode to MQACC_W01 using decoder 61
7919 // 13751: }
7920 6, 6, // 13755: case 0x6: {
7921 OPC_CheckPredicate, 48, // 13757: check predicate 48
7922 OPC_Decode, 212, 119, 31, // 13759: decode to PMAXU_W using decoder 31
7923 // 13759: }
7924 7, 0, // 13763: case 0x7: {
7925 OPC_CheckPredicate, 48, // 13765: check predicate 48
7926 OPC_Decode, 229, 117, 61, // 13767: decode to MQACC_W11 using decoder 61
7927 // 13767: }
7928 // 13767: } // switch Inst[14:12]
7929 // 13767: }
7930 126, 35, // 13771: case 0x7e: {
7931 OPC_SwitchField, 12, 3, // 13773: switch Inst[14:12] {
7932 0, 6, // 13776: case 0x0: {
7933 OPC_CheckPredicate, 43, // 13778: check predicate 43
7934 OPC_Decode, 254, 118, 31, // 13780: decode to PASUBU_B using decoder 31
7935 // 13780: }
7936 5, 6, // 13784: case 0x5: {
7937 OPC_CheckPredicate, 48, // 13786: check predicate 48
7938 OPC_Decode, 135, 120, 61, // 13788: decode to PMQRACC_W_H01 using decoder 61
7939 // 13788: }
7940 6, 6, // 13792: case 0x6: {
7941 OPC_CheckPredicate, 43, // 13794: check predicate 43
7942 OPC_Decode, 207, 119, 31, // 13796: decode to PMAXU_B using decoder 31
7943 // 13796: }
7944 7, 0, // 13800: case 0x7: {
7945 OPC_CheckPredicate, 48, // 13802: check predicate 48
7946 OPC_Decode, 136, 120, 61, // 13804: decode to PMQRACC_W_H11 using decoder 61
7947 // 13804: }
7948 // 13804: } // switch Inst[14:12]
7949 // 13804: }
7950 127, 0, // 13808: case 0x7f: {
7951 OPC_SwitchField, 12, 3, // 13810: switch Inst[14:12] {
7952 3, 6, // 13813: case 0x3: {
7953 OPC_CheckPredicate, 48, // 13815: check predicate 48
7954 OPC_Decode, 143, 117, 61, // 13817: decode to MACCSU_W11 using decoder 61
7955 // 13817: }
7956 5, 6, // 13821: case 0x5: {
7957 OPC_CheckPredicate, 48, // 13823: check predicate 48
7958 OPC_Decode, 234, 117, 61, // 13825: decode to MQRACC_W01 using decoder 61
7959 // 13825: }
7960 7, 0, // 13829: case 0x7: {
7961 OPC_CheckPredicate, 48, // 13831: check predicate 48
7962 OPC_Decode, 235, 117, 61, // 13833: decode to MQRACC_W11 using decoder 61
7963 // 13833: }
7964 // 13833: } // switch Inst[14:12]
7965 // 13833: }
7966 // 13833: } // switch Inst[31:25]
7967 // 13833: }
7968 67, 35, // 13837: case 0x43: {
7969 OPC_SwitchField, 25, 2, // 13839: switch Inst[26:25] {
7970 0, 6, // 13842: case 0x0: {
7971 OPC_CheckPredicate, 25, // 13844: check predicate 25
7972 OPC_Decode, 183, 115, 62, // 13846: decode to FMADD_S using decoder 62
7973 // 13846: }
7974 1, 6, // 13850: case 0x1: {
7975 OPC_CheckPredicate, 26, // 13852: check predicate 26
7976 OPC_Decode, 177, 115, 63, // 13854: decode to FMADD_D using decoder 63
7977 // 13854: }
7978 2, 6, // 13858: case 0x2: {
7979 OPC_CheckPredicate, 82, // 13860: check predicate 82
7980 OPC_Decode, 180, 115, 64, // 13862: decode to FMADD_H using decoder 64
7981 // 13862: }
7982 3, 0, // 13866: case 0x3: {
7983 OPC_CheckPredicate, 27, // 13868: check predicate 27
7984 OPC_Decode, 182, 115, 65, // 13870: decode to FMADD_Q using decoder 65
7985 // 13870: }
7986 // 13870: } // switch Inst[26:25]
7987 // 13870: }
7988 71, 35, // 13874: case 0x47: {
7989 OPC_SwitchField, 25, 2, // 13876: switch Inst[26:25] {
7990 0, 6, // 13879: case 0x0: {
7991 OPC_CheckPredicate, 25, // 13881: check predicate 25
7992 OPC_Decode, 215, 115, 62, // 13883: decode to FMSUB_S using decoder 62
7993 // 13883: }
7994 1, 6, // 13887: case 0x1: {
7995 OPC_CheckPredicate, 26, // 13889: check predicate 26
7996 OPC_Decode, 209, 115, 63, // 13891: decode to FMSUB_D using decoder 63
7997 // 13891: }
7998 2, 6, // 13895: case 0x2: {
7999 OPC_CheckPredicate, 82, // 13897: check predicate 82
8000 OPC_Decode, 212, 115, 64, // 13899: decode to FMSUB_H using decoder 64
8001 // 13899: }
8002 3, 0, // 13903: case 0x3: {
8003 OPC_CheckPredicate, 27, // 13905: check predicate 27
8004 OPC_Decode, 214, 115, 65, // 13907: decode to FMSUB_Q using decoder 65
8005 // 13907: }
8006 // 13907: } // switch Inst[26:25]
8007 // 13907: }
8008 75, 35, // 13911: case 0x4b: {
8009 OPC_SwitchField, 25, 2, // 13913: switch Inst[26:25] {
8010 0, 6, // 13916: case 0x0: {
8011 OPC_CheckPredicate, 25, // 13918: check predicate 25
8012 OPC_Decode, 250, 115, 62, // 13920: decode to FNMSUB_S using decoder 62
8013 // 13920: }
8014 1, 6, // 13924: case 0x1: {
8015 OPC_CheckPredicate, 26, // 13926: check predicate 26
8016 OPC_Decode, 244, 115, 63, // 13928: decode to FNMSUB_D using decoder 63
8017 // 13928: }
8018 2, 6, // 13932: case 0x2: {
8019 OPC_CheckPredicate, 82, // 13934: check predicate 82
8020 OPC_Decode, 247, 115, 64, // 13936: decode to FNMSUB_H using decoder 64
8021 // 13936: }
8022 3, 0, // 13940: case 0x3: {
8023 OPC_CheckPredicate, 27, // 13942: check predicate 27
8024 OPC_Decode, 249, 115, 65, // 13944: decode to FNMSUB_Q using decoder 65
8025 // 13944: }
8026 // 13944: } // switch Inst[26:25]
8027 // 13944: }
8028 79, 35, // 13948: case 0x4f: {
8029 OPC_SwitchField, 25, 2, // 13950: switch Inst[26:25] {
8030 0, 6, // 13953: case 0x0: {
8031 OPC_CheckPredicate, 25, // 13955: check predicate 25
8032 OPC_Decode, 242, 115, 62, // 13957: decode to FNMADD_S using decoder 62
8033 // 13957: }
8034 1, 6, // 13961: case 0x1: {
8035 OPC_CheckPredicate, 26, // 13963: check predicate 26
8036 OPC_Decode, 236, 115, 63, // 13965: decode to FNMADD_D using decoder 63
8037 // 13965: }
8038 2, 6, // 13969: case 0x2: {
8039 OPC_CheckPredicate, 82, // 13971: check predicate 82
8040 OPC_Decode, 239, 115, 64, // 13973: decode to FNMADD_H using decoder 64
8041 // 13973: }
8042 3, 0, // 13977: case 0x3: {
8043 OPC_CheckPredicate, 27, // 13979: check predicate 27
8044 OPC_Decode, 241, 115, 65, // 13981: decode to FNMADD_Q using decoder 65
8045 // 13981: }
8046 // 13981: } // switch Inst[26:25]
8047 // 13981: }
8048 83, 227, 10, // 13985: case 0x53: {
8049 OPC_SwitchField, 25, 7, // 13988: switch Inst[31:25] {
8050 0, 6, // 13991: case 0x0: {
8051 OPC_CheckPredicate, 25, // 13993: check predicate 25
8052 OPC_Decode, 159, 114, 66, // 13995: decode to FADD_S using decoder 66
8053 // 13995: }
8054 1, 6, // 13999: case 0x1: {
8055 OPC_CheckPredicate, 26, // 14001: check predicate 26
8056 OPC_Decode, 153, 114, 67, // 14003: decode to FADD_D using decoder 67
8057 // 14003: }
8058 2, 6, // 14007: case 0x2: {
8059 OPC_CheckPredicate, 82, // 14009: check predicate 82
8060 OPC_Decode, 156, 114, 68, // 14011: decode to FADD_H using decoder 68
8061 // 14011: }
8062 3, 6, // 14015: case 0x3: {
8063 OPC_CheckPredicate, 27, // 14017: check predicate 27
8064 OPC_Decode, 158, 114, 69, // 14019: decode to FADD_Q using decoder 69
8065 // 14019: }
8066 4, 6, // 14023: case 0x4: {
8067 OPC_CheckPredicate, 25, // 14025: check predicate 25
8068 OPC_Decode, 173, 116, 66, // 14027: decode to FSUB_S using decoder 66
8069 // 14027: }
8070 5, 6, // 14031: case 0x5: {
8071 OPC_CheckPredicate, 26, // 14033: check predicate 26
8072 OPC_Decode, 167, 116, 67, // 14035: decode to FSUB_D using decoder 67
8073 // 14035: }
8074 6, 6, // 14039: case 0x6: {
8075 OPC_CheckPredicate, 82, // 14041: check predicate 82
8076 OPC_Decode, 170, 116, 68, // 14043: decode to FSUB_H using decoder 68
8077 // 14043: }
8078 7, 6, // 14047: case 0x7: {
8079 OPC_CheckPredicate, 27, // 14049: check predicate 27
8080 OPC_Decode, 172, 116, 69, // 14051: decode to FSUB_Q using decoder 69
8081 // 14051: }
8082 8, 6, // 14055: case 0x8: {
8083 OPC_CheckPredicate, 25, // 14057: check predicate 25
8084 OPC_Decode, 223, 115, 66, // 14059: decode to FMUL_S using decoder 66
8085 // 14059: }
8086 9, 6, // 14063: case 0x9: {
8087 OPC_CheckPredicate, 26, // 14065: check predicate 26
8088 OPC_Decode, 217, 115, 67, // 14067: decode to FMUL_D using decoder 67
8089 // 14067: }
8090 10, 6, // 14071: case 0xa: {
8091 OPC_CheckPredicate, 82, // 14073: check predicate 82
8092 OPC_Decode, 220, 115, 68, // 14075: decode to FMUL_H using decoder 68
8093 // 14075: }
8094 11, 6, // 14079: case 0xb: {
8095 OPC_CheckPredicate, 27, // 14081: check predicate 27
8096 OPC_Decode, 222, 115, 69, // 14083: decode to FMUL_Q using decoder 69
8097 // 14083: }
8098 12, 6, // 14087: case 0xc: {
8099 OPC_CheckPredicate, 25, // 14089: check predicate 25
8100 OPC_Decode, 132, 115, 66, // 14091: decode to FDIV_S using decoder 66
8101 // 14091: }
8102 13, 6, // 14095: case 0xd: {
8103 OPC_CheckPredicate, 26, // 14097: check predicate 26
8104 OPC_Decode, 254, 114, 67, // 14099: decode to FDIV_D using decoder 67
8105 // 14099: }
8106 14, 6, // 14103: case 0xe: {
8107 OPC_CheckPredicate, 82, // 14105: check predicate 82
8108 OPC_Decode, 129, 115, 68, // 14107: decode to FDIV_H using decoder 68
8109 // 14107: }
8110 15, 6, // 14111: case 0xf: {
8111 OPC_CheckPredicate, 27, // 14113: check predicate 27
8112 OPC_Decode, 131, 115, 69, // 14115: decode to FDIV_Q using decoder 69
8113 // 14115: }
8114 16, 27, // 14119: case 0x10: {
8115 OPC_SwitchField, 12, 3, // 14121: switch Inst[14:12] {
8116 0, 6, // 14124: case 0x0: {
8117 OPC_CheckPredicate, 25, // 14126: check predicate 25
8118 OPC_Decode, 155, 116, 70, // 14128: decode to FSGNJ_S using decoder 70
8119 // 14128: }
8120 1, 6, // 14132: case 0x1: {
8121 OPC_CheckPredicate, 25, // 14134: check predicate 25
8122 OPC_Decode, 139, 116, 70, // 14136: decode to FSGNJN_S using decoder 70
8123 // 14136: }
8124 2, 0, // 14140: case 0x2: {
8125 OPC_CheckPredicate, 25, // 14142: check predicate 25
8126 OPC_Decode, 147, 116, 70, // 14144: decode to FSGNJX_S using decoder 70
8127 // 14144: }
8128 // 14144: } // switch Inst[14:12]
8129 // 14144: }
8130 17, 27, // 14148: case 0x11: {
8131 OPC_SwitchField, 12, 3, // 14150: switch Inst[14:12] {
8132 0, 6, // 14153: case 0x0: {
8133 OPC_CheckPredicate, 26, // 14155: check predicate 26
8134 OPC_Decode, 149, 116, 71, // 14157: decode to FSGNJ_D using decoder 71
8135 // 14157: }
8136 1, 6, // 14161: case 0x1: {
8137 OPC_CheckPredicate, 26, // 14163: check predicate 26
8138 OPC_Decode, 133, 116, 71, // 14165: decode to FSGNJN_D using decoder 71
8139 // 14165: }
8140 2, 0, // 14169: case 0x2: {
8141 OPC_CheckPredicate, 26, // 14171: check predicate 26
8142 OPC_Decode, 141, 116, 71, // 14173: decode to FSGNJX_D using decoder 71
8143 // 14173: }
8144 // 14173: } // switch Inst[14:12]
8145 // 14173: }
8146 18, 27, // 14177: case 0x12: {
8147 OPC_SwitchField, 12, 3, // 14179: switch Inst[14:12] {
8148 0, 6, // 14182: case 0x0: {
8149 OPC_CheckPredicate, 82, // 14184: check predicate 82
8150 OPC_Decode, 152, 116, 72, // 14186: decode to FSGNJ_H using decoder 72
8151 // 14186: }
8152 1, 6, // 14190: case 0x1: {
8153 OPC_CheckPredicate, 82, // 14192: check predicate 82
8154 OPC_Decode, 136, 116, 72, // 14194: decode to FSGNJN_H using decoder 72
8155 // 14194: }
8156 2, 0, // 14198: case 0x2: {
8157 OPC_CheckPredicate, 82, // 14200: check predicate 82
8158 OPC_Decode, 144, 116, 72, // 14202: decode to FSGNJX_H using decoder 72
8159 // 14202: }
8160 // 14202: } // switch Inst[14:12]
8161 // 14202: }
8162 19, 27, // 14206: case 0x13: {
8163 OPC_SwitchField, 12, 3, // 14208: switch Inst[14:12] {
8164 0, 6, // 14211: case 0x0: {
8165 OPC_CheckPredicate, 27, // 14213: check predicate 27
8166 OPC_Decode, 154, 116, 73, // 14215: decode to FSGNJ_Q using decoder 73
8167 // 14215: }
8168 1, 6, // 14219: case 0x1: {
8169 OPC_CheckPredicate, 27, // 14221: check predicate 27
8170 OPC_Decode, 138, 116, 73, // 14223: decode to FSGNJN_Q using decoder 73
8171 // 14223: }
8172 2, 0, // 14227: case 0x2: {
8173 OPC_CheckPredicate, 27, // 14229: check predicate 27
8174 OPC_Decode, 146, 116, 73, // 14231: decode to FSGNJX_Q using decoder 73
8175 // 14231: }
8176 // 14231: } // switch Inst[14:12]
8177 // 14231: }
8178 20, 35, // 14235: case 0x14: {
8179 OPC_SwitchField, 12, 3, // 14237: switch Inst[14:12] {
8180 0, 6, // 14240: case 0x0: {
8181 OPC_CheckPredicate, 25, // 14242: check predicate 25
8182 OPC_Decode, 207, 115, 70, // 14244: decode to FMIN_S using decoder 70
8183 // 14244: }
8184 1, 6, // 14248: case 0x1: {
8185 OPC_CheckPredicate, 25, // 14250: check predicate 25
8186 OPC_Decode, 195, 115, 70, // 14252: decode to FMAX_S using decoder 70
8187 // 14252: }
8188 2, 6, // 14256: case 0x2: {
8189 OPC_CheckPredicate, 83, // 14258: check predicate 83
8190 OPC_Decode, 200, 115, 70, // 14260: decode to FMINM_S using decoder 70
8191 // 14260: }
8192 3, 0, // 14264: case 0x3: {
8193 OPC_CheckPredicate, 83, // 14266: check predicate 83
8194 OPC_Decode, 188, 115, 70, // 14268: decode to FMAXM_S using decoder 70
8195 // 14268: }
8196 // 14268: } // switch Inst[14:12]
8197 // 14268: }
8198 21, 35, // 14272: case 0x15: {
8199 OPC_SwitchField, 12, 3, // 14274: switch Inst[14:12] {
8200 0, 6, // 14277: case 0x0: {
8201 OPC_CheckPredicate, 26, // 14279: check predicate 26
8202 OPC_Decode, 201, 115, 71, // 14281: decode to FMIN_D using decoder 71
8203 // 14281: }
8204 1, 6, // 14285: case 0x1: {
8205 OPC_CheckPredicate, 26, // 14287: check predicate 26
8206 OPC_Decode, 189, 115, 71, // 14289: decode to FMAX_D using decoder 71
8207 // 14289: }
8208 2, 6, // 14293: case 0x2: {
8209 OPC_CheckPredicate, 84, // 14295: check predicate 84
8210 OPC_Decode, 197, 115, 71, // 14297: decode to FMINM_D using decoder 71
8211 // 14297: }
8212 3, 0, // 14301: case 0x3: {
8213 OPC_CheckPredicate, 84, // 14303: check predicate 84
8214 OPC_Decode, 185, 115, 71, // 14305: decode to FMAXM_D using decoder 71
8215 // 14305: }
8216 // 14305: } // switch Inst[14:12]
8217 // 14305: }
8218 22, 35, // 14309: case 0x16: {
8219 OPC_SwitchField, 12, 3, // 14311: switch Inst[14:12] {
8220 0, 6, // 14314: case 0x0: {
8221 OPC_CheckPredicate, 82, // 14316: check predicate 82
8222 OPC_Decode, 204, 115, 72, // 14318: decode to FMIN_H using decoder 72
8223 // 14318: }
8224 1, 6, // 14322: case 0x1: {
8225 OPC_CheckPredicate, 82, // 14324: check predicate 82
8226 OPC_Decode, 192, 115, 72, // 14326: decode to FMAX_H using decoder 72
8227 // 14326: }
8228 2, 6, // 14330: case 0x2: {
8229 OPC_CheckPredicate, 85, // 14332: check predicate 85
8230 OPC_Decode, 198, 115, 72, // 14334: decode to FMINM_H using decoder 72
8231 // 14334: }
8232 3, 0, // 14338: case 0x3: {
8233 OPC_CheckPredicate, 85, // 14340: check predicate 85
8234 OPC_Decode, 186, 115, 72, // 14342: decode to FMAXM_H using decoder 72
8235 // 14342: }
8236 // 14342: } // switch Inst[14:12]
8237 // 14342: }
8238 23, 35, // 14346: case 0x17: {
8239 OPC_SwitchField, 12, 3, // 14348: switch Inst[14:12] {
8240 0, 6, // 14351: case 0x0: {
8241 OPC_CheckPredicate, 27, // 14353: check predicate 27
8242 OPC_Decode, 206, 115, 73, // 14355: decode to FMIN_Q using decoder 73
8243 // 14355: }
8244 1, 6, // 14359: case 0x1: {
8245 OPC_CheckPredicate, 27, // 14361: check predicate 27
8246 OPC_Decode, 194, 115, 73, // 14363: decode to FMAX_Q using decoder 73
8247 // 14363: }
8248 2, 6, // 14367: case 0x2: {
8249 OPC_CheckPredicate, 86, // 14369: check predicate 86
8250 OPC_Decode, 199, 115, 73, // 14371: decode to FMINM_Q using decoder 73
8251 // 14371: }
8252 3, 0, // 14375: case 0x3: {
8253 OPC_CheckPredicate, 86, // 14377: check predicate 86
8254 OPC_Decode, 187, 115, 73, // 14379: decode to FMAXM_Q using decoder 73
8255 // 14379: }
8256 // 14379: } // switch Inst[14:12]
8257 // 14379: }
8258 32, 51, // 14383: case 0x20: {
8259 OPC_SwitchField, 20, 5, // 14385: switch Inst[24:20] {
8260 1, 6, // 14388: case 0x1: {
8261 OPC_CheckPredicate, 26, // 14390: check predicate 26
8262 OPC_Decode, 224, 114, 74, // 14392: decode to FCVT_S_D using decoder 74
8263 // 14392: }
8264 2, 6, // 14396: case 0x2: {
8265 OPC_CheckPredicate, 87, // 14398: check predicate 87
8266 OPC_Decode, 227, 114, 75, // 14400: decode to FCVT_S_H using decoder 75
8267 // 14400: }
8268 3, 6, // 14404: case 0x3: {
8269 OPC_CheckPredicate, 27, // 14406: check predicate 27
8270 OPC_Decode, 233, 114, 76, // 14408: decode to FCVT_S_Q using decoder 76
8271 // 14408: }
8272 4, 6, // 14412: case 0x4: {
8273 OPC_CheckPredicate, 83, // 14414: check predicate 83
8274 OPC_Decode, 131, 116, 77, // 14416: decode to FROUND_S using decoder 77
8275 // 14416: }
8276 5, 6, // 14420: case 0x5: {
8277 OPC_CheckPredicate, 83, // 14422: check predicate 83
8278 OPC_Decode, 255, 115, 77, // 14424: decode to FROUNDNX_S using decoder 77
8279 // 14424: }
8280 6, 0, // 14428: case 0x6: {
8281 OPC_CheckPredicate, 88, // 14430: check predicate 88
8282 OPC_Decode, 223, 114, 75, // 14432: decode to FCVT_S_BF16 using decoder 75
8283 // 14432: }
8284 // 14432: } // switch Inst[24:20]
8285 // 14432: }
8286 33, 43, // 14436: case 0x21: {
8287 OPC_SwitchField, 20, 5, // 14438: switch Inst[24:20] {
8288 0, 6, // 14441: case 0x0: {
8289 OPC_CheckPredicate, 26, // 14443: check predicate 26
8290 OPC_Decode, 179, 114, 78, // 14445: decode to FCVT_D_S using decoder 78
8291 // 14445: }
8292 2, 6, // 14449: case 0x2: {
8293 OPC_CheckPredicate, 89, // 14451: check predicate 89
8294 OPC_Decode, 171, 114, 79, // 14453: decode to FCVT_D_H using decoder 79
8295 // 14453: }
8296 3, 6, // 14457: case 0x3: {
8297 OPC_CheckPredicate, 27, // 14459: check predicate 27
8298 OPC_Decode, 178, 114, 80, // 14461: decode to FCVT_D_Q using decoder 80
8299 // 14461: }
8300 4, 6, // 14465: case 0x4: {
8301 OPC_CheckPredicate, 84, // 14467: check predicate 84
8302 OPC_Decode, 128, 116, 81, // 14469: decode to FROUND_D using decoder 81
8303 // 14469: }
8304 5, 0, // 14473: case 0x5: {
8305 OPC_CheckPredicate, 84, // 14475: check predicate 84
8306 OPC_Decode, 252, 115, 81, // 14477: decode to FROUNDNX_D using decoder 81
8307 // 14477: }
8308 // 14477: } // switch Inst[24:20]
8309 // 14477: }
8310 34, 51, // 14481: case 0x22: {
8311 OPC_SwitchField, 20, 5, // 14483: switch Inst[24:20] {
8312 0, 6, // 14486: case 0x0: {
8313 OPC_CheckPredicate, 87, // 14488: check predicate 87
8314 OPC_Decode, 196, 114, 82, // 14490: decode to FCVT_H_S using decoder 82
8315 // 14490: }
8316 1, 6, // 14494: case 0x1: {
8317 OPC_CheckPredicate, 89, // 14496: check predicate 89
8318 OPC_Decode, 188, 114, 83, // 14498: decode to FCVT_H_D using decoder 83
8319 // 14498: }
8320 3, 6, // 14502: case 0x3: {
8321 OPC_CheckPredicate, 90, // 14504: check predicate 90
8322 OPC_Decode, 195, 114, 84, // 14506: decode to FCVT_H_Q using decoder 84
8323 // 14506: }
8324 4, 6, // 14510: case 0x4: {
8325 OPC_CheckPredicate, 85, // 14512: check predicate 85
8326 OPC_Decode, 129, 116, 85, // 14514: decode to FROUND_H using decoder 85
8327 // 14514: }
8328 5, 6, // 14518: case 0x5: {
8329 OPC_CheckPredicate, 85, // 14520: check predicate 85
8330 OPC_Decode, 253, 115, 85, // 14522: decode to FROUNDNX_H using decoder 85
8331 // 14522: }
8332 8, 0, // 14526: case 0x8: {
8333 OPC_CheckPredicate, 88, // 14528: check predicate 88
8334 OPC_Decode, 170, 114, 82, // 14530: decode to FCVT_BF16_S using decoder 82
8335 // 14530: }
8336 // 14530: } // switch Inst[24:20]
8337 // 14530: }
8338 35, 43, // 14534: case 0x23: {
8339 OPC_SwitchField, 20, 5, // 14536: switch Inst[24:20] {
8340 0, 6, // 14539: case 0x0: {
8341 OPC_CheckPredicate, 27, // 14541: check predicate 27
8342 OPC_Decode, 220, 114, 86, // 14543: decode to FCVT_Q_S using decoder 86
8343 // 14543: }
8344 1, 6, // 14547: case 0x1: {
8345 OPC_CheckPredicate, 27, // 14549: check predicate 27
8346 OPC_Decode, 216, 114, 87, // 14551: decode to FCVT_Q_D using decoder 87
8347 // 14551: }
8348 2, 6, // 14555: case 0x2: {
8349 OPC_CheckPredicate, 90, // 14557: check predicate 90
8350 OPC_Decode, 217, 114, 88, // 14559: decode to FCVT_Q_H using decoder 88
8351 // 14559: }
8352 4, 6, // 14563: case 0x4: {
8353 OPC_CheckPredicate, 86, // 14565: check predicate 86
8354 OPC_Decode, 130, 116, 89, // 14567: decode to FROUND_Q using decoder 89
8355 // 14567: }
8356 5, 0, // 14571: case 0x5: {
8357 OPC_CheckPredicate, 86, // 14573: check predicate 86
8358 OPC_Decode, 254, 115, 89, // 14575: decode to FROUNDNX_Q using decoder 89
8359 // 14575: }
8360 // 14575: } // switch Inst[24:20]
8361 // 14575: }
8362 44, 10, // 14579: case 0x2c: {
8363 OPC_CheckPredicate, 25, // 14581: check predicate 25
8364 OPC_CheckField, 20, 5, 0, // 14583: check Inst[24:20] == 0x0
8365 OPC_Decode, 165, 116, 77, // 14587: decode to FSQRT_S using decoder 77
8366 // 14587: }
8367 45, 10, // 14591: case 0x2d: {
8368 OPC_CheckPredicate, 26, // 14593: check predicate 26
8369 OPC_CheckField, 20, 5, 0, // 14595: check Inst[24:20] == 0x0
8370 OPC_Decode, 159, 116, 81, // 14599: decode to FSQRT_D using decoder 81
8371 // 14599: }
8372 46, 10, // 14603: case 0x2e: {
8373 OPC_CheckPredicate, 82, // 14605: check predicate 82
8374 OPC_CheckField, 20, 5, 0, // 14607: check Inst[24:20] == 0x0
8375 OPC_Decode, 162, 116, 85, // 14611: decode to FSQRT_H using decoder 85
8376 // 14611: }
8377 47, 10, // 14615: case 0x2f: {
8378 OPC_CheckPredicate, 27, // 14617: check predicate 27
8379 OPC_CheckField, 20, 5, 0, // 14619: check Inst[24:20] == 0x0
8380 OPC_Decode, 164, 116, 89, // 14623: decode to FSQRT_Q using decoder 89
8381 // 14623: }
8382 80, 43, // 14627: case 0x50: {
8383 OPC_SwitchField, 12, 3, // 14629: switch Inst[14:12] {
8384 0, 6, // 14632: case 0x0: {
8385 OPC_CheckPredicate, 25, // 14634: check predicate 25
8386 OPC_Decode, 156, 115, 90, // 14636: decode to FLE_S using decoder 90
8387 // 14636: }
8388 1, 6, // 14640: case 0x1: {
8389 OPC_CheckPredicate, 25, // 14642: check predicate 25
8390 OPC_Decode, 174, 115, 90, // 14644: decode to FLT_S using decoder 90
8391 // 14644: }
8392 2, 6, // 14648: case 0x2: {
8393 OPC_CheckPredicate, 25, // 14650: check predicate 25
8394 OPC_Decode, 143, 115, 90, // 14652: decode to FEQ_S using decoder 90
8395 // 14652: }
8396 4, 6, // 14656: case 0x4: {
8397 OPC_CheckPredicate, 83, // 14658: check predicate 83
8398 OPC_Decode, 149, 115, 90, // 14660: decode to FLEQ_S using decoder 90
8399 // 14660: }
8400 5, 0, // 14664: case 0x5: {
8401 OPC_CheckPredicate, 83, // 14666: check predicate 83
8402 OPC_Decode, 167, 115, 90, // 14668: decode to FLTQ_S using decoder 90
8403 // 14668: }
8404 // 14668: } // switch Inst[14:12]
8405 // 14668: }
8406 81, 43, // 14672: case 0x51: {
8407 OPC_SwitchField, 12, 3, // 14674: switch Inst[14:12] {
8408 0, 6, // 14677: case 0x0: {
8409 OPC_CheckPredicate, 26, // 14679: check predicate 26
8410 OPC_Decode, 150, 115, 91, // 14681: decode to FLE_D using decoder 91
8411 // 14681: }
8412 1, 6, // 14685: case 0x1: {
8413 OPC_CheckPredicate, 26, // 14687: check predicate 26
8414 OPC_Decode, 168, 115, 91, // 14689: decode to FLT_D using decoder 91
8415 // 14689: }
8416 2, 6, // 14693: case 0x2: {
8417 OPC_CheckPredicate, 26, // 14695: check predicate 26
8418 OPC_Decode, 137, 115, 91, // 14697: decode to FEQ_D using decoder 91
8419 // 14697: }
8420 4, 6, // 14701: case 0x4: {
8421 OPC_CheckPredicate, 84, // 14703: check predicate 84
8422 OPC_Decode, 146, 115, 91, // 14705: decode to FLEQ_D using decoder 91
8423 // 14705: }
8424 5, 0, // 14709: case 0x5: {
8425 OPC_CheckPredicate, 84, // 14711: check predicate 84
8426 OPC_Decode, 164, 115, 91, // 14713: decode to FLTQ_D using decoder 91
8427 // 14713: }
8428 // 14713: } // switch Inst[14:12]
8429 // 14713: }
8430 82, 43, // 14717: case 0x52: {
8431 OPC_SwitchField, 12, 3, // 14719: switch Inst[14:12] {
8432 0, 6, // 14722: case 0x0: {
8433 OPC_CheckPredicate, 82, // 14724: check predicate 82
8434 OPC_Decode, 153, 115, 92, // 14726: decode to FLE_H using decoder 92
8435 // 14726: }
8436 1, 6, // 14730: case 0x1: {
8437 OPC_CheckPredicate, 82, // 14732: check predicate 82
8438 OPC_Decode, 171, 115, 92, // 14734: decode to FLT_H using decoder 92
8439 // 14734: }
8440 2, 6, // 14738: case 0x2: {
8441 OPC_CheckPredicate, 82, // 14740: check predicate 82
8442 OPC_Decode, 140, 115, 92, // 14742: decode to FEQ_H using decoder 92
8443 // 14742: }
8444 4, 6, // 14746: case 0x4: {
8445 OPC_CheckPredicate, 85, // 14748: check predicate 85
8446 OPC_Decode, 147, 115, 92, // 14750: decode to FLEQ_H using decoder 92
8447 // 14750: }
8448 5, 0, // 14754: case 0x5: {
8449 OPC_CheckPredicate, 85, // 14756: check predicate 85
8450 OPC_Decode, 165, 115, 92, // 14758: decode to FLTQ_H using decoder 92
8451 // 14758: }
8452 // 14758: } // switch Inst[14:12]
8453 // 14758: }
8454 83, 43, // 14762: case 0x53: {
8455 OPC_SwitchField, 12, 3, // 14764: switch Inst[14:12] {
8456 0, 6, // 14767: case 0x0: {
8457 OPC_CheckPredicate, 27, // 14769: check predicate 27
8458 OPC_Decode, 155, 115, 93, // 14771: decode to FLE_Q using decoder 93
8459 // 14771: }
8460 1, 6, // 14775: case 0x1: {
8461 OPC_CheckPredicate, 27, // 14777: check predicate 27
8462 OPC_Decode, 173, 115, 93, // 14779: decode to FLT_Q using decoder 93
8463 // 14779: }
8464 2, 6, // 14783: case 0x2: {
8465 OPC_CheckPredicate, 27, // 14785: check predicate 27
8466 OPC_Decode, 142, 115, 93, // 14787: decode to FEQ_Q using decoder 93
8467 // 14787: }
8468 4, 6, // 14791: case 0x4: {
8469 OPC_CheckPredicate, 86, // 14793: check predicate 86
8470 OPC_Decode, 148, 115, 93, // 14795: decode to FLEQ_Q using decoder 93
8471 // 14795: }
8472 5, 0, // 14799: case 0x5: {
8473 OPC_CheckPredicate, 86, // 14801: check predicate 86
8474 OPC_Decode, 166, 115, 93, // 14803: decode to FLTQ_Q using decoder 93
8475 // 14803: }
8476 // 14803: } // switch Inst[14:12]
8477 // 14803: }
8478 89, 10, // 14807: case 0x59: {
8479 OPC_CheckPredicate, 91, // 14809: check predicate 91
8480 OPC_CheckField, 12, 3, 0, // 14811: check Inst[14:12] == 0x0
8481 OPC_Decode, 227, 115, 94, // 14815: decode to FMVP_D_X using decoder 94
8482 // 14815: }
8483 91, 10, // 14819: case 0x5b: {
8484 OPC_CheckPredicate, 92, // 14821: check predicate 92
8485 OPC_CheckField, 12, 3, 0, // 14823: check Inst[14:12] == 0x0
8486 OPC_Decode, 228, 115, 95, // 14827: decode to FMVP_Q_X using decoder 95
8487 // 14827: }
8488 96, 35, // 14831: case 0x60: {
8489 OPC_SwitchField, 20, 5, // 14833: switch Inst[24:20] {
8490 0, 6, // 14836: case 0x0: {
8491 OPC_CheckPredicate, 25, // 14838: check predicate 25
8492 OPC_Decode, 252, 114, 96, // 14840: decode to FCVT_W_S using decoder 96
8493 // 14840: }
8494 1, 6, // 14844: case 0x1: {
8495 OPC_CheckPredicate, 25, // 14846: check predicate 25
8496 OPC_Decode, 244, 114, 96, // 14848: decode to FCVT_WU_S using decoder 96
8497 // 14848: }
8498 2, 6, // 14852: case 0x2: {
8499 OPC_CheckPredicate, 93, // 14854: check predicate 93
8500 OPC_Decode, 214, 114, 96, // 14856: decode to FCVT_L_S using decoder 96
8501 // 14856: }
8502 3, 0, // 14860: case 0x3: {
8503 OPC_CheckPredicate, 93, // 14862: check predicate 93
8504 OPC_Decode, 207, 114, 96, // 14864: decode to FCVT_LU_S using decoder 96
8505 // 14864: }
8506 // 14864: } // switch Inst[24:20]
8507 // 14864: }
8508 97, 47, // 14868: case 0x61: {
8509 OPC_SwitchField, 20, 5, // 14870: switch Inst[24:20] {
8510 0, 6, // 14873: case 0x0: {
8511 OPC_CheckPredicate, 26, // 14875: check predicate 26
8512 OPC_Decode, 246, 114, 97, // 14877: decode to FCVT_W_D using decoder 97
8513 // 14877: }
8514 1, 6, // 14881: case 0x1: {
8515 OPC_CheckPredicate, 26, // 14883: check predicate 26
8516 OPC_Decode, 238, 114, 97, // 14885: decode to FCVT_WU_D using decoder 97
8517 // 14885: }
8518 2, 6, // 14889: case 0x2: {
8519 OPC_CheckPredicate, 94, // 14891: check predicate 94
8520 OPC_Decode, 209, 114, 97, // 14893: decode to FCVT_L_D using decoder 97
8521 // 14893: }
8522 3, 6, // 14897: case 0x3: {
8523 OPC_CheckPredicate, 94, // 14899: check predicate 94
8524 OPC_Decode, 202, 114, 97, // 14901: decode to FCVT_LU_D using decoder 97
8525 // 14901: }
8526 8, 0, // 14905: case 0x8: {
8527 OPC_CheckPredicate, 84, // 14907: check predicate 84
8528 OPC_CheckField, 12, 3, 1, // 14909: check Inst[14:12] == 0x1
8529 OPC_Decode, 169, 114, 98, // 14913: decode to FCVTMOD_W_D using decoder 98
8530 // 14913: }
8531 // 14913: } // switch Inst[24:20]
8532 // 14913: }
8533 98, 35, // 14917: case 0x62: {
8534 OPC_SwitchField, 20, 5, // 14919: switch Inst[24:20] {
8535 0, 6, // 14922: case 0x0: {
8536 OPC_CheckPredicate, 82, // 14924: check predicate 82
8537 OPC_Decode, 249, 114, 99, // 14926: decode to FCVT_W_H using decoder 99
8538 // 14926: }
8539 1, 6, // 14930: case 0x1: {
8540 OPC_CheckPredicate, 82, // 14932: check predicate 82
8541 OPC_Decode, 241, 114, 99, // 14934: decode to FCVT_WU_H using decoder 99
8542 // 14934: }
8543 2, 6, // 14938: case 0x2: {
8544 OPC_CheckPredicate, 95, // 14940: check predicate 95
8545 OPC_Decode, 211, 114, 99, // 14942: decode to FCVT_L_H using decoder 99
8546 // 14942: }
8547 3, 0, // 14946: case 0x3: {
8548 OPC_CheckPredicate, 95, // 14948: check predicate 95
8549 OPC_Decode, 204, 114, 99, // 14950: decode to FCVT_LU_H using decoder 99
8550 // 14950: }
8551 // 14950: } // switch Inst[24:20]
8552 // 14950: }
8553 99, 35, // 14954: case 0x63: {
8554 OPC_SwitchField, 20, 5, // 14956: switch Inst[24:20] {
8555 0, 6, // 14959: case 0x0: {
8556 OPC_CheckPredicate, 27, // 14961: check predicate 27
8557 OPC_Decode, 251, 114, 100, // 14963: decode to FCVT_W_Q using decoder 100
8558 // 14963: }
8559 1, 6, // 14967: case 0x1: {
8560 OPC_CheckPredicate, 27, // 14969: check predicate 27
8561 OPC_Decode, 243, 114, 100, // 14971: decode to FCVT_WU_Q using decoder 100
8562 // 14971: }
8563 2, 6, // 14975: case 0x2: {
8564 OPC_CheckPredicate, 96, // 14977: check predicate 96
8565 OPC_Decode, 213, 114, 100, // 14979: decode to FCVT_L_Q using decoder 100
8566 // 14979: }
8567 3, 0, // 14983: case 0x3: {
8568 OPC_CheckPredicate, 96, // 14985: check predicate 96
8569 OPC_Decode, 206, 114, 100, // 14987: decode to FCVT_LU_Q using decoder 100
8570 // 14987: }
8571 // 14987: } // switch Inst[24:20]
8572 // 14987: }
8573 104, 35, // 14991: case 0x68: {
8574 OPC_SwitchField, 20, 5, // 14993: switch Inst[24:20] {
8575 0, 6, // 14996: case 0x0: {
8576 OPC_CheckPredicate, 25, // 14998: check predicate 25
8577 OPC_Decode, 234, 114, 101, // 15000: decode to FCVT_S_W using decoder 101
8578 // 15000: }
8579 1, 6, // 15004: case 0x1: {
8580 OPC_CheckPredicate, 25, // 15006: check predicate 25
8581 OPC_Decode, 235, 114, 101, // 15008: decode to FCVT_S_WU using decoder 101
8582 // 15008: }
8583 2, 6, // 15012: case 0x2: {
8584 OPC_CheckPredicate, 93, // 15014: check predicate 93
8585 OPC_Decode, 229, 114, 101, // 15016: decode to FCVT_S_L using decoder 101
8586 // 15016: }
8587 3, 0, // 15020: case 0x3: {
8588 OPC_CheckPredicate, 93, // 15022: check predicate 93
8589 OPC_Decode, 230, 114, 101, // 15024: decode to FCVT_S_LU using decoder 101
8590 // 15024: }
8591 // 15024: } // switch Inst[24:20]
8592 // 15024: }
8593 105, 35, // 15028: case 0x69: {
8594 OPC_SwitchField, 20, 5, // 15030: switch Inst[24:20] {
8595 0, 6, // 15033: case 0x0: {
8596 OPC_CheckPredicate, 26, // 15035: check predicate 26
8597 OPC_Decode, 182, 114, 102, // 15037: decode to FCVT_D_W using decoder 102
8598 // 15037: }
8599 1, 6, // 15041: case 0x1: {
8600 OPC_CheckPredicate, 26, // 15043: check predicate 26
8601 OPC_Decode, 183, 114, 102, // 15045: decode to FCVT_D_WU using decoder 102
8602 // 15045: }
8603 2, 6, // 15049: case 0x2: {
8604 OPC_CheckPredicate, 94, // 15051: check predicate 94
8605 OPC_Decode, 174, 114, 102, // 15053: decode to FCVT_D_L using decoder 102
8606 // 15053: }
8607 3, 0, // 15057: case 0x3: {
8608 OPC_CheckPredicate, 94, // 15059: check predicate 94
8609 OPC_Decode, 175, 114, 102, // 15061: decode to FCVT_D_LU using decoder 102
8610 // 15061: }
8611 // 15061: } // switch Inst[24:20]
8612 // 15061: }
8613 106, 35, // 15065: case 0x6a: {
8614 OPC_SwitchField, 20, 5, // 15067: switch Inst[24:20] {
8615 0, 6, // 15070: case 0x0: {
8616 OPC_CheckPredicate, 82, // 15072: check predicate 82
8617 OPC_Decode, 198, 114, 103, // 15074: decode to FCVT_H_W using decoder 103
8618 // 15074: }
8619 1, 6, // 15078: case 0x1: {
8620 OPC_CheckPredicate, 82, // 15080: check predicate 82
8621 OPC_Decode, 199, 114, 103, // 15082: decode to FCVT_H_WU using decoder 103
8622 // 15082: }
8623 2, 6, // 15086: case 0x2: {
8624 OPC_CheckPredicate, 95, // 15088: check predicate 95
8625 OPC_Decode, 191, 114, 103, // 15090: decode to FCVT_H_L using decoder 103
8626 // 15090: }
8627 3, 0, // 15094: case 0x3: {
8628 OPC_CheckPredicate, 95, // 15096: check predicate 95
8629 OPC_Decode, 192, 114, 103, // 15098: decode to FCVT_H_LU using decoder 103
8630 // 15098: }
8631 // 15098: } // switch Inst[24:20]
8632 // 15098: }
8633 107, 35, // 15102: case 0x6b: {
8634 OPC_SwitchField, 20, 5, // 15104: switch Inst[24:20] {
8635 0, 6, // 15107: case 0x0: {
8636 OPC_CheckPredicate, 27, // 15109: check predicate 27
8637 OPC_Decode, 221, 114, 104, // 15111: decode to FCVT_Q_W using decoder 104
8638 // 15111: }
8639 1, 6, // 15115: case 0x1: {
8640 OPC_CheckPredicate, 27, // 15117: check predicate 27
8641 OPC_Decode, 222, 114, 104, // 15119: decode to FCVT_Q_WU using decoder 104
8642 // 15119: }
8643 2, 6, // 15123: case 0x2: {
8644 OPC_CheckPredicate, 96, // 15125: check predicate 96
8645 OPC_Decode, 218, 114, 104, // 15127: decode to FCVT_Q_L using decoder 104
8646 // 15127: }
8647 3, 0, // 15131: case 0x3: {
8648 OPC_CheckPredicate, 96, // 15133: check predicate 96
8649 OPC_Decode, 219, 114, 104, // 15135: decode to FCVT_Q_LU using decoder 104
8650 // 15135: }
8651 // 15135: } // switch Inst[24:20]
8652 // 15135: }
8653 112, 27, // 15139: case 0x70: {
8654 OPC_SwitchField, 12, 3, // 15141: switch Inst[14:12] {
8655 0, 10, // 15144: case 0x0: {
8656 OPC_CheckPredicate, 25, // 15146: check predicate 25
8657 OPC_CheckField, 20, 5, 0, // 15148: check Inst[24:20] == 0x0
8658 OPC_Decode, 234, 115, 105, // 15152: decode to FMV_X_W using decoder 105
8659 // 15152: }
8660 1, 0, // 15156: case 0x1: {
8661 OPC_CheckPredicate, 25, // 15158: check predicate 25
8662 OPC_CheckField, 20, 5, 0, // 15160: check Inst[24:20] == 0x0
8663 OPC_Decode, 167, 114, 105, // 15164: decode to FCLASS_S using decoder 105
8664 // 15164: }
8665 // 15164: } // switch Inst[14:12]
8666 // 15164: }
8667 113, 36, // 15168: case 0x71: {
8668 OPC_SwitchField, 12, 3, // 15170: switch Inst[14:12] {
8669 0, 19, // 15173: case 0x0: {
8670 OPC_SwitchField, 20, 5, // 15175: switch Inst[24:20] {
8671 0, 6, // 15178: case 0x0: {
8672 OPC_CheckPredicate, 94, // 15180: check predicate 94
8673 OPC_Decode, 232, 115, 106, // 15182: decode to FMV_X_D using decoder 106
8674 // 15182: }
8675 1, 0, // 15186: case 0x1: {
8676 OPC_CheckPredicate, 91, // 15188: check predicate 91
8677 OPC_Decode, 225, 115, 106, // 15190: decode to FMVH_X_D using decoder 106
8678 // 15190: }
8679 // 15190: } // switch Inst[24:20]
8680 // 15190: }
8681 1, 0, // 15194: case 0x1: {
8682 OPC_CheckPredicate, 26, // 15196: check predicate 26
8683 OPC_CheckField, 20, 5, 0, // 15198: check Inst[24:20] == 0x0
8684 OPC_Decode, 161, 114, 106, // 15202: decode to FCLASS_D using decoder 106
8685 // 15202: }
8686 // 15202: } // switch Inst[14:12]
8687 // 15202: }
8688 114, 27, // 15206: case 0x72: {
8689 OPC_SwitchField, 12, 3, // 15208: switch Inst[14:12] {
8690 0, 10, // 15211: case 0x0: {
8691 OPC_CheckPredicate, 24, // 15213: check predicate 24
8692 OPC_CheckField, 20, 5, 0, // 15215: check Inst[24:20] == 0x0
8693 OPC_Decode, 233, 115, 107, // 15219: decode to FMV_X_H using decoder 107
8694 // 15219: }
8695 1, 0, // 15223: case 0x1: {
8696 OPC_CheckPredicate, 82, // 15225: check predicate 82
8697 OPC_CheckField, 20, 5, 0, // 15227: check Inst[24:20] == 0x0
8698 OPC_Decode, 164, 114, 107, // 15231: decode to FCLASS_H using decoder 107
8699 // 15231: }
8700 // 15231: } // switch Inst[14:12]
8701 // 15231: }
8702 115, 27, // 15235: case 0x73: {
8703 OPC_SwitchField, 12, 3, // 15237: switch Inst[14:12] {
8704 0, 10, // 15240: case 0x0: {
8705 OPC_CheckPredicate, 92, // 15242: check predicate 92
8706 OPC_CheckField, 20, 5, 1, // 15244: check Inst[24:20] == 0x1
8707 OPC_Decode, 226, 115, 108, // 15248: decode to FMVH_X_Q using decoder 108
8708 // 15248: }
8709 1, 0, // 15252: case 0x1: {
8710 OPC_CheckPredicate, 27, // 15254: check predicate 27
8711 OPC_CheckField, 20, 5, 0, // 15256: check Inst[24:20] == 0x0
8712 OPC_Decode, 166, 114, 108, // 15260: decode to FCLASS_Q using decoder 108
8713 // 15260: }
8714 // 15260: } // switch Inst[14:12]
8715 // 15260: }
8716 120, 27, // 15264: case 0x78: {
8717 OPC_SwitchField, 20, 5, // 15266: switch Inst[24:20] {
8718 0, 10, // 15269: case 0x0: {
8719 OPC_CheckPredicate, 25, // 15271: check predicate 25
8720 OPC_CheckField, 12, 3, 0, // 15273: check Inst[14:12] == 0x0
8721 OPC_Decode, 231, 115, 109, // 15277: decode to FMV_W_X using decoder 109
8722 // 15277: }
8723 1, 0, // 15281: case 0x1: {
8724 OPC_CheckPredicate, 83, // 15283: check predicate 83
8725 OPC_CheckField, 12, 3, 0, // 15285: check Inst[14:12] == 0x0
8726 OPC_Decode, 162, 115, 110, // 15289: decode to FLI_S using decoder 110
8727 // 15289: }
8728 // 15289: } // switch Inst[24:20]
8729 // 15289: }
8730 121, 27, // 15293: case 0x79: {
8731 OPC_SwitchField, 20, 5, // 15295: switch Inst[24:20] {
8732 0, 10, // 15298: case 0x0: {
8733 OPC_CheckPredicate, 94, // 15300: check predicate 94
8734 OPC_CheckField, 12, 3, 0, // 15302: check Inst[14:12] == 0x0
8735 OPC_Decode, 229, 115, 111, // 15306: decode to FMV_D_X using decoder 111
8736 // 15306: }
8737 1, 0, // 15310: case 0x1: {
8738 OPC_CheckPredicate, 84, // 15312: check predicate 84
8739 OPC_CheckField, 12, 3, 0, // 15314: check Inst[14:12] == 0x0
8740 OPC_Decode, 159, 115, 112, // 15318: decode to FLI_D using decoder 112
8741 // 15318: }
8742 // 15318: } // switch Inst[24:20]
8743 // 15318: }
8744 122, 27, // 15322: case 0x7a: {
8745 OPC_SwitchField, 20, 5, // 15324: switch Inst[24:20] {
8746 0, 10, // 15327: case 0x0: {
8747 OPC_CheckPredicate, 24, // 15329: check predicate 24
8748 OPC_CheckField, 12, 3, 0, // 15331: check Inst[14:12] == 0x0
8749 OPC_Decode, 230, 115, 113, // 15335: decode to FMV_H_X using decoder 113
8750 // 15335: }
8751 1, 0, // 15339: case 0x1: {
8752 OPC_CheckPredicate, 97, // 15341: check predicate 97
8753 OPC_CheckField, 12, 3, 0, // 15343: check Inst[14:12] == 0x0
8754 OPC_Decode, 160, 115, 114, // 15347: decode to FLI_H using decoder 114
8755 // 15347: }
8756 // 15347: } // switch Inst[24:20]
8757 // 15347: }
8758 123, 0, // 15351: case 0x7b: {
8759 OPC_CheckPredicate, 86, // 15353: check predicate 86
8760 OPC_CheckField, 20, 5, 1, // 15355: check Inst[24:20] == 0x1
8761 OPC_CheckField, 12, 3, 0, // 15359: check Inst[14:12] == 0x0
8762 OPC_Decode, 161, 115, 115, // 15363: decode to FLI_Q using decoder 115
8763 // 15363: }
8764 // 15363: } // switch Inst[31:25]
8765 // 15363: }
8766 87, 185, 29, // 15367: case 0x57: {
8767 OPC_SwitchField, 12, 3, // 15370: switch Inst[14:12] {
8768 0, 152, 4, // 15373: case 0x0: {
8769 OPC_SwitchField, 26, 6, // 15376: switch Inst[31:26] {
8770 0, 6, // 15379: case 0x0: {
8771 OPC_CheckPredicate, 23, // 15381: check predicate 23
8772 OPC_Decode, 156, 126, 116, // 15383: decode to VADD_VV using decoder 116
8773 // 15383: }
8774 1, 6, // 15387: case 0x1: {
8775 OPC_CheckPredicate, 98, // 15389: check predicate 98
8776 OPC_Decode, 169, 126, 116, // 15391: decode to VANDN_VV using decoder 116
8777 // 15391: }
8778 2, 7, // 15395: case 0x2: {
8779 OPC_CheckPredicate, 23, // 15397: check predicate 23
8780 OPC_Decode, 180, 131, 1, 116, // 15399: decode to VSUB_VV using decoder 116
8781 // 15399: }
8782 4, 7, // 15404: case 0x4: {
8783 OPC_CheckPredicate, 23, // 15406: check predicate 23
8784 OPC_Decode, 172, 129, 1, 116, // 15408: decode to VMINU_VV using decoder 116
8785 // 15408: }
8786 5, 7, // 15413: case 0x5: {
8787 OPC_CheckPredicate, 23, // 15415: check predicate 23
8788 OPC_Decode, 174, 129, 1, 116, // 15417: decode to VMIN_VV using decoder 116
8789 // 15417: }
8790 6, 7, // 15422: case 0x6: {
8791 OPC_CheckPredicate, 23, // 15424: check predicate 23
8792 OPC_Decode, 155, 129, 1, 116, // 15426: decode to VMAXU_VV using decoder 116
8793 // 15426: }
8794 7, 7, // 15431: case 0x7: {
8795 OPC_CheckPredicate, 23, // 15433: check predicate 23
8796 OPC_Decode, 157, 129, 1, 116, // 15435: decode to VMAX_VV using decoder 116
8797 // 15435: }
8798 9, 6, // 15440: case 0x9: {
8799 OPC_CheckPredicate, 23, // 15442: check predicate 23
8800 OPC_Decode, 172, 126, 116, // 15444: decode to VAND_VV using decoder 116
8801 // 15444: }
8802 10, 7, // 15448: case 0xa: {
8803 OPC_CheckPredicate, 23, // 15450: check predicate 23
8804 OPC_Decode, 252, 129, 1, 116, // 15452: decode to VOR_VV using decoder 116
8805 // 15452: }
8806 11, 7, // 15457: case 0xb: {
8807 OPC_CheckPredicate, 23, // 15459: check predicate 23
8808 OPC_Decode, 129, 132, 1, 116, // 15461: decode to VXOR_VV using decoder 116
8809 // 15461: }
8810 12, 7, // 15466: case 0xc: {
8811 OPC_CheckPredicate, 23, // 15468: check predicate 23
8812 OPC_Decode, 149, 130, 1, 116, // 15470: decode to VRGATHER_VV using decoder 116
8813 // 15470: }
8814 14, 7, // 15475: case 0xe: {
8815 OPC_CheckPredicate, 23, // 15477: check predicate 23
8816 OPC_Decode, 147, 130, 1, 116, // 15479: decode to VRGATHEREI16_VV using decoder 116
8817 // 15479: }
8818 15, 7, // 15484: case 0xf: {
8819 OPC_CheckPredicate, 99, // 15486: check predicate 99
8820 OPC_Decode, 255, 129, 1, 116, // 15488: decode to VPAIRE_VV using decoder 116
8821 // 15488: }
8822 16, 10, // 15493: case 0x10: {
8823 OPC_CheckPredicate, 23, // 15495: check predicate 23
8824 OPC_CheckField, 25, 1, 0, // 15497: check Inst[25] == 0x0
8825 OPC_Decode, 153, 126, 117, // 15501: decode to VADC_VVM using decoder 117
8826 // 15501: }
8827 17, 21, // 15505: case 0x11: {
8828 OPC_SwitchField, 25, 1, // 15507: switch Inst[25] {
8829 0, 7, // 15510: case 0x0: {
8830 OPC_CheckPredicate, 23, // 15512: check predicate 23
8831 OPC_Decode, 252, 128, 1, 117, // 15514: decode to VMADC_VVM using decoder 117
8832 // 15514: }
8833 1, 0, // 15519: case 0x1: {
8834 OPC_CheckPredicate, 23, // 15521: check predicate 23
8835 OPC_Decode, 251, 128, 1, 118, // 15523: decode to VMADC_VV using decoder 118
8836 // 15523: }
8837 // 15523: } // switch Inst[25]
8838 // 15523: }
8839 18, 11, // 15528: case 0x12: {
8840 OPC_CheckPredicate, 23, // 15530: check predicate 23
8841 OPC_CheckField, 25, 1, 0, // 15532: check Inst[25] == 0x0
8842 OPC_Decode, 168, 130, 1, 117, // 15536: decode to VSBC_VVM using decoder 117
8843 // 15536: }
8844 19, 21, // 15541: case 0x13: {
8845 OPC_SwitchField, 25, 1, // 15543: switch Inst[25] {
8846 0, 7, // 15546: case 0x0: {
8847 OPC_CheckPredicate, 23, // 15548: check predicate 23
8848 OPC_Decode, 182, 129, 1, 117, // 15550: decode to VMSBC_VVM using decoder 117
8849 // 15550: }
8850 1, 0, // 15555: case 0x1: {
8851 OPC_CheckPredicate, 23, // 15557: check predicate 23
8852 OPC_Decode, 181, 129, 1, 118, // 15559: decode to VMSBC_VV using decoder 118
8853 // 15559: }
8854 // 15559: } // switch Inst[25]
8855 // 15559: }
8856 20, 7, // 15564: case 0x14: {
8857 OPC_CheckPredicate, 98, // 15566: check predicate 98
8858 OPC_Decode, 154, 130, 1, 116, // 15568: decode to VROR_VV using decoder 116
8859 // 15568: }
8860 21, 7, // 15573: case 0x15: {
8861 OPC_CheckPredicate, 98, // 15575: check predicate 98
8862 OPC_Decode, 151, 130, 1, 116, // 15577: decode to VROL_VV using decoder 116
8863 // 15577: }
8864 23, 25, // 15582: case 0x17: {
8865 OPC_SwitchField, 25, 1, // 15584: switch Inst[25] {
8866 0, 7, // 15587: case 0x0: {
8867 OPC_CheckPredicate, 23, // 15589: check predicate 23
8868 OPC_Decode, 160, 129, 1, 117, // 15591: decode to VMERGE_VVM using decoder 117
8869 // 15591: }
8870 1, 0, // 15596: case 0x1: {
8871 OPC_CheckPredicate, 23, // 15598: check predicate 23
8872 OPC_CheckField, 20, 5, 0, // 15600: check Inst[24:20] == 0x0
8873 OPC_Decode, 226, 129, 1, 119, // 15604: decode to VMV_V_V using decoder 119
8874 // 15604: }
8875 // 15604: } // switch Inst[25]
8876 // 15604: }
8877 24, 7, // 15609: case 0x18: {
8878 OPC_CheckPredicate, 23, // 15611: check predicate 23
8879 OPC_Decode, 187, 129, 1, 116, // 15613: decode to VMSEQ_VV using decoder 116
8880 // 15613: }
8881 25, 7, // 15618: case 0x19: {
8882 OPC_CheckPredicate, 23, // 15620: check predicate 23
8883 OPC_Decode, 205, 129, 1, 116, // 15622: decode to VMSNE_VV using decoder 116
8884 // 15622: }
8885 26, 7, // 15627: case 0x1a: {
8886 OPC_CheckPredicate, 23, // 15629: check predicate 23
8887 OPC_Decode, 200, 129, 1, 116, // 15631: decode to VMSLTU_VV using decoder 116
8888 // 15631: }
8889 27, 7, // 15636: case 0x1b: {
8890 OPC_CheckPredicate, 23, // 15638: check predicate 23
8891 OPC_Decode, 202, 129, 1, 116, // 15640: decode to VMSLT_VV using decoder 116
8892 // 15640: }
8893 28, 7, // 15645: case 0x1c: {
8894 OPC_CheckPredicate, 23, // 15647: check predicate 23
8895 OPC_Decode, 195, 129, 1, 116, // 15649: decode to VMSLEU_VV using decoder 116
8896 // 15649: }
8897 29, 7, // 15654: case 0x1d: {
8898 OPC_CheckPredicate, 23, // 15656: check predicate 23
8899 OPC_Decode, 198, 129, 1, 116, // 15658: decode to VMSLE_VV using decoder 116
8900 // 15658: }
8901 32, 7, // 15663: case 0x20: {
8902 OPC_CheckPredicate, 23, // 15665: check predicate 23
8903 OPC_Decode, 163, 130, 1, 116, // 15667: decode to VSADDU_VV using decoder 116
8904 // 15667: }
8905 33, 7, // 15672: case 0x21: {
8906 OPC_CheckPredicate, 23, // 15674: check predicate 23
8907 OPC_Decode, 166, 130, 1, 116, // 15676: decode to VSADD_VV using decoder 116
8908 // 15676: }
8909 34, 7, // 15681: case 0x22: {
8910 OPC_CheckPredicate, 23, // 15683: check predicate 23
8911 OPC_Decode, 176, 131, 1, 116, // 15685: decode to VSSUBU_VV using decoder 116
8912 // 15685: }
8913 35, 7, // 15690: case 0x23: {
8914 OPC_CheckPredicate, 23, // 15692: check predicate 23
8915 OPC_Decode, 178, 131, 1, 116, // 15694: decode to VSSUB_VV using decoder 116
8916 // 15694: }
8917 37, 7, // 15699: case 0x25: {
8918 OPC_CheckPredicate, 23, // 15701: check predicate 23
8919 OPC_Decode, 190, 130, 1, 116, // 15703: decode to VSLL_VV using decoder 116
8920 // 15703: }
8921 39, 7, // 15708: case 0x27: {
8922 OPC_CheckPredicate, 23, // 15710: check predicate 23
8923 OPC_Decode, 197, 130, 1, 116, // 15712: decode to VSMUL_VV using decoder 116
8924 // 15712: }
8925 40, 7, // 15717: case 0x28: {
8926 OPC_CheckPredicate, 23, // 15719: check predicate 23
8927 OPC_Decode, 236, 130, 1, 116, // 15721: decode to VSRL_VV using decoder 116
8928 // 15721: }
8929 41, 7, // 15726: case 0x29: {
8930 OPC_CheckPredicate, 23, // 15728: check predicate 23
8931 OPC_Decode, 233, 130, 1, 116, // 15730: decode to VSRA_VV using decoder 116
8932 // 15730: }
8933 42, 7, // 15735: case 0x2a: {
8934 OPC_CheckPredicate, 23, // 15737: check predicate 23
8935 OPC_Decode, 146, 131, 1, 116, // 15739: decode to VSSRL_VV using decoder 116
8936 // 15739: }
8937 43, 7, // 15744: case 0x2b: {
8938 OPC_CheckPredicate, 23, // 15746: check predicate 23
8939 OPC_Decode, 143, 131, 1, 116, // 15748: decode to VSSRA_VV using decoder 116
8940 // 15748: }
8941 44, 7, // 15753: case 0x2c: {
8942 OPC_CheckPredicate, 23, // 15755: check predicate 23
8943 OPC_Decode, 249, 129, 1, 116, // 15757: decode to VNSRL_WV using decoder 116
8944 // 15757: }
8945 45, 7, // 15762: case 0x2d: {
8946 OPC_CheckPredicate, 23, // 15764: check predicate 23
8947 OPC_Decode, 246, 129, 1, 116, // 15766: decode to VNSRA_WV using decoder 116
8948 // 15766: }
8949 46, 7, // 15771: case 0x2e: {
8950 OPC_CheckPredicate, 23, // 15773: check predicate 23
8951 OPC_Decode, 232, 129, 1, 116, // 15775: decode to VNCLIPU_WV using decoder 116
8952 // 15775: }
8953 47, 7, // 15780: case 0x2f: {
8954 OPC_CheckPredicate, 23, // 15782: check predicate 23
8955 OPC_Decode, 235, 129, 1, 116, // 15784: decode to VNCLIP_WV using decoder 116
8956 // 15784: }
8957 48, 7, // 15789: case 0x30: {
8958 OPC_CheckPredicate, 23, // 15791: check predicate 23
8959 OPC_Decode, 243, 131, 1, 116, // 15793: decode to VWREDSUMU_VS using decoder 116
8960 // 15793: }
8961 49, 7, // 15798: case 0x31: {
8962 OPC_CheckPredicate, 23, // 15800: check predicate 23
8963 OPC_Decode, 244, 131, 1, 116, // 15802: decode to VWREDSUM_VS using decoder 116
8964 // 15802: }
8965 53, 7, // 15807: case 0x35: {
8966 OPC_CheckPredicate, 100, // 15809: check predicate 100
8967 OPC_Decode, 246, 131, 1, 116, // 15811: decode to VWSLL_VV using decoder 116
8968 // 15811: }
8969 56, 11, // 15816: case 0x38: {
8970 OPC_CheckPredicate, 101, // 15818: check predicate 101
8971 OPC_CheckField, 25, 1, 1, // 15820: check Inst[25] == 0x1
8972 OPC_Decode, 176, 129, 1, 120, // 15824: decode to VMMACC_VV using decoder 120
8973 // 15824: }
8974 57, 20, // 15829: case 0x39: {
8975 OPC_SwitchField, 25, 1, // 15831: switch Inst[25] {
8976 0, 6, // 15834: case 0x0: {
8977 OPC_CheckPredicate, 102, // 15836: check predicate 102
8978 OPC_Decode, 167, 127, 121, // 15838: decode to VFWIMMACC_VV using decoder 121
8979 // 15838: }
8980 1, 0, // 15842: case 0x1: {
8981 OPC_CheckPredicate, 101, // 15844: check predicate 101
8982 OPC_Decode, 236, 131, 1, 120, // 15846: decode to VWMMACC_VV using decoder 120
8983 // 15846: }
8984 // 15846: } // switch Inst[25]
8985 // 15846: }
8986 58, 20, // 15851: case 0x3a: {
8987 OPC_SwitchField, 25, 1, // 15853: switch Inst[25] {
8988 0, 6, // 15856: case 0x0: {
8989 OPC_CheckPredicate, 102, // 15858: check predicate 102
8990 OPC_Decode, 255, 126, 121, // 15860: decode to VFQIMMACC_VV using decoder 121
8991 // 15860: }
8992 1, 0, // 15864: case 0x1: {
8993 OPC_CheckPredicate, 101, // 15866: check predicate 101
8994 OPC_Decode, 129, 130, 1, 120, // 15868: decode to VQMMACC_VV using decoder 120
8995 // 15868: }
8996 // 15868: } // switch Inst[25]
8997 // 15868: }
8998 59, 19, // 15873: case 0x3b: {
8999 OPC_SwitchField, 25, 1, // 15875: switch Inst[25] {
9000 0, 6, // 15878: case 0x0: {
9001 OPC_CheckPredicate, 102, // 15880: check predicate 102
9002 OPC_Decode, 200, 126, 121, // 15882: decode to VF8WIMMACC_VV using decoder 121
9003 // 15882: }
9004 1, 0, // 15886: case 0x1: {
9005 OPC_CheckPredicate, 101, // 15888: check predicate 101
9006 OPC_Decode, 143, 126, 120, // 15890: decode to V8WMMACC_VV using decoder 120
9007 // 15890: }
9008 // 15890: } // switch Inst[25]
9009 // 15890: }
9010 61, 7, // 15894: case 0x3d: {
9011 OPC_CheckPredicate, 103, // 15896: check predicate 103
9012 OPC_Decode, 219, 131, 1, 122, // 15898: decode to VWABDA_VV using decoder 122
9013 // 15898: }
9014 62, 0, // 15903: case 0x3e: {
9015 OPC_CheckPredicate, 103, // 15905: check predicate 103
9016 OPC_Decode, 217, 131, 1, 122, // 15907: decode to VWABDAU_VV using decoder 122
9017 // 15907: }
9018 // 15907: } // switch Inst[31:26]
9019 // 15907: }
9020 1, 133, 5, // 15912: case 0x1: {
9021 OPC_SwitchField, 26, 6, // 15915: switch Inst[31:26] {
9022 0, 6, // 15918: case 0x0: {
9023 OPC_CheckPredicate, 104, // 15920: check predicate 104
9024 OPC_Decode, 204, 126, 116, // 15922: decode to VFADD_VV using decoder 116
9025 // 15922: }
9026 1, 6, // 15926: case 0x1: {
9027 OPC_CheckPredicate, 104, // 15928: check predicate 104
9028 OPC_Decode, 139, 127, 116, // 15930: decode to VFREDUSUM_VS using decoder 116
9029 // 15930: }
9030 2, 6, // 15934: case 0x2: {
9031 OPC_CheckPredicate, 104, // 15936: check predicate 104
9032 OPC_Decode, 152, 127, 116, // 15938: decode to VFSUB_VV using decoder 116
9033 // 15938: }
9034 3, 6, // 15942: case 0x3: {
9035 OPC_CheckPredicate, 104, // 15944: check predicate 104
9036 OPC_Decode, 138, 127, 116, // 15946: decode to VFREDOSUM_VS using decoder 116
9037 // 15946: }
9038 4, 6, // 15950: case 0x4: {
9039 OPC_CheckPredicate, 104, // 15952: check predicate 104
9040 OPC_Decode, 224, 126, 116, // 15954: decode to VFMIN_VV using decoder 116
9041 // 15954: }
9042 5, 6, // 15958: case 0x5: {
9043 OPC_CheckPredicate, 104, // 15960: check predicate 104
9044 OPC_Decode, 137, 127, 116, // 15962: decode to VFREDMIN_VS using decoder 116
9045 // 15962: }
9046 6, 6, // 15966: case 0x6: {
9047 OPC_CheckPredicate, 104, // 15968: check predicate 104
9048 OPC_Decode, 221, 126, 116, // 15970: decode to VFMAX_VV using decoder 116
9049 // 15970: }
9050 7, 6, // 15974: case 0x7: {
9051 OPC_CheckPredicate, 104, // 15976: check predicate 104
9052 OPC_Decode, 136, 127, 116, // 15978: decode to VFREDMAX_VS using decoder 116
9053 // 15978: }
9054 8, 6, // 15982: case 0x8: {
9055 OPC_CheckPredicate, 104, // 15984: check predicate 104
9056 OPC_Decode, 147, 127, 116, // 15986: decode to VFSGNJ_VV using decoder 116
9057 // 15986: }
9058 9, 6, // 15990: case 0x9: {
9059 OPC_CheckPredicate, 104, // 15992: check predicate 104
9060 OPC_Decode, 143, 127, 116, // 15994: decode to VFSGNJN_VV using decoder 116
9061 // 15994: }
9062 10, 6, // 15998: case 0xa: {
9063 OPC_CheckPredicate, 104, // 16000: check predicate 104
9064 OPC_Decode, 145, 127, 116, // 16002: decode to VFSGNJX_VV using decoder 116
9065 // 16002: }
9066 16, 14, // 16006: case 0x10: {
9067 OPC_CheckPredicate, 104, // 16008: check predicate 104
9068 OPC_CheckField, 25, 1, 1, // 16010: check Inst[25] == 0x1
9069 OPC_CheckField, 15, 5, 0, // 16014: check Inst[19:15] == 0x0
9070 OPC_Decode, 232, 126, 123, // 16018: decode to VFMV_F_S using decoder 123
9071 // 16018: }
9072 18, 211, 1, // 16022: case 0x12: {
9073 OPC_SwitchField, 15, 5, // 16025: switch Inst[19:15] {
9074 0, 6, // 16028: case 0x0: {
9075 OPC_CheckPredicate, 104, // 16030: check predicate 104
9076 OPC_Decode, 211, 126, 124, // 16032: decode to VFCVT_XU_F_V using decoder 124
9077 // 16032: }
9078 1, 6, // 16036: case 0x1: {
9079 OPC_CheckPredicate, 104, // 16038: check predicate 104
9080 OPC_Decode, 212, 126, 124, // 16040: decode to VFCVT_X_F_V using decoder 124
9081 // 16040: }
9082 2, 6, // 16044: case 0x2: {
9083 OPC_CheckPredicate, 104, // 16046: check predicate 104
9084 OPC_Decode, 207, 126, 124, // 16048: decode to VFCVT_F_XU_V using decoder 124
9085 // 16048: }
9086 3, 6, // 16052: case 0x3: {
9087 OPC_CheckPredicate, 104, // 16054: check predicate 104
9088 OPC_Decode, 208, 126, 124, // 16056: decode to VFCVT_F_X_V using decoder 124
9089 // 16056: }
9090 6, 6, // 16060: case 0x6: {
9091 OPC_CheckPredicate, 104, // 16062: check predicate 104
9092 OPC_Decode, 209, 126, 124, // 16064: decode to VFCVT_RTZ_XU_F_V using decoder 124
9093 // 16064: }
9094 7, 6, // 16068: case 0x7: {
9095 OPC_CheckPredicate, 104, // 16070: check predicate 104
9096 OPC_Decode, 210, 126, 124, // 16072: decode to VFCVT_RTZ_X_F_V using decoder 124
9097 // 16072: }
9098 8, 6, // 16076: case 0x8: {
9099 OPC_CheckPredicate, 104, // 16078: check predicate 104
9100 OPC_Decode, 164, 127, 124, // 16080: decode to VFWCVT_XU_F_V using decoder 124
9101 // 16080: }
9102 9, 6, // 16084: case 0x9: {
9103 OPC_CheckPredicate, 104, // 16086: check predicate 104
9104 OPC_Decode, 165, 127, 124, // 16088: decode to VFWCVT_X_F_V using decoder 124
9105 // 16088: }
9106 10, 6, // 16092: case 0xa: {
9107 OPC_CheckPredicate, 104, // 16094: check predicate 104
9108 OPC_Decode, 160, 127, 124, // 16096: decode to VFWCVT_F_XU_V using decoder 124
9109 // 16096: }
9110 11, 6, // 16100: case 0xb: {
9111 OPC_CheckPredicate, 104, // 16102: check predicate 104
9112 OPC_Decode, 161, 127, 124, // 16104: decode to VFWCVT_F_X_V using decoder 124
9113 // 16104: }
9114 12, 6, // 16108: case 0xc: {
9115 OPC_CheckPredicate, 104, // 16110: check predicate 104
9116 OPC_Decode, 159, 127, 124, // 16112: decode to VFWCVT_F_F_V using decoder 124
9117 // 16112: }
9118 13, 6, // 16116: case 0xd: {
9119 OPC_CheckPredicate, 105, // 16118: check predicate 105
9120 OPC_Decode, 158, 127, 124, // 16120: decode to VFWCVTBF16_F_F_V using decoder 124
9121 // 16120: }
9122 14, 6, // 16124: case 0xe: {
9123 OPC_CheckPredicate, 104, // 16126: check predicate 104
9124 OPC_Decode, 162, 127, 124, // 16128: decode to VFWCVT_RTZ_XU_F_V using decoder 124
9125 // 16128: }
9126 15, 6, // 16132: case 0xf: {
9127 OPC_CheckPredicate, 104, // 16134: check predicate 104
9128 OPC_Decode, 163, 127, 124, // 16136: decode to VFWCVT_RTZ_X_F_V using decoder 124
9129 // 16136: }
9130 16, 6, // 16140: case 0x10: {
9131 OPC_CheckPredicate, 104, // 16142: check predicate 104
9132 OPC_Decode, 245, 126, 124, // 16144: decode to VFNCVT_XU_F_W using decoder 124
9133 // 16144: }
9134 17, 6, // 16148: case 0x11: {
9135 OPC_CheckPredicate, 104, // 16150: check predicate 104
9136 OPC_Decode, 246, 126, 124, // 16152: decode to VFNCVT_X_F_W using decoder 124
9137 // 16152: }
9138 18, 6, // 16156: case 0x12: {
9139 OPC_CheckPredicate, 104, // 16158: check predicate 104
9140 OPC_Decode, 239, 126, 124, // 16160: decode to VFNCVT_F_XU_W using decoder 124
9141 // 16160: }
9142 19, 6, // 16164: case 0x13: {
9143 OPC_CheckPredicate, 104, // 16166: check predicate 104
9144 OPC_Decode, 240, 126, 124, // 16168: decode to VFNCVT_F_X_W using decoder 124
9145 // 16168: }
9146 20, 6, // 16172: case 0x14: {
9147 OPC_CheckPredicate, 104, // 16174: check predicate 104
9148 OPC_Decode, 238, 126, 124, // 16176: decode to VFNCVT_F_F_W using decoder 124
9149 // 16176: }
9150 21, 6, // 16180: case 0x15: {
9151 OPC_CheckPredicate, 104, // 16182: check predicate 104
9152 OPC_Decode, 241, 126, 124, // 16184: decode to VFNCVT_ROD_F_F_W using decoder 124
9153 // 16184: }
9154 22, 6, // 16188: case 0x16: {
9155 OPC_CheckPredicate, 104, // 16190: check predicate 104
9156 OPC_Decode, 242, 126, 124, // 16192: decode to VFNCVT_RTZ_XU_F_W using decoder 124
9157 // 16192: }
9158 23, 6, // 16196: case 0x17: {
9159 OPC_CheckPredicate, 104, // 16198: check predicate 104
9160 OPC_Decode, 243, 126, 124, // 16200: decode to VFNCVT_RTZ_X_F_W using decoder 124
9161 // 16200: }
9162 25, 6, // 16204: case 0x19: {
9163 OPC_CheckPredicate, 106, // 16206: check predicate 106
9164 OPC_Decode, 237, 126, 124, // 16208: decode to VFNCVT_F_F_Q using decoder 124
9165 // 16208: }
9166 27, 6, // 16212: case 0x1b: {
9167 OPC_CheckPredicate, 106, // 16214: check predicate 106
9168 OPC_Decode, 244, 126, 124, // 16216: decode to VFNCVT_SAT_F_F_Q using decoder 124
9169 // 16216: }
9170 29, 6, // 16220: case 0x1d: {
9171 OPC_CheckPredicate, 105, // 16222: check predicate 105
9172 OPC_Decode, 235, 126, 124, // 16224: decode to VFNCVTBF16_F_F_W using decoder 124
9173 // 16224: }
9174 31, 0, // 16228: case 0x1f: {
9175 OPC_CheckPredicate, 106, // 16230: check predicate 106
9176 OPC_Decode, 236, 126, 124, // 16232: decode to VFNCVTBF16_SAT_F_F_W using decoder 124
9177 // 16232: }
9178 // 16232: } // switch Inst[19:15]
9179 // 16232: }
9180 19, 35, // 16236: case 0x13: {
9181 OPC_SwitchField, 15, 5, // 16238: switch Inst[19:15] {
9182 0, 6, // 16241: case 0x0: {
9183 OPC_CheckPredicate, 104, // 16243: check predicate 104
9184 OPC_Decode, 150, 127, 124, // 16245: decode to VFSQRT_V using decoder 124
9185 // 16245: }
9186 4, 6, // 16249: case 0x4: {
9187 OPC_CheckPredicate, 104, // 16251: check predicate 104
9188 OPC_Decode, 140, 127, 124, // 16253: decode to VFRSQRT7_V using decoder 124
9189 // 16253: }
9190 5, 6, // 16257: case 0x5: {
9191 OPC_CheckPredicate, 104, // 16259: check predicate 104
9192 OPC_Decode, 135, 127, 124, // 16261: decode to VFREC7_V using decoder 124
9193 // 16261: }
9194 16, 0, // 16265: case 0x10: {
9195 OPC_CheckPredicate, 104, // 16267: check predicate 104
9196 OPC_Decode, 206, 126, 124, // 16269: decode to VFCLASS_V using decoder 124
9197 // 16269: }
9198 // 16269: } // switch Inst[19:15]
9199 // 16269: }
9200 20, 10, // 16273: case 0x14: {
9201 OPC_CheckPredicate, 102, // 16275: check predicate 102
9202 OPC_CheckField, 25, 1, 1, // 16277: check Inst[25] == 0x1
9203 OPC_Decode, 225, 126, 120, // 16281: decode to VFMMACC_VV using decoder 120
9204 // 16281: }
9205 21, 19, // 16285: case 0x15: {
9206 OPC_SwitchField, 25, 1, // 16287: switch Inst[25] {
9207 0, 6, // 16290: case 0x0: {
9208 OPC_CheckPredicate, 102, // 16292: check predicate 102
9209 OPC_Decode, 177, 127, 121, // 16294: decode to VFWMMACC_VV_SCALE using decoder 121
9210 // 16294: }
9211 1, 0, // 16298: case 0x1: {
9212 OPC_CheckPredicate, 102, // 16300: check predicate 102
9213 OPC_Decode, 176, 127, 120, // 16302: decode to VFWMMACC_VV using decoder 120
9214 // 16302: }
9215 // 16302: } // switch Inst[25]
9216 // 16302: }
9217 22, 19, // 16306: case 0x16: {
9218 OPC_SwitchField, 25, 1, // 16308: switch Inst[25] {
9219 0, 6, // 16311: case 0x0: {
9220 OPC_CheckPredicate, 102, // 16313: check predicate 102
9221 OPC_Decode, 129, 127, 121, // 16315: decode to VFQMMACC_VV_SCALE using decoder 121
9222 // 16315: }
9223 1, 0, // 16319: case 0x1: {
9224 OPC_CheckPredicate, 102, // 16321: check predicate 102
9225 OPC_Decode, 128, 127, 120, // 16323: decode to VFQMMACC_VV using decoder 120
9226 // 16323: }
9227 // 16323: } // switch Inst[25]
9228 // 16323: }
9229 23, 19, // 16327: case 0x17: {
9230 OPC_SwitchField, 25, 1, // 16329: switch Inst[25] {
9231 0, 6, // 16332: case 0x0: {
9232 OPC_CheckPredicate, 102, // 16334: check predicate 102
9233 OPC_Decode, 202, 126, 121, // 16336: decode to VF8WMMACC_VV_SCALE using decoder 121
9234 // 16336: }
9235 1, 0, // 16340: case 0x1: {
9236 OPC_CheckPredicate, 102, // 16342: check predicate 102
9237 OPC_Decode, 201, 126, 120, // 16344: decode to VF8WMMACC_VV using decoder 120
9238 // 16344: }
9239 // 16344: } // switch Inst[25]
9240 // 16344: }
9241 24, 7, // 16348: case 0x18: {
9242 OPC_CheckPredicate, 104, // 16350: check predicate 104
9243 OPC_Decode, 163, 129, 1, 116, // 16352: decode to VMFEQ_VV using decoder 116
9244 // 16352: }
9245 25, 7, // 16357: case 0x19: {
9246 OPC_CheckPredicate, 104, // 16359: check predicate 104
9247 OPC_Decode, 167, 129, 1, 116, // 16361: decode to VMFLE_VV using decoder 116
9248 // 16361: }
9249 27, 7, // 16366: case 0x1b: {
9250 OPC_CheckPredicate, 104, // 16368: check predicate 104
9251 OPC_Decode, 169, 129, 1, 116, // 16370: decode to VMFLT_VV using decoder 116
9252 // 16370: }
9253 28, 7, // 16375: case 0x1c: {
9254 OPC_CheckPredicate, 104, // 16377: check predicate 104
9255 OPC_Decode, 171, 129, 1, 116, // 16379: decode to VMFNE_VV using decoder 116
9256 // 16379: }
9257 32, 6, // 16384: case 0x20: {
9258 OPC_CheckPredicate, 104, // 16386: check predicate 104
9259 OPC_Decode, 214, 126, 116, // 16388: decode to VFDIV_VV using decoder 116
9260 // 16388: }
9261 36, 6, // 16392: case 0x24: {
9262 OPC_CheckPredicate, 104, // 16394: check predicate 104
9263 OPC_Decode, 231, 126, 116, // 16396: decode to VFMUL_VV using decoder 116
9264 // 16396: }
9265 40, 6, // 16400: case 0x28: {
9266 OPC_CheckPredicate, 104, // 16402: check predicate 104
9267 OPC_Decode, 219, 126, 125, // 16404: decode to VFMADD_VV using decoder 125
9268 // 16404: }
9269 41, 6, // 16408: case 0x29: {
9270 OPC_CheckPredicate, 104, // 16410: check predicate 104
9271 OPC_Decode, 250, 126, 125, // 16412: decode to VFNMADD_VV using decoder 125
9272 // 16412: }
9273 42, 6, // 16416: case 0x2a: {
9274 OPC_CheckPredicate, 104, // 16418: check predicate 104
9275 OPC_Decode, 229, 126, 125, // 16420: decode to VFMSUB_VV using decoder 125
9276 // 16420: }
9277 43, 6, // 16424: case 0x2b: {
9278 OPC_CheckPredicate, 104, // 16426: check predicate 104
9279 OPC_Decode, 254, 126, 125, // 16428: decode to VFNMSUB_VV using decoder 125
9280 // 16428: }
9281 44, 6, // 16432: case 0x2c: {
9282 OPC_CheckPredicate, 104, // 16434: check predicate 104
9283 OPC_Decode, 217, 126, 125, // 16436: decode to VFMACC_VV using decoder 125
9284 // 16436: }
9285 45, 6, // 16440: case 0x2d: {
9286 OPC_CheckPredicate, 104, // 16442: check predicate 104
9287 OPC_Decode, 248, 126, 125, // 16444: decode to VFNMACC_VV using decoder 125
9288 // 16444: }
9289 46, 6, // 16448: case 0x2e: {
9290 OPC_CheckPredicate, 104, // 16450: check predicate 104
9291 OPC_Decode, 227, 126, 125, // 16452: decode to VFMSAC_VV using decoder 125
9292 // 16452: }
9293 47, 6, // 16456: case 0x2f: {
9294 OPC_CheckPredicate, 104, // 16458: check predicate 104
9295 OPC_Decode, 252, 126, 125, // 16460: decode to VFNMSAC_VV using decoder 125
9296 // 16460: }
9297 48, 6, // 16464: case 0x30: {
9298 OPC_CheckPredicate, 104, // 16466: check predicate 104
9299 OPC_Decode, 154, 127, 116, // 16468: decode to VFWADD_VV using decoder 116
9300 // 16468: }
9301 49, 6, // 16472: case 0x31: {
9302 OPC_CheckPredicate, 104, // 16474: check predicate 104
9303 OPC_Decode, 187, 127, 116, // 16476: decode to VFWREDUSUM_VS using decoder 116
9304 // 16476: }
9305 50, 6, // 16480: case 0x32: {
9306 OPC_CheckPredicate, 104, // 16482: check predicate 104
9307 OPC_Decode, 189, 127, 116, // 16484: decode to VFWSUB_VV using decoder 116
9308 // 16484: }
9309 51, 6, // 16488: case 0x33: {
9310 OPC_CheckPredicate, 104, // 16490: check predicate 104
9311 OPC_Decode, 186, 127, 116, // 16492: decode to VFWREDOSUM_VS using decoder 116
9312 // 16492: }
9313 52, 6, // 16496: case 0x34: {
9314 OPC_CheckPredicate, 104, // 16498: check predicate 104
9315 OPC_Decode, 156, 127, 116, // 16500: decode to VFWADD_WV using decoder 116
9316 // 16500: }
9317 54, 6, // 16504: case 0x36: {
9318 OPC_CheckPredicate, 104, // 16506: check predicate 104
9319 OPC_Decode, 191, 127, 116, // 16508: decode to VFWSUB_WV using decoder 116
9320 // 16508: }
9321 56, 6, // 16512: case 0x38: {
9322 OPC_CheckPredicate, 104, // 16514: check predicate 104
9323 OPC_Decode, 181, 127, 116, // 16516: decode to VFWMUL_VV using decoder 116
9324 // 16516: }
9325 59, 6, // 16520: case 0x3b: {
9326 OPC_CheckPredicate, 107, // 16522: check predicate 107
9327 OPC_Decode, 169, 127, 125, // 16524: decode to VFWMACCBF16_VV using decoder 125
9328 // 16524: }
9329 60, 6, // 16528: case 0x3c: {
9330 OPC_CheckPredicate, 104, // 16530: check predicate 104
9331 OPC_Decode, 171, 127, 125, // 16532: decode to VFWMACC_VV using decoder 125
9332 // 16532: }
9333 61, 6, // 16536: case 0x3d: {
9334 OPC_CheckPredicate, 104, // 16538: check predicate 104
9335 OPC_Decode, 183, 127, 125, // 16540: decode to VFWNMACC_VV using decoder 125
9336 // 16540: }
9337 62, 6, // 16544: case 0x3e: {
9338 OPC_CheckPredicate, 104, // 16546: check predicate 104
9339 OPC_Decode, 179, 127, 125, // 16548: decode to VFWMSAC_VV using decoder 125
9340 // 16548: }
9341 63, 0, // 16552: case 0x3f: {
9342 OPC_CheckPredicate, 104, // 16554: check predicate 104
9343 OPC_Decode, 185, 127, 125, // 16556: decode to VFWNMSAC_VV using decoder 125
9344 // 16556: }
9345 // 16556: } // switch Inst[31:26]
9346 // 16556: }
9347 2, 230, 5, // 16560: case 0x2: {
9348 OPC_SwitchField, 26, 6, // 16563: switch Inst[31:26] {
9349 0, 7, // 16566: case 0x0: {
9350 OPC_CheckPredicate, 23, // 16568: check predicate 23
9351 OPC_Decode, 140, 130, 1, 116, // 16570: decode to VREDSUM_VS using decoder 116
9352 // 16570: }
9353 1, 7, // 16575: case 0x1: {
9354 OPC_CheckPredicate, 23, // 16577: check predicate 23
9355 OPC_Decode, 134, 130, 1, 116, // 16579: decode to VREDAND_VS using decoder 116
9356 // 16579: }
9357 2, 7, // 16584: case 0x2: {
9358 OPC_CheckPredicate, 23, // 16586: check predicate 23
9359 OPC_Decode, 139, 130, 1, 116, // 16588: decode to VREDOR_VS using decoder 116
9360 // 16588: }
9361 3, 7, // 16593: case 0x3: {
9362 OPC_CheckPredicate, 23, // 16595: check predicate 23
9363 OPC_Decode, 141, 130, 1, 116, // 16597: decode to VREDXOR_VS using decoder 116
9364 // 16597: }
9365 4, 7, // 16602: case 0x4: {
9366 OPC_CheckPredicate, 23, // 16604: check predicate 23
9367 OPC_Decode, 137, 130, 1, 116, // 16606: decode to VREDMINU_VS using decoder 116
9368 // 16606: }
9369 5, 7, // 16611: case 0x5: {
9370 OPC_CheckPredicate, 23, // 16613: check predicate 23
9371 OPC_Decode, 138, 130, 1, 116, // 16615: decode to VREDMIN_VS using decoder 116
9372 // 16615: }
9373 6, 7, // 16620: case 0x6: {
9374 OPC_CheckPredicate, 23, // 16622: check predicate 23
9375 OPC_Decode, 135, 130, 1, 116, // 16624: decode to VREDMAXU_VS using decoder 116
9376 // 16624: }
9377 7, 7, // 16629: case 0x7: {
9378 OPC_CheckPredicate, 23, // 16631: check predicate 23
9379 OPC_Decode, 136, 130, 1, 116, // 16633: decode to VREDMAX_VS using decoder 116
9380 // 16633: }
9381 8, 6, // 16638: case 0x8: {
9382 OPC_CheckPredicate, 23, // 16640: check predicate 23
9383 OPC_Decode, 144, 126, 116, // 16642: decode to VAADDU_VV using decoder 116
9384 // 16642: }
9385 9, 6, // 16646: case 0x9: {
9386 OPC_CheckPredicate, 23, // 16648: check predicate 23
9387 OPC_Decode, 146, 126, 116, // 16650: decode to VAADD_VV using decoder 116
9388 // 16650: }
9389 10, 6, // 16654: case 0xa: {
9390 OPC_CheckPredicate, 23, // 16656: check predicate 23
9391 OPC_Decode, 174, 126, 116, // 16658: decode to VASUBU_VV using decoder 116
9392 // 16658: }
9393 11, 6, // 16662: case 0xb: {
9394 OPC_CheckPredicate, 23, // 16664: check predicate 23
9395 OPC_Decode, 176, 126, 116, // 16666: decode to VASUB_VV using decoder 116
9396 // 16666: }
9397 12, 6, // 16670: case 0xc: {
9398 OPC_CheckPredicate, 108, // 16672: check predicate 108
9399 OPC_Decode, 182, 126, 116, // 16674: decode to VCLMUL_VV using decoder 116
9400 // 16674: }
9401 13, 6, // 16678: case 0xd: {
9402 OPC_CheckPredicate, 108, // 16680: check predicate 108
9403 OPC_Decode, 180, 126, 116, // 16682: decode to VCLMULH_VV using decoder 116
9404 // 16682: }
9405 15, 7, // 16686: case 0xf: {
9406 OPC_CheckPredicate, 99, // 16688: check predicate 99
9407 OPC_Decode, 128, 130, 1, 116, // 16690: decode to VPAIRO_VV using decoder 116
9408 // 16690: }
9409 16, 32, // 16695: case 0x10: {
9410 OPC_SwitchField, 15, 5, // 16697: switch Inst[19:15] {
9411 0, 11, // 16700: case 0x0: {
9412 OPC_CheckPredicate, 23, // 16702: check predicate 23
9413 OPC_CheckField, 25, 1, 1, // 16704: check Inst[25] == 0x1
9414 OPC_Decode, 228, 129, 1, 126, // 16708: decode to VMV_X_S using decoder 126
9415 // 16708: }
9416 16, 6, // 16713: case 0x10: {
9417 OPC_CheckPredicate, 23, // 16715: check predicate 23
9418 OPC_Decode, 186, 126, 127, // 16717: decode to VCPOP_M using decoder 127
9419 // 16717: }
9420 17, 0, // 16721: case 0x11: {
9421 OPC_CheckPredicate, 23, // 16723: check predicate 23
9422 OPC_Decode, 215, 126, 127, // 16725: decode to VFIRST_M using decoder 127
9423 // 16725: }
9424 // 16725: } // switch Inst[19:15]
9425 // 16725: }
9426 18, 124, // 16729: case 0x12: {
9427 OPC_SwitchField, 15, 5, // 16731: switch Inst[19:15] {
9428 2, 7, // 16734: case 0x2: {
9429 OPC_CheckPredicate, 23, // 16736: check predicate 23
9430 OPC_Decode, 133, 132, 1, 124, // 16738: decode to VZEXT_VF8 using decoder 124
9431 // 16738: }
9432 3, 7, // 16743: case 0x3: {
9433 OPC_CheckPredicate, 23, // 16745: check predicate 23
9434 OPC_Decode, 179, 130, 1, 124, // 16747: decode to VSEXT_VF8 using decoder 124
9435 // 16747: }
9436 4, 7, // 16752: case 0x4: {
9437 OPC_CheckPredicate, 23, // 16754: check predicate 23
9438 OPC_Decode, 132, 132, 1, 124, // 16756: decode to VZEXT_VF4 using decoder 124
9439 // 16756: }
9440 5, 7, // 16761: case 0x5: {
9441 OPC_CheckPredicate, 23, // 16763: check predicate 23
9442 OPC_Decode, 178, 130, 1, 124, // 16765: decode to VSEXT_VF4 using decoder 124
9443 // 16765: }
9444 6, 7, // 16770: case 0x6: {
9445 OPC_CheckPredicate, 23, // 16772: check predicate 23
9446 OPC_Decode, 131, 132, 1, 124, // 16774: decode to VZEXT_VF2 using decoder 124
9447 // 16774: }
9448 7, 7, // 16779: case 0x7: {
9449 OPC_CheckPredicate, 23, // 16781: check predicate 23
9450 OPC_Decode, 177, 130, 1, 124, // 16783: decode to VSEXT_VF2 using decoder 124
9451 // 16783: }
9452 8, 6, // 16788: case 0x8: {
9453 OPC_CheckPredicate, 98, // 16790: check predicate 98
9454 OPC_Decode, 178, 126, 124, // 16792: decode to VBREV8_V using decoder 124
9455 // 16792: }
9456 9, 7, // 16796: case 0x9: {
9457 OPC_CheckPredicate, 98, // 16798: check predicate 98
9458 OPC_Decode, 146, 130, 1, 124, // 16800: decode to VREV8_V using decoder 124
9459 // 16800: }
9460 10, 6, // 16805: case 0xa: {
9461 OPC_CheckPredicate, 100, // 16807: check predicate 100
9462 OPC_Decode, 179, 126, 124, // 16809: decode to VBREV_V using decoder 124
9463 // 16809: }
9464 11, 7, // 16813: case 0xb: {
9465 OPC_CheckPredicate, 99, // 16815: check predicate 99
9466 OPC_Decode, 214, 131, 1, 124, // 16817: decode to VUNZIPE_V using decoder 124
9467 // 16817: }
9468 12, 6, // 16822: case 0xc: {
9469 OPC_CheckPredicate, 100, // 16824: check predicate 100
9470 OPC_Decode, 184, 126, 124, // 16826: decode to VCLZ_V using decoder 124
9471 // 16826: }
9472 13, 6, // 16830: case 0xd: {
9473 OPC_CheckPredicate, 100, // 16832: check predicate 100
9474 OPC_Decode, 188, 126, 124, // 16834: decode to VCTZ_V using decoder 124
9475 // 16834: }
9476 14, 6, // 16838: case 0xe: {
9477 OPC_CheckPredicate, 100, // 16840: check predicate 100
9478 OPC_Decode, 187, 126, 124, // 16842: decode to VCPOP_V using decoder 124
9479 // 16842: }
9480 15, 0, // 16846: case 0xf: {
9481 OPC_CheckPredicate, 99, // 16848: check predicate 99
9482 OPC_Decode, 215, 131, 1, 124, // 16850: decode to VUNZIPO_V using decoder 124
9483 // 16850: }
9484 // 16850: } // switch Inst[19:15]
9485 // 16850: }
9486 20, 51, // 16855: case 0x14: {
9487 OPC_SwitchField, 15, 5, // 16857: switch Inst[19:15] {
9488 1, 7, // 16860: case 0x1: {
9489 OPC_CheckPredicate, 23, // 16862: check predicate 23
9490 OPC_Decode, 185, 129, 1, 124, // 16864: decode to VMSBF_M using decoder 124
9491 // 16864: }
9492 2, 7, // 16869: case 0x2: {
9493 OPC_CheckPredicate, 23, // 16871: check predicate 23
9494 OPC_Decode, 207, 129, 1, 124, // 16873: decode to VMSOF_M using decoder 124
9495 // 16873: }
9496 3, 7, // 16878: case 0x3: {
9497 OPC_CheckPredicate, 23, // 16880: check predicate 23
9498 OPC_Decode, 193, 129, 1, 124, // 16882: decode to VMSIF_M using decoder 124
9499 // 16882: }
9500 16, 6, // 16887: case 0x10: {
9501 OPC_CheckPredicate, 23, // 16889: check predicate 23
9502 OPC_Decode, 197, 127, 124, // 16891: decode to VIOTA_M using decoder 124
9503 // 16891: }
9504 17, 0, // 16895: case 0x11: {
9505 OPC_CheckPredicate, 23, // 16897: check predicate 23
9506 OPC_CheckField, 20, 5, 0, // 16899: check Inst[24:20] == 0x0
9507 OPC_Decode, 196, 127, 128, 1, // 16903: decode to VID_V using decoder 128
9508 // 16903: }
9509 // 16903: } // switch Inst[19:15]
9510 // 16903: }
9511 21, 6, // 16908: case 0x15: {
9512 OPC_CheckPredicate, 103, // 16910: check predicate 103
9513 OPC_Decode, 150, 126, 116, // 16912: decode to VABD_VV using decoder 116
9514 // 16912: }
9515 22, 6, // 16916: case 0x16: {
9516 OPC_CheckPredicate, 103, // 16918: check predicate 103
9517 OPC_Decode, 148, 126, 116, // 16920: decode to VABDU_VV using decoder 116
9518 // 16920: }
9519 23, 10, // 16924: case 0x17: {
9520 OPC_CheckPredicate, 23, // 16926: check predicate 23
9521 OPC_CheckField, 25, 1, 1, // 16928: check Inst[25] == 0x1
9522 OPC_Decode, 185, 126, 118, // 16932: decode to VCOMPRESS_VM using decoder 118
9523 // 16932: }
9524 24, 11, // 16936: case 0x18: {
9525 OPC_CheckPredicate, 23, // 16938: check predicate 23
9526 OPC_CheckField, 25, 1, 1, // 16940: check Inst[25] == 0x1
9527 OPC_Decode, 153, 129, 1, 118, // 16944: decode to VMANDN_MM using decoder 118
9528 // 16944: }
9529 25, 11, // 16949: case 0x19: {
9530 OPC_CheckPredicate, 23, // 16951: check predicate 23
9531 OPC_CheckField, 25, 1, 1, // 16953: check Inst[25] == 0x1
9532 OPC_Decode, 154, 129, 1, 118, // 16957: decode to VMAND_MM using decoder 118
9533 // 16957: }
9534 26, 11, // 16962: case 0x1a: {
9535 OPC_CheckPredicate, 23, // 16964: check predicate 23
9536 OPC_CheckField, 25, 1, 1, // 16966: check Inst[25] == 0x1
9537 OPC_Decode, 180, 129, 1, 118, // 16970: decode to VMOR_MM using decoder 118
9538 // 16970: }
9539 27, 11, // 16975: case 0x1b: {
9540 OPC_CheckPredicate, 23, // 16977: check predicate 23
9541 OPC_CheckField, 25, 1, 1, // 16979: check Inst[25] == 0x1
9542 OPC_Decode, 230, 129, 1, 118, // 16983: decode to VMXOR_MM using decoder 118
9543 // 16983: }
9544 28, 11, // 16988: case 0x1c: {
9545 OPC_CheckPredicate, 23, // 16990: check predicate 23
9546 OPC_CheckField, 25, 1, 1, // 16992: check Inst[25] == 0x1
9547 OPC_Decode, 179, 129, 1, 118, // 16996: decode to VMORN_MM using decoder 118
9548 // 16996: }
9549 29, 11, // 17001: case 0x1d: {
9550 OPC_CheckPredicate, 23, // 17003: check predicate 23
9551 OPC_CheckField, 25, 1, 1, // 17005: check Inst[25] == 0x1
9552 OPC_Decode, 177, 129, 1, 118, // 17009: decode to VMNAND_MM using decoder 118
9553 // 17009: }
9554 30, 11, // 17014: case 0x1e: {
9555 OPC_CheckPredicate, 23, // 17016: check predicate 23
9556 OPC_CheckField, 25, 1, 1, // 17018: check Inst[25] == 0x1
9557 OPC_Decode, 178, 129, 1, 118, // 17022: decode to VMNOR_MM using decoder 118
9558 // 17022: }
9559 31, 11, // 17027: case 0x1f: {
9560 OPC_CheckPredicate, 23, // 17029: check predicate 23
9561 OPC_CheckField, 25, 1, 1, // 17031: check Inst[25] == 0x1
9562 OPC_Decode, 229, 129, 1, 118, // 17035: decode to VMXNOR_MM using decoder 118
9563 // 17035: }
9564 32, 6, // 17040: case 0x20: {
9565 OPC_CheckPredicate, 23, // 17042: check predicate 23
9566 OPC_Decode, 189, 126, 116, // 17044: decode to VDIVU_VV using decoder 116
9567 // 17044: }
9568 33, 6, // 17048: case 0x21: {
9569 OPC_CheckPredicate, 23, // 17050: check predicate 23
9570 OPC_Decode, 191, 126, 116, // 17052: decode to VDIV_VV using decoder 116
9571 // 17052: }
9572 34, 7, // 17056: case 0x22: {
9573 OPC_CheckPredicate, 23, // 17058: check predicate 23
9574 OPC_Decode, 142, 130, 1, 116, // 17060: decode to VREMU_VV using decoder 116
9575 // 17060: }
9576 35, 7, // 17065: case 0x23: {
9577 OPC_CheckPredicate, 23, // 17067: check predicate 23
9578 OPC_Decode, 144, 130, 1, 116, // 17069: decode to VREM_VV using decoder 116
9579 // 17069: }
9580 36, 7, // 17074: case 0x24: {
9581 OPC_CheckPredicate, 23, // 17076: check predicate 23
9582 OPC_Decode, 214, 129, 1, 116, // 17078: decode to VMULHU_VV using decoder 116
9583 // 17078: }
9584 37, 7, // 17083: case 0x25: {
9585 OPC_CheckPredicate, 23, // 17085: check predicate 23
9586 OPC_Decode, 218, 129, 1, 116, // 17087: decode to VMUL_VV using decoder 116
9587 // 17087: }
9588 38, 7, // 17092: case 0x26: {
9589 OPC_CheckPredicate, 23, // 17094: check predicate 23
9590 OPC_Decode, 212, 129, 1, 116, // 17096: decode to VMULHSU_VV using decoder 116
9591 // 17096: }
9592 39, 7, // 17101: case 0x27: {
9593 OPC_CheckPredicate, 23, // 17103: check predicate 23
9594 OPC_Decode, 216, 129, 1, 116, // 17105: decode to VMULH_VV using decoder 116
9595 // 17105: }
9596 40, 6, // 17110: case 0x28: {
9597 OPC_CheckPredicate, 109, // 17112: check predicate 109
9598 OPC_Decode, 196, 126, 122, // 17114: decode to VDOT4AU_VV using decoder 122
9599 // 17114: }
9600 41, 7, // 17118: case 0x29: {
9601 OPC_CheckPredicate, 23, // 17120: check predicate 23
9602 OPC_Decode, 255, 128, 1, 125, // 17122: decode to VMADD_VV using decoder 125
9603 // 17122: }
9604 42, 6, // 17127: case 0x2a: {
9605 OPC_CheckPredicate, 109, // 17129: check predicate 109
9606 OPC_Decode, 193, 126, 122, // 17131: decode to VDOT4ASU_VV using decoder 122
9607 // 17131: }
9608 43, 7, // 17135: case 0x2b: {
9609 OPC_CheckPredicate, 23, // 17137: check predicate 23
9610 OPC_Decode, 239, 129, 1, 125, // 17139: decode to VNMSUB_VV using decoder 125
9611 // 17139: }
9612 44, 6, // 17144: case 0x2c: {
9613 OPC_CheckPredicate, 109, // 17146: check predicate 109
9614 OPC_Decode, 198, 126, 122, // 17148: decode to VDOT4A_VV using decoder 122
9615 // 17148: }
9616 45, 7, // 17152: case 0x2d: {
9617 OPC_CheckPredicate, 23, // 17154: check predicate 23
9618 OPC_Decode, 247, 128, 1, 125, // 17156: decode to VMACC_VV using decoder 125
9619 // 17156: }
9620 47, 7, // 17161: case 0x2f: {
9621 OPC_CheckPredicate, 23, // 17163: check predicate 23
9622 OPC_Decode, 237, 129, 1, 125, // 17165: decode to VNMSAC_VV using decoder 125
9623 // 17165: }
9624 48, 7, // 17170: case 0x30: {
9625 OPC_CheckPredicate, 23, // 17172: check predicate 23
9626 OPC_Decode, 221, 131, 1, 116, // 17174: decode to VWADDU_VV using decoder 116
9627 // 17174: }
9628 49, 7, // 17179: case 0x31: {
9629 OPC_CheckPredicate, 23, // 17181: check predicate 23
9630 OPC_Decode, 225, 131, 1, 116, // 17183: decode to VWADD_VV using decoder 116
9631 // 17183: }
9632 50, 7, // 17188: case 0x32: {
9633 OPC_CheckPredicate, 23, // 17190: check predicate 23
9634 OPC_Decode, 248, 131, 1, 116, // 17192: decode to VWSUBU_VV using decoder 116
9635 // 17192: }
9636 51, 7, // 17197: case 0x33: {
9637 OPC_CheckPredicate, 23, // 17199: check predicate 23
9638 OPC_Decode, 252, 131, 1, 116, // 17201: decode to VWSUB_VV using decoder 116
9639 // 17201: }
9640 52, 7, // 17206: case 0x34: {
9641 OPC_CheckPredicate, 23, // 17208: check predicate 23
9642 OPC_Decode, 223, 131, 1, 116, // 17210: decode to VWADDU_WV using decoder 116
9643 // 17210: }
9644 53, 7, // 17215: case 0x35: {
9645 OPC_CheckPredicate, 23, // 17217: check predicate 23
9646 OPC_Decode, 227, 131, 1, 116, // 17219: decode to VWADD_WV using decoder 116
9647 // 17219: }
9648 54, 7, // 17224: case 0x36: {
9649 OPC_CheckPredicate, 23, // 17226: check predicate 23
9650 OPC_Decode, 250, 131, 1, 116, // 17228: decode to VWSUBU_WV using decoder 116
9651 // 17228: }
9652 55, 7, // 17233: case 0x37: {
9653 OPC_CheckPredicate, 23, // 17235: check predicate 23
9654 OPC_Decode, 254, 131, 1, 116, // 17237: decode to VWSUB_WV using decoder 116
9655 // 17237: }
9656 56, 7, // 17242: case 0x38: {
9657 OPC_CheckPredicate, 23, // 17244: check predicate 23
9658 OPC_Decode, 239, 131, 1, 116, // 17246: decode to VWMULU_VV using decoder 116
9659 // 17246: }
9660 58, 7, // 17251: case 0x3a: {
9661 OPC_CheckPredicate, 23, // 17253: check predicate 23
9662 OPC_Decode, 237, 131, 1, 116, // 17255: decode to VWMULSU_VV using decoder 116
9663 // 17255: }
9664 59, 7, // 17260: case 0x3b: {
9665 OPC_CheckPredicate, 23, // 17262: check predicate 23
9666 OPC_Decode, 241, 131, 1, 116, // 17264: decode to VWMUL_VV using decoder 116
9667 // 17264: }
9668 60, 7, // 17269: case 0x3c: {
9669 OPC_CheckPredicate, 23, // 17271: check predicate 23
9670 OPC_Decode, 232, 131, 1, 125, // 17273: decode to VWMACCU_VV using decoder 125
9671 // 17273: }
9672 61, 7, // 17278: case 0x3d: {
9673 OPC_CheckPredicate, 23, // 17280: check predicate 23
9674 OPC_Decode, 234, 131, 1, 125, // 17282: decode to VWMACC_VV using decoder 125
9675 // 17282: }
9676 62, 7, // 17287: case 0x3e: {
9677 OPC_CheckPredicate, 99, // 17289: check predicate 99
9678 OPC_Decode, 134, 132, 1, 116, // 17291: decode to VZIP_VV using decoder 116
9679 // 17291: }
9680 63, 0, // 17296: case 0x3f: {
9681 OPC_CheckPredicate, 23, // 17298: check predicate 23
9682 OPC_Decode, 229, 131, 1, 125, // 17300: decode to VWMACCSU_VV using decoder 125
9683 // 17300: }
9684 // 17300: } // switch Inst[31:26]
9685 // 17300: }
9686 3, 213, 3, // 17305: case 0x3: {
9687 OPC_SwitchField, 27, 5, // 17308: switch Inst[31:27] {
9688 0, 11, // 17311: case 0x0: {
9689 OPC_CheckPredicate, 23, // 17313: check predicate 23
9690 OPC_CheckField, 26, 1, 0, // 17315: check Inst[26] == 0x0
9691 OPC_Decode, 155, 126, 129, 1, // 17319: decode to VADD_VI using decoder 129
9692 // 17319: }
9693 1, 12, // 17324: case 0x1: {
9694 OPC_CheckPredicate, 23, // 17326: check predicate 23
9695 OPC_CheckField, 26, 1, 1, // 17328: check Inst[26] == 0x1
9696 OPC_Decode, 156, 130, 1, 129, 1, // 17332: decode to VRSUB_VI using decoder 129
9697 // 17332: }
9698 4, 11, // 17338: case 0x4: {
9699 OPC_CheckPredicate, 23, // 17340: check predicate 23
9700 OPC_CheckField, 26, 1, 1, // 17342: check Inst[26] == 0x1
9701 OPC_Decode, 171, 126, 129, 1, // 17346: decode to VAND_VI using decoder 129
9702 // 17346: }
9703 5, 23, // 17351: case 0x5: {
9704 OPC_SwitchField, 26, 1, // 17353: switch Inst[26] {
9705 0, 8, // 17356: case 0x0: {
9706 OPC_CheckPredicate, 23, // 17358: check predicate 23
9707 OPC_Decode, 251, 129, 1, 129, 1, // 17360: decode to VOR_VI using decoder 129
9708 // 17360: }
9709 1, 0, // 17366: case 0x1: {
9710 OPC_CheckPredicate, 23, // 17368: check predicate 23
9711 OPC_Decode, 128, 132, 1, 129, 1, // 17370: decode to VXOR_VI using decoder 129
9712 // 17370: }
9713 // 17370: } // switch Inst[26]
9714 // 17370: }
9715 6, 12, // 17376: case 0x6: {
9716 OPC_CheckPredicate, 23, // 17378: check predicate 23
9717 OPC_CheckField, 26, 1, 0, // 17380: check Inst[26] == 0x0
9718 OPC_Decode, 148, 130, 1, 130, 1, // 17384: decode to VRGATHER_VI using decoder 130
9719 // 17384: }
9720 7, 23, // 17390: case 0x7: {
9721 OPC_SwitchField, 26, 1, // 17392: switch Inst[26] {
9722 0, 8, // 17395: case 0x0: {
9723 OPC_CheckPredicate, 23, // 17397: check predicate 23
9724 OPC_Decode, 187, 130, 1, 130, 1, // 17399: decode to VSLIDEUP_VI using decoder 130
9725 // 17399: }
9726 1, 0, // 17405: case 0x1: {
9727 OPC_CheckPredicate, 23, // 17407: check predicate 23
9728 OPC_Decode, 185, 130, 1, 130, 1, // 17409: decode to VSLIDEDOWN_VI using decoder 130
9729 // 17409: }
9730 // 17409: } // switch Inst[26]
9731 // 17409: }
9732 8, 32, // 17415: case 0x8: {
9733 OPC_SwitchField, 25, 2, // 17417: switch Inst[26:25] {
9734 0, 7, // 17420: case 0x0: {
9735 OPC_CheckPredicate, 23, // 17422: check predicate 23
9736 OPC_Decode, 152, 126, 131, 1, // 17424: decode to VADC_VIM using decoder 131
9737 // 17424: }
9738 2, 8, // 17429: case 0x2: {
9739 OPC_CheckPredicate, 23, // 17431: check predicate 23
9740 OPC_Decode, 250, 128, 1, 131, 1, // 17433: decode to VMADC_VIM using decoder 131
9741 // 17433: }
9742 3, 0, // 17439: case 0x3: {
9743 OPC_CheckPredicate, 23, // 17441: check predicate 23
9744 OPC_Decode, 249, 128, 1, 132, 1, // 17443: decode to VMADC_VI using decoder 132
9745 // 17443: }
9746 // 17443: } // switch Inst[26:25]
9747 // 17443: }
9748 10, 8, // 17449: case 0xa: {
9749 OPC_CheckPredicate, 98, // 17451: check predicate 98
9750 OPC_Decode, 153, 130, 1, 133, 1, // 17453: decode to VROR_VI using decoder 133
9751 // 17453: }
9752 11, 27, // 17459: case 0xb: {
9753 OPC_SwitchField, 25, 2, // 17461: switch Inst[26:25] {
9754 2, 8, // 17464: case 0x2: {
9755 OPC_CheckPredicate, 23, // 17466: check predicate 23
9756 OPC_Decode, 159, 129, 1, 131, 1, // 17468: decode to VMERGE_VIM using decoder 131
9757 // 17468: }
9758 3, 0, // 17474: case 0x3: {
9759 OPC_CheckPredicate, 23, // 17476: check predicate 23
9760 OPC_CheckField, 20, 5, 0, // 17478: check Inst[24:20] == 0x0
9761 OPC_Decode, 225, 129, 1, 134, 1, // 17482: decode to VMV_V_I using decoder 134
9762 // 17482: }
9763 // 17482: } // switch Inst[26:25]
9764 // 17482: }
9765 12, 23, // 17488: case 0xc: {
9766 OPC_SwitchField, 26, 1, // 17490: switch Inst[26] {
9767 0, 8, // 17493: case 0x0: {
9768 OPC_CheckPredicate, 23, // 17495: check predicate 23
9769 OPC_Decode, 186, 129, 1, 129, 1, // 17497: decode to VMSEQ_VI using decoder 129
9770 // 17497: }
9771 1, 0, // 17503: case 0x1: {
9772 OPC_CheckPredicate, 23, // 17505: check predicate 23
9773 OPC_Decode, 204, 129, 1, 129, 1, // 17507: decode to VMSNE_VI using decoder 129
9774 // 17507: }
9775 // 17507: } // switch Inst[26]
9776 // 17507: }
9777 14, 23, // 17513: case 0xe: {
9778 OPC_SwitchField, 26, 1, // 17515: switch Inst[26] {
9779 0, 8, // 17518: case 0x0: {
9780 OPC_CheckPredicate, 23, // 17520: check predicate 23
9781 OPC_Decode, 194, 129, 1, 129, 1, // 17522: decode to VMSLEU_VI using decoder 129
9782 // 17522: }
9783 1, 0, // 17528: case 0x1: {
9784 OPC_CheckPredicate, 23, // 17530: check predicate 23
9785 OPC_Decode, 197, 129, 1, 129, 1, // 17532: decode to VMSLE_VI using decoder 129
9786 // 17532: }
9787 // 17532: } // switch Inst[26]
9788 // 17532: }
9789 15, 23, // 17538: case 0xf: {
9790 OPC_SwitchField, 26, 1, // 17540: switch Inst[26] {
9791 0, 8, // 17543: case 0x0: {
9792 OPC_CheckPredicate, 23, // 17545: check predicate 23
9793 OPC_Decode, 189, 129, 1, 129, 1, // 17547: decode to VMSGTU_VI using decoder 129
9794 // 17547: }
9795 1, 0, // 17553: case 0x1: {
9796 OPC_CheckPredicate, 23, // 17555: check predicate 23
9797 OPC_Decode, 191, 129, 1, 129, 1, // 17557: decode to VMSGT_VI using decoder 129
9798 // 17557: }
9799 // 17557: } // switch Inst[26]
9800 // 17557: }
9801 16, 23, // 17563: case 0x10: {
9802 OPC_SwitchField, 26, 1, // 17565: switch Inst[26] {
9803 0, 8, // 17568: case 0x0: {
9804 OPC_CheckPredicate, 23, // 17570: check predicate 23
9805 OPC_Decode, 162, 130, 1, 129, 1, // 17572: decode to VSADDU_VI using decoder 129
9806 // 17572: }
9807 1, 0, // 17578: case 0x1: {
9808 OPC_CheckPredicate, 23, // 17580: check predicate 23
9809 OPC_Decode, 165, 130, 1, 129, 1, // 17582: decode to VSADD_VI using decoder 129
9810 // 17582: }
9811 // 17582: } // switch Inst[26]
9812 // 17582: }
9813 18, 12, // 17588: case 0x12: {
9814 OPC_CheckPredicate, 23, // 17590: check predicate 23
9815 OPC_CheckField, 26, 1, 1, // 17592: check Inst[26] == 0x1
9816 OPC_Decode, 189, 130, 1, 130, 1, // 17596: decode to VSLL_VI using decoder 130
9817 // 17596: }
9818 19, 59, // 17602: case 0x13: {
9819 OPC_SwitchField, 15, 5, // 17604: switch Inst[19:15] {
9820 0, 12, // 17607: case 0x0: {
9821 OPC_CheckPredicate, 23, // 17609: check predicate 23
9822 OPC_CheckField, 25, 2, 3, // 17611: check Inst[26:25] == 0x3
9823 OPC_Decode, 220, 129, 1, 135, 1, // 17615: decode to VMV1R_V using decoder 135
9824 // 17615: }
9825 1, 12, // 17621: case 0x1: {
9826 OPC_CheckPredicate, 23, // 17623: check predicate 23
9827 OPC_CheckField, 25, 2, 3, // 17625: check Inst[26:25] == 0x3
9828 OPC_Decode, 221, 129, 1, 136, 1, // 17629: decode to VMV2R_V using decoder 136
9829 // 17629: }
9830 3, 12, // 17635: case 0x3: {
9831 OPC_CheckPredicate, 23, // 17637: check predicate 23
9832 OPC_CheckField, 25, 2, 3, // 17639: check Inst[26:25] == 0x3
9833 OPC_Decode, 222, 129, 1, 137, 1, // 17643: decode to VMV4R_V using decoder 137
9834 // 17643: }
9835 7, 0, // 17649: case 0x7: {
9836 OPC_CheckPredicate, 23, // 17651: check predicate 23
9837 OPC_CheckField, 25, 2, 3, // 17653: check Inst[26:25] == 0x3
9838 OPC_Decode, 223, 129, 1, 138, 1, // 17657: decode to VMV8R_V using decoder 138
9839 // 17657: }
9840 // 17657: } // switch Inst[19:15]
9841 // 17657: }
9842 20, 23, // 17663: case 0x14: {
9843 OPC_SwitchField, 26, 1, // 17665: switch Inst[26] {
9844 0, 8, // 17668: case 0x0: {
9845 OPC_CheckPredicate, 23, // 17670: check predicate 23
9846 OPC_Decode, 235, 130, 1, 130, 1, // 17672: decode to VSRL_VI using decoder 130
9847 // 17672: }
9848 1, 0, // 17678: case 0x1: {
9849 OPC_CheckPredicate, 23, // 17680: check predicate 23
9850 OPC_Decode, 232, 130, 1, 130, 1, // 17682: decode to VSRA_VI using decoder 130
9851 // 17682: }
9852 // 17682: } // switch Inst[26]
9853 // 17682: }
9854 21, 23, // 17688: case 0x15: {
9855 OPC_SwitchField, 26, 1, // 17690: switch Inst[26] {
9856 0, 8, // 17693: case 0x0: {
9857 OPC_CheckPredicate, 23, // 17695: check predicate 23
9858 OPC_Decode, 145, 131, 1, 130, 1, // 17697: decode to VSSRL_VI using decoder 130
9859 // 17697: }
9860 1, 0, // 17703: case 0x1: {
9861 OPC_CheckPredicate, 23, // 17705: check predicate 23
9862 OPC_Decode, 142, 131, 1, 130, 1, // 17707: decode to VSSRA_VI using decoder 130
9863 // 17707: }
9864 // 17707: } // switch Inst[26]
9865 // 17707: }
9866 22, 23, // 17713: case 0x16: {
9867 OPC_SwitchField, 26, 1, // 17715: switch Inst[26] {
9868 0, 8, // 17718: case 0x0: {
9869 OPC_CheckPredicate, 23, // 17720: check predicate 23
9870 OPC_Decode, 248, 129, 1, 130, 1, // 17722: decode to VNSRL_WI using decoder 130
9871 // 17722: }
9872 1, 0, // 17728: case 0x1: {
9873 OPC_CheckPredicate, 23, // 17730: check predicate 23
9874 OPC_Decode, 245, 129, 1, 130, 1, // 17732: decode to VNSRA_WI using decoder 130
9875 // 17732: }
9876 // 17732: } // switch Inst[26]
9877 // 17732: }
9878 23, 23, // 17738: case 0x17: {
9879 OPC_SwitchField, 26, 1, // 17740: switch Inst[26] {
9880 0, 8, // 17743: case 0x0: {
9881 OPC_CheckPredicate, 23, // 17745: check predicate 23
9882 OPC_Decode, 231, 129, 1, 130, 1, // 17747: decode to VNCLIPU_WI using decoder 130
9883 // 17747: }
9884 1, 0, // 17753: case 0x1: {
9885 OPC_CheckPredicate, 23, // 17755: check predicate 23
9886 OPC_Decode, 234, 129, 1, 130, 1, // 17757: decode to VNCLIP_WI using decoder 130
9887 // 17757: }
9888 // 17757: } // switch Inst[26]
9889 // 17757: }
9890 26, 0, // 17763: case 0x1a: {
9891 OPC_CheckPredicate, 100, // 17765: check predicate 100
9892 OPC_CheckField, 26, 1, 1, // 17767: check Inst[26] == 0x1
9893 OPC_Decode, 245, 131, 1, 130, 1, // 17771: decode to VWSLL_VI using decoder 130
9894 // 17771: }
9895 // 17771: } // switch Inst[31:27]
9896 // 17771: }
9897 4, 131, 4, // 17777: case 0x4: {
9898 OPC_SwitchField, 26, 6, // 17780: switch Inst[31:26] {
9899 0, 7, // 17783: case 0x0: {
9900 OPC_CheckPredicate, 23, // 17785: check predicate 23
9901 OPC_Decode, 157, 126, 139, 1, // 17787: decode to VADD_VX using decoder 139
9902 // 17787: }
9903 1, 7, // 17792: case 0x1: {
9904 OPC_CheckPredicate, 98, // 17794: check predicate 98
9905 OPC_Decode, 170, 126, 139, 1, // 17796: decode to VANDN_VX using decoder 139
9906 // 17796: }
9907 2, 8, // 17801: case 0x2: {
9908 OPC_CheckPredicate, 23, // 17803: check predicate 23
9909 OPC_Decode, 181, 131, 1, 139, 1, // 17805: decode to VSUB_VX using decoder 139
9910 // 17805: }
9911 3, 8, // 17811: case 0x3: {
9912 OPC_CheckPredicate, 23, // 17813: check predicate 23
9913 OPC_Decode, 157, 130, 1, 139, 1, // 17815: decode to VRSUB_VX using decoder 139
9914 // 17815: }
9915 4, 8, // 17821: case 0x4: {
9916 OPC_CheckPredicate, 23, // 17823: check predicate 23
9917 OPC_Decode, 173, 129, 1, 139, 1, // 17825: decode to VMINU_VX using decoder 139
9918 // 17825: }
9919 5, 8, // 17831: case 0x5: {
9920 OPC_CheckPredicate, 23, // 17833: check predicate 23
9921 OPC_Decode, 175, 129, 1, 139, 1, // 17835: decode to VMIN_VX using decoder 139
9922 // 17835: }
9923 6, 8, // 17841: case 0x6: {
9924 OPC_CheckPredicate, 23, // 17843: check predicate 23
9925 OPC_Decode, 156, 129, 1, 139, 1, // 17845: decode to VMAXU_VX using decoder 139
9926 // 17845: }
9927 7, 8, // 17851: case 0x7: {
9928 OPC_CheckPredicate, 23, // 17853: check predicate 23
9929 OPC_Decode, 158, 129, 1, 139, 1, // 17855: decode to VMAX_VX using decoder 139
9930 // 17855: }
9931 9, 7, // 17861: case 0x9: {
9932 OPC_CheckPredicate, 23, // 17863: check predicate 23
9933 OPC_Decode, 173, 126, 139, 1, // 17865: decode to VAND_VX using decoder 139
9934 // 17865: }
9935 10, 8, // 17870: case 0xa: {
9936 OPC_CheckPredicate, 23, // 17872: check predicate 23
9937 OPC_Decode, 253, 129, 1, 139, 1, // 17874: decode to VOR_VX using decoder 139
9938 // 17874: }
9939 11, 8, // 17880: case 0xb: {
9940 OPC_CheckPredicate, 23, // 17882: check predicate 23
9941 OPC_Decode, 130, 132, 1, 139, 1, // 17884: decode to VXOR_VX using decoder 139
9942 // 17884: }
9943 12, 8, // 17890: case 0xc: {
9944 OPC_CheckPredicate, 23, // 17892: check predicate 23
9945 OPC_Decode, 150, 130, 1, 139, 1, // 17894: decode to VRGATHER_VX using decoder 139
9946 // 17894: }
9947 14, 8, // 17900: case 0xe: {
9948 OPC_CheckPredicate, 23, // 17902: check predicate 23
9949 OPC_Decode, 188, 130, 1, 139, 1, // 17904: decode to VSLIDEUP_VX using decoder 139
9950 // 17904: }
9951 15, 8, // 17910: case 0xf: {
9952 OPC_CheckPredicate, 23, // 17912: check predicate 23
9953 OPC_Decode, 186, 130, 1, 139, 1, // 17914: decode to VSLIDEDOWN_VX using decoder 139
9954 // 17914: }
9955 16, 11, // 17920: case 0x10: {
9956 OPC_CheckPredicate, 23, // 17922: check predicate 23
9957 OPC_CheckField, 25, 1, 0, // 17924: check Inst[25] == 0x0
9958 OPC_Decode, 154, 126, 140, 1, // 17928: decode to VADC_VXM using decoder 140
9959 // 17928: }
9960 17, 23, // 17933: case 0x11: {
9961 OPC_SwitchField, 25, 1, // 17935: switch Inst[25] {
9962 0, 8, // 17938: case 0x0: {
9963 OPC_CheckPredicate, 23, // 17940: check predicate 23
9964 OPC_Decode, 254, 128, 1, 140, 1, // 17942: decode to VMADC_VXM using decoder 140
9965 // 17942: }
9966 1, 0, // 17948: case 0x1: {
9967 OPC_CheckPredicate, 23, // 17950: check predicate 23
9968 OPC_Decode, 253, 128, 1, 141, 1, // 17952: decode to VMADC_VX using decoder 141
9969 // 17952: }
9970 // 17952: } // switch Inst[25]
9971 // 17952: }
9972 18, 12, // 17958: case 0x12: {
9973 OPC_CheckPredicate, 23, // 17960: check predicate 23
9974 OPC_CheckField, 25, 1, 0, // 17962: check Inst[25] == 0x0
9975 OPC_Decode, 169, 130, 1, 140, 1, // 17966: decode to VSBC_VXM using decoder 140
9976 // 17966: }
9977 19, 23, // 17972: case 0x13: {
9978 OPC_SwitchField, 25, 1, // 17974: switch Inst[25] {
9979 0, 8, // 17977: case 0x0: {
9980 OPC_CheckPredicate, 23, // 17979: check predicate 23
9981 OPC_Decode, 184, 129, 1, 140, 1, // 17981: decode to VMSBC_VXM using decoder 140
9982 // 17981: }
9983 1, 0, // 17987: case 0x1: {
9984 OPC_CheckPredicate, 23, // 17989: check predicate 23
9985 OPC_Decode, 183, 129, 1, 141, 1, // 17991: decode to VMSBC_VX using decoder 141
9986 // 17991: }
9987 // 17991: } // switch Inst[25]
9988 // 17991: }
9989 20, 8, // 17997: case 0x14: {
9990 OPC_CheckPredicate, 98, // 17999: check predicate 98
9991 OPC_Decode, 155, 130, 1, 139, 1, // 18001: decode to VROR_VX using decoder 139
9992 // 18001: }
9993 21, 8, // 18007: case 0x15: {
9994 OPC_CheckPredicate, 98, // 18009: check predicate 98
9995 OPC_Decode, 152, 130, 1, 139, 1, // 18011: decode to VROL_VX using decoder 139
9996 // 18011: }
9997 23, 26, // 18017: case 0x17: {
9998 OPC_SwitchField, 25, 1, // 18019: switch Inst[25] {
9999 0, 8, // 18022: case 0x0: {
10000 OPC_CheckPredicate, 23, // 18024: check predicate 23
10001 OPC_Decode, 161, 129, 1, 140, 1, // 18026: decode to VMERGE_VXM using decoder 140
10002 // 18026: }
10003 1, 0, // 18032: case 0x1: {
10004 OPC_CheckPredicate, 23, // 18034: check predicate 23
10005 OPC_CheckField, 20, 5, 0, // 18036: check Inst[24:20] == 0x0
10006 OPC_Decode, 227, 129, 1, 2, // 18040: decode to VMV_V_X using decoder 2
10007 // 18040: }
10008 // 18040: } // switch Inst[25]
10009 // 18040: }
10010 24, 8, // 18045: case 0x18: {
10011 OPC_CheckPredicate, 23, // 18047: check predicate 23
10012 OPC_Decode, 188, 129, 1, 139, 1, // 18049: decode to VMSEQ_VX using decoder 139
10013 // 18049: }
10014 25, 8, // 18055: case 0x19: {
10015 OPC_CheckPredicate, 23, // 18057: check predicate 23
10016 OPC_Decode, 206, 129, 1, 139, 1, // 18059: decode to VMSNE_VX using decoder 139
10017 // 18059: }
10018 26, 8, // 18065: case 0x1a: {
10019 OPC_CheckPredicate, 23, // 18067: check predicate 23
10020 OPC_Decode, 201, 129, 1, 139, 1, // 18069: decode to VMSLTU_VX using decoder 139
10021 // 18069: }
10022 27, 8, // 18075: case 0x1b: {
10023 OPC_CheckPredicate, 23, // 18077: check predicate 23
10024 OPC_Decode, 203, 129, 1, 139, 1, // 18079: decode to VMSLT_VX using decoder 139
10025 // 18079: }
10026 28, 8, // 18085: case 0x1c: {
10027 OPC_CheckPredicate, 23, // 18087: check predicate 23
10028 OPC_Decode, 196, 129, 1, 139, 1, // 18089: decode to VMSLEU_VX using decoder 139
10029 // 18089: }
10030 29, 8, // 18095: case 0x1d: {
10031 OPC_CheckPredicate, 23, // 18097: check predicate 23
10032 OPC_Decode, 199, 129, 1, 139, 1, // 18099: decode to VMSLE_VX using decoder 139
10033 // 18099: }
10034 30, 8, // 18105: case 0x1e: {
10035 OPC_CheckPredicate, 23, // 18107: check predicate 23
10036 OPC_Decode, 190, 129, 1, 139, 1, // 18109: decode to VMSGTU_VX using decoder 139
10037 // 18109: }
10038 31, 8, // 18115: case 0x1f: {
10039 OPC_CheckPredicate, 23, // 18117: check predicate 23
10040 OPC_Decode, 192, 129, 1, 139, 1, // 18119: decode to VMSGT_VX using decoder 139
10041 // 18119: }
10042 32, 8, // 18125: case 0x20: {
10043 OPC_CheckPredicate, 23, // 18127: check predicate 23
10044 OPC_Decode, 164, 130, 1, 139, 1, // 18129: decode to VSADDU_VX using decoder 139
10045 // 18129: }
10046 33, 8, // 18135: case 0x21: {
10047 OPC_CheckPredicate, 23, // 18137: check predicate 23
10048 OPC_Decode, 167, 130, 1, 139, 1, // 18139: decode to VSADD_VX using decoder 139
10049 // 18139: }
10050 34, 8, // 18145: case 0x22: {
10051 OPC_CheckPredicate, 23, // 18147: check predicate 23
10052 OPC_Decode, 177, 131, 1, 139, 1, // 18149: decode to VSSUBU_VX using decoder 139
10053 // 18149: }
10054 35, 8, // 18155: case 0x23: {
10055 OPC_CheckPredicate, 23, // 18157: check predicate 23
10056 OPC_Decode, 179, 131, 1, 139, 1, // 18159: decode to VSSUB_VX using decoder 139
10057 // 18159: }
10058 37, 8, // 18165: case 0x25: {
10059 OPC_CheckPredicate, 23, // 18167: check predicate 23
10060 OPC_Decode, 191, 130, 1, 139, 1, // 18169: decode to VSLL_VX using decoder 139
10061 // 18169: }
10062 39, 8, // 18175: case 0x27: {
10063 OPC_CheckPredicate, 23, // 18177: check predicate 23
10064 OPC_Decode, 198, 130, 1, 139, 1, // 18179: decode to VSMUL_VX using decoder 139
10065 // 18179: }
10066 40, 8, // 18185: case 0x28: {
10067 OPC_CheckPredicate, 23, // 18187: check predicate 23
10068 OPC_Decode, 237, 130, 1, 139, 1, // 18189: decode to VSRL_VX using decoder 139
10069 // 18189: }
10070 41, 8, // 18195: case 0x29: {
10071 OPC_CheckPredicate, 23, // 18197: check predicate 23
10072 OPC_Decode, 234, 130, 1, 139, 1, // 18199: decode to VSRA_VX using decoder 139
10073 // 18199: }
10074 42, 8, // 18205: case 0x2a: {
10075 OPC_CheckPredicate, 23, // 18207: check predicate 23
10076 OPC_Decode, 147, 131, 1, 139, 1, // 18209: decode to VSSRL_VX using decoder 139
10077 // 18209: }
10078 43, 8, // 18215: case 0x2b: {
10079 OPC_CheckPredicate, 23, // 18217: check predicate 23
10080 OPC_Decode, 144, 131, 1, 139, 1, // 18219: decode to VSSRA_VX using decoder 139
10081 // 18219: }
10082 44, 8, // 18225: case 0x2c: {
10083 OPC_CheckPredicate, 23, // 18227: check predicate 23
10084 OPC_Decode, 250, 129, 1, 139, 1, // 18229: decode to VNSRL_WX using decoder 139
10085 // 18229: }
10086 45, 8, // 18235: case 0x2d: {
10087 OPC_CheckPredicate, 23, // 18237: check predicate 23
10088 OPC_Decode, 247, 129, 1, 139, 1, // 18239: decode to VNSRA_WX using decoder 139
10089 // 18239: }
10090 46, 8, // 18245: case 0x2e: {
10091 OPC_CheckPredicate, 23, // 18247: check predicate 23
10092 OPC_Decode, 233, 129, 1, 139, 1, // 18249: decode to VNCLIPU_WX using decoder 139
10093 // 18249: }
10094 47, 8, // 18255: case 0x2f: {
10095 OPC_CheckPredicate, 23, // 18257: check predicate 23
10096 OPC_Decode, 236, 129, 1, 139, 1, // 18259: decode to VNCLIP_WX using decoder 139
10097 // 18259: }
10098 53, 8, // 18265: case 0x35: {
10099 OPC_CheckPredicate, 100, // 18267: check predicate 100
10100 OPC_Decode, 247, 131, 1, 139, 1, // 18269: decode to VWSLL_VX using decoder 139
10101 // 18269: }
10102 61, 8, // 18275: case 0x3d: {
10103 OPC_CheckPredicate, 103, // 18277: check predicate 103
10104 OPC_Decode, 220, 131, 1, 142, 1, // 18279: decode to VWABDA_VX using decoder 142
10105 // 18279: }
10106 62, 0, // 18285: case 0x3e: {
10107 OPC_CheckPredicate, 103, // 18287: check predicate 103
10108 OPC_Decode, 218, 131, 1, 142, 1, // 18289: decode to VWABDAU_VX using decoder 142
10109 // 18289: }
10110 // 18289: } // switch Inst[31:26]
10111 // 18289: }
10112 5, 254, 2, // 18295: case 0x5: {
10113 OPC_SwitchField, 26, 6, // 18298: switch Inst[31:26] {
10114 0, 7, // 18301: case 0x0: {
10115 OPC_CheckPredicate, 104, // 18303: check predicate 104
10116 OPC_Decode, 203, 126, 143, 1, // 18305: decode to VFADD_VF using decoder 143
10117 // 18305: }
10118 2, 7, // 18310: case 0x2: {
10119 OPC_CheckPredicate, 104, // 18312: check predicate 104
10120 OPC_Decode, 151, 127, 143, 1, // 18314: decode to VFSUB_VF using decoder 143
10121 // 18314: }
10122 4, 7, // 18319: case 0x4: {
10123 OPC_CheckPredicate, 104, // 18321: check predicate 104
10124 OPC_Decode, 223, 126, 143, 1, // 18323: decode to VFMIN_VF using decoder 143
10125 // 18323: }
10126 6, 7, // 18328: case 0x6: {
10127 OPC_CheckPredicate, 104, // 18330: check predicate 104
10128 OPC_Decode, 220, 126, 143, 1, // 18332: decode to VFMAX_VF using decoder 143
10129 // 18332: }
10130 8, 7, // 18337: case 0x8: {
10131 OPC_CheckPredicate, 104, // 18339: check predicate 104
10132 OPC_Decode, 146, 127, 143, 1, // 18341: decode to VFSGNJ_VF using decoder 143
10133 // 18341: }
10134 9, 7, // 18346: case 0x9: {
10135 OPC_CheckPredicate, 104, // 18348: check predicate 104
10136 OPC_Decode, 142, 127, 143, 1, // 18350: decode to VFSGNJN_VF using decoder 143
10137 // 18350: }
10138 10, 7, // 18355: case 0xa: {
10139 OPC_CheckPredicate, 104, // 18357: check predicate 104
10140 OPC_Decode, 144, 127, 143, 1, // 18359: decode to VFSGNJX_VF using decoder 143
10141 // 18359: }
10142 14, 7, // 18364: case 0xe: {
10143 OPC_CheckPredicate, 104, // 18366: check predicate 104
10144 OPC_Decode, 149, 127, 143, 1, // 18368: decode to VFSLIDE1UP_VF using decoder 143
10145 // 18368: }
10146 15, 7, // 18373: case 0xf: {
10147 OPC_CheckPredicate, 104, // 18375: check predicate 104
10148 OPC_Decode, 148, 127, 143, 1, // 18377: decode to VFSLIDE1DOWN_VF using decoder 143
10149 // 18377: }
10150 16, 11, // 18382: case 0x10: {
10151 OPC_CheckPredicate, 104, // 18384: check predicate 104
10152 OPC_CheckField, 20, 6, 32, // 18386: check Inst[25:20] == 0x20
10153 OPC_Decode, 233, 126, 144, 1, // 18390: decode to VFMV_S_F using decoder 144
10154 // 18390: }
10155 23, 25, // 18395: case 0x17: {
10156 OPC_SwitchField, 25, 1, // 18397: switch Inst[25] {
10157 0, 7, // 18400: case 0x0: {
10158 OPC_CheckPredicate, 104, // 18402: check predicate 104
10159 OPC_Decode, 222, 126, 145, 1, // 18404: decode to VFMERGE_VFM using decoder 145
10160 // 18404: }
10161 1, 0, // 18409: case 0x1: {
10162 OPC_CheckPredicate, 104, // 18411: check predicate 104
10163 OPC_CheckField, 20, 5, 0, // 18413: check Inst[24:20] == 0x0
10164 OPC_Decode, 234, 126, 146, 1, // 18417: decode to VFMV_V_F using decoder 146
10165 // 18417: }
10166 // 18417: } // switch Inst[25]
10167 // 18417: }
10168 24, 8, // 18422: case 0x18: {
10169 OPC_CheckPredicate, 104, // 18424: check predicate 104
10170 OPC_Decode, 162, 129, 1, 143, 1, // 18426: decode to VMFEQ_VF using decoder 143
10171 // 18426: }
10172 25, 8, // 18432: case 0x19: {
10173 OPC_CheckPredicate, 104, // 18434: check predicate 104
10174 OPC_Decode, 166, 129, 1, 143, 1, // 18436: decode to VMFLE_VF using decoder 143
10175 // 18436: }
10176 27, 8, // 18442: case 0x1b: {
10177 OPC_CheckPredicate, 104, // 18444: check predicate 104
10178 OPC_Decode, 168, 129, 1, 143, 1, // 18446: decode to VMFLT_VF using decoder 143
10179 // 18446: }
10180 28, 8, // 18452: case 0x1c: {
10181 OPC_CheckPredicate, 104, // 18454: check predicate 104
10182 OPC_Decode, 170, 129, 1, 143, 1, // 18456: decode to VMFNE_VF using decoder 143
10183 // 18456: }
10184 29, 8, // 18462: case 0x1d: {
10185 OPC_CheckPredicate, 104, // 18464: check predicate 104
10186 OPC_Decode, 165, 129, 1, 143, 1, // 18466: decode to VMFGT_VF using decoder 143
10187 // 18466: }
10188 31, 8, // 18472: case 0x1f: {
10189 OPC_CheckPredicate, 104, // 18474: check predicate 104
10190 OPC_Decode, 164, 129, 1, 143, 1, // 18476: decode to VMFGE_VF using decoder 143
10191 // 18476: }
10192 32, 7, // 18482: case 0x20: {
10193 OPC_CheckPredicate, 104, // 18484: check predicate 104
10194 OPC_Decode, 213, 126, 143, 1, // 18486: decode to VFDIV_VF using decoder 143
10195 // 18486: }
10196 33, 7, // 18491: case 0x21: {
10197 OPC_CheckPredicate, 104, // 18493: check predicate 104
10198 OPC_Decode, 134, 127, 143, 1, // 18495: decode to VFRDIV_VF using decoder 143
10199 // 18495: }
10200 36, 7, // 18500: case 0x24: {
10201 OPC_CheckPredicate, 104, // 18502: check predicate 104
10202 OPC_Decode, 230, 126, 143, 1, // 18504: decode to VFMUL_VF using decoder 143
10203 // 18504: }
10204 39, 7, // 18509: case 0x27: {
10205 OPC_CheckPredicate, 104, // 18511: check predicate 104
10206 OPC_Decode, 141, 127, 143, 1, // 18513: decode to VFRSUB_VF using decoder 143
10207 // 18513: }
10208 40, 7, // 18518: case 0x28: {
10209 OPC_CheckPredicate, 104, // 18520: check predicate 104
10210 OPC_Decode, 218, 126, 147, 1, // 18522: decode to VFMADD_VF using decoder 147
10211 // 18522: }
10212 41, 7, // 18527: case 0x29: {
10213 OPC_CheckPredicate, 104, // 18529: check predicate 104
10214 OPC_Decode, 249, 126, 147, 1, // 18531: decode to VFNMADD_VF using decoder 147
10215 // 18531: }
10216 42, 7, // 18536: case 0x2a: {
10217 OPC_CheckPredicate, 104, // 18538: check predicate 104
10218 OPC_Decode, 228, 126, 147, 1, // 18540: decode to VFMSUB_VF using decoder 147
10219 // 18540: }
10220 43, 7, // 18545: case 0x2b: {
10221 OPC_CheckPredicate, 104, // 18547: check predicate 104
10222 OPC_Decode, 253, 126, 147, 1, // 18549: decode to VFNMSUB_VF using decoder 147
10223 // 18549: }
10224 44, 7, // 18554: case 0x2c: {
10225 OPC_CheckPredicate, 104, // 18556: check predicate 104
10226 OPC_Decode, 216, 126, 147, 1, // 18558: decode to VFMACC_VF using decoder 147
10227 // 18558: }
10228 45, 7, // 18563: case 0x2d: {
10229 OPC_CheckPredicate, 104, // 18565: check predicate 104
10230 OPC_Decode, 247, 126, 147, 1, // 18567: decode to VFNMACC_VF using decoder 147
10231 // 18567: }
10232 46, 7, // 18572: case 0x2e: {
10233 OPC_CheckPredicate, 104, // 18574: check predicate 104
10234 OPC_Decode, 226, 126, 147, 1, // 18576: decode to VFMSAC_VF using decoder 147
10235 // 18576: }
10236 47, 7, // 18581: case 0x2f: {
10237 OPC_CheckPredicate, 104, // 18583: check predicate 104
10238 OPC_Decode, 251, 126, 147, 1, // 18585: decode to VFNMSAC_VF using decoder 147
10239 // 18585: }
10240 48, 7, // 18590: case 0x30: {
10241 OPC_CheckPredicate, 104, // 18592: check predicate 104
10242 OPC_Decode, 153, 127, 143, 1, // 18594: decode to VFWADD_VF using decoder 143
10243 // 18594: }
10244 50, 7, // 18599: case 0x32: {
10245 OPC_CheckPredicate, 104, // 18601: check predicate 104
10246 OPC_Decode, 188, 127, 143, 1, // 18603: decode to VFWSUB_VF using decoder 143
10247 // 18603: }
10248 52, 7, // 18608: case 0x34: {
10249 OPC_CheckPredicate, 104, // 18610: check predicate 104
10250 OPC_Decode, 155, 127, 143, 1, // 18612: decode to VFWADD_WF using decoder 143
10251 // 18612: }
10252 54, 7, // 18617: case 0x36: {
10253 OPC_CheckPredicate, 104, // 18619: check predicate 104
10254 OPC_Decode, 190, 127, 143, 1, // 18621: decode to VFWSUB_WF using decoder 143
10255 // 18621: }
10256 56, 7, // 18626: case 0x38: {
10257 OPC_CheckPredicate, 104, // 18628: check predicate 104
10258 OPC_Decode, 180, 127, 143, 1, // 18630: decode to VFWMUL_VF using decoder 143
10259 // 18630: }
10260 59, 7, // 18635: case 0x3b: {
10261 OPC_CheckPredicate, 107, // 18637: check predicate 107
10262 OPC_Decode, 168, 127, 147, 1, // 18639: decode to VFWMACCBF16_VF using decoder 147
10263 // 18639: }
10264 60, 7, // 18644: case 0x3c: {
10265 OPC_CheckPredicate, 104, // 18646: check predicate 104
10266 OPC_Decode, 170, 127, 147, 1, // 18648: decode to VFWMACC_VF using decoder 147
10267 // 18648: }
10268 61, 7, // 18653: case 0x3d: {
10269 OPC_CheckPredicate, 104, // 18655: check predicate 104
10270 OPC_Decode, 182, 127, 147, 1, // 18657: decode to VFWNMACC_VF using decoder 147
10271 // 18657: }
10272 62, 7, // 18662: case 0x3e: {
10273 OPC_CheckPredicate, 104, // 18664: check predicate 104
10274 OPC_Decode, 178, 127, 147, 1, // 18666: decode to VFWMSAC_VF using decoder 147
10275 // 18666: }
10276 63, 0, // 18671: case 0x3f: {
10277 OPC_CheckPredicate, 104, // 18673: check predicate 104
10278 OPC_Decode, 184, 127, 147, 1, // 18675: decode to VFWNMSAC_VF using decoder 147
10279 // 18675: }
10280 // 18675: } // switch Inst[31:26]
10281 // 18675: }
10282 6, 157, 3, // 18680: case 0x6: {
10283 OPC_SwitchField, 26, 6, // 18683: switch Inst[31:26] {
10284 8, 7, // 18686: case 0x8: {
10285 OPC_CheckPredicate, 23, // 18688: check predicate 23
10286 OPC_Decode, 145, 126, 139, 1, // 18690: decode to VAADDU_VX using decoder 139
10287 // 18690: }
10288 9, 7, // 18695: case 0x9: {
10289 OPC_CheckPredicate, 23, // 18697: check predicate 23
10290 OPC_Decode, 147, 126, 139, 1, // 18699: decode to VAADD_VX using decoder 139
10291 // 18699: }
10292 10, 7, // 18704: case 0xa: {
10293 OPC_CheckPredicate, 23, // 18706: check predicate 23
10294 OPC_Decode, 175, 126, 139, 1, // 18708: decode to VASUBU_VX using decoder 139
10295 // 18708: }
10296 11, 7, // 18713: case 0xb: {
10297 OPC_CheckPredicate, 23, // 18715: check predicate 23
10298 OPC_Decode, 177, 126, 139, 1, // 18717: decode to VASUB_VX using decoder 139
10299 // 18717: }
10300 12, 7, // 18722: case 0xc: {
10301 OPC_CheckPredicate, 108, // 18724: check predicate 108
10302 OPC_Decode, 183, 126, 139, 1, // 18726: decode to VCLMUL_VX using decoder 139
10303 // 18726: }
10304 13, 7, // 18731: case 0xd: {
10305 OPC_CheckPredicate, 108, // 18733: check predicate 108
10306 OPC_Decode, 181, 126, 139, 1, // 18735: decode to VCLMULH_VX using decoder 139
10307 // 18735: }
10308 14, 8, // 18740: case 0xe: {
10309 OPC_CheckPredicate, 23, // 18742: check predicate 23
10310 OPC_Decode, 184, 130, 1, 139, 1, // 18744: decode to VSLIDE1UP_VX using decoder 139
10311 // 18744: }
10312 15, 8, // 18750: case 0xf: {
10313 OPC_CheckPredicate, 23, // 18752: check predicate 23
10314 OPC_Decode, 183, 130, 1, 139, 1, // 18754: decode to VSLIDE1DOWN_VX using decoder 139
10315 // 18754: }
10316 16, 12, // 18760: case 0x10: {
10317 OPC_CheckPredicate, 23, // 18762: check predicate 23
10318 OPC_CheckField, 20, 6, 32, // 18764: check Inst[25:20] == 0x20
10319 OPC_Decode, 224, 129, 1, 148, 1, // 18768: decode to VMV_S_X using decoder 148
10320 // 18768: }
10321 21, 7, // 18774: case 0x15: {
10322 OPC_CheckPredicate, 103, // 18776: check predicate 103
10323 OPC_Decode, 151, 126, 139, 1, // 18778: decode to VABD_VX using decoder 139
10324 // 18778: }
10325 22, 7, // 18783: case 0x16: {
10326 OPC_CheckPredicate, 103, // 18785: check predicate 103
10327 OPC_Decode, 149, 126, 139, 1, // 18787: decode to VABDU_VX using decoder 139
10328 // 18787: }
10329 32, 7, // 18792: case 0x20: {
10330 OPC_CheckPredicate, 23, // 18794: check predicate 23
10331 OPC_Decode, 190, 126, 139, 1, // 18796: decode to VDIVU_VX using decoder 139
10332 // 18796: }
10333 33, 7, // 18801: case 0x21: {
10334 OPC_CheckPredicate, 23, // 18803: check predicate 23
10335 OPC_Decode, 192, 126, 139, 1, // 18805: decode to VDIV_VX using decoder 139
10336 // 18805: }
10337 34, 8, // 18810: case 0x22: {
10338 OPC_CheckPredicate, 23, // 18812: check predicate 23
10339 OPC_Decode, 143, 130, 1, 139, 1, // 18814: decode to VREMU_VX using decoder 139
10340 // 18814: }
10341 35, 8, // 18820: case 0x23: {
10342 OPC_CheckPredicate, 23, // 18822: check predicate 23
10343 OPC_Decode, 145, 130, 1, 139, 1, // 18824: decode to VREM_VX using decoder 139
10344 // 18824: }
10345 36, 8, // 18830: case 0x24: {
10346 OPC_CheckPredicate, 23, // 18832: check predicate 23
10347 OPC_Decode, 215, 129, 1, 139, 1, // 18834: decode to VMULHU_VX using decoder 139
10348 // 18834: }
10349 37, 8, // 18840: case 0x25: {
10350 OPC_CheckPredicate, 23, // 18842: check predicate 23
10351 OPC_Decode, 219, 129, 1, 139, 1, // 18844: decode to VMUL_VX using decoder 139
10352 // 18844: }
10353 38, 8, // 18850: case 0x26: {
10354 OPC_CheckPredicate, 23, // 18852: check predicate 23
10355 OPC_Decode, 213, 129, 1, 139, 1, // 18854: decode to VMULHSU_VX using decoder 139
10356 // 18854: }
10357 39, 8, // 18860: case 0x27: {
10358 OPC_CheckPredicate, 23, // 18862: check predicate 23
10359 OPC_Decode, 217, 129, 1, 139, 1, // 18864: decode to VMULH_VX using decoder 139
10360 // 18864: }
10361 40, 7, // 18870: case 0x28: {
10362 OPC_CheckPredicate, 109, // 18872: check predicate 109
10363 OPC_Decode, 197, 126, 142, 1, // 18874: decode to VDOT4AU_VX using decoder 142
10364 // 18874: }
10365 41, 8, // 18879: case 0x29: {
10366 OPC_CheckPredicate, 23, // 18881: check predicate 23
10367 OPC_Decode, 128, 129, 1, 149, 1, // 18883: decode to VMADD_VX using decoder 149
10368 // 18883: }
10369 42, 7, // 18889: case 0x2a: {
10370 OPC_CheckPredicate, 109, // 18891: check predicate 109
10371 OPC_Decode, 194, 126, 142, 1, // 18893: decode to VDOT4ASU_VX using decoder 142
10372 // 18893: }
10373 43, 8, // 18898: case 0x2b: {
10374 OPC_CheckPredicate, 23, // 18900: check predicate 23
10375 OPC_Decode, 240, 129, 1, 149, 1, // 18902: decode to VNMSUB_VX using decoder 149
10376 // 18902: }
10377 44, 7, // 18908: case 0x2c: {
10378 OPC_CheckPredicate, 109, // 18910: check predicate 109
10379 OPC_Decode, 199, 126, 142, 1, // 18912: decode to VDOT4A_VX using decoder 142
10380 // 18912: }
10381 45, 8, // 18917: case 0x2d: {
10382 OPC_CheckPredicate, 23, // 18919: check predicate 23
10383 OPC_Decode, 248, 128, 1, 149, 1, // 18921: decode to VMACC_VX using decoder 149
10384 // 18921: }
10385 46, 7, // 18927: case 0x2e: {
10386 OPC_CheckPredicate, 109, // 18929: check predicate 109
10387 OPC_Decode, 195, 126, 142, 1, // 18931: decode to VDOT4AUS_VX using decoder 142
10388 // 18931: }
10389 47, 8, // 18936: case 0x2f: {
10390 OPC_CheckPredicate, 23, // 18938: check predicate 23
10391 OPC_Decode, 238, 129, 1, 149, 1, // 18940: decode to VNMSAC_VX using decoder 149
10392 // 18940: }
10393 48, 8, // 18946: case 0x30: {
10394 OPC_CheckPredicate, 23, // 18948: check predicate 23
10395 OPC_Decode, 222, 131, 1, 139, 1, // 18950: decode to VWADDU_VX using decoder 139
10396 // 18950: }
10397 49, 8, // 18956: case 0x31: {
10398 OPC_CheckPredicate, 23, // 18958: check predicate 23
10399 OPC_Decode, 226, 131, 1, 139, 1, // 18960: decode to VWADD_VX using decoder 139
10400 // 18960: }
10401 50, 8, // 18966: case 0x32: {
10402 OPC_CheckPredicate, 23, // 18968: check predicate 23
10403 OPC_Decode, 249, 131, 1, 139, 1, // 18970: decode to VWSUBU_VX using decoder 139
10404 // 18970: }
10405 51, 8, // 18976: case 0x33: {
10406 OPC_CheckPredicate, 23, // 18978: check predicate 23
10407 OPC_Decode, 253, 131, 1, 139, 1, // 18980: decode to VWSUB_VX using decoder 139
10408 // 18980: }
10409 52, 8, // 18986: case 0x34: {
10410 OPC_CheckPredicate, 23, // 18988: check predicate 23
10411 OPC_Decode, 224, 131, 1, 139, 1, // 18990: decode to VWADDU_WX using decoder 139
10412 // 18990: }
10413 53, 8, // 18996: case 0x35: {
10414 OPC_CheckPredicate, 23, // 18998: check predicate 23
10415 OPC_Decode, 228, 131, 1, 139, 1, // 19000: decode to VWADD_WX using decoder 139
10416 // 19000: }
10417 54, 8, // 19006: case 0x36: {
10418 OPC_CheckPredicate, 23, // 19008: check predicate 23
10419 OPC_Decode, 251, 131, 1, 139, 1, // 19010: decode to VWSUBU_WX using decoder 139
10420 // 19010: }
10421 55, 8, // 19016: case 0x37: {
10422 OPC_CheckPredicate, 23, // 19018: check predicate 23
10423 OPC_Decode, 255, 131, 1, 139, 1, // 19020: decode to VWSUB_WX using decoder 139
10424 // 19020: }
10425 56, 8, // 19026: case 0x38: {
10426 OPC_CheckPredicate, 23, // 19028: check predicate 23
10427 OPC_Decode, 240, 131, 1, 139, 1, // 19030: decode to VWMULU_VX using decoder 139
10428 // 19030: }
10429 58, 8, // 19036: case 0x3a: {
10430 OPC_CheckPredicate, 23, // 19038: check predicate 23
10431 OPC_Decode, 238, 131, 1, 139, 1, // 19040: decode to VWMULSU_VX using decoder 139
10432 // 19040: }
10433 59, 8, // 19046: case 0x3b: {
10434 OPC_CheckPredicate, 23, // 19048: check predicate 23
10435 OPC_Decode, 242, 131, 1, 139, 1, // 19050: decode to VWMUL_VX using decoder 139
10436 // 19050: }
10437 60, 8, // 19056: case 0x3c: {
10438 OPC_CheckPredicate, 23, // 19058: check predicate 23
10439 OPC_Decode, 233, 131, 1, 149, 1, // 19060: decode to VWMACCU_VX using decoder 149
10440 // 19060: }
10441 61, 8, // 19066: case 0x3d: {
10442 OPC_CheckPredicate, 23, // 19068: check predicate 23
10443 OPC_Decode, 235, 131, 1, 149, 1, // 19070: decode to VWMACC_VX using decoder 149
10444 // 19070: }
10445 62, 8, // 19076: case 0x3e: {
10446 OPC_CheckPredicate, 23, // 19078: check predicate 23
10447 OPC_Decode, 231, 131, 1, 149, 1, // 19080: decode to VWMACCUS_VX using decoder 149
10448 // 19080: }
10449 63, 0, // 19086: case 0x3f: {
10450 OPC_CheckPredicate, 23, // 19088: check predicate 23
10451 OPC_Decode, 230, 131, 1, 149, 1, // 19090: decode to VWMACCSU_VX using decoder 149
10452 // 19090: }
10453 // 19090: } // switch Inst[31:26]
10454 // 19090: }
10455 7, 0, // 19096: case 0x7: {
10456 OPC_SwitchField, 31, 1, // 19098: switch Inst[31] {
10457 0, 8, // 19101: case 0x0: {
10458 OPC_CheckPredicate, 23, // 19103: check predicate 23
10459 OPC_Decode, 176, 130, 1, 150, 1, // 19105: decode to VSETVLI using decoder 150
10460 // 19105: }
10461 1, 0, // 19111: case 0x1: {
10462 OPC_SwitchField, 30, 1, // 19113: switch Inst[30] {
10463 0, 11, // 19116: case 0x0: {
10464 OPC_CheckPredicate, 23, // 19118: check predicate 23
10465 OPC_CheckField, 25, 5, 0, // 19120: check Inst[29:25] == 0x0
10466 OPC_Decode, 175, 130, 1, 31, // 19124: decode to VSETVL using decoder 31
10467 // 19124: }
10468 1, 0, // 19129: case 0x1: {
10469 OPC_CheckPredicate, 23, // 19131: check predicate 23
10470 OPC_Decode, 174, 130, 1, 151, 1, // 19133: decode to VSETIVLI using decoder 151
10471 // 19133: }
10472 // 19133: } // switch Inst[30]
10473 // 19133: }
10474 // 19133: } // switch Inst[31]
10475 // 19133: }
10476 // 19133: } // switch Inst[14:12]
10477 // 19133: }
10478 99, 63, // 19139: case 0x63: {
10479 OPC_SwitchField, 12, 3, // 19141: switch Inst[14:12] {
10480 0, 5, // 19144: case 0x0: {
10481 OPC_Decode, 226, 110, 152, 1, // 19146: decode to BEQ using decoder 152
10482 // 19146: }
10483 1, 5, // 19151: case 0x1: {
10484 OPC_Decode, 236, 110, 152, 1, // 19153: decode to BNE using decoder 152
10485 // 19153: }
10486 2, 7, // 19158: case 0x2: {
10487 OPC_CheckPredicate, 110, // 19160: check predicate 110
10488 OPC_Decode, 227, 110, 153, 1, // 19162: decode to BEQI using decoder 153
10489 // 19162: }
10490 3, 7, // 19167: case 0x3: {
10491 OPC_CheckPredicate, 110, // 19169: check predicate 110
10492 OPC_Decode, 237, 110, 153, 1, // 19171: decode to BNEI using decoder 153
10493 // 19171: }
10494 4, 5, // 19176: case 0x4: {
10495 OPC_Decode, 234, 110, 152, 1, // 19178: decode to BLT using decoder 152
10496 // 19178: }
10497 5, 5, // 19183: case 0x5: {
10498 OPC_Decode, 230, 110, 152, 1, // 19185: decode to BGE using decoder 152
10499 // 19185: }
10500 6, 5, // 19190: case 0x6: {
10501 OPC_Decode, 235, 110, 152, 1, // 19192: decode to BLTU using decoder 152
10502 // 19192: }
10503 7, 0, // 19197: case 0x7: {
10504 OPC_Decode, 231, 110, 152, 1, // 19199: decode to BGEU using decoder 152
10505 // 19199: }
10506 // 19199: } // switch Inst[14:12]
10507 // 19199: }
10508 103, 8, // 19204: case 0x67: {
10509 OPC_CheckField, 12, 3, 0, // 19206: check Inst[14:12] == 0x0
10510 OPC_Decode, 221, 116, 0, // 19210: decode to JALR using decoder 0
10511 // 19210: }
10512 111, 5, // 19214: case 0x6f: {
10513 OPC_Decode, 220, 116, 154, 1, // 19216: decode to JAL using decoder 154
10514 // 19216: }
10515 115, 173, 7, // 19221: case 0x73: {
10516 OPC_SwitchField, 12, 3, // 19224: switch Inst[14:12] {
10517 0, 201, 2, // 19227: case 0x0: {
10518 OPC_SwitchField, 25, 7, // 19230: switch Inst[31:25] {
10519 0, 51, // 19233: case 0x0: {
10520 OPC_SwitchField, 15, 10, // 19235: switch Inst[24:15] {
10521 0, 8, // 19238: case 0x0: {
10522 OPC_CheckField, 7, 5, 0, // 19240: check Inst[11:7] == 0x0
10523 OPC_Decode, 152, 114, 14, // 19244: decode to ECALL using decoder 14
10524 // 19244: }
10525 32, 8, // 19248: case 0x20: {
10526 OPC_CheckField, 7, 5, 0, // 19250: check Inst[11:7] == 0x0
10527 OPC_Decode, 151, 114, 14, // 19254: decode to EBREAK using decoder 14
10528 // 19254: }
10529 160, 3, 11, // 19258: case 0x1a0: {
10530 OPC_CheckPredicate, 111, // 19261: check predicate 111
10531 OPC_CheckField, 7, 5, 0, // 19263: check Inst[11:7] == 0x0
10532 OPC_Decode, 146, 132, 1, 14, // 19267: decode to WRS_NTO using decoder 14
10533 // 19267: }
10534 160, 7, 0, // 19272: case 0x3a0: {
10535 OPC_CheckPredicate, 111, // 19275: check predicate 111
10536 OPC_CheckField, 7, 5, 0, // 19277: check Inst[11:7] == 0x0
10537 OPC_Decode, 147, 132, 1, 14, // 19281: decode to WRS_STO using decoder 14
10538 // 19281: }
10539 // 19281: } // switch Inst[24:15]
10540 // 19281: }
10541 8, 82, // 19286: case 0x8: {
10542 OPC_SwitchField, 20, 5, // 19288: switch Inst[24:20] {
10543 2, 12, // 19291: case 0x2: {
10544 OPC_CheckField, 15, 5, 0, // 19293: check Inst[19:15] == 0x0
10545 OPC_CheckField, 7, 5, 0, // 19297: check Inst[11:7] == 0x0
10546 OPC_Decode, 250, 124, 14, // 19301: decode to SRET using decoder 14
10547 // 19301: }
10548 4, 14, // 19305: case 0x4: {
10549 OPC_CheckPredicate, 112, // 19307: check predicate 112
10550 OPC_CheckField, 15, 5, 0, // 19309: check Inst[19:15] == 0x0
10551 OPC_CheckField, 7, 5, 0, // 19313: check Inst[11:7] == 0x0
10552 OPC_Decode, 226, 123, 14, // 19317: decode to SCTRCLR using decoder 14
10553 // 19317: }
10554 5, 13, // 19321: case 0x5: {
10555 OPC_CheckField, 15, 5, 0, // 19323: check Inst[19:15] == 0x0
10556 OPC_CheckField, 7, 5, 0, // 19327: check Inst[11:7] == 0x0
10557 OPC_Decode, 139, 132, 1, 14, // 19331: decode to WFI using decoder 14
10558 // 19331: }
10559 8, 14, // 19336: case 0x8: {
10560 OPC_CheckPredicate, 113, // 19338: check predicate 113
10561 OPC_CheckField, 15, 5, 0, // 19340: check Inst[19:15] == 0x0
10562 OPC_CheckField, 7, 5, 0, // 19344: check Inst[11:7] == 0x0
10563 OPC_Decode, 213, 124, 14, // 19348: decode to SIPOPRET using decoder 14
10564 // 19348: }
10565 9, 7, // 19352: case 0x9: {
10566 OPC_CheckPredicate, 114, // 19354: check predicate 114
10567 OPC_Decode, 225, 123, 155, 1, // 19356: decode to SCSPSPUSH using decoder 155
10568 // 19356: }
10569 12, 0, // 19361: case 0xc: {
10570 OPC_CheckPredicate, 114, // 19363: check predicate 114
10571 OPC_Decode, 224, 123, 155, 1, // 19365: decode to SCSPSPOP using decoder 155
10572 // 19365: }
10573 // 19365: } // switch Inst[24:20]
10574 // 19365: }
10575 9, 9, // 19370: case 0x9: {
10576 OPC_CheckField, 7, 5, 0, // 19372: check Inst[11:7] == 0x0
10577 OPC_Decode, 242, 123, 156, 1, // 19376: decode to SFENCE_VMA using decoder 156
10578 // 19376: }
10579 11, 11, // 19381: case 0xb: {
10580 OPC_CheckPredicate, 115, // 19383: check predicate 115
10581 OPC_CheckField, 7, 5, 0, // 19385: check Inst[11:7] == 0x0
10582 OPC_Decode, 212, 124, 156, 1, // 19389: decode to SINVAL_VMA using decoder 156
10583 // 19389: }
10584 12, 27, // 19394: case 0xc: {
10585 OPC_SwitchField, 15, 10, // 19396: switch Inst[24:15] {
10586 0, 10, // 19399: case 0x0: {
10587 OPC_CheckPredicate, 115, // 19401: check predicate 115
10588 OPC_CheckField, 7, 5, 0, // 19403: check Inst[11:7] == 0x0
10589 OPC_Decode, 243, 123, 14, // 19407: decode to SFENCE_W_INVAL using decoder 14
10590 // 19407: }
10591 32, 0, // 19411: case 0x20: {
10592 OPC_CheckPredicate, 115, // 19413: check predicate 115
10593 OPC_CheckField, 7, 5, 0, // 19415: check Inst[11:7] == 0x0
10594 OPC_Decode, 241, 123, 14, // 19419: decode to SFENCE_INVAL_IR using decoder 14
10595 // 19419: }
10596 // 19419: } // switch Inst[24:15]
10597 // 19419: }
10598 17, 11, // 19423: case 0x11: {
10599 OPC_CheckPredicate, 116, // 19425: check predicate 116
10600 OPC_CheckField, 7, 5, 0, // 19427: check Inst[11:7] == 0x0
10601 OPC_Decode, 177, 116, 156, 1, // 19431: decode to HFENCE_VVMA using decoder 156
10602 // 19431: }
10603 19, 11, // 19436: case 0x13: {
10604 OPC_CheckPredicate, 117, // 19438: check predicate 117
10605 OPC_CheckField, 7, 5, 0, // 19440: check Inst[11:7] == 0x0
10606 OPC_Decode, 179, 116, 156, 1, // 19444: decode to HINVAL_VVMA using decoder 156
10607 // 19444: }
10608 24, 51, // 19449: case 0x18: {
10609 OPC_SwitchField, 20, 5, // 19451: switch Inst[24:20] {
10610 2, 12, // 19454: case 0x2: {
10611 OPC_CheckField, 15, 5, 0, // 19456: check Inst[19:15] == 0x0
10612 OPC_CheckField, 7, 5, 0, // 19460: check Inst[11:7] == 0x0
10613 OPC_Decode, 238, 117, 14, // 19464: decode to MRET using decoder 14
10614 // 19464: }
10615 8, 14, // 19468: case 0x8: {
10616 OPC_CheckPredicate, 118, // 19470: check predicate 118
10617 OPC_CheckField, 15, 5, 0, // 19472: check Inst[19:15] == 0x0
10618 OPC_CheckField, 7, 5, 0, // 19476: check Inst[11:7] == 0x0
10619 OPC_Decode, 173, 117, 14, // 19480: decode to MIPOPRET using decoder 14
10620 // 19480: }
10621 9, 7, // 19484: case 0x9: {
10622 OPC_CheckPredicate, 119, // 19486: check predicate 119
10623 OPC_Decode, 159, 117, 155, 1, // 19488: decode to MCSPSPUSH using decoder 155
10624 // 19488: }
10625 12, 0, // 19493: case 0xc: {
10626 OPC_CheckPredicate, 119, // 19495: check predicate 119
10627 OPC_Decode, 158, 117, 155, 1, // 19497: decode to MCSPSPOP using decoder 155
10628 // 19497: }
10629 // 19497: } // switch Inst[24:20]
10630 // 19497: }
10631 49, 11, // 19502: case 0x31: {
10632 OPC_CheckPredicate, 116, // 19504: check predicate 116
10633 OPC_CheckField, 7, 5, 0, // 19506: check Inst[11:7] == 0x0
10634 OPC_Decode, 176, 116, 156, 1, // 19510: decode to HFENCE_GVMA using decoder 156
10635 // 19510: }
10636 51, 11, // 19515: case 0x33: {
10637 OPC_CheckPredicate, 117, // 19517: check predicate 117
10638 OPC_CheckField, 7, 5, 0, // 19519: check Inst[11:7] == 0x0
10639 OPC_Decode, 178, 116, 156, 1, // 19523: decode to HINVAL_GVMA using decoder 156
10640 // 19523: }
10641 56, 14, // 19528: case 0x38: {
10642 OPC_CheckPredicate, 120, // 19530: check predicate 120
10643 OPC_CheckField, 15, 10, 64, // 19532: check Inst[24:15] == 0x40
10644 OPC_CheckField, 7, 5, 0, // 19536: check Inst[11:7] == 0x0
10645 OPC_Decode, 183, 117, 14, // 19540: decode to MNRET using decoder 14
10646 // 19540: }
10647 61, 0, // 19544: case 0x3d: {
10648 OPC_CheckField, 15, 10, 192, 4, // 19546: check Inst[24:15] == 0x240
10649 OPC_CheckField, 7, 5, 0, // 19551: check Inst[11:7] == 0x0
10650 OPC_Decode, 150, 114, 14, // 19555: decode to DRET using decoder 14
10651 // 19555: }
10652 // 19555: } // switch Inst[31:25]
10653 // 19555: }
10654 1, 21, // 19559: case 0x1: {
10655 OPC_Scope, 14, // 19561: try {
10656 OPC_CheckField, 7, 5, 0, // 19563: check Inst[11:7] == 0x0
10657 OPC_CheckField, 15, 17, 128, 128, 6, // 19567: check Inst[31:15] == 0x18000
10658 OPC_Decode, 135, 126, 14, // 19573: decode to UNIMP using decoder 14
10659 // 19573: } else try {
10660 OPC_Decode, 138, 111, 157, 1, // 19577: decode to CSRRW using decoder 157
10661 // 19577: }
10662 // 19577: }
10663 2, 5, // 19582: case 0x2: {
10664 OPC_Decode, 136, 111, 157, 1, // 19584: decode to CSRRS using decoder 157
10665 // 19584: }
10666 3, 5, // 19589: case 0x3: {
10667 OPC_Decode, 134, 111, 157, 1, // 19591: decode to CSRRC using decoder 157
10668 // 19591: }
10669 4, 161, 4, // 19596: case 0x4: {
10670 OPC_SwitchField, 25, 7, // 19599: switch Inst[31:25] {
10671 48, 19, // 19602: case 0x30: {
10672 OPC_SwitchField, 20, 5, // 19604: switch Inst[24:20] {
10673 0, 6, // 19607: case 0x0: {
10674 OPC_CheckPredicate, 116, // 19609: check predicate 116
10675 OPC_Decode, 182, 116, 17, // 19611: decode to HLV_B using decoder 17
10676 // 19611: }
10677 1, 0, // 19615: case 0x1: {
10678 OPC_CheckPredicate, 116, // 19617: check predicate 116
10679 OPC_Decode, 183, 116, 17, // 19619: decode to HLV_BU using decoder 17
10680 // 19619: }
10681 // 19619: } // switch Inst[24:20]
10682 // 19619: }
10683 49, 10, // 19623: case 0x31: {
10684 OPC_CheckPredicate, 116, // 19625: check predicate 116
10685 OPC_CheckField, 7, 5, 0, // 19627: check Inst[11:7] == 0x0
10686 OPC_Decode, 189, 116, 59, // 19631: decode to HSV_B using decoder 59
10687 // 19631: }
10688 50, 27, // 19635: case 0x32: {
10689 OPC_SwitchField, 20, 5, // 19637: switch Inst[24:20] {
10690 0, 6, // 19640: case 0x0: {
10691 OPC_CheckPredicate, 116, // 19642: check predicate 116
10692 OPC_Decode, 185, 116, 17, // 19644: decode to HLV_H using decoder 17
10693 // 19644: }
10694 1, 6, // 19648: case 0x1: {
10695 OPC_CheckPredicate, 116, // 19650: check predicate 116
10696 OPC_Decode, 186, 116, 17, // 19652: decode to HLV_HU using decoder 17
10697 // 19652: }
10698 3, 0, // 19656: case 0x3: {
10699 OPC_CheckPredicate, 116, // 19658: check predicate 116
10700 OPC_Decode, 180, 116, 17, // 19660: decode to HLVX_HU using decoder 17
10701 // 19660: }
10702 // 19660: } // switch Inst[24:20]
10703 // 19660: }
10704 51, 10, // 19664: case 0x33: {
10705 OPC_CheckPredicate, 116, // 19666: check predicate 116
10706 OPC_CheckField, 7, 5, 0, // 19668: check Inst[11:7] == 0x0
10707 OPC_Decode, 191, 116, 59, // 19672: decode to HSV_H using decoder 59
10708 // 19672: }
10709 52, 27, // 19676: case 0x34: {
10710 OPC_SwitchField, 20, 5, // 19678: switch Inst[24:20] {
10711 0, 6, // 19681: case 0x0: {
10712 OPC_CheckPredicate, 116, // 19683: check predicate 116
10713 OPC_Decode, 187, 116, 17, // 19685: decode to HLV_W using decoder 17
10714 // 19685: }
10715 1, 6, // 19689: case 0x1: {
10716 OPC_CheckPredicate, 121, // 19691: check predicate 121
10717 OPC_Decode, 188, 116, 17, // 19693: decode to HLV_WU using decoder 17
10718 // 19693: }
10719 3, 0, // 19697: case 0x3: {
10720 OPC_CheckPredicate, 116, // 19699: check predicate 116
10721 OPC_Decode, 181, 116, 17, // 19701: decode to HLVX_WU using decoder 17
10722 // 19701: }
10723 // 19701: } // switch Inst[24:20]
10724 // 19701: }
10725 53, 10, // 19705: case 0x35: {
10726 OPC_CheckPredicate, 116, // 19707: check predicate 116
10727 OPC_CheckField, 7, 5, 0, // 19709: check Inst[11:7] == 0x0
10728 OPC_Decode, 192, 116, 59, // 19713: decode to HSV_W using decoder 59
10729 // 19713: }
10730 54, 10, // 19717: case 0x36: {
10731 OPC_CheckPredicate, 121, // 19719: check predicate 121
10732 OPC_CheckField, 20, 5, 0, // 19721: check Inst[24:20] == 0x0
10733 OPC_Decode, 184, 116, 17, // 19725: decode to HLV_D using decoder 17
10734 // 19725: }
10735 55, 10, // 19729: case 0x37: {
10736 OPC_CheckPredicate, 121, // 19731: check predicate 121
10737 OPC_CheckField, 7, 5, 0, // 19733: check Inst[11:7] == 0x0
10738 OPC_Decode, 190, 116, 59, // 19737: decode to HSV_D using decoder 59
10739 // 19737: }
10740 64, 35, // 19741: case 0x40: {
10741 OPC_SwitchField, 20, 5, // 19743: switch Inst[24:20] {
10742 28, 6, // 19746: case 0x1c: {
10743 OPC_CheckPredicate, 122, // 19748: check predicate 122
10744 OPC_Decode, 192, 117, 17, // 19750: decode to MOP_R_0 using decoder 17
10745 // 19750: }
10746 29, 6, // 19754: case 0x1d: {
10747 OPC_CheckPredicate, 122, // 19756: check predicate 122
10748 OPC_Decode, 193, 117, 17, // 19758: decode to MOP_R_1 using decoder 17
10749 // 19758: }
10750 30, 6, // 19762: case 0x1e: {
10751 OPC_CheckPredicate, 122, // 19764: check predicate 122
10752 OPC_Decode, 204, 117, 17, // 19766: decode to MOP_R_2 using decoder 17
10753 // 19766: }
10754 31, 0, // 19770: case 0x1f: {
10755 OPC_CheckPredicate, 122, // 19772: check predicate 122
10756 OPC_Decode, 215, 117, 17, // 19774: decode to MOP_R_3 using decoder 17
10757 // 19774: }
10758 // 19774: } // switch Inst[24:20]
10759 // 19774: }
10760 65, 6, // 19778: case 0x41: {
10761 OPC_CheckPredicate, 122, // 19780: check predicate 122
10762 OPC_Decode, 184, 117, 31, // 19782: decode to MOP_RR_0 using decoder 31
10763 // 19782: }
10764 66, 35, // 19786: case 0x42: {
10765 OPC_SwitchField, 20, 5, // 19788: switch Inst[24:20] {
10766 28, 6, // 19791: case 0x1c: {
10767 OPC_CheckPredicate, 122, // 19793: check predicate 122
10768 OPC_Decode, 218, 117, 17, // 19795: decode to MOP_R_4 using decoder 17
10769 // 19795: }
10770 29, 6, // 19799: case 0x1d: {
10771 OPC_CheckPredicate, 122, // 19801: check predicate 122
10772 OPC_Decode, 219, 117, 17, // 19803: decode to MOP_R_5 using decoder 17
10773 // 19803: }
10774 30, 6, // 19807: case 0x1e: {
10775 OPC_CheckPredicate, 122, // 19809: check predicate 122
10776 OPC_Decode, 220, 117, 17, // 19811: decode to MOP_R_6 using decoder 17
10777 // 19811: }
10778 31, 0, // 19815: case 0x1f: {
10779 OPC_CheckPredicate, 122, // 19817: check predicate 122
10780 OPC_Decode, 221, 117, 17, // 19819: decode to MOP_R_7 using decoder 17
10781 // 19819: }
10782 // 19819: } // switch Inst[24:20]
10783 // 19819: }
10784 67, 6, // 19823: case 0x43: {
10785 OPC_CheckPredicate, 122, // 19825: check predicate 122
10786 OPC_Decode, 185, 117, 31, // 19827: decode to MOP_RR_1 using decoder 31
10787 // 19827: }
10788 68, 35, // 19831: case 0x44: {
10789 OPC_SwitchField, 20, 5, // 19833: switch Inst[24:20] {
10790 28, 6, // 19836: case 0x1c: {
10791 OPC_CheckPredicate, 122, // 19838: check predicate 122
10792 OPC_Decode, 222, 117, 17, // 19840: decode to MOP_R_8 using decoder 17
10793 // 19840: }
10794 29, 6, // 19844: case 0x1d: {
10795 OPC_CheckPredicate, 122, // 19846: check predicate 122
10796 OPC_Decode, 223, 117, 17, // 19848: decode to MOP_R_9 using decoder 17
10797 // 19848: }
10798 30, 6, // 19852: case 0x1e: {
10799 OPC_CheckPredicate, 122, // 19854: check predicate 122
10800 OPC_Decode, 194, 117, 17, // 19856: decode to MOP_R_10 using decoder 17
10801 // 19856: }
10802 31, 0, // 19860: case 0x1f: {
10803 OPC_CheckPredicate, 122, // 19862: check predicate 122
10804 OPC_Decode, 195, 117, 17, // 19864: decode to MOP_R_11 using decoder 17
10805 // 19864: }
10806 // 19864: } // switch Inst[24:20]
10807 // 19864: }
10808 69, 6, // 19868: case 0x45: {
10809 OPC_CheckPredicate, 122, // 19870: check predicate 122
10810 OPC_Decode, 186, 117, 31, // 19872: decode to MOP_RR_2 using decoder 31
10811 // 19872: }
10812 70, 35, // 19876: case 0x46: {
10813 OPC_SwitchField, 20, 5, // 19878: switch Inst[24:20] {
10814 28, 6, // 19881: case 0x1c: {
10815 OPC_CheckPredicate, 122, // 19883: check predicate 122
10816 OPC_Decode, 196, 117, 17, // 19885: decode to MOP_R_12 using decoder 17
10817 // 19885: }
10818 29, 6, // 19889: case 0x1d: {
10819 OPC_CheckPredicate, 122, // 19891: check predicate 122
10820 OPC_Decode, 197, 117, 17, // 19893: decode to MOP_R_13 using decoder 17
10821 // 19893: }
10822 30, 6, // 19897: case 0x1e: {
10823 OPC_CheckPredicate, 122, // 19899: check predicate 122
10824 OPC_Decode, 198, 117, 17, // 19901: decode to MOP_R_14 using decoder 17
10825 // 19901: }
10826 31, 0, // 19905: case 0x1f: {
10827 OPC_CheckPredicate, 122, // 19907: check predicate 122
10828 OPC_Decode, 199, 117, 17, // 19909: decode to MOP_R_15 using decoder 17
10829 // 19909: }
10830 // 19909: } // switch Inst[24:20]
10831 // 19909: }
10832 71, 6, // 19913: case 0x47: {
10833 OPC_CheckPredicate, 122, // 19915: check predicate 122
10834 OPC_Decode, 187, 117, 31, // 19917: decode to MOP_RR_3 using decoder 31
10835 // 19917: }
10836 96, 35, // 19921: case 0x60: {
10837 OPC_SwitchField, 20, 5, // 19923: switch Inst[24:20] {
10838 28, 6, // 19926: case 0x1c: {
10839 OPC_CheckPredicate, 122, // 19928: check predicate 122
10840 OPC_Decode, 200, 117, 17, // 19930: decode to MOP_R_16 using decoder 17
10841 // 19930: }
10842 29, 6, // 19934: case 0x1d: {
10843 OPC_CheckPredicate, 122, // 19936: check predicate 122
10844 OPC_Decode, 201, 117, 17, // 19938: decode to MOP_R_17 using decoder 17
10845 // 19938: }
10846 30, 6, // 19942: case 0x1e: {
10847 OPC_CheckPredicate, 122, // 19944: check predicate 122
10848 OPC_Decode, 202, 117, 17, // 19946: decode to MOP_R_18 using decoder 17
10849 // 19946: }
10850 31, 0, // 19950: case 0x1f: {
10851 OPC_CheckPredicate, 122, // 19952: check predicate 122
10852 OPC_Decode, 203, 117, 17, // 19954: decode to MOP_R_19 using decoder 17
10853 // 19954: }
10854 // 19954: } // switch Inst[24:20]
10855 // 19954: }
10856 97, 6, // 19958: case 0x61: {
10857 OPC_CheckPredicate, 122, // 19960: check predicate 122
10858 OPC_Decode, 188, 117, 31, // 19962: decode to MOP_RR_4 using decoder 31
10859 // 19962: }
10860 98, 35, // 19966: case 0x62: {
10861 OPC_SwitchField, 20, 5, // 19968: switch Inst[24:20] {
10862 28, 6, // 19971: case 0x1c: {
10863 OPC_CheckPredicate, 122, // 19973: check predicate 122
10864 OPC_Decode, 205, 117, 17, // 19975: decode to MOP_R_20 using decoder 17
10865 // 19975: }
10866 29, 6, // 19979: case 0x1d: {
10867 OPC_CheckPredicate, 122, // 19981: check predicate 122
10868 OPC_Decode, 206, 117, 17, // 19983: decode to MOP_R_21 using decoder 17
10869 // 19983: }
10870 30, 6, // 19987: case 0x1e: {
10871 OPC_CheckPredicate, 122, // 19989: check predicate 122
10872 OPC_Decode, 207, 117, 17, // 19991: decode to MOP_R_22 using decoder 17
10873 // 19991: }
10874 31, 0, // 19995: case 0x1f: {
10875 OPC_CheckPredicate, 122, // 19997: check predicate 122
10876 OPC_Decode, 208, 117, 17, // 19999: decode to MOP_R_23 using decoder 17
10877 // 19999: }
10878 // 19999: } // switch Inst[24:20]
10879 // 19999: }
10880 99, 6, // 20003: case 0x63: {
10881 OPC_CheckPredicate, 122, // 20005: check predicate 122
10882 OPC_Decode, 189, 117, 31, // 20007: decode to MOP_RR_5 using decoder 31
10883 // 20007: }
10884 100, 35, // 20011: case 0x64: {
10885 OPC_SwitchField, 20, 5, // 20013: switch Inst[24:20] {
10886 28, 6, // 20016: case 0x1c: {
10887 OPC_CheckPredicate, 122, // 20018: check predicate 122
10888 OPC_Decode, 209, 117, 17, // 20020: decode to MOP_R_24 using decoder 17
10889 // 20020: }
10890 29, 6, // 20024: case 0x1d: {
10891 OPC_CheckPredicate, 122, // 20026: check predicate 122
10892 OPC_Decode, 210, 117, 17, // 20028: decode to MOP_R_25 using decoder 17
10893 // 20028: }
10894 30, 6, // 20032: case 0x1e: {
10895 OPC_CheckPredicate, 122, // 20034: check predicate 122
10896 OPC_Decode, 211, 117, 17, // 20036: decode to MOP_R_26 using decoder 17
10897 // 20036: }
10898 31, 0, // 20040: case 0x1f: {
10899 OPC_CheckPredicate, 122, // 20042: check predicate 122
10900 OPC_Decode, 212, 117, 17, // 20044: decode to MOP_R_27 using decoder 17
10901 // 20044: }
10902 // 20044: } // switch Inst[24:20]
10903 // 20044: }
10904 101, 6, // 20048: case 0x65: {
10905 OPC_CheckPredicate, 122, // 20050: check predicate 122
10906 OPC_Decode, 190, 117, 31, // 20052: decode to MOP_RR_6 using decoder 31
10907 // 20052: }
10908 102, 61, // 20056: case 0x66: {
10909 OPC_SwitchField, 20, 5, // 20058: switch Inst[24:20] {
10910 28, 32, // 20061: case 0x1c: {
10911 OPC_Scope, 11, // 20063: try {
10912 OPC_CheckField, 7, 5, 0, // 20065: check Inst[11:7] == 0x0
10913 OPC_CheckPredicate, 122, // 20069: check predicate 122
10914 OPC_Decode, 142, 125, 158, 1, // 20071: decode to SSPOPCHK using decoder 158
10915 OPC_Scope, 11, // 20076: } else try {
10916 OPC_CheckField, 15, 5, 0, // 20078: check Inst[19:15] == 0x0
10917 OPC_CheckPredicate, 122, // 20082: check predicate 122
10918 OPC_Decode, 144, 125, 159, 1, // 20084: decode to SSRDP using decoder 159
10919 // 20084: } else try {
10920 OPC_CheckPredicate, 122, // 20089: check predicate 122
10921 OPC_Decode, 213, 117, 17, // 20091: decode to MOP_R_28 using decoder 17
10922 // 20091: }
10923 // 20091: }
10924 29, 6, // 20095: case 0x1d: {
10925 OPC_CheckPredicate, 122, // 20097: check predicate 122
10926 OPC_Decode, 214, 117, 17, // 20099: decode to MOP_R_29 using decoder 17
10927 // 20099: }
10928 30, 6, // 20103: case 0x1e: {
10929 OPC_CheckPredicate, 122, // 20105: check predicate 122
10930 OPC_Decode, 216, 117, 17, // 20107: decode to MOP_R_30 using decoder 17
10931 // 20107: }
10932 31, 0, // 20111: case 0x1f: {
10933 OPC_CheckPredicate, 122, // 20113: check predicate 122
10934 OPC_Decode, 217, 117, 17, // 20115: decode to MOP_R_31 using decoder 17
10935 // 20115: }
10936 // 20115: } // switch Inst[24:20]
10937 // 20115: }
10938 103, 0, // 20119: case 0x67: {
10939 OPC_Scope, 15, // 20121: try {
10940 OPC_CheckField, 7, 5, 0, // 20123: check Inst[11:7] == 0x0
10941 OPC_CheckPredicate, 122, // 20127: check predicate 122
10942 OPC_CheckField, 15, 5, 0, // 20129: check Inst[19:15] == 0x0
10943 OPC_Decode, 143, 125, 160, 1, // 20133: decode to SSPUSH using decoder 160
10944 // 20133: } else try {
10945 OPC_CheckPredicate, 122, // 20138: check predicate 122
10946 OPC_Decode, 191, 117, 31, // 20140: decode to MOP_RR_7 using decoder 31
10947 // 20140: }
10948 // 20140: }
10949 // 20140: } // switch Inst[31:25]
10950 // 20140: }
10951 5, 5, // 20144: case 0x5: {
10952 OPC_Decode, 139, 111, 161, 1, // 20146: decode to CSRRWI using decoder 161
10953 // 20146: }
10954 6, 5, // 20151: case 0x6: {
10955 OPC_Decode, 137, 111, 161, 1, // 20153: decode to CSRRSI using decoder 161
10956 // 20153: }
10957 7, 0, // 20158: case 0x7: {
10958 OPC_Decode, 135, 111, 161, 1, // 20160: decode to CSRRCI using decoder 161
10959 // 20160: }
10960 // 20160: } // switch Inst[14:12]
10961 // 20160: }
10962 119, 238, 3, // 20165: case 0x77: {
10963 OPC_SwitchField, 26, 6, // 20168: switch Inst[31:26] {
10964 32, 15, // 20171: case 0x20: {
10965 OPC_CheckPredicate, 123, // 20173: check predicate 123
10966 OPC_CheckField, 25, 1, 1, // 20175: check Inst[25] == 0x1
10967 OPC_CheckField, 12, 3, 2, // 20179: check Inst[14:12] == 0x2
10968 OPC_Decode, 193, 130, 1, 118, // 20183: decode to VSM3ME_VV using decoder 118
10969 // 20183: }
10970 33, 16, // 20188: case 0x21: {
10971 OPC_CheckPredicate, 124, // 20190: check predicate 124
10972 OPC_CheckField, 25, 1, 1, // 20192: check Inst[25] == 0x1
10973 OPC_CheckField, 12, 3, 2, // 20196: check Inst[14:12] == 0x2
10974 OPC_Decode, 194, 130, 1, 162, 1, // 20200: decode to VSM4K_VI using decoder 162
10975 // 20200: }
10976 34, 15, // 20206: case 0x22: {
10977 OPC_CheckPredicate, 125, // 20208: check predicate 125
10978 OPC_CheckField, 25, 1, 1, // 20210: check Inst[25] == 0x1
10979 OPC_CheckField, 12, 3, 2, // 20214: check Inst[14:12] == 0x2
10980 OPC_Decode, 166, 126, 162, 1, // 20218: decode to VAESKF1_VI using decoder 162
10981 // 20218: }
10982 35, 15, // 20223: case 0x23: {
10983 OPC_CheckPredicate, 126, // 20225: check predicate 126
10984 OPC_CheckField, 25, 1, 1, // 20227: check Inst[25] == 0x1
10985 OPC_CheckField, 12, 3, 2, // 20231: check Inst[14:12] == 0x2
10986 OPC_Decode, 192, 127, 163, 1, // 20235: decode to VGHSH_VS using decoder 163
10987 // 20235: }
10988 36, 10, // 20240: case 0x24: {
10989 OPC_CheckPredicate, 127, // 20242: check predicate 127
10990 OPC_CheckField, 12, 3, 1, // 20244: check Inst[14:12] == 0x1
10991 OPC_Decode, 166, 127, 122, // 20248: decode to VFWDOTA_VV using decoder 122
10992 // 20248: }
10993 38, 22, // 20252: case 0x26: {
10994 OPC_SwitchField, 12, 3, // 20254: switch Inst[14:12] {
10995 0, 8, // 20257: case 0x0: {
10996 OPC_CheckPredicate, 128, 1, // 20259: check predicate 128
10997 OPC_Decode, 133, 130, 1, 122, // 20262: decode to VQWDOTAU_VV using decoder 122
10998 // 20262: }
10999 1, 0, // 20267: case 0x1: {
11000 OPC_CheckPredicate, 129, 1, // 20269: check predicate 129
11001 OPC_Decode, 133, 127, 122, // 20272: decode to VFQWDOTA_VV using decoder 122
11002 // 20272: }
11003 // 20272: } // switch Inst[14:12]
11004 // 20272: }
11005 39, 22, // 20276: case 0x27: {
11006 OPC_SwitchField, 12, 3, // 20278: switch Inst[14:12] {
11007 0, 8, // 20281: case 0x0: {
11008 OPC_CheckPredicate, 128, 1, // 20283: check predicate 128
11009 OPC_Decode, 132, 130, 1, 122, // 20286: decode to VQWDOTAS_VV using decoder 122
11010 // 20286: }
11011 1, 0, // 20291: case 0x1: {
11012 OPC_CheckPredicate, 129, 1, // 20293: check predicate 129
11013 OPC_Decode, 132, 127, 122, // 20296: decode to VFQWDOTA_ALT_VV using decoder 122
11014 // 20296: }
11015 // 20296: } // switch Inst[14:12]
11016 // 20296: }
11017 40, 85, // 20300: case 0x28: {
11018 OPC_SwitchField, 12, 8, // 20302: switch Inst[19:12] {
11019 2, 11, // 20305: case 0x2: {
11020 OPC_CheckPredicate, 125, // 20307: check predicate 125
11021 OPC_CheckField, 25, 1, 1, // 20309: check Inst[25] == 0x1
11022 OPC_Decode, 161, 126, 164, 1, // 20313: decode to VAESDM_VV using decoder 164
11023 // 20313: }
11024 10, 11, // 20318: case 0xa: {
11025 OPC_CheckPredicate, 125, // 20320: check predicate 125
11026 OPC_CheckField, 25, 1, 1, // 20322: check Inst[25] == 0x1
11027 OPC_Decode, 159, 126, 164, 1, // 20326: decode to VAESDF_VV using decoder 164
11028 // 20326: }
11029 18, 11, // 20331: case 0x12: {
11030 OPC_CheckPredicate, 125, // 20333: check predicate 125
11031 OPC_CheckField, 25, 1, 1, // 20335: check Inst[25] == 0x1
11032 OPC_Decode, 165, 126, 164, 1, // 20339: decode to VAESEM_VV using decoder 164
11033 // 20339: }
11034 26, 11, // 20344: case 0x1a: {
11035 OPC_CheckPredicate, 125, // 20346: check predicate 125
11036 OPC_CheckField, 25, 1, 1, // 20348: check Inst[25] == 0x1
11037 OPC_Decode, 163, 126, 164, 1, // 20352: decode to VAESEF_VV using decoder 164
11038 // 20352: }
11039 130, 1, 12, // 20357: case 0x82: {
11040 OPC_CheckPredicate, 124, // 20360: check predicate 124
11041 OPC_CheckField, 25, 1, 1, // 20362: check Inst[25] == 0x1
11042 OPC_Decode, 196, 130, 1, 164, 1, // 20366: decode to VSM4R_VV using decoder 164
11043 // 20366: }
11044 138, 1, 0, // 20372: case 0x8a: {
11045 OPC_CheckPredicate, 130, 1, // 20375: check predicate 130
11046 OPC_CheckField, 25, 1, 1, // 20378: check Inst[25] == 0x1
11047 OPC_Decode, 195, 127, 164, 1, // 20382: decode to VGMUL_VV using decoder 164
11048 // 20382: }
11049 // 20382: } // switch Inst[19:12]
11050 // 20382: }
11051 41, 97, // 20387: case 0x29: {
11052 OPC_SwitchField, 12, 8, // 20389: switch Inst[19:12] {
11053 2, 11, // 20392: case 0x2: {
11054 OPC_CheckPredicate, 125, // 20394: check predicate 125
11055 OPC_CheckField, 25, 1, 1, // 20396: check Inst[25] == 0x1
11056 OPC_Decode, 160, 126, 164, 1, // 20400: decode to VAESDM_VS using decoder 164
11057 // 20400: }
11058 10, 11, // 20405: case 0xa: {
11059 OPC_CheckPredicate, 125, // 20407: check predicate 125
11060 OPC_CheckField, 25, 1, 1, // 20409: check Inst[25] == 0x1
11061 OPC_Decode, 158, 126, 164, 1, // 20413: decode to VAESDF_VS using decoder 164
11062 // 20413: }
11063 18, 11, // 20418: case 0x12: {
11064 OPC_CheckPredicate, 125, // 20420: check predicate 125
11065 OPC_CheckField, 25, 1, 1, // 20422: check Inst[25] == 0x1
11066 OPC_Decode, 164, 126, 164, 1, // 20426: decode to VAESEM_VS using decoder 164
11067 // 20426: }
11068 26, 11, // 20431: case 0x1a: {
11069 OPC_CheckPredicate, 125, // 20433: check predicate 125
11070 OPC_CheckField, 25, 1, 1, // 20435: check Inst[25] == 0x1
11071 OPC_Decode, 162, 126, 164, 1, // 20439: decode to VAESEF_VS using decoder 164
11072 // 20439: }
11073 58, 11, // 20444: case 0x3a: {
11074 OPC_CheckPredicate, 125, // 20446: check predicate 125
11075 OPC_CheckField, 25, 1, 1, // 20448: check Inst[25] == 0x1
11076 OPC_Decode, 168, 126, 164, 1, // 20452: decode to VAESZ_VS using decoder 164
11077 // 20452: }
11078 130, 1, 12, // 20457: case 0x82: {
11079 OPC_CheckPredicate, 124, // 20460: check predicate 124
11080 OPC_CheckField, 25, 1, 1, // 20462: check Inst[25] == 0x1
11081 OPC_Decode, 195, 130, 1, 164, 1, // 20466: decode to VSM4R_VS using decoder 164
11082 // 20466: }
11083 138, 1, 0, // 20472: case 0x8a: {
11084 OPC_CheckPredicate, 126, // 20475: check predicate 126
11085 OPC_CheckField, 25, 1, 1, // 20477: check Inst[25] == 0x1
11086 OPC_Decode, 194, 127, 164, 1, // 20481: decode to VGMUL_VS using decoder 164
11087 // 20481: }
11088 // 20481: } // switch Inst[19:12]
11089 // 20481: }
11090 42, 15, // 20486: case 0x2a: {
11091 OPC_CheckPredicate, 125, // 20488: check predicate 125
11092 OPC_CheckField, 25, 1, 1, // 20490: check Inst[25] == 0x1
11093 OPC_CheckField, 12, 3, 2, // 20494: check Inst[14:12] == 0x2
11094 OPC_Decode, 167, 126, 165, 1, // 20498: decode to VAESKF2_VI using decoder 165
11095 // 20498: }
11096 43, 27, // 20503: case 0x2b: {
11097 OPC_SwitchField, 12, 3, // 20505: switch Inst[14:12] {
11098 1, 8, // 20508: case 0x1: {
11099 OPC_CheckPredicate, 131, 1, // 20510: check predicate 131
11100 OPC_Decode, 205, 126, 166, 1, // 20513: decode to VFBDOTA_VV using decoder 166
11101 // 20513: }
11102 2, 0, // 20518: case 0x2: {
11103 OPC_CheckPredicate, 123, // 20520: check predicate 123
11104 OPC_CheckField, 25, 1, 1, // 20522: check Inst[25] == 0x1
11105 OPC_Decode, 192, 130, 1, 165, 1, // 20526: decode to VSM3C_VI using decoder 165
11106 // 20526: }
11107 // 20526: } // switch Inst[14:12]
11108 // 20526: }
11109 44, 27, // 20532: case 0x2c: {
11110 OPC_SwitchField, 12, 3, // 20534: switch Inst[14:12] {
11111 1, 8, // 20537: case 0x1: {
11112 OPC_CheckPredicate, 132, 1, // 20539: check predicate 132
11113 OPC_Decode, 157, 127, 166, 1, // 20542: decode to VFWBDOTA_VV using decoder 166
11114 // 20542: }
11115 2, 0, // 20547: case 0x2: {
11116 OPC_CheckPredicate, 130, 1, // 20549: check predicate 130
11117 OPC_CheckField, 25, 1, 1, // 20552: check Inst[25] == 0x1
11118 OPC_Decode, 193, 127, 163, 1, // 20556: decode to VGHSH_VV using decoder 163
11119 // 20556: }
11120 // 20556: } // switch Inst[14:12]
11121 // 20556: }
11122 45, 17, // 20561: case 0x2d: {
11123 OPC_CheckPredicate, 133, 1, // 20563: check predicate 133
11124 OPC_CheckField, 25, 1, 1, // 20566: check Inst[25] == 0x1
11125 OPC_CheckField, 12, 3, 2, // 20570: check Inst[14:12] == 0x2
11126 OPC_Decode, 182, 130, 1, 163, 1, // 20574: decode to VSHA2MS_VV using decoder 163
11127 // 20574: }
11128 46, 39, // 20580: case 0x2e: {
11129 OPC_SwitchField, 12, 3, // 20582: switch Inst[14:12] {
11130 0, 9, // 20585: case 0x0: {
11131 OPC_CheckPredicate, 134, 1, // 20587: check predicate 134
11132 OPC_Decode, 131, 130, 1, 166, 1, // 20590: decode to VQWBDOTAU_VV using decoder 166
11133 // 20590: }
11134 1, 8, // 20596: case 0x1: {
11135 OPC_CheckPredicate, 135, 1, // 20598: check predicate 135
11136 OPC_Decode, 131, 127, 166, 1, // 20601: decode to VFQWBDOTA_VV using decoder 166
11137 // 20601: }
11138 2, 0, // 20606: case 0x2: {
11139 OPC_CheckPredicate, 133, 1, // 20608: check predicate 133
11140 OPC_CheckField, 25, 1, 1, // 20611: check Inst[25] == 0x1
11141 OPC_Decode, 180, 130, 1, 163, 1, // 20615: decode to VSHA2CH_VV using decoder 163
11142 // 20615: }
11143 // 20615: } // switch Inst[14:12]
11144 // 20615: }
11145 47, 0, // 20621: case 0x2f: {
11146 OPC_SwitchField, 12, 3, // 20623: switch Inst[14:12] {
11147 0, 9, // 20626: case 0x0: {
11148 OPC_CheckPredicate, 134, 1, // 20628: check predicate 134
11149 OPC_Decode, 130, 130, 1, 166, 1, // 20631: decode to VQWBDOTAS_VV using decoder 166
11150 // 20631: }
11151 1, 8, // 20637: case 0x1: {
11152 OPC_CheckPredicate, 135, 1, // 20639: check predicate 135
11153 OPC_Decode, 130, 127, 166, 1, // 20642: decode to VFQWBDOTA_ALT_VV using decoder 166
11154 // 20642: }
11155 2, 0, // 20647: case 0x2: {
11156 OPC_CheckPredicate, 133, 1, // 20649: check predicate 133
11157 OPC_CheckField, 25, 1, 1, // 20652: check Inst[25] == 0x1
11158 OPC_Decode, 181, 130, 1, 163, 1, // 20656: decode to VSHA2CL_VV using decoder 163
11159 // 20656: }
11160 // 20656: } // switch Inst[14:12]
11161 // 20656: }
11162 // 20656: } // switch Inst[31:26]
11163 // 20656: }
11164 123, 0, // 20662: case 0x7b: {
11165 OPC_SwitchField, 12, 3, // 20664: switch Inst[14:12] {
11166 0, 239, 1, // 20667: case 0x0: {
11167 OPC_SwitchField, 25, 7, // 20670: switch Inst[31:25] {
11168 1, 9, // 20673: case 0x1: {
11169 OPC_CheckPredicate, 136, 1, // 20675: check predicate 136
11170 OPC_Decode, 174, 132, 1, 167, 1, // 20678: decode to YHIW using decoder 167
11171 // 20678: }
11172 3, 24, // 20684: case 0x3: {
11173 OPC_Scope, 13, // 20686: try {
11174 OPC_CheckField, 20, 5, 0, // 20688: check Inst[24:20] == 0x0
11175 OPC_CheckPredicate, 136, 1, // 20692: check predicate 136
11176 OPC_Decode, 176, 132, 1, 168, 1, // 20695: decode to YMV using decoder 168
11177 // 20695: } else try {
11178 OPC_CheckPredicate, 136, 1, // 20701: check predicate 136
11179 OPC_Decode, 163, 132, 1, 169, 1, // 20704: decode to YADD using decoder 169
11180 // 20704: }
11181 // 20704: }
11182 6, 9, // 20710: case 0x6: {
11183 OPC_CheckPredicate, 136, 1, // 20712: check predicate 136
11184 OPC_Decode, 172, 132, 1, 170, 1, // 20715: decode to YEQ using decoder 170
11185 // 20715: }
11186 7, 9, // 20721: case 0x7: {
11187 OPC_CheckPredicate, 136, 1, // 20723: check predicate 136
11188 OPC_Decode, 184, 132, 1, 171, 1, // 20726: decode to YUNSEALS using decoder 171
11189 // 20726: }
11190 11, 9, // 20732: case 0xb: {
11191 OPC_CheckPredicate, 136, 1, // 20734: check predicate 136
11192 OPC_Decode, 165, 132, 1, 172, 1, // 20737: decode to YADDRW using decoder 172
11193 // 20737: }
11194 14, 9, // 20743: case 0xe: {
11195 OPC_CheckPredicate, 136, 1, // 20745: check predicate 136
11196 OPC_Decode, 180, 132, 1, 170, 1, // 20748: decode to YSS using decoder 170
11197 // 20748: }
11198 15, 9, // 20754: case 0xf: {
11199 OPC_CheckPredicate, 136, 1, // 20756: check predicate 136
11200 OPC_Decode, 168, 132, 1, 171, 1, // 20759: decode to YBLD using decoder 171
11201 // 20759: }
11202 19, 9, // 20765: case 0x13: {
11203 OPC_CheckPredicate, 136, 1, // 20767: check predicate 136
11204 OPC_Decode, 177, 132, 1, 172, 1, // 20770: decode to YPERMC using decoder 172
11205 // 20770: }
11206 23, 13, // 20776: case 0x17: {
11207 OPC_CheckPredicate, 136, 1, // 20778: check predicate 136
11208 OPC_CheckField, 15, 5, 0, // 20781: check Inst[19:15] == 0x0
11209 OPC_Decode, 179, 132, 1, 173, 1, // 20785: decode to YSEALE using decoder 173
11210 // 20785: }
11211 27, 9, // 20791: case 0x1b: {
11212 OPC_CheckPredicate, 136, 1, // 20793: check predicate 136
11213 OPC_Decode, 170, 132, 1, 172, 1, // 20796: decode to YBNDSW using decoder 172
11214 // 20796: }
11215 35, 9, // 20802: case 0x23: {
11216 OPC_CheckPredicate, 136, 1, // 20804: check predicate 136
11217 OPC_Decode, 169, 132, 1, 172, 1, // 20807: decode to YBNDSRW using decoder 172
11218 // 20807: }
11219 120, 12, // 20813: case 0x78: {
11220 OPC_CheckPredicate, 136, 1, // 20815: check predicate 136
11221 OPC_CheckField, 20, 5, 0, // 20818: check Inst[24:20] == 0x0
11222 OPC_Decode, 166, 132, 1, 17, // 20822: decode to YAMASK using decoder 17
11223 // 20822: }
11224 122, 0, // 20827: case 0x7a: {
11225 OPC_SwitchField, 20, 5, // 20829: switch Inst[24:20] {
11226 0, 9, // 20832: case 0x0: {
11227 OPC_CheckPredicate, 136, 1, // 20834: check predicate 136
11228 OPC_Decode, 167, 132, 1, 174, 1, // 20837: decode to YBASER using decoder 174
11229 // 20837: }
11230 1, 9, // 20843: case 0x1: {
11231 OPC_CheckPredicate, 136, 1, // 20845: check predicate 136
11232 OPC_Decode, 178, 132, 1, 174, 1, // 20848: decode to YPERMR using decoder 174
11233 // 20848: }
11234 2, 9, // 20854: case 0x2: {
11235 OPC_CheckPredicate, 136, 1, // 20856: check predicate 136
11236 OPC_Decode, 182, 132, 1, 174, 1, // 20859: decode to YTOPR using decoder 174
11237 // 20859: }
11238 3, 9, // 20865: case 0x3: {
11239 OPC_CheckPredicate, 136, 1, // 20867: check predicate 136
11240 OPC_Decode, 175, 132, 1, 174, 1, // 20870: decode to YLENR using decoder 174
11241 // 20870: }
11242 4, 9, // 20876: case 0x4: {
11243 OPC_CheckPredicate, 136, 1, // 20878: check predicate 136
11244 OPC_Decode, 181, 132, 1, 174, 1, // 20881: decode to YTAGR using decoder 174
11245 // 20881: }
11246 5, 9, // 20887: case 0x5: {
11247 OPC_CheckPredicate, 136, 1, // 20889: check predicate 136
11248 OPC_Decode, 183, 132, 1, 174, 1, // 20892: decode to YTYPER using decoder 174
11249 // 20892: }
11250 7, 0, // 20898: case 0x7: {
11251 OPC_CheckPredicate, 136, 1, // 20900: check predicate 136
11252 OPC_Decode, 173, 132, 1, 174, 1, // 20903: decode to YHIR using decoder 174
11253 // 20903: }
11254 // 20903: } // switch Inst[24:20]
11255 // 20903: }
11256 // 20903: } // switch Inst[31:25]
11257 // 20903: }
11258 4, 9, // 20909: case 0x4: {
11259 OPC_CheckPredicate, 136, 1, // 20911: check predicate 136
11260 OPC_Decode, 164, 132, 1, 175, 1, // 20914: decode to YADDI using decoder 175
11261 // 20914: }
11262 5, 0, // 20920: case 0x5: {
11263 OPC_CheckPredicate, 136, 1, // 20922: check predicate 136
11264 OPC_CheckField, 29, 3, 7, // 20925: check Inst[31:29] == 0x7
11265 OPC_Decode, 171, 132, 1, 176, 1, // 20929: decode to YBNDSWI using decoder 176
11266 // 20929: }
11267 // 20929: } // switch Inst[14:12]
11268 // 20929: }
11269 // 20929: } // 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, 217, 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, 200, 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, 218, 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, 201, 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, 145, 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, 221, 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, 146, 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, 222, 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, 139, 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, 151, 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, 132, 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, 145, 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, 139, 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, 136, 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, 140, 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, 141, 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, 137, 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, 138, 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, 229, 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, 238, 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, 214, 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, 217, 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, 215, 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, 216, 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, 138, 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, 150, 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, 140, 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, 152, 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, 131, 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, 144, 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, 133, 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, 146, 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, 255, 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, 140, 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, 128, 118, 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, 141, 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, 141, 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, 247, 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, 219, 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, 225, 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, 231, 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, 239, 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, 240, 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, 241, 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, 244, 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, 161, 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, 168, 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, 246, 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, 165, 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, 170, 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, 251, 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, 248, 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, 166, 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, 163, 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, 252, 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, 249, 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, 167, 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, 164, 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, 245, 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, 162, 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, 169, 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, 253, 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, 254, 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, 224, 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, 230, 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, 226, 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, 232, 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, 222, 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, 168, 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, 206, 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, 207, 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, 208, 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, 211, 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, 214, 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, 217, 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, 131, 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, 132, 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, 133, 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, 136, 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, 139, 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, 142, 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, 230, 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, 167, 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, 142, 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, 160, 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, 144, 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, 158, 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, 162, 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, 148, 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, 153, 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, 154, 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, 147, 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, 156, 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, 150, 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, 141, 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, 159, 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, 143, 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, 157, 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, 161, 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, 146, 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, 151, 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, 152, 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, 145, 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, 155, 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, 149, 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, 161, 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, 229, 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, 228, 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, 160, 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, 158, 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, 210, 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, 209, 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, 213, 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, 212, 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, 216, 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, 215, 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, 135, 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, 134, 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, 138, 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, 137, 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, 141, 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, 140, 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, 166, 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, 150, 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, 224, 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, 223, 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, 222, 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, 221, 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, 128, 108, 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, 255, 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, 254, 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, 253, 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, 175, 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, 174, 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, 177, 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, 176, 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, 132, 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, 131, 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, 130, 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, 129, 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, 252, 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, 251, 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, 250, 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, 249, 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, 228, 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, 227, 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, 226, 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, 225, 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, 244, 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, 243, 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, 173, 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, 133, 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, 242, 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, 241, 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, 236, 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, 235, 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, 234, 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, 233, 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, 248, 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, 247, 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, 246, 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, 245, 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, 240, 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, 239, 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, 238, 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, 237, 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, 232, 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, 231, 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, 230, 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, 229, 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, 138, 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, 163, 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, 171, 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, 231, 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, 238, 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, 246, 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, 245, 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, 165, 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, 170, 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, 140, 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, 139, 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, 149, 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, 247, 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, 129, 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, 130, 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, 162, 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, 155, 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, 248, 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, 164, 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, 157, 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, 156, 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, 153, 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, 242, 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, 241, 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, 240, 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, 239, 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, 200, 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, 199, 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, 198, 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, 254, 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, 253, 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, 146, 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, 144, 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, 145, 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, 249, 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, 250, 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, 237, 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, 234, 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, 236, 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, 233, 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, 235, 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, 232, 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, 251, 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, 223, 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, 148, 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, 154, 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, 152, 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, 166, 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, 167, 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, 172, 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, 151, 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, 255, 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, 205, 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, 221, 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, 204, 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, 147, 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, 252, 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, 128, 109, 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, 168, 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, 164, 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, 169, 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, 165, 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, 163, 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, 135, 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, 134, 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, 136, 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, 137, 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, 220, 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, 227, 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, 203, 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, 218, 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, 224, 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, 201, 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, 219, 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, 226, 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, 202, 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, 225, 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, 143, 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, 189, 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, 188, 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, 190, 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, 178, 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, 179, 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, 180, 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, 175, 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, 176, 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, 177, 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, 186, 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, 184, 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, 183, 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, 187, 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, 185, 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, 181, 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, 182, 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, 171, 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, 170, 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, 173, 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, 174, 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, 172, 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, 195, 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, 194, 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, 193, 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, 197, 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, 196, 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, 191, 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, 192, 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, 244, 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, 169, 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, 243, 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, 159, 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, 169, 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, 185, 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, 186, 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, 197, 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, 190, 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, 162, 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, 161, 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, 195, 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, 196, 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, 193, 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, 194, 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, 198, 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, 199, 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, 200, 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, 175, 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, 192, 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, 177, 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, 173, 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, 191, 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, 172, 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, 176, 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, 188, 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, 178, 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, 174, 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, 187, 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, 189, 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, 163, 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, 165, 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, 164, 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, 166, 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, 154, 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, 179, 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, 180, 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, 157, 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, 170, 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, 181, 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, 182, 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, 159, 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, 160, 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, 183, 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, 171, 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, 184, 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, 158, 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, 155, 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, 156, 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, 174, 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, 243, 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, 157, 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, 159, 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, 167, 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, 157, 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, 193, 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, 184, 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, 247, 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, 175, 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, 217, 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, 169, 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, 205, 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, 218, 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, 241, 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, 212, 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, 229, 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, 204, 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, 211, 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, 198, 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, 199, 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, 163, 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, 235, 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, 157, 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, 223, 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, 151, 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, 130, 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, 254, 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, 233, 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, 253, 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, 193, 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, 172, 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, 163, 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, 144, 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, 141, 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, 147, 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, 135, 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, 253, 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, 131, 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, 247, 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, 164, 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, 143, 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, 137, 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, 238, 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, 241, 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, 180, 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, 145, 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, 180, 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, 185, 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, 183, 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, 153, 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, 192, 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, 180, 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, 246, 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, 174, 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, 216, 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, 168, 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, 204, 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, 217, 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, 240, 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, 211, 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, 228, 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, 203, 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, 210, 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, 197, 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, 198, 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, 162, 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, 234, 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, 156, 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, 222, 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, 150, 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, 232, 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, 192, 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, 162, 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, 143, 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, 140, 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, 146, 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, 134, 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, 252, 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, 130, 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, 246, 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, 163, 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, 142, 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, 136, 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, 240, 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, 239, 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, 183, 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, 189, 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, 145, 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, 149, 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, 147, 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, 151, 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, 131, 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, 255, 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, 173, 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, 154, 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, 181, 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, 162, 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, 152, 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, 176, 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, 182, 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, 185, 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, 175, 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, 181, 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, 184, 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, 173, 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, 179, 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, 172, 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, 178, 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, 245, 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, 147, 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, 191, 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, 244, 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, 146, 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, 190, 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, 158, 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, 160, 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, 168, 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, 181, 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, 186, 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, 242, 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, 165, 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, 166, 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, 187, 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, 252, 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, 142, 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, 148, 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, 149, 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, 209, 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, 210, 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, 195, 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, 196, 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, 155, 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, 156, 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, 153, 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, 154, 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, 188, 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, 190, 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, 189, 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, 191, 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, 146, 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, 150, 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, 148, 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, 152, 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, 169, 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, 177, 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, 171, 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, 179, 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, 186, 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, 223, 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, 168, 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, 176, 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, 170, 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, 178, 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, 161, 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, 171, 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, 228, 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, 224, 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, 229, 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, 225, 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, 161, 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, 197, 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, 188, 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, 251, 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, 179, 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, 221, 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, 173, 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, 209, 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, 222, 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, 245, 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, 216, 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, 233, 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, 208, 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, 215, 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, 202, 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, 203, 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, 167, 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, 239, 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, 161, 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, 227, 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, 155, 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, 132, 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, 128, 112, 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, 237, 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, 197, 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, 174, 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, 167, 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, 155, 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, 182, 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, 145, 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, 151, 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, 139, 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, 129, 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, 135, 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, 251, 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, 170, 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, 177, 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, 230, 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, 226, 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, 231, 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, 227, 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, 160, 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, 196, 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, 187, 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, 250, 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, 178, 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, 220, 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, 172, 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, 208, 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, 221, 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, 244, 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, 215, 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, 232, 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, 207, 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, 214, 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, 201, 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, 202, 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, 166, 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, 238, 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, 160, 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, 226, 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, 154, 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, 236, 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, 196, 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, 166, 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, 144, 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, 150, 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, 138, 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, 128, 113, 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, 134, 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, 250, 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, 169, 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, 182, 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, 191, 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, 187, 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, 192, 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, 188, 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, 159, 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, 195, 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, 186, 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, 249, 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, 177, 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, 219, 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, 171, 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, 207, 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, 220, 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, 243, 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, 214, 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, 231, 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, 206, 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, 213, 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, 200, 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, 201, 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, 165, 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, 237, 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, 159, 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, 225, 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, 153, 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, 133, 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, 129, 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, 235, 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, 195, 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, 175, 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, 165, 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, 156, 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, 183, 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, 143, 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, 149, 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, 137, 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, 255, 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, 133, 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, 249, 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, 144, 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, 184, 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, 193, 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, 189, 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, 194, 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, 190, 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, 158, 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, 194, 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, 185, 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, 248, 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, 176, 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, 218, 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, 170, 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, 206, 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, 219, 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, 242, 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, 213, 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, 230, 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, 205, 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, 212, 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, 199, 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, 200, 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, 164, 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, 236, 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, 158, 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, 224, 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, 152, 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, 234, 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, 194, 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, 164, 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, 142, 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, 148, 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, 136, 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, 254, 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, 132, 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, 248, 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, 138, 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, 139, 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, 140, 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, 141, 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, 180, 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, 176, 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, 175, 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, 179, 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, 174, 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, 177, 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, 178, 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, 181, 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, 182, 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, 241, 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, 242, 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, 242, 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, 145, 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, 243, 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, 146, 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, 241, 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, 142, 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, 228, 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, 129, 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, 243, 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, 244, 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, 254, 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, 231, 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, 132, 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, 239, 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, 140, 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, 232, 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, 133, 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, 240, 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, 141, 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, 230, 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, 131, 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, 238, 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, 139, 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, 229, 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, 130, 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, 237, 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, 138, 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, 216, 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, 235, 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, 136, 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, 236, 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, 137, 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, 234, 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, 135, 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, 233, 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, 134, 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, 150, 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, 148, 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, 144, 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, 152, 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, 149, 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, 151, 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, 143, 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, 147, 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, 172, 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, 173, 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, 174, 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, 175, 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, 245, 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, 246, 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, 244, 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, 141, 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, 131, 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, 148, 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, 152, 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, 164, 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, 179, 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, 145, 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, 135, 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, 142, 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, 132, 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, 149, 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, 153, 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, 138, 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, 128, 124, 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, 161, 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, 176, 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, 156, 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, 157, 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, 180, 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, 183, 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, 182, 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, 181, 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, 162, 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, 177, 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, 163, 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, 178, 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, 175, 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, 174, 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, 173, 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, 158, 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, 159, 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, 146, 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, 136, 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, 143, 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, 133, 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, 150, 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, 154, 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, 139, 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, 129, 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, 169, 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, 171, 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, 167, 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, 165, 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, 147, 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, 137, 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, 255, 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, 253, 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, 254, 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, 252, 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, 160, 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, 251, 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, 250, 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, 249, 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, 248, 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, 247, 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, 170, 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, 172, 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, 168, 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, 166, 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, 144, 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, 134, 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, 151, 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, 155, 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, 140, 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, 130, 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, 155, 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, 165, 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, 156, 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, 181, 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, 182, 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, 185, 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, 187, 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, 186, 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, 250, 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, 253, 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, 251, 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, 252, 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, 162, 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, 167, 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, 158, 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, 164, 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, 163, 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, 168, 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, 159, 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, 161, 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, 160, 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, 166, 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, 157, 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, 184, 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, 183, 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, 234, 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, 154, 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, 240, 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, 241, 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, 219, 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, 222, 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, 221, 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, 224, 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, 220, 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, 223, 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, 225, 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, 226, 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, 255, 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, 227, 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, 171, 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, 172, 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, 254, 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, 228, 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, 169, 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, 170, 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, 199, 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, 189, 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, 206, 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, 188, 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, 202, 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, 196, 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, 209, 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, 195, 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, 204, 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, 215, 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, 211, 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, 214, 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, 201, 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, 194, 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, 208, 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, 193, 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, 200, 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, 191, 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, 207, 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, 190, 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, 203, 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, 198, 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, 210, 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, 197, 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, 205, 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, 218, 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, 212, 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, 217, 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, 213, 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, 216, 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, 192, 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, 237, 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, 230, 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, 243, 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, 229, 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, 239, 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, 236, 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, 245, 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, 235, 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, 242, 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, 249, 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, 246, 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, 248, 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, 238, 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, 233, 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, 244, 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, 232, 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, 247, 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, 231, 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, 174, 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, 176, 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, 173, 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, 175, 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, 133, 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, 134, 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, 131, 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, 132, 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, 128, 126, 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, 129, 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, 130, 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, 178, 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, 180, 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, 177, 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, 179, 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, 193, 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, 255, 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, 251, 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, 248, 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, 249, 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, 222, 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, 213, 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, 218, 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, 214, 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, 186, 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, 254, 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, 187, 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, 250, 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, 211, 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, 252, 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, 212, 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, 253, 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, 174, 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, 221, 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, 190, 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, 217, 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, 173, 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, 219, 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, 162, 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, 220, 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, 164, 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, 215, 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, 163, 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, 216, 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, 179, 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, 180, 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, 165, 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, 166, 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, 184, 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, 185, 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, 192, 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, 178, 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, 165, 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, 128, 123, 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, 149, 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, 147, 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, 148, 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, 142, 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, 144, 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, 146, 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, 143, 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, 145, 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, 188, 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, 189, 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, 166, 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, 190, 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, 191, 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, 129, 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, 186, 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, 187, 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, 176, 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, 181, 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, 182, 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, 183, 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, 177, 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, 150, 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, 130, 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, 151, 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, 131, 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, 160, 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, 140, 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, 161, 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, 141, 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, 170, 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, 168, 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, 167, 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, 169, 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, 171, 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, 172, 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, 174, 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, 173, 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, 156, 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, 136, 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, 157, 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, 137, 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, 152, 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, 132, 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, 153, 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, 133, 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, 158, 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, 138, 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, 159, 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, 139, 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, 154, 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, 134, 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, 155, 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, 135, 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, 188, 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, 189, 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, 175, 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, 175, 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, 167, 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, 172, 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, 170, 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, 168, 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, 171, 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, 169, 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, 172, 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, 189, 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, 178, 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, 210, 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, 245, 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, 237, 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, 154, 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, 168, 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, 218, 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, 255, 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, 150, 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, 134, 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, 142, 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, 202, 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, 190, 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, 225, 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, 180, 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, 160, 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, 151, 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, 169, 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, 138, 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, 247, 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, 239, 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, 186, 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, 184, 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, 162, 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, 184, 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, 179, 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, 181, 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, 216, 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, 211, 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, 213, 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, 251, 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, 246, 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, 248, 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, 243, 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, 238, 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, 240, 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, 160, 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, 155, 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, 157, 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, 174, 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, 169, 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, 171, 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, 224, 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, 219, 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, 221, 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, 133, 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, 128, 115, 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, 130, 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, 156, 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, 140, 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, 148, 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, 151, 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, 135, 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, 143, 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, 153, 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, 137, 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, 145, 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, 208, 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, 196, 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, 203, 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, 191, 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, 205, 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, 193, 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, 226, 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, 228, 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, 181, 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, 173, 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, 197, 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, 190, 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, 166, 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, 161, 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, 163, 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, 157, 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, 175, 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, 144, 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, 152, 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, 170, 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, 139, 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, 154, 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, 172, 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, 141, 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, 253, 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, 245, 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, 215, 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, 208, 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, 248, 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, 240, 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, 210, 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, 203, 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, 250, 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, 242, 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, 212, 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, 205, 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, 237, 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, 236, 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, 232, 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, 231, 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, 187, 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, 185, 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, 177, 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, 176, 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, 201, 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, 200, 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, 194, 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, 193, 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, 168, 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, 163, 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, 165, 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, 239, 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, 246, 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, 241, 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, 223, 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, 225, 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, 247, 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, 242, 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, 224, 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, 226, 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, 233, 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, 234, 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, 227, 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, 232, 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, 230, 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, 228, 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, 231, 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, 229, 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, 235, 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, 236, 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, 237, 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, 238, 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, 240, 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, 243, 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, 244, 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, 245, 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